@vapi-network/cli 0.7.0 → 0.9.0

package/dist/runtime-local.d.ts

@@ -0,0 +1,40 @@
+import { type ChildProcess } from "node:child_process";
+import { type Runtime, type RuntimeKind } from "@vapi-network/mcp";
+import { type CliDependencies } from "./cli.js";
+import { type RailwayRuntimeOptions } from "./runtime-railway.js";
+type Spawn = (command: string, args: readonly string[], options: {
+    detached: true;
+    stdio: ["ignore", number, number];
+    env: NodeJS.ProcessEnv;
+    windowsHide: true;
+}) => Pick<ChildProcess, "pid" | "unref">;
+export type LocalRuntimeOptions = {
+    home: string;
+    entry?: string;
+    execPath?: string;
+    env?: NodeJS.ProcessEnv;
+    spawn?: Spawn;
+    kill?: (pid: number, signal: NodeJS.Signals | 0) => void;
+    /** Full command line of a live process, or undefined when there is none. */
+    processCommand?: (pid: number) => string | undefined;
+    openLog?: (path: string) => number;
+    closeFd?: (fd: number) => void;
+    readFile?: (path: string, encoding: "utf8") => Promise<string>;
+    now?: () => Date;
+};
+export declare function createLocalRuntime(options: LocalRuntimeOptions): Runtime;
+/** What one start asks of a remote runtime. Status, list and stop need none of it. */
+export type RuntimeRequest = {
+    checkpoint?: string;
+    allowRemoteKey?: boolean;
+    keepSandbox?: boolean;
+    /** The member accounts the owner confirmed; a railway start refuses any other. */
+    confirmedMembers?: readonly string[];
+};
+export type RuntimeOptions = LocalRuntimeOptions & {
+    railway?: Omit<RailwayRuntimeOptions, "home">;
+};
+export declare function runtimeForKind(kind: RuntimeKind, options: RuntimeOptions): Runtime;
+export declare function resolveRuntime(kind: RuntimeKind, home: string, dependencies: CliDependencies, request?: RuntimeRequest): Runtime;
+export declare function parseRuntimeKind(value: string | undefined): RuntimeKind;
+export {};

package/dist/runtime-railway.d.ts

