open-index/open-npm huggingface dataset:
npm package: @orqusio/mcp-server
Description: Orquscan MCP Server - Query Orqus blockchain data from AI tools
Latest version: 1.0.1

# Orquscan MCP Server

A [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) server that lets AI assistants query blockchain data from the Orqus chain via Orquscan APIs.

## Available Tools

| Tool | Description |
|------|-------------|
| `get_balance` | Get native and token balances for an address |
| `get_address_info` | Get basic info about an address (contract status) |
| `get_address_transactions` | Get recent transactions for an address |
| `get_block` | Get block details by number |
| `get_latest_blocks` | Get most recent blocks |
| `get_transaction` | Get transaction details by hash |
| `get_latest_transactions` | Get most recent transactions |
| `get_token_info` | Get token details or list top tokens |
| `get_token_holders` | Get top holders of a token |
| `get_contract_source` | Get verified contract source code and ABI |
| `get_verified_contracts` | List verified smart contracts |
| `search` | Search for addresses, transactions, blocks, or tokens |
| `get_gas_price` | Get current gas price estimates |
| `get_validators` | Get validator list with status |
| `get_chain_stats` | Get chain overview stats |
| `get_chart_data` | Get historical chart data |

## Setup

```bash
npm install
npm run build
```

## Usage with Claude Code

Add to your Claude Code MCP config (`~/.claude/claude_desktop_config.json` or project `.mcp.json`):

```json
{
  "mcpServers": {
    "orquscan": {
      "command": "node",
      "args": ["/path/to/orquscan-mcp/dist/index.js"],
      "env": {
        "ORQUSCAN_API_URL": "https://api.orquscan.io/api/v2"
      }
    }
  }
}
```

Or if published to npm:

```json
{
  "mcpServers": {
    "orquscan": {
      "command": "npx",
      "args": ["@orqusio/mcp-server"]
    }
  }
}
```

## Usage with Cursor

Add to `.cursor/mcp.json` in your project:

```json
{
  "mcpServers": {
    "orquscan": {
      "command": "node",
      "args": ["/path/to/orquscan-mcp/dist/index.js"]
    }
  }
}
```

## Usage with ChatGPT (SSE transport)

Start the SSE server:

```bash
npm run start:sse
```

Then connect using the SSE endpoint: `http://localhost:3100/sse`

## Docker Deployment

```bash
docker build -t orquscan-mcp .
docker run -p 3100:3100 \
  -e ORQUSCAN_API_URL=https://api.orquscan.io/api/v2 \
  -e ORQUSCAN_CONTRACTS_URL=https://contracts.orquscan.io \
  orquscan-mcp
```

## Environment Variables

| Variable | Default | Description |
|----------|---------|-------------|
| `ORQUSCAN_API_URL` | `https://api.orquscan.io/api/v2` | Base URL for the orqus-stats v2 API |
| `ORQUSCAN_CONTRACTS_URL` | `https://contracts.orquscan.io` | Base URL for the contract verification API |
| `ORQUSCAN_CHAIN_ID` | `153871` | Chain ID for contract verification lookups |
| `PORT` | `3100` | Port for SSE HTTP server |

## Development

