@haven_ai/mcp 0.1.0-alpha

package/dist/cli.cjs

@@ -0,0 +1,589 @@
+#!/usr/bin/env node
+'use strict';
+
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var sdk = require('@haven_ai/sdk');
+var promises = require('fs/promises');
+var v3 = require('zod/v3');
+var crypto = require('crypto');
+var path = require('path');
+
+async function loadCredentials(path = process.env.HAVEN_CREDENTIALS) {
+  if (path) {
+    return loadCredentialsFromFile(path);
+  }
+  const envCreds = loadCredentialsFromEnv();
+  if (envCreds) return envCreds;
+  throw new Error(
+    "No Haven credentials found. Set HAVEN_CREDENTIALS to a Haven agent credential JSON file, pass --credentials <path>, or set HAVEN_API_KEY and HAVEN_DELEGATE_KEY environment variables."
+  );
+}
+async function loadCredentialsFromFile(path) {
+  let rawText;
+  try {
+    rawText = await promises.readFile(path, "utf8");
+  } catch (err) {
+    throw new Error(`Could not read Haven credentials at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch {
+    throw new Error("Haven credentials must be JSON with api_key and delegate_key fields.");
+  }
+  const apiKey = stringField(raw.api_key ?? raw.apiKey);
+  const delegateKey = stringField(raw.delegate_key ?? raw.delegateKey);
+  if (!apiKey) {
+    throw new Error("Haven credentials are missing api_key.");
+  }
+  if (!delegateKey) {
+    throw new Error("Haven MCP requires delegate_key so payments can be signed locally.");
+  }
+  return {
+    apiKey,
+    delegateKey,
+    agentId: stringField(raw.agent_id ?? raw.agentId),
+    safeAddress: stringField(raw.safe_address ?? raw.safeAddress),
+    apiUrl: stringField(raw.api_url ?? raw.apiUrl),
+    sourcePath: path
+  };
+}
+function loadCredentialsFromEnv() {
+  const apiKey = stringField(process.env.HAVEN_API_KEY);
+  const delegateKey = stringField(process.env.HAVEN_DELEGATE_KEY);
+  if (!apiKey && !delegateKey) return null;
+  if (!apiKey) {
+    throw new Error("HAVEN_DELEGATE_KEY is set but HAVEN_API_KEY is missing.");
+  }
+  if (!delegateKey) {
+    throw new Error("HAVEN_API_KEY is set but HAVEN_DELEGATE_KEY is missing. Haven MCP requires a delegate key so payments can be signed locally.");
+  }
+  return {
+    apiKey,
+    delegateKey,
+    agentId: stringField(process.env.HAVEN_AGENT_ID),
+    safeAddress: stringField(process.env.HAVEN_SAFE_ADDRESS),
+    apiUrl: stringField(process.env.HAVEN_API_URL)
+  };
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+var headersSchema = v3.z.record(v3.z.string(), v3.z.string()).optional();
+var toolSchemas = {
+  haven_quote_x402: {
+    url: v3.z.string().url(),
+    method: v3.z.string().optional(),
+    headers: headersSchema,
+    body: v3.z.string().optional(),
+    idempotencyKey: v3.z.string().optional()
+  },
+  haven_pay_x402_quote: {
+    quote: v3.z.unknown(),
+    idempotencyKey: v3.z.string().optional()
+  },
+  haven_resume_x402_payment: {
+    payment_id: v3.z.string().optional(),
+    resume_state: v3.z.unknown().optional()
+  },
+  haven_quote_mpp: {
+    url: v3.z.string().url().optional(),
+    challenge: v3.z.unknown().optional(),
+    method: v3.z.string().optional(),
+    headers: headersSchema,
+    body: v3.z.string().optional(),
+    idempotencyKey: v3.z.string().optional()
+  },
+  haven_pay_mpp_challenge: {
+    quote: v3.z.unknown(),
+    idempotencyKey: v3.z.string().optional()
+  },
+  haven_resume_mpp_payment: {
+    payment_id: v3.z.string().optional(),
+    resume_state: v3.z.unknown().optional()
+  },
+  haven_get_payment_status: {
+    payment_id: v3.z.string()
+  },
+  haven_get_resume_state: {
+    payment_id: v3.z.string()
+  },
+  haven_get_agent: {},
+  haven_get_allowances: {},
+  haven_list_receipts: {
+    limit: v3.z.number().int().min(1).max(100).optional()
+  }
+};
+var toolDescriptions = {
+  haven_quote_x402: "Inspect an HTTP 402 x402 paid resource without creating a Haven payment, signature, approval, or on-chain transaction.",
+  haven_pay_x402_quote: "Pay a previously inspected x402 quote. The delegate key signs locally; Haven only validates and relays signed, on-chain-constrained payment transactions. If approval is needed, preserve the returned resume_state and wait for nextAction=retry_original_x402_request before resuming.",
+  haven_resume_x402_payment: "Resume an x402 payment after the Haven wallet owner approved the funding step. Accepts either resume_state or payment_id. Only use when get status returns nextAction=retry_original_x402_request; do not start a new merchant session.",
+  haven_quote_mpp: "Inspect a Haven MPP challenge or paid MPP URL without creating a Haven payment, signature, approval, or on-chain transaction.",
+  haven_pay_mpp_challenge: "Pay a previously inspected MPP challenge. The delegate key signs locally; Haven only validates and relays signed, on-chain-constrained payment transactions. If approval is needed, preserve resume_state or payment_id.",
+  haven_resume_mpp_payment: "Resume an MPP payment after the Haven wallet owner approved the funding step. Accepts either resume_state or payment_id and retries the original paid resource.",
+  haven_get_payment_status: "Fetch structured Haven payment status, including phase and nextAction taxonomy for agent recovery.",
+  haven_get_resume_state: "Rehydrate stored x402/MPP resume_state by payment_id. This returns context only; signing still happens locally when a resume tool is called.",
+  haven_get_agent: "Return the authenticated agent identity, Haven wallet, delegate address, chain, and status.",
+  haven_get_allowances: "Return configured and on-chain allowance state for the authenticated agent. On-chain allowance is the real spend gate.",
+  haven_list_receipts: "List recent machine-payment receipts/evidence for bookkeeping. Proof header values are not returned."
+};
+function createToolHandlers(haven) {
+  return {
+    haven_quote_x402: async (input) => {
+      const args = objectInput("haven_quote_x402", input);
+      return runTool(async () => haven.quoteX402(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey }));
+    },
+    haven_pay_x402_quote: async (input) => {
+      const args = objectInput("haven_pay_x402_quote", input);
+      return runTool(async () => {
+        const response = await haven.payX402Quote(args.quote, { idempotencyKey: args.idempotencyKey });
+        return responsePayload(response);
+      });
+    },
+    haven_resume_x402_payment: async (input) => {
+      const args = objectInput("haven_resume_x402_payment", input);
+      return runTool(async () => {
+        const state = await resumeState(args, "x402");
+        const response = await haven.resumeX402Payment(state);
+        return responsePayload(response);
+      });
+    },
+    haven_quote_mpp: async (input) => {
+      const args = objectInput("haven_quote_mpp", input);
+      return runTool(async () => {
+        if (args.challenge) {
+          return haven.quoteMpp(args.challenge, requestInit(args), {
+            idempotencyKey: args.idempotencyKey
+          });
+        }
+        if (!args.url) {
+          throw new sdk.HavenApiError("haven_quote_mpp requires either url or challenge.", 400);
+        }
+        return haven.quoteMpp(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey });
+      });
+    },
+    haven_pay_mpp_challenge: async (input) => {
+      const args = objectInput("haven_pay_mpp_challenge", input);
+      return runTool(async () => {
+        const response = await haven.payMppChallenge(args.quote, { idempotencyKey: args.idempotencyKey });
+        return responsePayload(response);
+      });
+    },
+    haven_resume_mpp_payment: async (input) => {
+      const args = objectInput("haven_resume_mpp_payment", input);
+      return runTool(async () => {
+        const state = await resumeState(args, "mpp");
+        const response = await haven.resumeMppPayment(state);
+        return responsePayload(response);
+      });
+    },
+    haven_get_payment_status: async (input) => {
+      const args = objectInput("haven_get_payment_status", input);
+      return runTool(async () => haven.getPaymentStatus(args.payment_id));
+    },
+    haven_get_resume_state: async (input) => {
+      const args = objectInput("haven_get_resume_state", input);
+      return runTool(async () => haven.getResumeState(args.payment_id));
+    },
+    haven_get_agent: async () => runTool(async () => haven.getAgent()),
+    haven_get_allowances: async () => runTool(async () => haven.getAllowances()),
+    haven_list_receipts: async (input) => {
+      const args = objectInput("haven_list_receipts", input);
+      return runTool(async () => haven.listReceipts({ limit: args.limit }));
+    }
+  };
+  async function resumeState(args, rail) {
+    const state = args.resume_state ?? (args.payment_id ? await haven.getResumeState(args.payment_id) : void 0);
+    if (!state || typeof state !== "object") {
+      throw new sdk.HavenApiError(`haven_resume_${rail}_payment requires resume_state or payment_id.`, 400);
+    }
+    if (state.rail !== rail) {
+      throw new sdk.HavenApiError(`Resume state is not for the ${rail} rail.`, 409, state);
+    }
+    return state;
+  }
+}
+function objectInput(name, input) {
+  return v3.z.object(toolSchemas[name]).parse(input ?? {});
+}
+function requestInit(input) {
+  if (!input.method && !input.headers && input.body === void 0) return void 0;
+  return {
+    method: input.method,
+    headers: input.headers,
+    body: input.body
+  };
+}
+async function runTool(fn) {
+  try {
+    return { success: true, data: await fn() };
+  } catch (err) {
+    return normalizeError(err);
+  }
+}
+async function responsePayload(response) {
+  const text = await response.text();
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: parseMaybeJson(text)
+  };
+}
+function parseMaybeJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function normalizeError(err) {
+  if (err instanceof sdk.HavenPaymentStateError) {
+    return {
+      success: false,
+      code: err.code,
+      message: err.message,
+      statusCode: err.statusCode,
+      paymentId: err.paymentId,
+      status: err.status,
+      phase: err.phase,
+      nextAction: err.nextAction,
+      resume_state: err.resumeState,
+      body: err.body
+    };
+  }
+  if (err instanceof sdk.HavenSigningError) {
+    return {
+      success: false,
+      code: err.code,
+      message: err.message
+    };
+  }
+  if (err instanceof sdk.HavenApiError) {
+    const body = err.body;
+    return {
+      success: false,
+      code: err.code,
+      message: err.message,
+      statusCode: err.statusCode,
+      paymentId: err.paymentId,
+      phase: stringOrUndefined(body?.phase),
+      nextAction: stringOrUndefined(body?.nextAction) ?? stringOrUndefined(body?.next_action) ?? sdk.AgentPaymentNextAction.StopAndTellUser,
+      body: err.body
+    };
+  }
+  if (err instanceof sdk.HavenError) {
+    return {
+      success: false,
+      code: err.code,
+      message: err.message,
+      statusCode: err.statusCode,
+      paymentId: err.paymentId
+    };
+  }
+  return {
+    success: false,
+    code: "UNKNOWN_ERROR",
+    message: err instanceof Error ? err.message : String(err),
+    nextAction: sdk.AgentPaymentNextAction.StopAndTellUser
+  };
+}
+function stringOrUndefined(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function computeConsentHash(input) {
+  const allowanceCanonical = [...input.allowanceSummary].map((a) => `${a.token}:${a.amount}:${a.resetMinutes ?? "none"}`).sort().join("|");
+  const toolCanonical = [...input.toolNames].sort().join(",");
+  const identity = [
+    input.apiKeyPrefix,
+    input.apiUrl ?? "",
+    input.agentId ?? "",
+    (input.safeAddress ?? "").toLowerCase(),
+    (input.delegateAddress ?? "").toLowerCase(),
+    input.chainId ?? ""
+  ].join("|");
+  return crypto.createHash("sha256").update(`${identity}
+${toolCanonical}
+${allowanceCanonical}`).digest("hex").slice(0, 16);
+}
+function renderConsentBlock(input, hash) {
+  const lines = [
+    "",
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "Haven MCP server \u2014 first-launch consent",
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "",
+    `Credential: ${input.apiKeyPrefix}\u2026`
+  ];
+  if (input.apiUrl) lines.push(`Haven API: ${input.apiUrl}`);
+  if (input.agentId) lines.push(`Agent ID:  ${input.agentId}`);
+  if (input.safeAddress) lines.push(`Haven wallet (Safe): ${input.safeAddress}`);
+  if (input.delegateAddress) lines.push(`Delegate (local signer): ${input.delegateAddress}`);
+  if (typeof input.chainId === "number") lines.push(`Chain ID:  ${input.chainId}`);
+  lines.push("");
+  lines.push("Confirm these match the Haven wallet and chain you intend the");
+  lines.push("agent runtime to use. The delegate above is the only key that");
+  lines.push("signs payments \u2014 it lives in this process, not on Haven's backend.");
+  lines.push("");
+  lines.push("Tools this server will expose to your agent runtime:");
+  for (const name of input.toolNames) {
+    lines.push(`  \u2022 ${name}`);
+    lines.push(`      ${toolDescriptions[name]}`);
+  }
+  lines.push("");
+  if (input.allowanceSummary.length === 0) {
+    lines.push("On-chain allowance: none configured.");
+    lines.push("  Any payment will queue for manual approval. The on-chain");
+    lines.push("  Safe AllowanceModule is the real spend gate.");
+  } else {
+    lines.push("On-chain allowance (the real spend gate, Safe AllowanceModule):");
+    for (const a of input.allowanceSummary) {
+      const reset = a.resetMinutes ? ` per ${a.resetMinutes} min` : " (no reset)";
+      lines.push(`  \u2022 up to ${a.amount} ${a.token}${reset}`);
+    }
+  }
+  lines.push("");
+  lines.push("Anything above the on-chain allowance pauses for owner approval");
+  lines.push("in the Haven dashboard. Revoking the agent on-chain disables");
+  lines.push("every MCP tool that would spend.");
+  lines.push("");
+  lines.push(`Consent hash: ${hash}`);
+  lines.push("");
+  lines.push("To acknowledge, EITHER:");
+  lines.push(`  \u2022 set HAVEN_MCP_ACK=${hash} in this process's environment, OR`);
+  lines.push("  \u2022 re-run with --ack to write the acknowledgement next to your");
+  lines.push("    credential file (sidecar <credentials>.ack.json).");
+  lines.push("");
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  lines.push("");
+  return lines.join("\n");
+}
+async function ensureConsent(input, options = {}) {
+  const env = options.env ?? process.env;
+  const out = options.out ?? process.stderr;
+  const hash = computeConsentHash(input);
+  if (env.HAVEN_MCP_ACK === "skip") {
+    return { ok: true, hash, reason: "env_var_skip" };
+  }
+  if (typeof env.HAVEN_MCP_ACK === "string" && env.HAVEN_MCP_ACK.length > 0) {
+    if (env.HAVEN_MCP_ACK === hash) {
+      return { ok: true, hash, reason: "env_var_match" };
+    }
+    out.write(renderConsentBlock(input, hash));
+    out.write(
+      `HAVEN_MCP_ACK was set but did not match the current consent hash.
+Expected: ${hash}
+Got:      ${env.HAVEN_MCP_ACK}
+Re-acknowledge with the new hash above, or run with --ack.
+
+`
+    );
+    return { ok: false, hash, reason: "env_var_mismatch" };
+  }
+  const ackPath = sidecarPath(options.credentialsPath);
+  if (ackPath) {
+    const stored = await readAckFile(ackPath);
+    if (stored?.ack === hash) {
+      return { ok: true, hash, reason: "ack_file_match" };
+    }
+  }
+  if (options.writeAck && ackPath) {
+    out.write(renderConsentBlock(input, hash));
+    await writeAckFile(ackPath, hash);
+    out.write(`Wrote acknowledgement to ${ackPath}
+
+`);
+    return { ok: true, hash, reason: "wrote_ack_file" };
+  }
+  out.write(renderConsentBlock(input, hash));
+  return { ok: false, hash, reason: "no_acknowledgement" };
+}
+function sidecarPath(credentialsPath) {
+  if (!credentialsPath) return null;
+  return path.resolve(`${credentialsPath}.ack.json`);
+}
+async function readAckFile(path) {
+  try {
+    const raw = await promises.readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return { ack: typeof parsed.ack === "string" ? parsed.ack : void 0 };
+  } catch {
+    return null;
+  }
+}
+async function writeAckFile(path$1, hash) {
+  await promises.mkdir(path.dirname(path$1), { recursive: true });
+  await promises.writeFile(
+    path$1,
+    JSON.stringify({ ack: hash, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf8"
+  );
+}
+async function consentInputFromClient(haven, seed, toolNames) {
+  let allowanceSummary = [];
+  let safeAddress = seed.safeAddress;
+  let delegateAddress;
+  let chainId;
+  try {
+    const summary = await haven.getAllowances();
+    const list = isAllowanceSummary(summary) ? summary.allowances : Array.isArray(summary) ? summary : [];
+    if (isAllowanceSummary(summary)) {
+      safeAddress = summary.safeAddress ?? safeAddress;
+      delegateAddress = summary.delegateAddress;
+      chainId = typeof summary.chainId === "number" ? summary.chainId : chainId;
+    }
+    allowanceSummary = list.map((a) => ({
+      token: a.tokenSymbol ?? "UNKNOWN",
+      amount: a.onchain?.amount ?? a.configuredAmount ?? "0",
+      resetMinutes: typeof a.onchain?.resetTimeMin === "number" ? a.onchain.resetTimeMin : typeof a.resetPeriodMin === "number" ? a.resetPeriodMin : null
+    }));
+  } catch {
+  }
+  return {
+    apiKeyPrefix: derivePrefix(seed.apiKey),
+    apiUrl: seed.apiUrl,
+    agentId: seed.agentId,
+    safeAddress,
+    delegateAddress,
+    chainId,
+    toolNames,
+    allowanceSummary
+  };
+}
+function isAllowanceSummary(value) {
+  return typeof value === "object" && value !== null && "allowances" in value && Array.isArray(value.allowances);
+}
+function derivePrefix(apiKey) {
+  return apiKey.slice(0, 12);
+}
+function registeredToolNames() {
+  return Object.keys(toolSchemas);
+}
+
+// src/server.ts
+async function resolveHavenClient(options = {}) {
+  const credentials = options.credentials ?? await loadCredentials(options.credentialsPath);
+  const client = new sdk.HavenClient({
+    apiKey: credentials.apiKey,
+    delegateKey: credentials.delegateKey,
+    baseUrl: credentials.apiUrl
+  });
+  return { client, credentials };
+}
+function buildMcpServer(haven) {
+  const server = new mcp_js.McpServer({
+    name: "@haven_ai/mcp",
+    version: "0.1.0-alpha"
+  });
+  const handlers = createToolHandlers(haven);
+  const registerTool = server.tool.bind(server);
+  for (const name of Object.keys(toolSchemas)) {
+    registerTool(
+      name,
+      toolDescriptions[name],
+      toolSchemas[name],
+      async (args) => haven.withRequestContext(
+        { "X-Haven-MCP-Tool": name },
+        async () => toMcpResult(await handlers[name](args))
+      )
+    );
+  }
+  return server;
+}
+async function runStdioServer(options = {}) {
+  const { client: haven, credentials } = await resolveHavenClient(options);
+  if (!options.skipConsent) {
+    const decision = await runConsentGate(haven, credentials, options);
+    if (!decision.ok) {
+      const err = new Error(
+        decision.reason === "env_var_mismatch" ? "Haven MCP consent acknowledgement does not match the current configuration." : "Haven MCP server requires a one-time consent acknowledgement before starting."
+      );
+      err.code = "HAVEN_MCP_NO_CONSENT";
+      throw err;
+    }
+  }
+  const server = buildMcpServer(haven);
+  await server.connect(new stdio_js.StdioServerTransport());
+}
+async function runConsentGate(haven, credentials, options) {
+  const toolNames = registeredToolNames();
+  const input = await consentInputFromClient(
+    haven,
+    {
+      apiKey: credentials.apiKey,
+      apiUrl: credentials.apiUrl,
+      agentId: credentials.agentId,
+      safeAddress: credentials.safeAddress
+    },
+    toolNames
+  );
+  const credentialsPath = options.credentialsPath ?? credentials.sourcePath;
+  return ensureConsent(input, {
+    credentialsPath,
+    writeAck: options.writeAck
+  });
+}
+function toMcpResult(payload) {
+  return {
+    isError: !payload.success,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(payload, null, 2)
+      }
+    ]
+  };
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const options = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--credentials" || arg === "--credentials-path") {
+      options.credentialsPath = argv[i + 1];
+      i += 1;
+    } else if (arg === "--transport") {
+      const transport = argv[i + 1];
+      i += 1;
+      if (transport !== "stdio") {
+        throw new Error("Only local stdio transport is supported. Haven does not provide a remote MCP signer mode.");
+      }
+    } else if (arg === "--ack") {
+      options.writeAck = true;
+    } else if (arg === "--help" || arg === "-h") {
+      process.stdout.write([
+        "Haven MCP server",
+        "",
+        "Usage:",
+        "  npx @haven_ai/mcp --credentials /path/to/agent.json",
+        "",
+        "Options:",
+        "  --credentials <path>       Haven credential JSON file. Also supported: HAVEN_CREDENTIALS.",
+        "  --transport stdio          Local stdio transport. This is the only supported mode.",
+        "  --ack                      Acknowledge the first-launch consent block and write",
+        "                             a sidecar acknowledgement file next to the credential.",
+        "",
+        "Consent:",
+        "  On first launch the server prints the tool list and the on-chain",
+        "  allowance summary, then refuses to start unless you have acknowledged.",
+        "  Acknowledge with EITHER --ack OR HAVEN_MCP_ACK=<hash> in your environment.",
+        ""
+      ].join("\n"));
+      process.exit(0);
+    }
+  }
+  return options;
+}
+async function main() {
+  await runStdioServer(parseArgs(process.argv.slice(2)));
+}
+main().catch((err) => {
+  process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map