@@ -0,0 +1,198 @@
+import { WalletStore, type AgentProfile, type SecretStore, type SwarmBalanceReader, type SwarmFile, type SwarmMember, type VapiConfig } from "@vapi-network/core";
+import { type Runtime, type RuntimeMember, type RuntimeRun } from "@vapi-network/mcp";
+/**
+ * The experimental `railway` runtime: one swarm member runs `vapi agent run
+ * --bundle-env` inside a Railway sandbox booted from a checkpoint that has the
+ * vAPI CLI preinstalled.
+ *
+ * Only that member's own private key and its own link credentials leave this
+ * machine, inside a member bundle passed through `--env-file`. Never the
+ * recovery phrase, never the treasury, never another account. vAPI never reads
+ * or stores Railway tokens: the `railway` CLI uses whatever it is logged into
+ * (or `RAILWAY_API_TOKEN`).
+ */
+/**
+ * Every `railway` invocation this adapter makes, in one place so flags are
+ * easy to correct. Measured against Railway CLI 5.30.1; `--json` on `create`
+ * is assumed. `create` may return while the sandbox is still booting, so the
+ * adapter runs `readyCommand` until it succeeds before the detached run.
+ */
+export declare const RAILWAY_CLI: {
+    readonly binary: "railway";
+    readonly create: (options: {
+        checkpoint: string;
+        envFile: string;
+        idleTimeoutMinutes: number;
+    }) => string[];
+    readonly exec: (id: string, command: readonly string[], detach: boolean) => string[];
+    readonly destroy: (id: string) => string[];
+    readonly readyCommand: readonly ["true"];
+    readonly resultPath: "/tmp/vapi-result.json";
+    readonly bundleVariable: "VAPI_MEMBER_BUNDLE";
+};
+/** The largest target a member running on Railway may hold: 1.00 USDC. */
+export declare const REMOTE_MAX_TARGET_ATOMIC = 1000000n;
+/** The largest effective ceiling a member running on Railway may hold: 2.00 USDC. */
+export declare const REMOTE_MAX_CEILING_ATOMIC = 2000000n;
+export declare const DEFAULT_RAILWAY_IDLE_TIMEOUT_MINUTES = 30;
+/** How often the adapter asks a new sandbox whether it runs yet: 20 × 1.5 s, about 30 s. */
+export declare const DEFAULT_RAILWAY_READY_ATTEMPTS = 20;
+export declare const DEFAULT_RAILWAY_READY_INTERVAL_MS = 1500;
+/** How long a SIGINT/SIGTERM during `start` waits for the sandbox destroy before re-raising. */
+export declare const DEFAULT_RAILWAY_SIGNAL_DESTROY_TIMEOUT_MS = 5000;
+/** A checkpoint name: 1-64 characters, a letter or digit first, so it never reads as an option. */
+export declare const RAILWAY_CHECKPOINT_PATTERN: RegExp;
+export declare const RAILWAY_CHECKPOINT_RULE = "1-64 letters, digits, '.', '_' or '-', starting with a letter or digit";
+export type RailwayExecResult = {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+};
+export type RailwayExec = (file: string, args: readonly string[]) => Promise<RailwayExecResult>;
+/**
+ * Runs one process with stdin closed and this process's environment, so the
+ * `railway` CLI authenticates however it is set up here. It rejects only when
+ * the binary cannot be started at all.
+ */
+export declare const defaultRailwayExec: RailwayExec;
+/** Reads the sandbox id from `railway sandbox create --json` output. Never echoes the output. */
+export declare function parseSandboxId(stdout: string): string;
+export type RemoteKeyRefusalCode = "not_in_swarm" | "swarm_treasury" | "not_a_member" | "lead_mode" | "target_too_high" | "ceiling_too_high" | "ceiling_disabled" | "remote_key_not_allowed" | "agent_marker" | "balance_too_high" | "balance_on_other_network" | "balance_unreadable" | "authorization_unresolved" | "no_daily_allowance" | "unsafe_config" | "unsupported_network" | "member_not_confirmed";
+/** A member that may not run on a remote sandbox. The message says how to fix it. */
+export declare class RemoteKeyRefusedError extends Error {
+    readonly code: RemoteKeyRefusalCode;
+    readonly name = "RemoteKeyRefusedError";
+    constructor(code: RemoteKeyRefusalCode, message: string);
+}
+export type RemoteSafeMember = {
+    swarm: SwarmFile;
+    swarmMember: SwarmMember;
+    /** The configured ceiling; never null for a remote-safe member. */
+    ceilingAtomic: bigint;
+    effectiveCeilingAtomic: bigint;
+};
+/**
+ * Refuses, before any key is read, every member whose key may not leave this
+ * machine: accounts outside a swarm, a swarm treasury, non-members, lead runs,
+ * a target above 1.00 USDC, an effective ceiling above 2.00 USDC or disabled,
+ * and any run without an explicit `allowRemoteKey`.
+ */
+export declare function assertRemoteSafeMember(args: {
+    home: string;
+    member: RuntimeMember;
+    mode: RuntimeRun["mode"];
+    store: Pick<WalletStore, "ceilingCaps" | "ceilingSweepPending">;
+    allowRemoteKey?: boolean;
+    readSwarm?: (home: string, name: string) => Promise<SwarmFile>;
+}): Promise<RemoteSafeMember>;
+export type RailwayRuntimeFs = {
+    mkdtemp: (prefix: string) => Promise<string>;
+    writeFile: (path: string, data: string, options: {
+        encoding: "utf8";
+        mode: number;
+        flag: "wx";
+    }) => Promise<void>;
+    rm: (path: string, options: {
+        recursive: true;
+        force: true;
+    }) => Promise<void>;
+    stat: (path: string) => Promise<{
+        mode: number;
+    }>;
+};
+export type RailwayRuntimeOptions = {
+    home: string;
+    store?: WalletStore | (() => Promise<WalletStore>);
+    vaultKey?: () => Promise<{
+        path: string;
+        key: Uint8Array;
+    }>;
+    secrets?: SecretStore;
+    checkpoint?: string;
+    idleTimeoutMinutes?: number;
+    allowRemoteKey?: boolean;
+    /**
+     * The member accounts the owner confirmed for this run. `start` refuses any
+     * other member, and every member when the set is missing.
+     */
+    confirmedMembers?: readonly string[];
+    keepSandbox?: boolean;
+    exec?: RailwayExec;
+    fs?: Partial<RailwayRuntimeFs>;
+    /** Parent directory of the temporary env-file directory. Defaults to `os.tmpdir()`. */
+    tmpdir?: string;
+    readProfile?: (name: string) => Promise<AgentProfile>;
+    readSwarm?: (home: string, name: string) => Promise<SwarmFile>;
+    /** The owner's local config. Only network ids, USDC and discovery URLs reach a bundle. */
+    config?: () => Promise<VapiConfig>;
+    /**
+     * Reads a member's live USDC balance before its key is exported. Defaults to
+     * an RPC read on the swarm network through the owner's local config.
+     */
+    balanceReader?: SwarmBalanceReader;
+    /** The fetch the default balance reader uses. */
+    fetchImpl?: typeof fetch;
+    now?: () => Date;
+    tty?: boolean;
+    /**
+     * An environment checked for `VAPI_NO_SECRETS` and the agent markers, which
+     * refuse a key export exactly as they refuse `vapi export-key`. `process.env`
+     * is always checked as well, so an injected clean environment cannot lift a
+     * marker this process runs under.
+     */
+    env?: NodeJS.ProcessEnv;
+    /** Readiness probes after `sandbox create`. Defaults to {@link DEFAULT_RAILWAY_READY_ATTEMPTS}. */
+    readyAttempts?: number;
+    readyIntervalMs?: number;
+    sleep?: (milliseconds: number) => Promise<void>;
+    /**
+     * How long a SIGINT/SIGTERM during `start` waits for `sandbox destroy`
+     * before it re-raises. Defaults to {@link DEFAULT_RAILWAY_SIGNAL_DESTROY_TIMEOUT_MS}.
+     */
+    signalDestroyTimeoutMs?: number;
+};
+/**
+ * What this machine knows about a run's sandbox, at `<home>/runs/<runId>.railway.json`
+ * (0600). Written before `sandbox create`, so a sandbox holding a member key is
+ * never untracked: `creating` (no id yet, or create failed unclearly), `running`,
+ * `orphaned` (a destroy failed or was interrupted) or `kept` (finished with
+ * keepSandbox). No key, bundle or credential is ever in it.
+ */
+export type RailwaySidecar = {
+    v: 1;
+    runId: string;
+    account: string;
+    swarm: string;
+    state: "creating" | "running" | "orphaned" | "kept";
+    sandboxId?: string;
+    checkpoint: string;
+    keepSandbox: boolean;
+};
+export declare function railwaySidecarPath(home: string, runId: string): string;
+export declare function createRailwayRuntime(options: RailwayRuntimeOptions): Runtime;
+/**
+ * Every sidecar in `<home>/runs/`, including the 0.6 pre-release shape (read
+ * as `running`). Unreadable or invalid files are skipped.
+ */
+export declare function listRailwaySidecars(home: string): Promise<RailwaySidecar[]>;
+/**
+ * Destroys the sandbox a sidecar names and deletes the sidecar. Without a
+ * sandbox id, or when the destroy fails, the sidecar stays (`orphaned` after a
+ * failed destroy) and `error` tells the owner the exact `railway` command.
+ */
+export declare function destroyRailwaySidecar(home: string, runId: string, options?: {
+    exec?: RailwayExec;
+}): Promise<{
+    runId: string;
+    sandboxId?: string;
+    destroyed: boolean;
+    error?: string;
+}>;
+export declare function assertRemoteBalance(args: Parameters<SwarmBalanceReader>[0] & {
+    swarm: string;
+    readBalance: SwarmBalanceReader;
+}): Promise<void>;
+/** The default balance reader: an RPC read through the owner's local network config. */
+export declare function ownerBalanceReader(config: VapiConfig, fetchImpl: typeof fetch | undefined): SwarmBalanceReader;
+/** Why a key export was refused in an agent or locked-down environment. */
+export declare function agentMarkerRefusal(marker: string): RemoteKeyRefusedError;