```bash
npm run dev     # Run with tsx (hot reload)
npm run build   # Compile TypeScript
npm start       # Run stdio transport
npm run start:sse  # Run SSE HTTP transport
```
npm package: @orrery-io/sdk
Description: TypeScript SDK for [Orrery](https://github.com/orrery-io/orrery) — implement external task workers that integrate with your BPMN processes.
Latest version: 0.1.7

# @orrery-io/sdk

TypeScript SDK for [Orrery](https://github.com/orrery-io/orrery) — implement external task workers that integrate with your BPMN processes.

## Installation

```bash
npm install @orrery-io/sdk
```

## Usage

### Worker (recommended)

The worker handles polling, locking, heartbeats, retries, and graceful shutdown automatically.

```typescript
import { createWorker, subscribe, runWorker } from "@orrery-io/sdk";

const worker = subscribe(
  createWorker({ baseUrl: "http://localhost:3000" }),
  { topic: "send-email" },
  async (task) => {
    await sendEmail(task.variables.to, task.variables.subject);
    return {}; // returned variables are merged into the process instance
  }
);

await runWorker(worker);
```

`runWorker` blocks until `SIGINT` or `SIGTERM`, then drains in-flight tasks before exiting.

### Multiple topics

```typescript
let worker = createWorker({
  baseUrl: "http://localhost:3000",
  workerId: "my-worker",
  concurrency: 8,
  lockDurationMs: 60_000,
});

worker = subscribe(worker, { topic: "send-email" }, handleEmail);
worker = subscribe(worker, { topic: "generate-pdf" }, handlePdf);

await runWorker(worker);
```

### Low-level client

Use `createClient` directly if you need manual control over polling.

```typescript
import { createClient } from "@orrery-io/sdk";

const client = createClient({ baseUrl: "http://localhost:3000" });

const tasks = await client.fetchAndLock({
  workerId: "my-worker",
  subscriptions: [{ topic: "send-email" }],
  maxTasks: 5,
  lockDurationMs: 30_000,
});

for (const task of tasks) {
  try {
    await doWork(task);
    await client.completeTask(task.id, "my-worker", { result: "ok" });
  } catch (err) {
    await client.failTask(task.id, "my-worker", err.message);
  }
}
```

## Configuration

| Option | Default | Description |
|--------|---------|-------------|
| `baseUrl` | `$ORRERY_URL` or `http://localhost:3000` | Orrery server URL |
| `workerId` | `worker-<timestamp>` | Unique worker identifier |
| `concurrency` | `4` | Max tasks processed in parallel |
| `lockDurationMs` | `30000` | How long to hold a task lock |
| `requestTimeoutMs` | `20000` | Long-poll timeout for fetch-and-lock |
npm package: @orria-labs/runtime-citty
Description: Citty CLI adapter for Orria Runtime
Latest version: 1.0.0

# `@orria-labs/runtime-citty`

CLI adapter для `@orria-labs/runtime` поверх `citty`.

- npm: `https://www.npmjs.com/package/@orria-labs/runtime-citty`

## Что поддерживается

- file-based discovery команд из `src/transport/cli/command`
- nested commands и aliases
- `defineCommand(...)`
- adapter-level root command через `createCliAdapter(...)`
- programmatic `run(...)` и `invoke(...)`
- `renderUsage()`, `reload()`, `watch()`, `unwatch()`
- generated типы для canonical command paths и alias paths

## Базовый adapter

```ts
import path from "node:path";
import { createCliAdapter } from "@orria-labs/runtime-citty";

export const cliAdapter = createCliAdapter({
  rootDir: path.resolve(import.meta.dir, "../../.."),
});
```

## Команда

```ts
import { defineCommand } from "@orria-labs/runtime-citty";

export default defineCommand({
  aliases: ["new"],
  meta: {
    description: "Create user through action bus",
  },
  args: {
    email: {
      type: "string",
      required: true,
      description: "User email",
    },
  },
  run: ({ ctx, args }) => ctx.action.user.create({ email: args.email }),
});
```

Контекст command получает:

- `ctx`
- `adapterContext`
- `command`
- `commandPath`
- стандартный `citty` context (`args`, `rawArgs` и т.д.)

## Как строится путь команды

По умолчанию путь выводится из файловой структуры:

- `src/transport/cli/command/system/info.ts` → `system info`
- `src/transport/cli/command/user/create.ts` → `user create`
- `index.ts` в конце пути отбрасывается

Путь можно переопределить через:

- `path: "user/create"`
- `path: ["user", "create"]`
- `name`, если он содержит `/`

Aliases задаются через `aliases` или `meta.aliases`.

## Programmatic вызов

```ts
await app.adapter.cli.run(["user", "create", "--email", "demo@example.com"]);

const result = await app.adapter.cli.invoke([
  "user",
  "new",
  "--email",
  "alias@example.com",
]);
```

После `orria-runtime generate` adapter пишет `src/generated/cli/command-registry.d.ts`, и `run(...)` / `invoke(...)` получают типизацию по discovered paths и aliases.

## Root command

`createCliAdapter(...)` умеет описывать и корневую команду:

- `name`
- `meta`
- `args`
- `setup`
- `cleanup`
- `run`
- `commands`

Это удобно, когда часть команд приходит из файловой структуры, а часть задаётся программно.

## Dev-режим

Adapter поддерживает `reload()`, `watch()` и `unwatch()`. Watch работает через общий polling watcher из core и синхронизирует command tree после изменений файлов.

Подробнее — `../../docs/cli-adapter.md`.
npm package: @orria-labs/runtime-croner
Description: Croner scheduler adapter for Orria Runtime
Latest version: 1.0.0

# `@orria-labs/runtime-croner`

Cron adapter для `@orria-labs/runtime` поверх `croner`.

- npm: `https://www.npmjs.com/package/@orria-labs/runtime-croner`

## Что поддерживается

- file-based discovery schedules из `src/transport/cron/schedules`
- `defineCron(...)`
- workflow targets через string key, `workflowRef(...)` и `workflowTarget(...)`
- `start()`, `stop()`, `reload()`, `watch()`, `unwatch()`
- `trigger(name)` с типизацией discovered schedule names
- execution metadata и состояние последних запусков

## Базовый adapter

```ts
import path from "node:path";
import { createCronAdapter } from "@orria-labs/runtime-croner";

export const cronAdapter = createCronAdapter({
  rootDir: path.resolve(import.meta.dir, "../../.."),
});
```

## Schedule

```ts
import { defineCron, workflowTarget } from "@orria-labs/runtime-croner";

export default defineCron<GeneratedBusTypes>({
  name: "user.replay-registration",
  schedule: "0 * * * *",
  target: workflowTarget<GeneratedBusTypes>(
    "workflow.user.registration",
    () => ({
      userId: "scheduled_user",
      email: "cron@example.com",
    }),
  ),
  options: {
    timezone: "UTC",
    paused: true,
  },
});
```

## Target-варианты

`target` может быть:

- функцией `(executionContext) => ...`
- string workflow key, например `"workflow.user.registration"`
- `workflowRef(...)`
- `workflowTarget(...)`

В workflow adapter автоматически прокидывает meta:

- `source: "cron:<schedule-name>"`
- `cronName`
- `cronSource`
- `cronRunId`
- `cronTriggeredAt`

## Runtime API

```ts
await app.adapter.cron.start();
await app.adapter.cron.trigger("user.replay-registration");

app.adapter.cron.jobs["user.replay-registration"].lastExecution;
```

Каждый `job controller` даёт:

- `name`
- `schedule`
- `running`
- `nextRunAt`
- `lastExecution`
- `stop()`
- `trigger(source?)`

## Codegen

После `orria-runtime generate` adapter пишет `src/generated/cron/schedule-registry.d.ts`, поэтому `trigger(name)` и связанные literal names получают типизацию.

## Dev-режим

Adapter поддерживает `reload()`, `watch()` и `unwatch()`. При reload пересобирается список schedules, валидируются workflow targets и при необходимости заново поднимаются runtime jobs.

Подробнее — `../../docs/cron-adapter.md`.