@vapi-network/cli 0.3.0 → 0.5.0

package/dist/login.d.ts

@@ -0,0 +1,8 @@
+import { type CliDependencies, type CliIo } from "./cli.js";
+export declare function loginCommand(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies): Promise<void>;
+/** Shared device-link flow used by `vapi login` and `vapi agent create`. */
+export declare function runLoginFlow(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies, options?: {
+    routerAllowanceUsd?: number;
+}): Promise<void>;
+export declare function logoutCommand(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies): Promise<void>;
+export declare function whoamiCommand(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies): Promise<void>;

package/dist/publish-client.d.ts

@@ -0,0 +1,193 @@
+/**
+ * The registry's listing write API, as seen from one person's terminal.
+ *
+ * Everything else in this client reads the registry without an account. Listing
+ * an API is the one thing that writes, so it is the one thing that carries a
+ * bearer credential and a wallet signature. It lives in the CLI package rather
+ * than in a source adapter because it is not discovery: there is no MCP tool,
+ * and the only caller is the CLI.
+ *
+ * Every response is returned exactly as the registry sent it, so `--json` can
+ * hand it on untouched and an unknown field is carried rather than dropped. The
+ * readers below only look for what the human output needs.
+ */
+import type { Address } from "viem";
+/** The categories the registry's listing form accepts. */
+export declare const LISTING_CATEGORIES: readonly ["ai", "data", "crypto", "compute", "search"];
+export type ListingCategory = (typeof LISTING_CATEGORIES)[number];
+/** How the registry should read the URL it was handed. Left out, it decides. */
+export declare const PROBE_MODES: readonly ["origin", "endpoint", "openapi"];
+export type ProbeMode = (typeof PROBE_MODES)[number];
+/** The states `vapi publish` can ask a listing to move to. */
+export type ListingStatusAction = "activate" | "request_verification" | "suspend";
+/** Payouts settle in USDC on Base, so the payout signature is bound to Base. */
+export declare const PAYOUT_CHAIN_ID: "eip155:8453";
+/**
+ * The sentence the provider signs. It is not a login: it says which wallet the
+ * registry should pay, and it is the only thing this command ever signs.
+ */
+export declare const PAYOUT_STATEMENT = "Confirm this wallet receives vAPI Call payouts";
+/** The sentence a claim message states, completed with the origin being claimed. */
+export declare const CLAIM_STATEMENT_PREFIX = "Claim the vAPI Call listings served from";
+/** Where a person creates the key this client authenticates with. */
+export declare const API_KEY_CONSOLE_PATH = "/account";
+/** One candidate endpoint the probe found behind the URL it was given. */
+export type ProbeOperation = Readonly<{
+    name: string;
+    method?: string;
+    url?: string;
+    description?: string;
+    operationId?: string;
+    requestContentType?: string;
+    requestSchema?: unknown;
+    responseContentType?: string;
+    pathTemplate?: string;
+    pathParameters?: unknown;
+}> & Readonly<Record<string, unknown>>;
+/** Why the registry will not list this URL, in the registry's own words. */
+export type ProbeRejection = Readonly<{
+    code?: string;
+    message?: string;
+    hint?: string;
+}> & Readonly<Record<string, unknown>>;
+/** The console's `VendorProbeResult`, read tolerantly. */
+export type ProbeResult = Readonly<{
+    operations?: readonly ProbeOperation[];
+    accepts?: readonly unknown[];
+    diagnostics?: Readonly<{
+        steps?: readonly unknown[];
+        rejection?: ProbeRejection | null;
+    }>;
+}> & Readonly<Record<string, unknown>>;
+export type PayoutNonce = Readonly<{
+    nonce: string;
+    message?: string;
+}> & Readonly<Record<string, unknown>>;
+export type SplitterNetworkState = Readonly<{
+    network?: string;
+    name?: string;
+    chainId?: number;
+    factoryAddress?: string;
+    splitterAddress?: string;
+    deployed?: boolean;
+    balanceWei?: string;
+}> & Readonly<Record<string, unknown>>;
+export type SplitterStates = Readonly<{
+    networkStates?: readonly SplitterNetworkState[];
+    feeBp?: number;
+}> & Readonly<Record<string, unknown>>;
+export type ListingEndpointInput = {
+    name: string;
+    method: string;
+    url: string;
+    description: string;
+    operationId?: string;
+    requestContentType?: string;
+    requestSchema?: unknown;
+    responseContentType?: string;
+    pathTemplate?: string;
+    pathParameters?: unknown;
+};
+export type CreateListingInput = {
+    name: string;
+    description: string;
+    category: ListingCategory;
+    endpoints: ListingEndpointInput[];
+    payoutWallet: string;
+    siweMessage: string;
+    signature: string;
+};
+export type CreatedListing = Readonly<{
+    ok?: boolean;
+    listing?: Readonly<{
+        slug?: string;
+        status?: string;
+        verification?: string;
+    }> & Readonly<Record<string, unknown>>;
+}> & Readonly<Record<string, unknown>>;
+export type ListingStatusResult = Readonly<{
+    ok?: boolean;
+    status?: string;
+    verification?: string;
+}> & Readonly<Record<string, unknown>>;
+export type MyListings = Readonly<{
+    listings?: readonly unknown[];
+}> & Readonly<Record<string, unknown>>;
+export type ClaimNonce = Readonly<{
+    message?: string;
+}> & Readonly<Record<string, unknown>>;
+export type ClaimInput = {
+    origin: string;
+    message: string;
+    signature: string;
+};
+export type ClaimResult = Readonly<{
+    claimed?: readonly unknown[];
+}> & Readonly<Record<string, unknown>>;
+/**
+ * A refusal from the registry, already turned into the sentence a person
+ * should read. The status is kept so a caller can tell a rejection from an
+ * outage without parsing the message.
+ */
+export declare class RegistryApiError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+export type ListingsClientOptions = {
+    /** The registry base URL, with any mount prefix it carries. */
+    baseUrl: string;
+    /** The `vapi_sk_…` key, sent as a bearer token and never logged. */
+    apiKey?: string;
+    /** A caller that adds and refreshes its own bearer credential. */
+    authenticatedFetch?: typeof fetch;
+    fetchImpl?: typeof fetch;
+    allowPrivateNetwork?: boolean;
+};
+export type ListingsClient = {
+    readonly baseUrl: string;
+    probe(input: {
+        url: string;
+        method?: string;
+        mode?: ProbeMode;
+    }): Promise<ProbeResult>;
+    payoutNonce(wallet: string): Promise<PayoutNonce>;
+    splitters(wallet: string): Promise<SplitterStates>;
+    create(input: CreateListingInput): Promise<CreatedListing>;
+    status(slug: string, action: ListingStatusAction): Promise<ListingStatusResult>;
+    mine(): Promise<MyListings>;
+    claimNonce(origin: string, wallet: string): Promise<ClaimNonce>;
+    claim(input: ClaimInput): Promise<ClaimResult>;
+};
+/** Appends one absolute path to the registry base, keeping any mount prefix. */
+export declare function listingsUrl(baseUrl: string, path: string): URL;
+export declare function createListingsClient(options: ListingsClientOptions): ListingsClient;
+/**
+ * Refuses to sign a claim message that is not the one the claim contract
+ * describes: an EIP-4361 message from this registry's host, for this wallet,
+ * on Base, stating the origin being claimed. The registry writes the message,
+ * so this is the line that keeps a wallet from signing anything else it sends.
+ */
+export declare function assertClaimMessage(message: string, expected: {
+    baseUrl: string;
+    origin: string;
+    address: Address;
+}): void;
+/**
+ * The canonical EIP-4361 message a provider signs to name their payout wallet.
+ * The registry may send its own `message`, in which case that one is signed
+ * verbatim; this is what the client builds when it does not, so the two sides
+ * agree byte for byte.
+ */
+export declare function buildPayoutSiweMessage(args: {
+    baseUrl: string;
+    address: Address;
+    nonce: string;
+    issuedAt: string;
+}): string;
+/** The operations a probe found, normalized to the fields a listing needs. */
+export declare function readProbeOperations(probe: ProbeResult): ProbeOperation[];
+/** The rejection a probe carries, or undefined when the URL passed. */
+export declare function readProbeRejection(probe: ProbeResult): ProbeRejection | undefined;
+/** One line per probe step, whatever shape the registry sends them in. */
+export declare function formatProbeSteps(probe: ProbeResult): string[];

package/dist/router.d.ts

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

package/dist/stake.d.ts

@@ -0,0 +1,3 @@
+import { type CliDependencies, type CliIo } from "./cli.js";
+export declare const STAKE_URL = "https://api.vapinetwork.ai/stake";
+export declare function stakeCommand(argv: string[], json: boolean, io: CliIo, dependencies: CliDependencies): Promise<void>;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "0.3.0";
+export declare const CLI_VERSION = "0.5.0";

package/package.json

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