open-index/open-npm huggingface dataset:
npm package: @phidiassj/aiyoperps-mcp-bridge
Description: Stdio MCP bridge for the AiyoPerps local HTTP MCP endpoint.
Latest version: 0.8.6

# AiyoPerps MCP Bridge

This package exposes a standard MCP `stdio` server that forwards requests to the local AiyoPerps HTTP MCP endpoint.

It supports both:
- classic `Content-Length` framed MCP stdio
- newline-delimited JSON messages used by current Codex MCP startup

## Usage

```bash
npx -y @phidiassj/aiyoperps-mcp-bridge
```

Custom endpoint:

```bash
npx -y @phidiassj/aiyoperps-mcp-bridge --url http://127.0.0.1:5078/mcp
```

Use `--url` whenever your MCP endpoint is not the local default.

Or via environment variable:

```bash
AIYOPERPS_MCP_URL=http://127.0.0.1:5078/mcp npx -y @phidiassj/aiyoperps-mcp-bridge
```

Health check only:

```bash
npx -y @phidiassj/aiyoperps-mcp-bridge --health-check --url http://127.0.0.1:5078/mcp
```

Startup validation before entering stdio mode:

```bash
npx -y @phidiassj/aiyoperps-mcp-bridge --startup-ping --url http://127.0.0.1:5078/mcp
```

Write local diagnostics to a file:

```bash
npx -y @phidiassj/aiyoperps-mcp-bridge --debug-log ~/.aiyoperps/mcp-bridge/codex-debug.log --quiet --url http://127.0.0.1:5078/mcp
```

## Typical MCP config

```json
{
  "mcpServers": {
    "aiyoperps": {
      "command": "npx",
      "args": [
        "-y",
        "@phidiassj/aiyoperps-mcp-bridge",
        "--debug-log",
        "~/.aiyoperps/mcp-bridge/codex-debug.log",
        "--quiet",
        "--url",
        "http://127.0.0.1:5078/mcp"
      ]
    }
  }
}
```
npm package: @phidiassj/aiyoperps-mcp-installer
Description: Interactive installer for registering AiyoPerps MCP with supported AI agent hosts.
Latest version: 0.7.0

# AiyoPerps MCP Installer

Interactive installer for registering the AiyoPerps MCP bridge with supported AI agent hosts.

## Usage

```bash
npx -y @phidiassj/aiyoperps-mcp-installer
```

Optional MCP endpoint override:

```bash
npx -y @phidiassj/aiyoperps-mcp-installer --url http://127.0.0.1:5078/mcp
```

## Current host strategy

- `Codex`: patch `~/.codex/config.toml` by updating only the `mcp_servers.aiyoperps` block
- `Claude Code CLI`: use `claude mcp add-json` / `claude mcp remove`
- `Claude Desktop`: merge into the desktop JSON config
- `OpenClaw`: use `openclaw config set` / `openclaw config unset`

## Notes

- The installer creates `*.bak` backups before editing local config files.
- If a host is detected but not considered safe to modify, the installer reports it and skips automatic changes.
- For Codex, the installer writes `startup_timeout_sec = 60`.
- Before writing host config, the installer installs the bridge package into a stable local runtime directory instead of relying on `npx` at every startup.
- The generated MCP entry uses `node <local bridge script> --debug-log <local log path> --quiet --url <detected endpoint>`.
- The generated bridge debug log is stored in the local bridge runtime directory (for example `~/.aiyoperps/mcp-bridge/codex-debug.log` on Linux/WSL).
- Before installation, the installer probes candidate MCP URLs and only writes config if it finds a reachable endpoint.
npm package: @phifans/audio
Description: Another WebAudio library
Latest version: 0.0.7

# @PhiFans/audio

Another WebAudio library.


## Install 

You can install `@phifans/audio` via npm:

```shell
npm install @phifans/audio
# ...or any package manager you like
pnpm install @phifans/audio
```

