@haven_ai/mcp 0.0.0-dev.202609031523.fd49e1a

package/dist/cli.js

@@ -0,0 +1,953 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { composeDescription, toolDescriptions as toolDescriptions$1, HavenClient, isSupportedNodeVersion, unsupportedNodeVersionMessage, HavenPaymentStateError, HavenSigningError, HavenApiError, AgentPaymentNextAction, HavenError, verifyPaymentReceipt, discoverMerchantMcpUrl, sameUrl } from '@haven_ai/sdk';
+import { readFile, mkdir, writeFile, stat } from 'fs/promises';
+import { z } from 'zod/v3';
+import { createHash } from 'crypto';
+import { resolve, dirname } from 'path';
+
+async function loadCredentials(source = process.env.HAVEN_CREDENTIALS) {
+  if (typeof source === "string") {
+    return loadCredentialsFromFile(source);
+  }
+  if (source?.credentialsPath) {
+    return loadCredentialsFromFile(source.credentialsPath);
+  }
+  if (source?.identityPath || source?.signerPath) {
+    if (!source.identityPath || !source.signerPath) {
+      throw new Error("Haven split credentials require both --identity and --signer paths.");
+    }
+    return loadCredentialsFromSplitFiles(source.identityPath, source.signerPath);
+  }
+  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 readFile(path, "utf8");
+  } catch (err) {
+    throw new Error(`Could not read Haven credentials at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  await warnIfCredentialFilePermissive(path);
+  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),
+    delegateAddress: stringField(raw.delegate_address ?? raw.delegateAddress),
+    chainId: numberField(raw.chain_id ?? raw.chainId),
+    network: stringField(raw.network),
+    apiUrl: stringField(raw.api_url ?? raw.apiUrl),
+    allowanceSummary: allowanceSummaryField(raw.allowance_summary ?? raw.allowanceSummary ?? raw.agent_budget ?? raw.agentBudget),
+    sourcePath: path
+  };
+}
+async function loadCredentialsFromSplitFiles(identityPath, signerPath) {
+  const identity = await readJsonFile(identityPath, "Haven identity credentials");
+  const signer = await readJsonFile(signerPath, "Haven signer credentials");
+  await warnIfCredentialFilePermissive(identityPath);
+  await warnIfCredentialFilePermissive(signerPath);
+  const apiKey = stringField(identity.api_key ?? identity.apiKey);
+  const delegateKey = stringField(signer.delegate_key ?? signer.delegateKey);
+  if (!apiKey) {
+    throw new Error("Haven identity credentials are missing api_key.");
+  }
+  if (!delegateKey) {
+    throw new Error("Haven signer credentials are missing delegate_key.");
+  }
+  return {
+    apiKey,
+    delegateKey,
+    agentId: matchingStringField(
+      "agent_id",
+      identity.agent_id ?? identity.agentId,
+      signer.agent_id ?? signer.agentId
+    ),
+    safeAddress: matchingStringField(
+      "safe_address",
+      identity.safe_address ?? identity.safeAddress,
+      signer.safe_address ?? signer.safeAddress,
+      { caseInsensitive: true }
+    ),
+    delegateAddress: matchingStringField(
+      "delegate_address",
+      signer.delegate_address ?? signer.delegateAddress,
+      identity.delegate_address ?? identity.delegateAddress,
+      { caseInsensitive: true }
+    ),
+    chainId: matchingNumberField(
+      "chain_id",
+      identity.chain_id ?? identity.chainId,
+      signer.chain_id ?? signer.chainId
+    ),
+    network: matchingStringField(
+      "network",
+      identity.network,
+      signer.network,
+      { caseInsensitive: true }
+    ),
+    apiUrl: stringField(identity.api_url ?? identity.apiUrl),
+    allowanceSummary: allowanceSummaryField(
+      identity.allowance_summary ?? identity.allowanceSummary ?? identity.agent_budget ?? identity.agentBudget
+    ),
+    sourcePath: identityPath,
+    identityPath,
+    signerPath
+  };
+}
+async function readJsonFile(path, label) {
+  let rawText;
+  try {
+    rawText = await readFile(path, "utf8");
+  } catch (err) {
+    throw new Error(`Could not read ${label} at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    return JSON.parse(rawText);
+  } catch {
+    throw new Error(`${label} must be JSON.`);
+  }
+}
+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),
+    chainId: numberField(process.env.HAVEN_CHAIN_ID),
+    network: stringField(process.env.HAVEN_NETWORK),
+    apiUrl: stringField(process.env.HAVEN_API_URL)
+  };
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberField(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() && /^\d+$/.test(value.trim())) return Number(value.trim());
+  return void 0;
+}
+function matchingStringField(label, preferred, fallback, options = {}) {
+  const preferredValue = stringField(preferred);
+  const fallbackValue = stringField(fallback);
+  if (preferredValue && fallbackValue && !sameCredentialValue(preferredValue, fallbackValue, options.caseInsensitive)) {
+    throw mismatchedSplitCredentialError(label);
+  }
+  return preferredValue ?? fallbackValue;
+}
+function matchingNumberField(label, preferred, fallback) {
+  const preferredValue = numberField(preferred);
+  const fallbackValue = numberField(fallback);
+  if (preferredValue !== void 0 && fallbackValue !== void 0 && preferredValue !== fallbackValue) {
+    throw mismatchedSplitCredentialError(label);
+  }
+  return preferredValue ?? fallbackValue;
+}
+function sameCredentialValue(first, second, caseInsensitive = false) {
+  return caseInsensitive ? first.toLowerCase() === second.toLowerCase() : first === second;
+}
+function mismatchedSplitCredentialError(label) {
+  return new Error(
+    `Haven split credentials have mismatched ${label} values. Recreate the identity and signer credential files from the same Haven agent.`
+  );
+}
+function allowanceSummaryField(value) {
+  if (!Array.isArray(value)) return void 0;
+  const allowances = value.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const raw = item;
+    const token = stringField(raw.token ?? raw.token_symbol ?? raw.tokenSymbol);
+    const amount = stringField(raw.amount ?? raw.allowance_amount ?? raw.allowanceAmount);
+    const reset = raw.resetMinutes ?? raw.reset_minutes ?? raw.reset_period_min ?? raw.resetPeriodMin;
+    if (!token || !amount) return [];
+    return [{
+      token,
+      amount,
+      resetMinutes: reset === null ? null : numberField(reset) ?? null
+    }];
+  });
+  return allowances.length > 0 ? allowances : void 0;
+}
+async function warnIfCredentialFilePermissive(path, log = (message) => process.stderr.write(`${message}
+`), platform = process.platform) {
+  if (platform === "win32") return;
+  let mode;
+  try {
+    const stats = await stat(path);
+    mode = stats.mode;
+  } catch {
+    return;
+  }
+  const groupOrOther = mode & 63;
+  if (groupOrOther !== 0) {
+    const octal = (mode & 511).toString(8).padStart(4, "0");
+    log(
+      `haven-mcp: warning: credential file at ${path} is readable beyond the owner (mode ${octal}). Run: chmod 600 ${path}`
+    );
+  }
+}
+var headersSchema = z.record(z.string(), z.string()).optional();
+var toolSchemas = {
+  haven_send: {
+    asset: z.enum(["ETH", "USDC"]),
+    recipient: z.string().min(1),
+    amount: z.string().min(1),
+    idempotencyKey: z.string().optional()
+  },
+  haven_pay_mcp_tool: {
+    merchant_url: z.string().url(),
+    tool_name: z.string().min(1),
+    arguments: z.record(z.string(), z.unknown()).optional(),
+    idempotencyKey: z.string().optional()
+  },
+  haven_quote_x402: {
+    url: z.string().url(),
+    method: z.string().optional(),
+    headers: headersSchema,
+    body: z.string().optional(),
+    idempotencyKey: z.string().optional()
+  },
+  haven_pay_x402_quote: {
+    quote: z.unknown(),
+    idempotencyKey: z.string().optional()
+  },
+  haven_pay_x402: {
+    url: z.string().url(),
+    method: z.string().optional(),
+    headers: headersSchema,
+    body: z.string().optional(),
+    idempotencyKey: z.string().optional()
+  },
+  haven_resume_x402_payment: {
+    payment_id: z.string().optional(),
+    resume_state: z.unknown().optional()
+  },
+  haven_get_payment_status: {
+    payment_id: z.string()
+  },
+  haven_get_resume_state: {
+    payment_id: z.string()
+  },
+  haven_get_agent: {},
+  haven_get_allowances: {},
+  haven_sweep_delegate: {},
+  haven_discover_tools: {
+    category: z.string().optional(),
+    search: z.string().optional(),
+    rail: z.enum(["x402", "mpp"]).optional(),
+    verified: z.enum(["any", "verified", "operator"]).optional()
+  },
+  haven_submit_catalog_entry: {
+    resource_url: z.string().min(1),
+    website: z.string().optional()
+  },
+  haven_list_receipts: {
+    limit: z.number().int().min(1).max(100).optional()
+  },
+  haven_verify_receipt: {
+    receipt: z.unknown()
+  }
+};
+var toolDescriptions = {
+  haven_send: composeDescription(toolDescriptions$1.send),
+  haven_pay_mcp_tool: composeDescription(toolDescriptions$1.payMcpTool),
+  haven_quote_x402: composeDescription(toolDescriptions$1.quoteX402),
+  haven_pay_x402_quote: composeDescription(toolDescriptions$1.payX402),
+  haven_pay_x402: composeDescription(toolDescriptions$1.payX402OneShot),
+  haven_resume_x402_payment: composeDescription(toolDescriptions$1.resumeX402),
+  haven_get_payment_status: composeDescription(toolDescriptions$1.getPaymentStatus),
+  haven_get_resume_state: composeDescription(toolDescriptions$1.getResumeState),
+  haven_get_agent: composeDescription(toolDescriptions$1.getAgent),
+  haven_get_allowances: composeDescription(toolDescriptions$1.getAllowances),
+  haven_sweep_delegate: composeDescription(toolDescriptions$1.sweep_delegate),
+  haven_discover_tools: composeDescription(toolDescriptions$1.discoverTools),
+  haven_submit_catalog_entry: composeDescription(toolDescriptions$1.submitCatalogEntry),
+  haven_list_receipts: composeDescription(toolDescriptions$1.listReceipts),
+  haven_verify_receipt: composeDescription(toolDescriptions$1.verifyReceipt)
+};
+function createToolHandlers(haven) {
+  return {
+    haven_send: async (input) => {
+      return runTool(async () => {
+        const args = objectInput("haven_send", input);
+        try {
+          const result = await haven.pay({
+            token: args.asset,
+            amount: args.amount,
+            to: args.recipient,
+            // #1207: was accepted by the schema but silently dropped — now
+            // carried to the backend's replay contract.
+            idempotencyKey: typeof args.idempotencyKey === "string" ? args.idempotencyKey : void 0
+          });
+          return {
+            payment_id: result.paymentId,
+            status: result.status,
+            tx_hash: result.txHash ?? null,
+            asset: args.asset,
+            amount: args.amount,
+            recipient: args.recipient
+          };
+        } catch (err) {
+          if (err instanceof HavenPaymentStateError && isPendingApproval(err.status)) {
+            return {
+              payment_id: err.paymentId,
+              status: "pending_approval",
+              next_action: "stop_and_tell_user",
+              message: "This payment is not payable and nothing is queued for anyone to approve \u2014 stop and tell the user, then ask the wallet owner to grant or raise the agent budget in Haven. Do not retry, re-sign, or poll.",
+              asset: args.asset,
+              amount: args.amount,
+              recipient: args.recipient
+            };
+          }
+          throw err;
+        }
+      });
+    },
+    haven_pay_mcp_tool: async (input) => {
+      return runTool(async () => {
+        const args = objectInput("haven_pay_mcp_tool", input);
+        const envelope = buildMcpToolsCallEnvelope(args.tool_name, args.arguments);
+        const init = {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(envelope)
+        };
+        let merchantUrl = args.merchant_url;
+        const idempotencyKey = args.idempotencyKey;
+        const attempt = () => haven.fetch(merchantUrl, init, { idempotencyKey });
+        let response = await attempt();
+        if (!response.ok) {
+          const discovered = await discoverMerchantMcpUrl(merchantUrl);
+          if (!discovered || sameUrl(discovered, merchantUrl)) {
+            throw discoveryMissError(response, merchantUrl, discovered);
+          }
+          const inputUrl = merchantUrl;
+          merchantUrl = discovered;
+          const retryResponse = await attempt();
+          if (!retryResponse.ok) {
+            throw discoveryMissError(retryResponse, merchantUrl, discovered, inputUrl);
+          }
+          response = retryResponse;
+        }
+        const payload = await responsePayload(response);
+        return {
+          ...payload,
+          // The RESOLVED endpoint (#1271/#1301), not the input as given.
+          merchant_url: merchantUrl,
+          ...merchantUrl !== args.merchant_url ? { merchant_url_discovered_from: args.merchant_url } : {}
+        };
+      });
+    },
+    haven_quote_x402: async (input) => {
+      const args = objectInput("haven_quote_x402", input);
+      try {
+        return { success: true, data: await haven.quoteX402(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey }) };
+      } catch (err) {
+        return normalizeError(err);
+      }
+    },
+    haven_pay_x402_quote: async (input) => {
+      const args = objectInput("haven_pay_x402_quote", input);
+      const quote = args.quote;
+      if (!quote || typeof quote !== "object") {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote argument is missing or is not a valid x402 quote object. Call haven_quote_x402 first to obtain a quote, or use haven_pay_x402 to handle the full probe \u2192 pay \u2192 retry round trip automatically.",
+          "haven_quote_x402"
+        );
+      }
+      if (!quote.paymentRequired) {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote is missing the required paymentRequired field. Call haven_quote_x402 first to obtain a valid x402 quote.",
+          "haven_quote_x402"
+        );
+      }
+      return runTool(async () => {
+        const response = await haven.payX402Quote(args.quote, { idempotencyKey: args.idempotencyKey });
+        return responsePayload(response);
+      });
+    },
+    haven_pay_x402: async (input) => {
+      const args = objectInput("haven_pay_x402", input);
+      return runTool(async () => {
+        const response = await haven.fetch(args.url, requestInit(args), { 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_get_payment_status: async (input) => {
+      const args = objectInput("haven_get_payment_status", input);
+      return runTool(async () => haven.getPaymentStatusWithPostPurchaseAllowance(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.getAgentSummary()),
+    haven_get_allowances: async () => runTool(async () => haven.getAllowances()),
+    haven_sweep_delegate: async () => runTool(async () => haven.sweepDelegate()),
+    haven_discover_tools: async (input) => {
+      const args = objectInput("haven_discover_tools", input);
+      return runTool(async () => {
+        const entries = await haven.discoverTools({
+          category: typeof args.category === "string" ? args.category : void 0,
+          search: typeof args.search === "string" ? args.search : void 0,
+          rail: args.rail === "x402" || args.rail === "mpp" ? args.rail : void 0,
+          verified: args.verified === "verified" || args.verified === "operator" ? args.verified : void 0
+        });
+        return entries.map((entry) => ({
+          id: entry.id,
+          name: entry.name,
+          description: entry.description,
+          category: entry.category,
+          resource_url: entry.resourceUrl,
+          rail: entry.rail,
+          protocol: entry.protocol,
+          tool_name: entry.toolName,
+          tool_arguments: entry.toolArguments,
+          price_display: entry.priceDisplay,
+          price_atomic: entry.priceAtomic,
+          asset: entry.asset,
+          network: entry.network,
+          status: entry.status,
+          verified_at: entry.verifiedAt,
+          source: entry.source,
+          domain_verified: entry.domainVerified,
+          verified_payable: entry.verifiedPayable,
+          // Which Haven pay tool reaches this entry from the local MCP surface.
+          // #1328: the 'mpp' rail's only-ever catalog row (the Haven MPP demo
+          // resource) is delisted with the mpp_demo retirement, so this
+          // fallback is unreachable today; it stays x402 rather than naming a
+          // deleted tool in case a future non-demo 'mpp' rail entry appears.
+          suggested_tool: entry.protocol === "mcp" ? "haven_pay_mcp_tool" : "haven_pay_x402"
+        }));
+      });
+    },
+    haven_submit_catalog_entry: async (input) => {
+      const args = objectInput("haven_submit_catalog_entry", input);
+      return runTool(async () => {
+        const submission = await haven.submitCatalogEntry(
+          String(args.resource_url),
+          typeof args.website === "string" ? { website: args.website } : void 0
+        );
+        return {
+          id: submission.id,
+          verify_token: submission.verifyToken,
+          status: submission.status
+        };
+      });
+    },
+    haven_list_receipts: async (input) => {
+      const args = objectInput("haven_list_receipts", input);
+      return runTool(async () => haven.listReceipts({ limit: args.limit }));
+    },
+    haven_verify_receipt: async (input) => {
+      const args = objectInput("haven_verify_receipt", input);
+      return runTool(async () => verifyPaymentReceipt(args.receipt));
+    }
+  };
+  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 HavenApiError(`haven_resume_${rail}_payment requires resume_state or payment_id.`, 400);
+    }
+    if (state.rail !== rail) {
+      throw new HavenApiError(`Resume state is not for the ${rail} rail.`, 409, state);
+    }
+    return state;
+  }
+}
+function isPendingApproval(status) {
+  return status === "pending" || status === "pending_approval";
+}
+function wrongTool(code, message, suggested_tool) {
+  return { success: false, code, message, suggested_tool };
+}
+function buildMcpToolsCallEnvelope(toolName, args) {
+  return {
+    jsonrpc: "2.0",
+    id: `haven-mcp-${Date.now()}`,
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args ?? {}
+    }
+  };
+}
+function objectInput(name, input) {
+  return 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 discoveryMissError(response, merchantUrl, discovered, discoveredFromUrl) {
+  const base = discoveredFromUrl ? `Merchant call to ${merchantUrl} failed with HTTP ${response.status} (at the DISCOVERED endpoint ${merchantUrl}, resolved from ${discoveredFromUrl} via the merchant discovery document).` : `Merchant call to ${merchantUrl} failed with HTTP ${response.status}.`;
+  const guidance = discoveredFromUrl ? "" : discovered ? ` Same-origin discovery resolved the same URL (${discovered}), which still did not answer successfully.` : ` No same-origin discovery document was found at /.well-known/haven-demo-merchant or /. If ${merchantUrl} is a base merchant URL, pass the exact MCP endpoint instead (often <origin>/mcp).`;
+  return new HavenApiError(`${base}${guidance}`, response.status || 400);
+}
+function normalizeError(err) {
+  if (err instanceof 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 HavenSigningError) {
+    return {
+      success: false,
+      code: err.code,
+      message: err.message
+    };
+  }
+  if (err instanceof 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) ?? AgentPaymentNextAction.StopAndTellUser,
+      body: err.body
+    };
+  }
+  if (err instanceof 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: 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 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 budget: none configured.");
+    lines.push("  Until the wallet owner grants this agent a budget in Haven,");
+    lines.push("  every payment it attempts is declined on-chain.");
+  } else {
+    lines.push("On-chain budget (the real spend gate \u2014 enforced by the agent's");
+    lines.push("signed delegation, not by Haven):");
+    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 budget is declined before any money");
+  lines.push("moves \u2014 it is not queued, and no one is asked to review it. If the");
+  lines.push("agent needs more room, the wallet owner grants or raises the budget");
+  lines.push("in Haven. Revoking the agent on-chain disables every MCP tool that");
+  lines.push("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 resolve(`${credentialsPath}.ack.json`);
+}
+async function readAckFile(path) {
+  try {
+    const raw = await 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, hash) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(
+    path,
+    JSON.stringify({ ack: hash, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf8"
+  );
+}
+async function consentInputFromClient(haven, seed, toolNames) {
+  let allowanceSummary = seed.allowanceSummary ?? [];
+  let safeAddress = seed.safeAddress;
+  let delegateAddress = seed.delegateAddress;
+  let chainId = seed.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;
+    }
+    const liveAllowanceSummary = 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
+    }));
+    allowanceSummary = liveAllowanceSummary;
+  } 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 = {}) {
+  assertSupportedNodeVersion(options.nodeVersion);
+  const credentialSource = options.credentialsPath || options.identityPath || options.signerPath ? {
+    credentialsPath: options.credentialsPath,
+    identityPath: options.identityPath,
+    signerPath: options.signerPath
+  } : void 0;
+  const credentials = options.credentials ?? await loadCredentials(credentialSource);
+  const client = new HavenClient({
+    apiKey: credentials.apiKey,
+    delegateKey: credentials.delegateKey,
+    baseUrl: credentials.apiUrl
+  });
+  return { client, credentials };
+}
+var MCP_NAME = "@haven_ai/mcp";
+var MCP_VERSION = "0.0.0-dev.202609031523.fd49e1a";
+var MCP_INSTRUCTIONS = [
+  "Haven local MCP server: signs in-process with the delegate key it holds on",
+  "this machine \u2014 the key never leaves this process. Call haven_get_agent",
+  "first, every session: identity, readiness, and live remaining budget in",
+  "one call. Do not guess the wallet, network, or budget.",
+  "",
+  "To pay: haven_discover_tools to find a payable service, then",
+  "haven_pay_mcp_tool for MCP merchants or haven_pay_x402 for any x402",
+  "paywall. Tool responses carry nextAction \u2014 follow it; description prose",
+  "is fallback, not the source of truth.",
+  "",
+  "A payment outside the agent budget is declined before any money moves. Haven",
+  "holds no approval queue, so there is nothing to poll and no approval will",
+  "ever arrive for it. On a decline, or on any status you do not",
+  "recognise, stop and tell the user: do not retry or re-sign, and ask them to",
+  "grant or raise the budget in Haven. Spend authority is enforced on-chain by",
+  "the user's account; Haven never holds keys and cannot override it."
+].join("\n");
+function buildMcpServer(haven) {
+  const server = new McpServer(
+    {
+      name: MCP_NAME,
+      version: MCP_VERSION
+    },
+    { instructions: MCP_INSTRUCTIONS }
+  );
+  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;
+}
+function assertSupportedNodeVersion(nodeVersion = process.versions.node) {
+  if (isSupportedNodeVersion(nodeVersion)) return;
+  const err = new Error(
+    unsupportedNodeVersionMessage({ subject: "The Haven MCP server", nodeVersion })
+  );
+  err.code = "HAVEN_MCP_UNSUPPORTED_NODE";
+  throw err;
+}
+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 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,
+      delegateAddress: credentials.delegateAddress,
+      chainId: credentials.chainId,
+      allowanceSummary: credentials.allowanceSummary
+    },
+    toolNames
+  );
+  const credentialsPath = options.identityPath ?? 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 === "--identity") {
+      options.identityPath = argv[i + 1];
+      i += 1;
+    } else if (arg === "--signer") {
+      options.signerPath = 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",
+        "  npx @haven_ai/mcp --identity /path/to/identity.json --signer /path/to/signer.json",
+        "",
+        "Options:",
+        "  --credentials <path>       Haven credential JSON file. Also supported: HAVEN_CREDENTIALS.",
+        "  --identity <path>          Haven identity JSON file written by @haven_ai/connect.",
+        "  --signer <path>            Haven signer JSON file written by @haven_ai/connect.",
+        "  --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.js.map
+//# sourceMappingURL=cli.js.map