@typeship-ax/mcp 0.6.0

package/dist/mcp.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/** Fetch-style handler: mount in any runtime (workers, serverless, node).
+ * Never rejects: every failure is an HTTP or JSON-RPC error response. */
+export declare function handleHttp(request: Request): Promise<Response>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":";AA2SA;yEACyE;AACzE,wBAAsB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsDpE"}

package/dist/mcp.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+// typeship — MCP server. Generated by typeship — https://typeship.dev
+// Speaks MCP 2026-07-28 (stateless: per-request _meta, server/discover; no
+// initialize handshake, no sessions); the protocol layer and tool surface
+// live in ./mcp-protocol.js, shared with typeship's hosted endpoint. Two
+// transports, zero dependencies:
+//   node mcp.js            stdio (newline-delimited JSON-RPC 2.0)
+//   node mcp.js --http     Streamable HTTP on PORT (default 3000)
+// Surface switches (flags or environment):
+//   --read-only / TYPESHIP_MCP_READ_ONLY=1     reads only; writes are not callable
+//   --tools a,b / TYPESHIP_MCP_TOOLS=a,b       only these resources or tools
+//   TYPESHIP_MCP_MAX_RESULT_CHARS=<n>          result size cap (default 64000)
+// handleHttp() is exported for serverless/worker runtimes.
+// In HTTP mode an incoming Authorization header is forwarded to the
+// upstream API (per-request passthrough); stdio resolves auth from the
+// environment, then from credentials/config saved by the CLI's `login`
+// and `config` commands (same files, so one login covers both bins).
+import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TypeshipClient, formatDebugEvent } from "./index.js";
+import { GLOBALS, OPS, buildArgs } from "./ops.js";
+import { DEFAULT_MAX_RESULT_CHARS, SUPPORTED_PROTOCOL_VERSIONS, argumentsError, asJsonRpc, binaryOutcome, callSharedTool, checkRequestHeaders, dataOutcome, errorOutcome, fetchDocsText, handleRpc, isRpcOutcome, pageOutcome, parseIncludeList, prepareCall, serverInstructions, takeCancelled, textError, toolDefinitions, visibleOps, } from "./mcp-protocol.js";
+const BIN = "typeship";
+const PKG_NAME = "@typeship-ax/mcp";
+const SERVER_NAME = "typeship-mcp";
+const SERVER_VERSION = "0.6.0";
+/** The MCP client's announced name (clientInfo in request _meta), for the User-Agent. */
+let MCP_CLIENT_NAME = null;
+function noteClientInfo(message) {
+    const meta = message?.params?._meta;
+    const name = meta?.["io.modelcontextprotocol/clientInfo"]?.name;
+    if (typeof name === "string" && name && name !== MCP_CLIENT_NAME) {
+        MCP_CLIENT_NAME = name.slice(0, 60);
+        clientInstance = undefined;
+    }
+}
+const DEFAULT_BASE_URL = "https://typeship.dev/api/v1";
+const AUTH_SCALARS = [{ "option": "bearerToken", "flag": "token", "env": "TYPESHIP_TOKEN" }];
+const BASIC = null;
+const OAUTH_TOKEN_URL = null;
+const ENVIRONMENTS = {};
+const DOCS_URL_DEFAULT = "https://typeship.dev";
+/** "meta" collapses per-operation tools into search/read/execute so huge
+ * APIs don't flood agent context with hundreds of tools. */
+const TOOL_MODE = "meta";
+/** Authorization server for OAuth discovery (RFC 9728), from the spec. */
+const OAUTH_ISSUER = null;
+/** Project-supplied guidance appended to the server instructions. */
+const CUSTOM_INSTRUCTIONS = null;
+/** The tool that returns the caller (the CLI's whoami target), named in the instructions. */
+const IDENTITY_TOOL = "account_retrieve";
+/** Surface switches: reads only, and/or a subset of resources or tools.
+ * Flags win over the environment. */
+const ARGV = process.argv.slice(2);
+const READ_ONLY = ARGV.includes("--read-only") || process.env["TYPESHIP_MCP_READ_ONLY"] === "1" || process.env["TYPESHIP_MCP_READ_ONLY"] === "true";
+const INCLUDE = parseIncludeList(ARGV.includes("--tools") ? ARGV[ARGV.indexOf("--tools") + 1] : process.env["TYPESHIP_MCP_TOOLS"]);
+const MAX_RESULT_CHARS = Number(process.env["TYPESHIP_MCP_MAX_RESULT_CHARS"]) || DEFAULT_MAX_RESULT_CHARS;
+/** One sentence on where credentials come from on each transport; goes
+ * into the instructions and into 401 results. */
+const AUTH_HINT_STDIO = "Credentials come from the MCP server's environment (TYPESHIP_TOKEN) or from 'typeship login'";
+const AUTH_HINT_HTTP = "Send the API credential as the Authorization header of each MCP request; it is forwarded to the API as is";
+/** The tool list is fixed at generation, so clients may cache it for an
+ * hour and shared caches may hold it (identical for every caller). */
+const TOOLS_TTL_MS = 60 * 60 * 1000;
+function configDir() {
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), BIN);
+}
+function readJson(file) {
+    try {
+        return JSON.parse(readFileSync(join(configDir(), file), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function makeClient() {
+    const stored = readJson("credentials.json");
+    const config = readJson("config.json");
+    const options = {};
+    const baseUrl = process.env["TYPESHIP_BASE_URL"]
+        ?? config?.baseUrl
+        ?? (config?.environment !== undefined ? ENVIRONMENTS[config.environment] : undefined)
+        ?? DEFAULT_BASE_URL ?? undefined;
+    if (baseUrl === undefined) {
+        // Thrown, not exited: the agent gets an isError result naming the fix
+        // instead of a server that vanished mid-conversation.
+        throw new Error("No base URL configured: set TYPESHIP_BASE_URL in the MCP server's environment, or run '" + BIN + " config set base-url <url>'.");
+    }
+    options.baseUrl = baseUrl;
+    for (const a of AUTH_SCALARS) {
+        const v = process.env[a.env] ?? stored?.scalars?.[a.option];
+        if (v !== undefined)
+            options[a.option] = v;
+    }
+    if (BASIC) {
+        const username = process.env[BASIC.envUser] ?? stored?.basic?.username;
+        const password = process.env[BASIC.envPass] ?? stored?.basic?.password;
+        if (username !== undefined && password !== undefined)
+            options.basicAuth = { username, password };
+    }
+    const oauthClientId = process.env["TYPESHIP_CLIENT_ID"];
+    const oauthClientSecret = process.env["TYPESHIP_CLIENT_SECRET"];
+    if ((oauthClientId === undefined) !== (oauthClientSecret === undefined)) {
+        throw new Error("OAuth client credentials are incomplete: set both TYPESHIP_CLIENT_ID and TYPESHIP_CLIENT_SECRET in the MCP server's environment.");
+    }
+    if (oauthClientId !== undefined && oauthClientSecret !== undefined) {
+        const tokenUrl = process.env["TYPESHIP_TOKEN_URL"] ?? OAUTH_TOKEN_URL ?? undefined;
+        if (!tokenUrl)
+            throw new Error("OAuth client credentials need a token URL: set TYPESHIP_TOKEN_URL in the MCP server's environment.");
+        options.clientCredentials = { clientId: oauthClientId, clientSecret: oauthClientSecret, tokenUrl };
+    }
+    if (options.bearerToken === undefined && stored?.oauth?.accessToken !== undefined) {
+        options.bearerToken = stored.oauth.accessToken;
+    }
+    for (const g of GLOBALS) {
+        const value = process.env["TYPESHIP_" + g.envSuffix];
+        if (value !== undefined)
+            options[g.option] = value;
+    }
+    if (process.env["TYPESHIP_DEBUG"] === "1") {
+        options.debug = (event) => process.stderr.write(formatDebugEvent(BIN + "-mcp", event) + "\n");
+    }
+    // The local MCP server identifies itself (surface + the client it serves, when announced).
+    options.defaultHeaders = { "User-Agent": PKG_NAME + "-mcp/" + SERVER_VERSION + " (typeship" + (MCP_CLIENT_NAME ? "; client=" + MCP_CLIENT_NAME : "") + ")" };
+    return new TypeshipClient(options);
+}
+let clientInstance;
+function getClient() {
+    return (clientInstance ??= makeClient());
+}
+/** Run one operation through the generated SDK: the same client, the same
+ * typed errors and pagination a hand-written caller would get. */
+async function callOperation(op, rawArgs, authHeader) {
+    // Arguments are checked against the tool's schema first: unknown names,
+    // wrong types and missing requirements come back as one isError result,
+    // nothing reaches the API half-formed and nothing is dropped silently.
+    const prepared = prepareCall(op, rawArgs, { maxChars: MAX_RESULT_CHARS });
+    if (!prepared.ok)
+        return prepared.outcome;
+    const { args, fields, maxChars } = prepared.call;
+    const values = {};
+    for (const p of op.params) {
+        if (args[p.name] !== undefined)
+            values[p.name] = args[p.name];
+    }
+    // File arguments are local paths on this machine; unreadable ones are
+    // argument errors, reported before anything is sent.
+    const fileIssues = [];
+    let rawBody = op.bodyStyle === "data" ? args.body : undefined;
+    if (LOCAL_PROCESS) {
+        for (const p of op.params) {
+            if (p.type !== "file" || typeof values[p.name] !== "string")
+                continue;
+            try {
+                values[p.name] = fileArgument(values[p.name]);
+            }
+            catch (e) {
+                fileIssues.push({ code: "INVALID_ARGUMENT", argument: p.name, message: p.name + ": cannot read " + String(values[p.name]) + " (" + e.message + ")" });
+            }
+        }
+        if (op.bodyKind === "binary" && typeof rawBody === "string") {
+            try {
+                rawBody = fileArgument(rawBody);
+            }
+            catch (e) {
+                fileIssues.push({ code: "INVALID_ARGUMENT", argument: "body", message: "body: cannot read " + String(rawBody) + " (" + e.message + ")" });
+            }
+        }
+    }
+    if (fileIssues.length > 0)
+        return argumentsError(op, fileIssues);
+    const callArgs = buildArgs(op, values, rawBody, typeof args.select === "string" ? args.select : undefined);
+    if (authHeader)
+        callArgs.push({ headers: { Authorization: authHeader } });
+    const errorContext = {
+        authHint: authHeader !== undefined ? AUTH_HINT_HTTP : AUTH_HINT_STDIO,
+        docsUrl: docsSource.docsUrl(),
+        hadCredential: authHeader !== undefined || AUTH_SCALARS.some((a) => process.env[a.env] !== undefined) || readJson("credentials.json") !== null,
+    };
+    const shape = { fields, maxChars, pagination: op.pagination, args };
+    try {
+        const target = getClient()[op.resource];
+        const result = await target[op.method](...callArgs);
+        if (!result.ok)
+            return errorOutcome(result.error, errorContext);
+        if (op.paginated) {
+            const page = result.data;
+            return pageOutcome(page.items, page.nextPageParams(), shape);
+        }
+        // A binary body (the SDK hands back a Blob): an image block, or a file
+        // on disk, never "{}".
+        if (result.data instanceof Blob)
+            return binaryOutcome(result.data, { tool: op.tool, ...(LOCAL_PROCESS ? { saveBinary } : {}) });
+        return dataOutcome(result.data, shape);
+    }
+    catch (e) {
+        return textError(e.message ?? "Tool call failed");
+    }
+}
+/** Running as a process on this machine (stdio, or --http launched here),
+ * as opposed to imported by a worker: the server can read and write local
+ * files, so uploads are tools and binaries are saved to disk. */
+const LOCAL_PROCESS = invokedDirectly();
+/** The callable operations: event streams are CLI-only, uploads are tools
+ * only on a local server (mcpExposed), writes are out under --read-only,
+ * and --tools narrows to a subset. A hidden operation is unknown to
+ * tools/call and execute alike. */
+const MCP_OPS = visibleOps(OPS, { readOnly: READ_ONLY, include: INCLUDE, uploads: LOCAL_PROCESS });
+const HIDDEN_WRITES = READ_ONLY ? visibleOps(OPS, { include: INCLUDE, uploads: LOCAL_PROCESS }).length - MCP_OPS.length : 0;
+const HAS_UPLOADS = MCP_OPS.some((op) => op.bodyKind === "multipart" || op.bodyKind === "binary");
+/** A local file as an upload part (multipart field or raw body). */
+function fileArgument(path) {
+    return new File([readFileSync(path)], basename(path));
+}
+/** Where binary responses land on a local server: a per-server temp dir. */
+function saveBinary(bytes, _mediaType, suggestedName) {
+    const dir = join(tmpdir(), SERVER_NAME);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, Date.now().toString(36) + "-" + suggestedName);
+    writeFileSync(path, bytes);
+    return path;
+}
+const docsSource = {
+    ops: MCP_OPS,
+    docsUrl: () => readJson("config.json")?.docsUrl ?? DOCS_URL_DEFAULT,
+    fetchText: fetchDocsText,
+};
+/** The MCP server for one request context (the HTTP transport passes the
+ * caller's Authorization through; stdio has none). */
+function serverFor(authHeader) {
+    const website = docsSource.docsUrl();
+    return {
+        serverInfo: { name: SERVER_NAME, title: "typeship", version: SERVER_VERSION, ...(website ? { websiteUrl: website } : {}) },
+        instructions: serverInstructions({
+            title: "typeship",
+            toolCount: MCP_OPS.length,
+            mode: TOOL_MODE,
+            readOnly: READ_ONLY,
+            hiddenWrites: HIDDEN_WRITES,
+            authHint: authHeader !== undefined ? AUTH_HINT_HTTP : AUTH_HINT_STDIO,
+            identityTool: MCP_OPS.some((o) => o.tool === IDENTITY_TOOL) ? IDENTITY_TOOL : null,
+            uploads: HAS_UPLOADS,
+            custom: CUSTOM_INSTRUCTIONS,
+        }),
+        toolsTtlMs: TOOLS_TTL_MS,
+        listTools: () => toolDefinitions(docsSource.ops, TOOL_MODE),
+        callTool: async (name, args) => {
+            const shared = await callSharedTool(name, args, docsSource, (op, opArgs) => callOperation(op, opArgs, authHeader));
+            if (shared !== undefined)
+                return shared;
+            // tools/list is the callable contract. In meta mode every operation
+            // goes through execute, including its destructive-operation
+            // confirmation gate; an unlisted operation name must stay unknown.
+            if (TOOL_MODE !== "operations")
+                return undefined;
+            const op = MCP_OPS.find((o) => o.tool === name);
+            return op ? callOperation(op, args, authHeader) : undefined;
+        },
+    };
+}
+// ---- Streamable HTTP transport ---------------------------------------------
+/** Origins allowed to call the HTTP transport from a browser. Non-browser
+ * MCP clients send no Origin and are always accepted; the spec requires
+ * validating the header when present (DNS-rebinding defense), so browser
+ * callers must be same-host, localhost, or listed in
+ * TYPESHIP_MCP_ALLOWED_ORIGINS (comma-separated, "*" for any). */
+function originAllowed(request) {
+    const origin = request.headers.get("origin");
+    if (origin === null)
+        return true;
+    const allowed = (process.env["TYPESHIP_MCP_ALLOWED_ORIGINS"] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    if (allowed.includes("*") || allowed.includes(origin))
+        return true;
+    try {
+        const o = new URL(origin);
+        if (o.host === new URL(request.url).host)
+            return true;
+        return ["localhost", "127.0.0.1", "[::1]"].includes(o.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function corsHeaders(request) {
+    return {
+        "Access-Control-Allow-Origin": request.headers.get("origin") ?? "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization, Accept, MCP-Protocol-Version, Mcp-Method, Mcp-Name",
+        Vary: "Origin",
+    };
+}
+function protectedResourceMetadata(origin) {
+    return {
+        resource: origin,
+        ...(OAUTH_ISSUER ? { authorization_servers: [OAUTH_ISSUER] } : {}),
+        bearer_methods_supported: ["header"],
+    };
+}
+/** Fetch-style handler: mount in any runtime (workers, serverless, node).
+ * Never rejects: every failure is an HTTP or JSON-RPC error response. */
+export async function handleHttp(request) {
+    const url = new URL(request.url);
+    const cors = corsHeaders(request);
+    const json = (status, body, extra = {}) => new Response(JSON.stringify(body), { status, headers: { ...cors, "Content-Type": "application/json", ...extra } });
+    if (request.method === "OPTIONS") {
+        return new Response(null, { status: originAllowed(request) ? 204 : 403, headers: cors });
+    }
+    if (!originAllowed(request)) {
+        return json(403, { jsonrpc: "2.0", error: { code: -32600, message: "Origin not allowed. Set TYPESHIP_MCP_ALLOWED_ORIGINS to permit browser callers." } });
+    }
+    if (url.pathname.endsWith("/.well-known/oauth-protected-resource")) {
+        return json(200, protectedResourceMetadata(url.origin));
+    }
+    if (request.method !== "POST") {
+        // GET streams, DELETE (session end) and Mcp-Session-Id belong to earlier
+        // revisions; the spec asks modern-only servers to answer 405.
+        return json(405, { error: "POST JSON-RPC messages to this endpoint (MCP " + SUPPORTED_PROTOCOL_VERSIONS[0] + ", stateless)." }, { Allow: "POST, OPTIONS" });
+    }
+    const authHeader = request.headers.get("authorization") ?? undefined;
+    const envHasAuth = AUTH_SCALARS.some((a) => process.env[a.env] !== undefined);
+    if (OAUTH_ISSUER && !authHeader && !envHasAuth) {
+        return json(401, { error: "Authorization required." }, {
+            "WWW-Authenticate": 'Bearer resource_metadata="' + url.origin + '/.well-known/oauth-protected-resource"',
+        });
+    }
+    let incoming;
+    try {
+        incoming = await request.json();
+    }
+    catch {
+        return json(400, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+    }
+    const parsed = asJsonRpc(incoming);
+    if (isRpcOutcome(parsed))
+        return json(parsed.status, parsed.message);
+    // Header/body agreement is checked for requests; the spec defines no
+    // header requirements for notification POSTs.
+    if (parsed.id !== undefined && parsed.id !== null && parsed.method !== "initialize") {
+        const mismatch = checkRequestHeaders(request.headers, parsed);
+        if (mismatch)
+            return json(mismatch.status, mismatch.message);
+    }
+    noteClientInfo(parsed);
+    let outcome;
+    try {
+        outcome = await handleRpc(serverFor(authHeader), parsed);
+    }
+    catch (e) {
+        return json(500, { jsonrpc: "2.0", id: parsed.id ?? null, error: { code: -32603, message: e.message ?? "Internal error" } });
+    }
+    if (outcome.message === null) {
+        return new Response(null, { status: outcome.status, headers: cors });
+    }
+    return json(outcome.status, outcome.message);
+}
+function startHttp(port) {
+    void import("node:http").then(({ createServer }) => {
+        createServer((req, res) => {
+            let body = "";
+            req.on("data", (chunk) => (body += chunk));
+            req.on("end", () => {
+                void handleHttp(new Request("http://localhost:" + port + (req.url ?? "/"), {
+                    method: req.method,
+                    headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")])),
+                    ...(req.method === "POST" ? { body } : {}),
+                })).then(async (response) => {
+                    res.statusCode = response.status;
+                    response.headers.forEach((value, key) => res.setHeader(key, value));
+                    res.end(await response.text());
+                }).catch((e) => {
+                    // handleHttp never rejects; this guards the Request construction
+                    // and socket writes so one bad connection can't take the server.
+                    process.stderr.write(SERVER_NAME + ": " + (e.message ?? String(e)) + "\n");
+                    if (!res.headersSent)
+                        res.statusCode = 500;
+                    res.end();
+                });
+            });
+        }).listen(port, () => {
+            process.stderr.write(SERVER_NAME + " listening on http://localhost:" + port + "\n");
+        });
+    });
+}
+// ---- stdio transport --------------------------------------------------------
+async function startStdio() {
+    // dynamic: node:readline doesn't exist in worker runtimes, and workers
+    // never take the stdio path
+    const { createInterface } = await import("node:readline");
+    const rl = createInterface({ input: process.stdin });
+    const write = (message) => process.stdout.write(JSON.stringify(message) + "\n");
+    const server = serverFor();
+    rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (trimmed === "")
+            return;
+        let incoming;
+        try {
+            incoming = JSON.parse(trimmed);
+        }
+        catch {
+            write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+            return;
+        }
+        const id = incoming !== null && typeof incoming === "object" && !Array.isArray(incoming) ? incoming.id : undefined;
+        noteClientInfo(incoming);
+        void handleRpc(server, incoming)
+            .then((outcome) => {
+            if (outcome.message === null)
+                return;
+            // A cancelled request gets no response (spec: MUST NOT send further messages).
+            if (takeCancelled(id))
+                return;
+            write(outcome.message);
+        })
+            .catch((e) => {
+            if (id !== undefined) {
+                write({ jsonrpc: "2.0", id: id ?? null, error: { code: -32603, message: e.message ?? "Internal error" } });
+            }
+        });
+    });
+    // Spec: exit promptly when stdin closes.
+    rl.on("close", () => process.exit(0));
+}
+/** True when this file is the process entry: `node dist/mcp.js`, the
+ * package's `typeship-mcp` bin (a symlink, so compare real paths), or
+ * `npx tsx src/mcp.ts`. False when imported (worker.ts, tests). */
+function invokedDirectly() {
+    const entry = process.argv[1];
+    if (typeof entry !== "string" || entry === "")
+        return false;
+    try {
+        return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return /mcp\.(js|mjs|ts)$/.test(entry);
+    }
+}
+if (invokedDirectly()) {
+    const httpFlag = process.argv.indexOf("--http");
+    if (httpFlag !== -1) {
+        const port = Number(process.argv[httpFlag + 1]) || Number(process.env.PORT) || 3000;
+        startHttp(port);
+    }
+    else {
+        void startStdio();
+    }
+}

package/dist/ops.d.ts

@@ -0,0 +1,115 @@
+export interface ParamSpec {
+    /** wire name (JSON key, query name, or path placeholder) */
+    name: string;
+    /** CLI flag, without the leading dashes */
+    flag: string;
+    /** property name the SDK params object uses */
+    ts: string;
+    kind: "path" | "query" | "header" | "body";
+    /** "file": a binary multipart field; the CLI takes a path and uploads it.
+     * "array"/"object": the schema says so (a lone scalar flag value becomes a
+     * one-item array; an object must be JSON). "json": a union or untyped
+     * value — JSON if it parses, else the raw text. */
+    type: "string" | "number" | "boolean" | "array" | "object" | "json" | "file";
+    required: boolean;
+    enum?: string[];
+    /** Element type of an "array" param: what each repeated/comma value coerces to. */
+    items?: {
+        type: "string" | "number" | "boolean" | "object" | "json";
+        enum?: string[];
+    };
+    /** A date-shaped string: the CLI and MCP server resolve relative forms (-P7D, today). */
+    format?: "date" | "date-time";
+    description?: string;
+    /** Settable once on the client (globals option); optional per call. */
+    global?: boolean;
+}
+export interface OpSpec {
+    resource: string;
+    method: string;
+    command: [string, string];
+    /** Full kebab method name, still routable, when command[1] was shortened. */
+    commandAlias?: string;
+    tool: string;
+    httpMethod: string;
+    path: string;
+    summary?: string;
+    /** Full operation description, for the docs command (help stays terse). */
+    description?: string;
+    /** What agents see in tools/list: summary, the description's first
+     * sentence, method + path. Computed once so package and hosted agree. */
+    toolDescription: string;
+    paginated: boolean;
+    hasBody: boolean;
+    bodyStyle: "none" | "fields" | "data";
+    /** wire encoding of the body, for generic executors */
+    bodyKind: "json" | "form" | "multipart" | "binary" | "text" | null;
+    /** Success body is a text/event-stream: the CLI streams events as NDJSON;
+     * not an MCP tool. */
+    sse: boolean;
+    hasParams: boolean;
+    /** GraphQL ops whose field returns an object accept a selection-set
+     * override (a leaf-returning field has nothing to select). */
+    select: boolean;
+    /** present for GraphQL ops: enough to build the request document */
+    graphql?: {
+        field: string;
+        kind: "query" | "mutation";
+        docPrefix: string;
+        defaultSelection: string;
+    };
+    /** Retried by default (idempotent verb), like the SDK method. */
+    idempotent: boolean;
+    /** Header the SDK fills with one UUID per call (Idempotency-Key). */
+    idempotencyHeader?: string;
+    /** Operation-level retry policy (x-typeship-retries). */
+    retry?: {
+        maxRetries?: number;
+        statuses?: number[];
+        initialDelayMs?: number;
+        maxDelayMs?: number;
+        retryNonIdempotent?: boolean;
+    };
+    /** Page-walking config for generic executors, same shape as the SDK's PageConfig. */
+    pagination?: {
+        style: "cursor" | "cursorFromLastId" | "page" | "offset";
+        itemsField: string;
+        cursorParam?: string;
+        nextCursorField?: string;
+        hasMoreField?: string;
+        idField?: string;
+        pageParam?: string;
+        offsetParam?: string;
+        limitParam?: string;
+    };
+    /** The spec's security requirement: "required" fails fast without a
+     * credential; "none" works anonymously; "optional" is either. */
+    auth: "required" | "optional" | "none";
+    /** Whether calling this operation only reads, writes, or destroys state. */
+    safety: "read" | "write" | "destructive";
+    params: ParamSpec[];
+    inputSchema: Record<string, unknown>;
+    /** Deterministic arguments derived from inputSchema for runnable examples. */
+    exampleArguments: Record<string, unknown>;
+    /** What the tool returns (JSON Schema 2020-12), when the spec documents
+     * a success body; paginated tools describe { items, hasMore, nextPage }. */
+    outputSchema?: Record<string, unknown>;
+}
+export declare const OPS: OpSpec[];
+/** Parameters settable once on the client (globals option): CLI/MCP fill
+ * them from flags or environment; the SDK falls back per request. */
+export declare const GLOBALS: {
+    name: string;
+    option: string;
+    flag: string;
+    envSuffix: string;
+}[];
+export declare function findOp(resource: string, method: string): OpSpec | undefined;
+export declare function missingRequired(op: OpSpec, values: Record<string, unknown>): string[];
+/**
+ * Assemble the SDK method's positional arguments from a flat map of values
+ * keyed by wire name (plus an optional raw body for bodyStyle "data" or a
+ * --data base object).
+ */
+export declare function buildArgs(op: OpSpec, values: Record<string, unknown>, dataBody?: unknown, select?: string): unknown[];
+//# sourceMappingURL=ops.d.ts.map

package/dist/ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../src/ops.ts"],"names":[],"mappings":"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"}