package/dist/swarm.d.ts

@@ -0,0 +1,2 @@
+import { type CliDependencies, type CliIo } from "./cli.js";
+export declare function swarmCommand(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies): Promise<number>;

package/dist/task.d.ts

@@ -0,0 +1,36 @@
+import { type TasksChain, type TasksClient, type TasksClientOptions, type PendingTransactions, type UploadFileInput } from "@vapi-network/core/tasks";
+import { parseArguments, type CliDependencies, type CliIo, type WalletTarget } from "./cli.js";
+export type TasksCommandDependencies = {
+    client?: TasksClient | ((options: TasksClientOptions) => TasksClient);
+    chain?: TasksChain;
+    sleep?: (milliseconds: number) => Promise<void>;
+    randomUUID?: () => string;
+};
+export declare const TASK_HELP = "Usage:\n  vapi task search [--open] [--min <usd>] [--tab trending|new|closing|paid] [--limit <n>] [--json]\n  vapi task show <id> [--account <name>] [--json]\n  vapi task post --title <text> --brief <file|-> --amount <usd> --deadline <duration|ISO> [--intake proposals|submissions] [--max-awards <k>] [--webhook <https-url>] [--account <name>] [--json]\n  vapi task propose <id> --price <usd> --duration <duration> --note <text> [--account <name>] [--json]\n  vapi task submit <id> --proof <https-url> [--proof <https-url>...] [--file <path>...] [--account <name>] [--json]\n  vapi task award <id> <proposalId> [--account <name>] [--json]\n  vapi task sign <id> [--yes] [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task fund <id> [--yes] [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task deliver <id> --files <path...> --note <text> [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task release <id> [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task refund <id> [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task dispute <id> --evidence-hash <0x + 64 hex> [--yes] [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task counter-evidence <id> --evidence-hash <0x + 64 hex> [--yes] [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task resolve-unmatched <id> [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task message <id> <text> [--account <name>] [--json]\n  vapi task thread <id> [--after <cursor>] [--account <name>] [--json]\n  vapi task watch <id> [--until <state>] [--auto-release] [--timeout 7d] [--interval 5s] [--counterparty <0x\u2026>] [--account <name>] [--json]\n  vapi task status <id> [--account <name>] [--json]\n\nDurations: 5s, 10m, 48h, 7d, or an ISO-8601 timestamp. Posting and proposal terms require at least 10 minutes.\nDispute accepts a precomputed evidence hash only; evidence-file hashing is still undecided upstream.\nWatch requires an interval of at least 1s and a positive timeout. Auto-release uses the acting wallet's agent profile, or defaults, and releases only amounts strictly below the threshold.\nPosting a task moves no money. Task reads require tasks:read and writes require tasks:write; write access includes reads.\nThe thread cursor is the previous page's nextBeforeSeq; --after reads older messages using beforeSeq.\nEvery command accepts --json. Watch and a partially completed sign may write more than one JSON value. Human diagnostics go to stderr.\n\nExit codes:\n  0  ok\n  1  error, including invalid usage, unavailable routes and chain failures\n  2  policy refusal only (JSON ok:false with reason policy.perTask or policy.perDay)\n  3  approval needed in non-interactive mode\n\nFund, deliver, release, refund, dispute, counter-evidence, resolve-unmatched and watch auto-release sign with the local vault wallet. The CLI waits for two confirmations and records pending transactions for recovery. It never retries a chain mutation automatically.";
+type Parsed = ReturnType<typeof parseArguments>;
+type TaskRoute = keyof TasksClient;
+export declare class TaskCommandError extends Error {
+    readonly code: string;
+    readonly manifestHash?: `0x${string}` | undefined;
+    constructor(code: string, message: string, manifestHash?: `0x${string}` | undefined);
+}
+/** Relative milliseconds; timestamps are measured from the supplied clock. */
+export declare function parseTaskDuration(text: string, now: Date): number;
+export type TaskContext = {
+    client: TasksClient;
+    chain: TasksChain;
+    pending?: PendingTransactions;
+    baseUrl: string;
+    target?: WalletTarget;
+    token?: string;
+    randomUUID: () => string;
+    sleep: (milliseconds: number) => Promise<void>;
+    signInHint: string;
+};
+/** Reuses wallet selection, registry configuration and device-link credentials. */
+export declare function taskContext(parsed: Parsed, io: CliIo, dependencies: CliDependencies, publicOnly?: boolean): Promise<TaskContext>;
+export declare function taskRequest<T>(verb: string, route: TaskRoute, operation: () => Promise<T>): Promise<T>;
+export declare function taskOutput(io: CliIo, json: boolean, context: TaskContext, verb: string, value: object, lines: string[]): void;
+export declare function taskCommand(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies): Promise<number | undefined>;
+export declare function readTaskFile(path: string): Promise<UploadFileInput>;
+export {};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "0.7.0";
+export declare const CLI_VERSION = "0.9.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vapi-network/cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Command-line interface for the non-custodial vAPI Network wallet",
   "license": "Apache-2.0",
   "repository": {