open-index/open-npm huggingface dataset:
npm package: @inloopx/mockserver
Description: Easily mock your webservices while testing frontends.
Author: Mohammad Hallal
Latest version: 1.2.4

# mockserver

[![Build Status](https://travis-ci.org/namshi/mockserver.svg?branch=master)](https://travis-ci.org/namshi/mockserver)

**mockserver** is a library that will help you mock your APIs
in **a matter of seconds**: you simply organize your mocked
HTTP responses in a bunch of js files and it will serve them
like they were coming from a real API; in this way you can
write your frontends without caring too much whether your
backend is really ready or not.

## Installation

Mockserver can be installed globally if you need
to run it as a command:

```
$ npm install -g mockserver

$ mockserver -p 8080 -m test/mocks
Mockserver serving mocks under "test/mocks" at http://localhost:8080
```

or as a regular NPM module if you need to use it as
a library within your code:

``` bash
npm install mockserver
```

then in your test file:

``` javascript
var http    =  require('http');
var mockserver  =  require('mockserver');

http.createServer(mockserver('path/to/your/mocks')).listen(9001);
```

This will run a simple HTTP webserver, handled by mockserver, on port
9001.

At this point you can simply define your first mock: create a file in
`path/to/your/mocks/example-response` called `GET.js`:

```
const status = 200

const headers = [
  "Access-Control-Allow-Origin: *",
]

const body = {
  OK: Math.random() < 0.5
}

module.exports = {
  headers,
  status,
  body
}

```

If you open your browser at `http://localhost:9001/example-response`
you will see something like this:

![example output](https://raw.githubusercontent.com/namshi/mockserver/readme/bin/images/example-response.png)

And it's over: now you can start writing your frontends without
having to wait for your APIs to be ready, or without having to spend
too much time mocking them, as mockserver lets you do it in seconds.
npm package: @inlustra/task-runner
Description: A Task
Latest version: 1.0.0

# Inlustra's Task Runner

A sub-task manager/pipeline to handle child processes.

## Install

```
  npm i @inlustra/task-manager
```

## TL:DR

Takes jobs (Child Processes) and handles piping up to a single stream across processes.
A Task is made up of multiple jobs with a previous job condition (eg. the previous job must be a success)

* Jobs are run consecutively
* All stage updates (Complete, Error, Cancelled, Skipped) are bubbled up through events.
* Handles errors without blowing up (If not handled explicitly!)


### The simplest way to get tasks running one after the other

Create a task, made up of multiple jobs, this is the equivalent of a pipeline

```javascript
const task = {
  name: 'A Simple Task',
  description: 'A task to list some files',
  jobs: [
    new ShellJob('ls ./'), // List the files
    new ShellJob('sleep 5'), // Sleep for 5 seconds
    new ShellJob('exit 1'), // Then error
    new ShellJob('echo "This won\'t appear!"') // The task runner won't run this job
  ]
}

const taskHandler = new TaskHandler(task)
taskHandler.on(TaskHandler.Events.STAGE_UPDATE, (stages) => {
  console.log('The next stage in the task has run!')
  console.log(stages)
})
```

## Using the task runner to add tasks


```javascript
const task = {
  name: 'A Simple Task',
  description: 'A task to list some files',
  jobs: [
    new ShellJob('ls ./'), // List the files
    new ShellJob('sleep 5'), // Sleep for 5 seconds
    new ShellJob('exit 1'), // Then error
    new ShellJob('echo "This won\'t appear!"') // The task runner won't run this job
  ]
}
```

Register the task, add your pipes and start it!

```javascript
const taskRunner = new TaskRunner()
taskRunner.addGlobalPipe(process.stdout) // Will print all outputs from any tasks to the console
const taskKey = taskRunner.register(task)
taskRunner.addTaskPipe(taskKey, fs.createWriteStream('./'))
```

# TODO

- Document the options available (Jobs can run on error)
- Document the Event types in TaskHandler and TaskRunner
- Bubble up errors to the developer
npm package: @inlustris/youtube-mcp
Description: No-fuss YouTube transcripts for MCP - no API keys required! A Model Context Protocol server to get YouTube video transcripts.
Author: inlustris
Latest version: 1.0.8

# @inlustris/youtube-mcp

**No-fuss YouTube transcripts for MCP - no API keys required!**

![NPM Version](https://img.shields.io/npm/v/@inlustris/youtube-mcp)
![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6)

A Model Context Protocol (MCP) server for YouTube video transcripts and search.

*No fuss setup - no Google API keys required!* Just install and start extracting transcripts.

## Features

- Get YouTube video transcripts with timestamps
- Search YouTube videos and channels
- Get channel video lists
- Chunking support for large transcripts

## Installation

```bash
npm install -g @inlustris/youtube-mcp
```

## Configuration

Add to your MCP client config (e.g., `.cursor/mcp.json`):

```json
{
  "mcpServers": {
    "youtube": {
      "command": "npx",
      "args": ["-y", "@inlustris/youtube-mcp@latest"]
    }
  }
}
```

## Available Tools

### `get_transcript`
Get video transcript from YouTube URL.

Parameters:
- `videoUrl` (required): YouTube video URL
- `chunkSize` (optional): Max characters per chunk
- `chunkBySilence` (optional): Split by silence breaks
- `silenceThreshold` (optional): Silence duration in ms

### `search_videos`
Search YouTube videos.

Parameters:
- `query` (required): Search terms
- `sortBy` (optional): `relevance`, `date`, `rating`, `viewCount`, `title`

### `search_channels`
Search YouTube channels.

Parameters:
- `query` (required): Search terms
- `sortBy` (optional): `relevance`, `date`, `rating`, `viewCount`, `title`, `videoCount`

### `get_channel_videos`
Get videos from a channel.

Parameters:
- `channelId` (required): YouTube channel ID
- `maxResults` (optional): Number of videos (max 200)

## Development

```bash
npm install
npm run dev        # Development server
npm run start:http # HTTP server for testing
```

## License

MIT

## Keywords

YouTube transcript, MCP server, Model Context Protocol, YouTube API, video transcript extraction, AI tools, TypeScript, FastMCP, YouTube search, channel analysis, video content analysis, transcript chunking, Claude Desktop, Cursor IDE, AI development tools, YouTube data extraction, video processing, content analysis, automated transcription