## Example

```js
import { Bus, Clip } from '@phifans/audio';

const bus = new Bus();
const musicChannel = bus.createChannel('music');
const sfxChannel = bus.createChannel('sfx');

const musicClip = await Clip.from('https://example.com/music.mp3');
const sfxClip = await Clip.from('https://example.com/sfx.mp3');

// Play a music
musicClip.channel = musicChannel;
musicClip.play();

// Or play a sfx
sfxChannel.startTick();
sfxChannel.pushClipToQueue(sfxClip);
```

## Documents

See https://phifans.github.io/audio/

## Thanks

* [bemuse.ninja](https://github.com/bemusic/bemuse)

## License

```
The MIT License (MIT)
Copyright © 2025 PhiFans

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
```
npm package: @phikes/plain-date
Description: A Date subclass and implementation without time. Comptaible with date-fns helpers.
Author: Phillip Kessels
Latest version: 4.0.0

# @phikes/plain-date

A Date subclass and implementation without time. Comptaible with date-fns helpers.

## Usage

```bash
npm install@phikes/plain-date
yarn add @phikes/plain-date
```

```typescript
// implements the Date interface and extends the Date class

new PlainDate()
new PlainDate(1992, 0, 22)
new PlainDate("1992-01-22")
new PlainDate(new Date())
PlainDate.fromString("1992-01-22")
PlainDate.fromDate(new Date())
// ...
plainDate.toString() // returns the date as ISO8601 formatted string without timestamp
// ...

// compatible with date-fns helpers
isToday(new PlainDate())
isBefore(new Date(), new PlainDate())
isBefore(new PlainDate(), new PlainDate())
isSameDay(new PlainDate(), new Date())
nextSaturday(new PlainDate())
addDays(new PlainDate(), 1)
// ...
```
npm package: @phil-rice/debug
Description: A general debug utility that allows debugs to be turned on and off easily and thus left in the code
Latest version: 0.3.34

# Debugging

I often find that I use 'printline debugging'. This is where we add 'console.log' lines to 
code in order to find defects.

In general it's a bad idea to leave these in production for a number of reasons: 
* They pollute console.log with noise making it hard to find real issues
* They can take time (but actually usually don't)

However when logging we often have different levels of logging. In java for example
we often have 'logging levels'. 'Error', 'Warn', 'Info' and debug, and then we have tools to
examine the logging files. 

While I don't feel the need for levels here (yet), I want the ability to 'turn on and off' 
debugging in parts of the code.

For example I might have a section of the code called 'generations' and I might want to have
logging messages that only appear when I have a problem in the 'generations' code and
want to debug it. 

# Setting up to use
I typically have an object I used for dependency inject. Say it's called context. 
I have a comma separated list of names called debugString. This
is the list of 'sections' that I want debugging enabled for

```
let contextWithDebug=addDebug(debugString, x => console.log('#', ...x))(context)
```
This context was previously some object, and now it is an object with `{debug: <the debug function>}` added

# Using
``` 
    let s = contextWithDebug.debug('generations');
    ...
    ...
    s.message(() => ['some', 'list', 'that', 'might', 'get', 'logged']
    ...
    ...
    ...s.k(() => 'about to fullfill a promise', () => <something that returns a promise>>)
```
* The first line created a javascript object that will only print to the output when the debugString contains 'generations'.
* s.message sends a message to console.log if 'generations' is in the debugString
* s.k() returns the promise returned by `<something that returns a promise>`. It logs errors in that promise as well
npm package: @phil-rice/generations
Description: A library that typologically sorts data into generations
Latest version: 0.3.34

# A library to do topological sorting

Many things have have 'generations'. This is where 'a series of tasks have to be done before others'

For example when you have a series of software libraries that you produce,
and some use other libraries, then when you compile/pubish them (and you want to do this in parallel),
you can sort them into generations:
* gen0: those that don't depend on any others
* gen1: those that only depend on gen0
* gen2: those that only depend on gen1 or gen0
* ...

# Using the library

## GenerationFns
You need to create an instance of 
```
interface GenerationFns<G> {
    name: (g: G) => string,
    children: (g: G) => string[],
    errorMessage: (view: GenerationView) => Error
}
```
All the sorting is done by names (for speed as much as anything) so each G has to have a unique name

## Sorting

A reasonably common use case is when we have a list of Gs. This isn't the full list. For
example we might have 10,000 items in a todo list: some depedendant on each other. We are
only going to topologically sort some of these, so we ignore things that aren't in the list we are sorting

There are two methods used:

```
 function calcGenerationsPromise<G>(genFns: GenerationFns<G>): (gs: G[]) => Promise<G[][]> 
 function calcGenerations<G>(genFns: GenerationFns<G>): (gs: G[]) => GenerationsResult<G> {
```
The methods with a promise can be convenient when working with heavy async code, and captures the idea that the
sort can fail (if there is a loop)
npm package: @phil-rice/lenstest
Description: Tests the lens defined in @phil-rice/lens, and the state defined in @phil-rice/state
Latest version: 0.2.5

This project holds the tests for

* [@phil-rice/lens: Easy - perhaps even beautiful - code for editing deep immutable objects](modules/lens/README.md)
* [@phil-rice/state: State management for projects (including React) using the lens in the above project](modules/state/README.md)
 
They have been moved here to keep the main projects small
npm package: @phil-rice/nonfunctionals
Description: A library that allows wrapping of functions and kleislis with non functional capablities
Latest version: 0.2.5

This project allows the wrapping of functions and kleislis (approx: a function that returns a promise) with
non functional capabilities

There are two main exports
* NonFunctionalsForFunction 
* NonFunctionalsForPromiseFunctions

Each is a facard to the capablities that can use used.

At the moment this is just a play project
npm package: @phil-rice/validation
Description: A library for validating json
Latest version: 0.3.34

# This is library for single field validation.

This is a common requirement in my applications: objects are parsed from JSON and I want
to make sure that they meet a contract

I want a list of all the error messages, and I would like it if the code reads declarative.

The `return type` of the validation is a string[] or a Promise<string[]>

## Approach
We wrap the object under test with a validate object then we can do things like the following. The validate
object accumulates issues internaly and you can call `.issues` to see those issues
```
function validateProjectDetails(v: Validate<ProjectDetails>) {
    return v.isString("name").//
        isString("description").//
        isString("template").//
        isObject("details", validateDetails)
}

function validateDetails(v: Validate<Details>) {
    return v.isBoolean("publish", 'Should the project be published').//
        isArrayofObjects('links', v => v).//
        optObject("extraDeps", v => v, 'These are added to package.json dependencies').//
        optObject("extraDevDeps", v => v, 'These are added to package.json devDependencies').//
        optObject("extraBins", v => v, 'These are added to package.json bin')
}
```
## Extra goodness
When working with CLIs I often want to validate that directories and files exist.


```
function validateTemplateDirectory(context: string, c: Config, templateDir: string): Promise<string[]> {
    let dir = path.join(c.templateDir, templateDir);
    return Validate.validateDirectoryExists(context, dir).then(dirErrors => dirErrors.length === 0 ?
        Validate.validateFile(`package.json in template directory ${templateDir}`, path.join(dir, 'package.json'), validatePackageJson) :
        dirErrors)
}```
npm package: @phil.nic/xpf
Description: Personal Winston logging setup.
Author: phil.nic
Latest version: 1.0.0

#    xpf
#### 𝑗𝑜𝑢𝑟𝑛𝑎𝑙𝑖𝑧𝑎𝑡𝑖𝑜𝑛 𝒙𝒑𝒇 𝑙𝑜𝑔𝑔𝑖𝑛𝑔

---