open-index/open-npm huggingface dataset:
npm package: @rayburst/types
Description: Shared types and schemas for Rayburst
Latest version: 0.1.15

# @rayburst/types

Shared TypeScript types and Zod schemas for Rayburst code visualization and dependency analysis platform.

## Installation

```bash
npm install @rayburst/types
```

## Usage

```typescript
import {
  AnalysisNode,
  AnalysisEdge,
  PlanData,
  AnalysisResult,
  ProjectMetadata,
  BranchMetadata
} from '@rayburst/types';
```

## Type Definitions

### Node Types

Supports the following node types:
- `component` - React components
- `function` - Functions
- `state` - State declarations (useState, etc.)
- `api` - API endpoints
- `conditional` - Conditional logic (if/else)
- `ternary` - Ternary expressions
- `switch` - Switch statements
- `try-catch` - Try/catch blocks
- `task` - Task nodes

### Node Schema

```typescript
type AnalysisNode = {
  id: string;
  type: 'component' | 'function' | 'state' | 'api' | 'conditional' | 'ternary' | 'switch' | 'try-catch' | 'task';
  position: { x: number; y: number };
  data: {
    label: string;
    description?: string;
    // Type-specific fields...
  };
};
```

### Edge Schema

```typescript
type AnalysisEdge = {
  id: string;
  source: string;
  target: string;
  type: string;
  label?: string;
  sourceHandle?: string;
  targetHandle?: string;
};
```

### PlanData Schema

```typescript
type PlanData = {
  nodes: AnalysisNode[];
  edges: AnalysisEdge[];
};
```

### AnalysisResult Schema

```typescript
type AnalysisResult = {
  project: ProjectMetadata;
  branches: BranchMetadata[];
  planData: Record<string, PlanData>;
  analyzedAt: string;
  logs?: string[];
};
```

## Validation

All schemas include Zod validators for runtime type checking:

```typescript
import { NodeSchema, EdgeSchema, AnalysisResultSchema } from '@rayburst/types';

// Validate data at runtime
const validatedNode = NodeSchema.parse(nodeData);
const validatedResult = AnalysisResultSchema.parse(analysisData);
```

## License

MIT
npm package: @raycashxyz/mpp
Description: Private machine-to-machine payments for the [Machine Payments Protocol](https://mpp.dev), powered by [Raycash](https://raycash.xyz).
Latest version: 0.1.2

# @raycashxyz/mpp

Private machine-to-machine payments for the [Machine Payments Protocol](https://mpp.dev), powered by [Raycash](https://raycash.xyz).

AI agents pay for API services through payment channels where settlement exits through an FHE-encrypted token wrapper — the recipient's identity is hidden on-chain.

## Install

```bash
npm install @raycashxyz/mpp
```

## Server (Operator)

Add payment verification to any HTTP endpoint:

```typescript
import { raycash } from "@raycashxyz/mpp/server";
import { Mppx } from "mppx/hono"; // or mppx/express, etc.

const mppx = Mppx.create({
  secretKey: process.env.MPP_SECRET_KEY,
  methods: [
    raycash({
      currency: "0x...",           // ERC-20 token address
      chainId: 11155111,           // Sepolia
      minDeposit: "100000",        // 0.1 USDC
      serviceUrl: "https://my-api.com",
      raycashBaseUrl: "https://raycash.xyz",
      apiKey: process.env.RAYCASH_API_KEY,
    }),
  ],
});

app.get("/data", mppx.channel({ amount: "1000" }), (c) => {
  return c.json({ result: "paid data" });
});
```

## Client (Agent)

Make paid requests with automatic channel management:

```typescript
import { raycash } from "@raycashxyz/mpp/client";
import { Method } from "mppx";

const client = Method.toClient(raycashChannel, raycash({
  account: walletAccount,
  onFundChannel: async ({ channelAddress, minDeposit }) => {
    // Send tokens to the channel address
  },
}));
```

## How It Works

1. Agent requests a resource → service returns `402` with pricing
2. Agent signs an EIP-712 voucher authorizing payment
3. Agent retries with the voucher → service verifies via Raycash → serves data
4. Operator settles vouchers on-chain → funds enter the confidential wrapper
5. Recipient identity stays encrypted (FHE) — observers can't link payments to operators

## Links

- [Raycash Dashboard](https://raycash.xyz) — create apps, manage channels, settle payments
- [MPP Protocol](https://mpp.dev) — the open standard for machine payments
- [Whitepaper](https://github.com/raycashxyz/mpp/blob/main/WHITEPAPER.md)

## License

MIT
npm package: @raycashxyz/mpp-pay
Description: CLI for making paid API requests via the Machine Payments Protocol
Latest version: 0.1.1

# @raycashxyz/mpp-pay

CLI for making paid API requests via the [Machine Payments Protocol](https://mpp.dev) with [Raycash](https://raycash.xyz) private payments.

## Install

```bash
npm install -g @raycashxyz/mpp-pay
```

Or use directly with `npx`:

```bash
npx @raycashxyz/mpp-pay <url>
```

## Usage

```bash
# Create a signing wallet (first time only — no ETH needed)
mpp-pay --create-wallet

# Make a paid request
mpp-pay "https://your-api.com/endpoint"

# POST with body
mpp-pay "https://your-api.com/endpoint" --method POST --body '{"input":"hello"}'

# Check wallet
mpp-pay --wallet
```

## How It Works

1. You request a paid endpoint → gets `402 Payment Required`
2. `mpp-pay` reads the payment challenge, creates a channel (first time), signs a voucher
3. Retries with payment → returns the response
4. If the channel needs funding, shows the address to send tokens to

The wallet is a local signing key (`~/.mpp-wallet.json`). It never needs gas or on-chain transactions — it only signs payment vouchers off-chain.

## License

MIT
npm package: @raycast/api
Description: Build extensions for Raycast with React and Node.js.
Author: Raycast Technologies Ltd.
Latest version: 1.104.12

<p align="center">
  <img src="https://raw.githubusercontent.com/raycast/extensions/main/images/store-logo.png" height="128">
  <h1 align="center">Raycast Extensions</h1>
</p>

<p align="center">
  <a aria-label="Follow Raycast on Twitter" href="https://twitter.com/raycastapp">
    <img alt="" src="https://img.shields.io/badge/Follow%20@raycastapp-black.svg?style=for-the-badge&logo=Twitter">
  </a>
  <a aria-label="Join the community on Slack" href="https://raycast.com/slack">
    <img alt="" src="https://img.shields.io/badge/Join%20the%20community-black.svg?style=for-the-badge&logo=Slack">
  </a>
</p>

Raycast lets you control your tools with a few keystrokes. The Extensions API allows tailoring Raycast to your needs. List your open pull requests, control your light bulbs at home, or speed up any other everyday task.

![Header](https://raw.githubusercontent.com/raycast/extensions/main/images/header.png)

## Getting Started

Visit [https://developers.raycast.com](https://developers.raycast.com) to get started with our API. And if you want to discover what others have built, check out [our Store](https://raycast.com/store).

## Community

Join our [Slack community](https://raycast.com/community) to share your extension, debug nasty bugs or simply get to know like-minded folks.
npm package: @raycast/eslint-config
Description: ESLint configuration for Raycast extensions
Author: Raycast Technologies Ltd.
Latest version: 2.1.1

# Raycast ESLint Config

Raycast provides by default an opinionated ESLint configuration that includes everything you need to lint your Raycast extensions.

Find more on [developers.raycast.com](https://developers.raycast.com/information/tools/eslint).
npm package: @raycast/eslint-plugin
Description: ESLint plugin designed to help Raycast's extensions authors follow best practices
Author: Raycast Technologies Ltd.
Latest version: 2.1.1

# Raycast ESLint Plugin

Raycast provides a plugin designed to help you follow best practices as you build extensions.

Find more on [developers.raycast.com](https://developers.raycast.com/information/tools/eslint).

## Rules

You'll find below a summary of all the rules included in our ESLint plugin.

<!-- begin auto-generated rules list -->

🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).

| Name                                                     | Description                         | 🔧 |
| :------------------------------------------------------- | :---------------------------------- | :- |
| [prefer-ellipsis](docs/rules/prefer-ellipsis.md)         | Prefer Ellipsis Character           | 🔧 |
| [prefer-placeholders](docs/rules/prefer-placeholders.md) | Prefer Placeholders for Text Fields |    |
| [prefer-title-case](docs/rules/prefer-title-case.md)     | Prefer Title Case                   | 🔧 |

<!-- end auto-generated rules list -->
npm package: @raycast/extract-tools-info
Description: A CLI to extract the information of tools at build time
Author: mathieudutour
Latest version: 0.0.7

# `@raycast/extract-tools-info`

A CLI to extract the information of tools at build time

## Usage

<!-- usage -->

```sh-session
$ npm install -g @raycast/extract-tools-info
$ extract-tools-info --help
Extract tool information from tool source files

USAGE
  $ extract-tools-info  EXTENSION_PATH [-d] [-v]

ARGUMENTS
  EXTENSION_PATH  Path to the extension

FLAGS
  -d, --dry      Print the schemas instead of writing them to the package.json
  -v, --verbose  Print verbose output

DESCRIPTION
  Extract tool information from tool source files

```

## Dev

```sh-session
npm run dev
```
npm package: @raycast/generate-docs
Description: This tool does a few things:
Author: mathieudutour
Latest version: 0.9.5

# @raycast/generate-docs

This tool does a few things:

- Check that all assets are indeed used in the docs
- Check that all links lead somewhere
- Replaces all instances of `<InterfaceTableFromJSDoc name="..." />` by a markdown table generated from the JS Doc
- Replaces all instances of `<PropsTableFromJSDoc component="..." />` by a markdown table generated from the JS Doc

## Usage

```
npx @raycast/generate-docs --docs=PATH/TO/DOCS/FOLDER --types=PATH/TO/TYPES/FILE.d.ts --output=PATH/TO/OUTPUT/FOLDER
```
npm package: @raycast/icons
Description: Icons library for Raycast frontend projects
Author: Raycast Technologies Ltd.
Latest version: 0.4.7

# Raycast Icons

This library contains Raycast Icons exported as React components.

## Getting Started

First, install the library:

```
npm install @raycast/icons
```

Then, import the icons:

```tsx
import { AddPersonIcon, CircleFilledIcon } from "@raycast/icons";

function MyComponent() {
  return (
    <div>
      <AddPersonIcon />
      <CircleFilledIcon />
    </div>
  );
}
```

## Publishing

1. Increase the version in `package.json`
2. Run `npm run build`
3. Run `npm publish`

Make sure you have the correct permissions to publish to the npm registry and is logged in with the account in both the cli and the npm website.
npm package: @raycast/migration
Description: Tool to automate the migration to a newer version of the @raycast/api
Author: mathieudutour
Latest version: 1.103.0

# Automated migrations

Whenever possible, we provide tools to automate the migration to a newer version of the API using [codemods](https://github.com/facebook/jscodeshift).

To run the codemods, run the following command in your extension directory:

```bash
npx @raycast/migration .
```

It will detect the version of the API you were previously using and apply all the migrations that have been available since.

After running it, do go through the updated files and make sure nothing is broken - there are always edge cases.
npm package: @raycast/utils
Description: Set of utilities to streamline building Raycast extensions
Author: Raycast Technologies Ltd.
Latest version: 2.2.3

# Raycast Utilities

In addition to the [Raycast API](https://developers.raycast.com/api-reference/ai) which is bundled as part of the app, we also provide a sibling package that contains a set of utilities to streamline common patterns and operations used in extensions.

![image](https://user-images.githubusercontent.com/3254314/181186048-37bf34c2-a317-4181-8976-2122af6a8506.png)

## Installation

This package can be installed independently using `npm`.

```
npm install --save @raycast/utils
```

[`@raycast/utils`](https://www.npmjs.com/package/@raycast/utils) has a [peer dependency](https://docs.npmjs.com/cli/v8/configuring-npm/package-json#peerdependencies) on [`@raycast/api`](https://www.npmjs.com/package/@raycast/api). This means that a certain version of `@raycast/utils` will require a version above a certain version of `@raycast/api`. `npm` will warn you if that is not the case.

## Documentation

Find the documentation on [developers.raycast.com](https://developers.raycast.com/utilities/getting-started).
npm package: @raycaster/realtime
Description: A client and signaling server for WebRTC
Latest version: 0.2.0

# realtime

> 🚧 Documentation & stable implementation in progress 🚧

A signaling server & web client for WebRTC.

The goal of this library is to absorb some of the complexity of WebRTC, and handle negotiating the connection between two peers, allowing the direct transfer of any arbitrary data between the two peers. This may be well-suited for video chat, game data updates, or other applications that require real-time performance.

It handles this through some of the following:

- Exchanging [`RTCPeerConnection` offers](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/createOffer) between peers.
- Exchanging [`RTCPeerConnection` answers](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/createAnswer) between peers.
- Exchanging [ICE candidates](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/addIceCandidate) between peers.
- Creating [data channels](https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/createDataChannel) to send arbitrary JSON data through the peer connection.

## API

### SignalingEvents
Signaling events are the set of events that `realtime` uses internally for connecting two peers via WebRTC.

The static types for the event types / event payloads are shared across the client and server.

```tsx
enum SignalingEvents {
  Initialize = "Initialize",
  UserConnected = "UserConnected",
  UserDisconnected = "UserDisconnected",
  SendOffer = "SendOffer",
  ReceiveOffer = "ReceiveOffer",
  SendAnswer = "SendAnswer",
  ReceiveAnswer = "ReceiveAnswer",
  SendCandidate = "SendCandidate",
  ReceiveCandidate = "ReceiveCandidate",
}
```

### SignalingServer
The signaling server is responsible for negotiating a `RTCPeerConnection` between 2 clients. Once the peer connection is established, all data is sent between the two clients without the need of the intermediate server.

#### Example
```tsx
import { SignalingServer } from "@raycaster/realtime";
import { createServer } from "http";

// attach the signaling server to the top-level http server
const httpServer = createServer();
const signalingServer = new SignalingServer({ server: httpServer });

httpServer.listen(3000);
```

### RTCClient
The RTC client is meant to be used in the browser, and initiates a connection request through the included signaling server to another peer. Once the connection is established, the two peers are able to send data directly to each other.

#### Example
```tsx
import { RTCClient } from "@raycaster/realtime";

const client = new RTCClient({ url: 'ws://localhost:3000' });
```