@haven_ai/signer 0.1.0-alpha

package/dist/cli.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { randomUUID, createHash } from 'crypto';
+import { readFile, mkdir, writeFile, stat, appendFile } from 'fs/promises';
+import { homedir } from 'os';
+import { resolve, dirname } from 'path';
+import { addressFromKey, HavenSigningError, selectStandardPaymentOption, HavenApiError, toStandardPaymentRequirements, x402AuthorizationAmount, buildX402ExpectedMessage, verifySignature, signHash, HavenError } from '@haven_ai/sdk';
+import { z } from 'zod/v3';
+import { hashMessage } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { exact } from 'x402/schemes';
+
+function defaultSigningAuditPath(credentialsPath) {
+  if (credentialsPath) return resolve(`${credentialsPath}.signer-audit.jsonl`);
+  return resolve(homedir(), ".haven", "signer-audit.jsonl");
+}
+async function appendSigningAuditEntry(entry, path) {
+  await mkdir(dirname(path), { recursive: true });
+  await appendFile(path, `${JSON.stringify(entry)}
+`, "utf8");
+}
+function createSigningAuditEntry(tool, payloadHash, context, now = /* @__PURE__ */ new Date()) {
+  const entry = {
+    version: 1,
+    timestamp: now.toISOString(),
+    tool,
+    payload_hash: payloadHash,
+    delegate_address: context.delegateAddress
+  };
+  if (context.safeAddress) entry.safe_address = context.safeAddress;
+  if (typeof context.chainId === "number") entry.chain_id = context.chainId;
+  return entry;
+}
+function hashPayloadForAudit(payload) {
+  return `0x${createHash("sha256").update(stableStringify(payload)).digest("hex")}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    const primitive = JSON.stringify(value);
+    return primitive === void 0 ? "undefined" : primitive;
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
+}
+var x402ExpectedSchema = z.object({
+  payment_id: z.string().min(1),
+  payload_hash: z.string().regex(/^0x[0-9a-fA-F]+$/, "payload_hash must be a 0x-prefixed hex string"),
+  resource_url: z.string().url(),
+  merchant_to: z.string().min(1),
+  amount: z.string().min(1),
+  asset: z.string().min(1),
+  network: z.string().min(1),
+  auth: z.object({
+    version: z.literal(1),
+    message: z.string().min(1),
+    signature: z.string().regex(/^0x[0-9a-fA-F]+$/, "signature must be a 0x-prefixed hex string"),
+    signer: z.string().min(1)
+  })
+});
+var toolSchemas = {
+  haven_sign: {
+    // The unsigned hash from haven_pay / haven_x402_authorize (payload_hash).
+    payload_hash: z.string().regex(/^0x[0-9a-fA-F]+$/, "payload_hash must be a 0x-prefixed hex string"),
+    // Pass x402.expected from hosted haven_x402_authorize when this hash funds
+    // a standard x402 merchant retry. The signer records it locally and returns
+    // an opaque x402_binding for the later header-signing step.
+    x402_expected: x402ExpectedSchema.optional()
+  },
+  haven_x402_sign_header: {
+    // The parsed HTTP 402 PaymentRequired from the merchant.
+    payment_required: z.unknown(),
+    // Opaque binding returned by haven_sign when x402_expected was supplied.
+    x402_binding: z.string().min(1)
+  }
+};
+var SIGN_DESCRIPTION = [
+  "Sign an unsigned Haven payment hash with the delegate key on this machine.",
+  "Pass the payload_hash returned by haven_pay or haven_x402_authorize. For x402, also pass",
+  "x402_expected from haven_x402_authorize; the signer records it locally and returns",
+  "{ signature, x402_binding }. Hand signature to haven_submit, then use x402_binding for",
+  "haven_x402_sign_header. The delegate key never leaves this process."
+].join(" ");
+var X402_SIGN_HEADER_DESCRIPTION = [
+  "Build and sign the EIP-3009 X-PAYMENT header for the merchant leg of an x402 payment, using",
+  "the delegate key on this machine. Pass the same payment_required you gave haven_x402_authorize",
+  "and the x402_binding returned by haven_sign. The signer consumes the recorded funding context",
+  "and rejects mismatched amount, merchant, resource, asset, or network before signing. Returns",
+  "{ payment_header } to send to the merchant as the X-PAYMENT header on your retry. Do this only",
+  "after the funding step (haven_submit) has confirmed."
+].join(" ");
+var toolDescriptions = {
+  haven_sign: SIGN_DESCRIPTION,
+  haven_x402_sign_header: X402_SIGN_HEADER_DESCRIPTION
+};
+function createToolHandlers(signer, options = {}) {
+  return {
+    haven_sign: async (input) => runTool(async () => {
+      const args = parse("haven_sign", input);
+      const x402Expected = args.x402_expected ? {
+        paymentId: args.x402_expected.payment_id,
+        payloadHash: args.x402_expected.payload_hash,
+        resourceUrl: args.x402_expected.resource_url,
+        merchantTo: args.x402_expected.merchant_to,
+        amount: args.x402_expected.amount,
+        asset: args.x402_expected.asset,
+        network: args.x402_expected.network,
+        auth: args.x402_expected.auth
+      } : null;
+      const result = x402Expected ? signer.signX402FundingHash(args.payload_hash, x402Expected) : null;
+      if (!result) {
+        const signature = signer.signPaymentHash(args.payload_hash);
+        await auditSigning("haven_sign", args.payload_hash);
+        return { signature };
+      }
+      await auditSigning("haven_sign", args.payload_hash);
+      return { signature: result.signature, x402_binding: result.x402Binding };
+    }),
+    haven_x402_sign_header: async (input) => runTool(async () => {
+      const args = parse("haven_x402_sign_header", input);
+      const result = await signer.buildX402PaymentHeader(
+        args.payment_required,
+        args.x402_binding
+      );
+      await auditSigning(
+        "haven_x402_sign_header",
+        hashPayloadForAudit(args.payment_required)
+      );
+      return { payment_header: result.paymentHeader, accepted: result.accepted };
+    })
+  };
+  async function auditSigning(tool, payloadHash) {
+    if (!options.audit) return;
+    const { auditPath, ...context } = options.audit;
+    await appendSigningAuditEntry(
+      createSigningAuditEntry(tool, payloadHash, {
+        ...context,
+        delegateAddress: signer.delegateAddress
+      }),
+      auditPath
+    );
+  }
+}
+function parse(name, input) {
+  return z.object(toolSchemas[name]).parse(input ?? {});
+}
+async function runTool(fn) {
+  try {
+    return { success: true, data: await fn() };
+  } catch (err) {
+    return normalizeError(err);
+  }
+}
+function normalizeError(err) {
+  if (err instanceof z.ZodError) {
+    return {
+      success: false,
+      code: "INVALID_INPUT",
+      message: err.errors.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`).join("; "),
+      statusCode: 400
+    };
+  }
+  if (err instanceof HavenSigningError) {
+    return { success: false, code: err.code, message: err.message };
+  }
+  if (err instanceof HavenApiError) {
+    return { success: false, code: err.code, message: err.message, statusCode: err.statusCode };
+  }
+  if (err instanceof HavenError) {
+    return { success: false, code: err.code, message: err.message, statusCode: err.statusCode };
+  }
+  return {
+    success: false,
+    code: "UNKNOWN_ERROR",
+    message: err instanceof Error ? err.message : String(err)
+  };
+}
+
+// src/consent.ts
+var SIGNER_ACK_ENV = "HAVEN_SIGNER_ACK";
+function computeSignerConsentHash(input) {
+  const identity = [
+    input.delegateAddress.toLowerCase(),
+    (input.safeAddress ?? "").toLowerCase(),
+    input.agentId ?? "",
+    input.chainId ?? "",
+    input.network ?? ""
+  ].join("|");
+  const toolCanonical = [...input.toolNames].sort().join(",");
+  return createHash("sha256").update(`${identity}
+${toolCanonical}`).digest("hex").slice(0, 16);
+}
+function renderSignerConsentBlock(input, hash) {
+  const lines = [
+    "",
+    "------------------------------------------------------------",
+    "Haven edge signer - first-launch consent",
+    "------------------------------------------------------------",
+    "",
+    `Delegate address: ${input.delegateAddress}`
+  ];
+  lines.push(`Haven wallet:     ${input.safeAddress ?? "not provided to this signer"}`);
+  if (input.agentId) lines.push(`Agent ID:         ${input.agentId}`);
+  if (typeof input.chainId === "number") lines.push(`Chain ID:         ${input.chainId}`);
+  if (input.network) lines.push(`Network:          ${input.network}`);
+  lines.push("");
+  lines.push("This local signer holds the delegate key on this machine and signs");
+  lines.push("payment payloads or x402 merchant headers for the delegate address above.");
+  lines.push("It does not call the Haven API, so it cannot show a live allowance summary.");
+  lines.push("On-chain Safe rules remain the real spend gate, and the wallet owner can");
+  lines.push("pause or revoke agent authority outside this signer.");
+  lines.push("");
+  lines.push("Tools this signer will expose to your agent runtime:");
+  for (const name of input.toolNames) {
+    lines.push(`  - ${name}`);
+    lines.push(`      ${toolDescriptions[name]}`);
+  }
+  lines.push("");
+  lines.push("A local audit entry is appended for every signing operation. Audit entries");
+  lines.push("record timestamp, tool, payload hash, and delegate address; never the key,");
+  lines.push("signature, or x402 payment header.");
+  lines.push("");
+  lines.push(`Consent hash: ${hash}`);
+  lines.push("");
+  lines.push("To acknowledge, EITHER:");
+  lines.push(`  - set ${SIGNER_ACK_ENV}=${hash} in this process's environment, OR`);
+  lines.push("  - re-run with --ack to write the acknowledgement next to your");
+  lines.push("    credential file (sidecar <credentials>.signer-ack.json).");
+  lines.push("");
+  lines.push("------------------------------------------------------------");
+  lines.push("");
+  return lines.join("\n");
+}
+async function ensureSignerConsent(input, options = {}) {
+  const env = options.env ?? process.env;
+  const out = options.out ?? process.stderr;
+  const hash = computeSignerConsentHash(input);
+  const envAck = env[SIGNER_ACK_ENV];
+  if (typeof envAck === "string" && envAck.length > 0) {
+    if (envAck === hash) return { ok: true, hash, reason: "env_var_match" };
+    out.write(renderSignerConsentBlock(input, hash));
+    out.write(
+      `${SIGNER_ACK_ENV} was set but did not match the current signer consent hash.
+Expected: ${hash}
+Got:      ${envAck}
+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(renderSignerConsentBlock(input, hash));
+    await writeAckFile(ackPath, hash);
+    out.write(`Wrote acknowledgement to ${ackPath}
+
+`);
+    return { ok: true, hash, reason: "wrote_ack_file" };
+  }
+  out.write(renderSignerConsentBlock(input, hash));
+  return { ok: false, hash, reason: "no_acknowledgement" };
+}
+function registeredSignerToolNames() {
+  return Object.keys(toolSchemas);
+}
+function sidecarPath(credentialsPath) {
+  if (!credentialsPath) return null;
+  return resolve(`${credentialsPath}.signer-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"
+  );
+}
+function createEdgeSigner(delegateKey, options = {}) {
+  let delegateAddress;
+  try {
+    delegateAddress = addressFromKey(delegateKey);
+  } catch (err) {
+    throw new HavenSigningError(
+      `Invalid delegate key: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const x402Bindings = /* @__PURE__ */ new Map();
+  function signAndVerify(hash) {
+    const signature = signHash(delegateKey, hash);
+    if (!verifySignature(hash, signature, delegateAddress)) {
+      throw new HavenSigningError(
+        "Local signature verification failed \u2014 recovered address does not match the delegate key."
+      );
+    }
+    return signature;
+  }
+  return {
+    delegateAddress,
+    signPaymentHash(hash) {
+      return signAndVerify(hash);
+    },
+    signX402FundingHash(hash, expected) {
+      assertExpectedBinding(hash, expected, options.x402BindingSigner);
+      const signature = signAndVerify(hash);
+      const x402Binding = randomUUID();
+      x402Bindings.set(x402Binding, { ...expected });
+      return { signature, x402Binding };
+    },
+    async buildX402PaymentHeader(paymentRequired, x402Binding) {
+      const expected = x402Bindings.get(x402Binding);
+      if (!expected) {
+        throw new HavenSigningError(
+          "x402 funding binding is required before signing a merchant header. Sign the hosted funding hash with x402_expected first."
+        );
+      }
+      const option = selectStandardPaymentOption(paymentRequired.accepts);
+      if (!option) {
+        throw new HavenApiError(
+          "No compatible payment option found in x402 requirements. Haven supports standard x402 exact payments on Base USDC.",
+          400
+        );
+      }
+      assertX402MatchesExpected(paymentRequired, option, expected);
+      const account = privateKeyToAccount(delegateKey);
+      const requirements = toStandardPaymentRequirements(paymentRequired, option);
+      const header = await exact.evm.createPaymentHeader(
+        account,
+        paymentRequired.x402Version,
+        requirements
+      );
+      if (paymentRequired.x402Version < 2) {
+        x402Bindings.delete(x402Binding);
+        return { paymentHeader: header, accepted: option };
+      }
+      try {
+        const payment = decodeBase64Json(header);
+        const wrapped = encodeBase64Json({
+          x402Version: paymentRequired.x402Version,
+          accepted: option,
+          payload: payment.payload
+        });
+        return { paymentHeader: wrapped, accepted: option };
+      } finally {
+        x402Bindings.delete(x402Binding);
+      }
+    }
+  };
+}
+function assertX402MatchesExpected(paymentRequired, option, expected) {
+  assertExpectedShape(expected);
+  const headerResource = option.resource ?? paymentRequired.resource.url;
+  if (headerResource !== expected.resourceUrl) {
+    throw new HavenSigningError("x402 payment_required resource does not match the funded intent.");
+  }
+  if (!sameAddress(option.payTo, expected.merchantTo)) {
+    throw new HavenSigningError("x402 merchant recipient does not match the funded intent.");
+  }
+  if (x402AuthorizationAmount(option) !== expected.amount) {
+    throw new HavenSigningError("x402 amount does not match the funded intent.");
+  }
+  if (!sameAddress(option.asset, expected.asset)) {
+    throw new HavenSigningError("x402 asset does not match the funded intent.");
+  }
+  if (option.network !== expected.network) {
+    throw new HavenSigningError("x402 network does not match the funded intent.");
+  }
+}
+function assertExpectedShape(expected) {
+  if (!expected || typeof expected !== "object") {
+    throw new HavenSigningError("x402 expected funding context is required before signing a merchant header.");
+  }
+}
+function assertExpectedBinding(payloadHash, expected, trustedSigner) {
+  assertExpectedShape(expected);
+  if (!trustedSigner) {
+    throw new HavenSigningError(
+      "x402 expected-context verifier is not configured. Set HAVEN_X402_BINDING_SIGNER before signing x402 funding hashes."
+    );
+  }
+  if (expected.payloadHash.toLowerCase() !== payloadHash.toLowerCase()) {
+    throw new HavenSigningError("x402 expected context does not match the funding hash being signed.");
+  }
+  const message = buildX402ExpectedMessage({
+    paymentId: expected.paymentId,
+    payloadHash: expected.payloadHash,
+    resourceUrl: expected.resourceUrl,
+    merchantTo: expected.merchantTo,
+    amount: expected.amount,
+    asset: expected.asset,
+    network: expected.network
+  });
+  if (expected.auth?.version !== 1 || expected.auth.message !== message) {
+    throw new HavenSigningError("x402 expected context authentication message is invalid.");
+  }
+  if (!sameAddress(expected.auth.signer, trustedSigner)) {
+    throw new HavenSigningError("x402 expected context was not signed by the configured Haven signer.");
+  }
+  if (!verifySignature(hashMessage(message), expected.auth.signature, trustedSigner)) {
+    throw new HavenSigningError("x402 expected context signature could not be verified.");
+  }
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function decodeBase64Json(value) {
+  return JSON.parse(Buffer.from(value, "base64").toString("utf8"));
+}
+function encodeBase64Json(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+async function loadSignerCredentials(path = process.env.HAVEN_CREDENTIALS) {
+  if (path) return loadFromFile(path);
+  const envKey = stringField(process.env.HAVEN_DELEGATE_KEY);
+  if (envKey) {
+    return {
+      delegateKey: envKey,
+      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),
+      x402BindingSigner: stringField(process.env.HAVEN_X402_BINDING_SIGNER)
+    };
+  }
+  throw new Error(
+    "No delegate key found. Set HAVEN_DELEGATE_KEY, pass --credentials <path>, or set HAVEN_CREDENTIALS to a Haven agent credential JSON file."
+  );
+}
+async function loadFromFile(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 a delegate_key field.");
+  }
+  const delegateKey = stringField(raw.delegate_key ?? raw.delegateKey);
+  if (!delegateKey) {
+    throw new Error("Haven credentials are missing delegate_key \u2014 the edge signer needs it to sign.");
+  }
+  const chainId = numberField(raw.chain_id ?? raw.chainId);
+  return {
+    delegateKey,
+    agentId: stringField(raw.agent_id ?? raw.agentId),
+    safeAddress: stringField(raw.safe_address ?? raw.safeAddress),
+    chainId,
+    network: stringField(raw.network),
+    x402BindingSigner: stringField(
+      raw.x402_binding_signer ?? raw.x402BindingSigner ?? process.env.HAVEN_X402_BINDING_SIGNER
+    ),
+    sourcePath: path
+  };
+}
+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()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+async function warnIfCredentialFilePermissive(path, log = (message) => process.stderr.write(`${message}
+`), platform = process.platform) {
+  if (platform === "win32") return;
+  let mode;
+  try {
+    mode = (await stat(path)).mode;
+  } catch {
+    return;
+  }
+  if ((mode & 63) !== 0) {
+    const octal = (mode & 511).toString(8).padStart(4, "0");
+    log(
+      `haven-signer: warning: credential file at ${path} is readable beyond the owner (mode ${octal}). Run: chmod 600 ${path}`
+    );
+  }
+}
+
+// src/server.ts
+var SIGNER_NAME = "@haven_ai/signer";
+var SIGNER_VERSION = "0.1.0-alpha";
+async function resolveSignerRuntime(options = {}) {
+  if (options.delegateKey) {
+    return {
+      signer: createEdgeSigner(options.delegateKey, {
+        x402BindingSigner: options.x402BindingSigner ?? process.env.HAVEN_X402_BINDING_SIGNER
+      })
+    };
+  }
+  const creds = await loadSignerCredentials(options.credentialsPath);
+  return {
+    signer: createEdgeSigner(creds.delegateKey, {
+      x402BindingSigner: options.x402BindingSigner ?? creds.x402BindingSigner ?? process.env.HAVEN_X402_BINDING_SIGNER
+    }),
+    credentials: creds
+  };
+}
+function buildSignerMcpServer(signer, options = {}) {
+  const server = new McpServer({ name: SIGNER_NAME, version: SIGNER_VERSION });
+  const credentialsPath = options.credentials?.sourcePath;
+  const handlers = createToolHandlers(signer, {
+    audit: {
+      auditPath: options.auditPath ?? defaultSigningAuditPath(credentialsPath),
+      delegateAddress: signer.delegateAddress,
+      safeAddress: options.credentials?.safeAddress,
+      chainId: options.credentials?.chainId
+    }
+  });
+  const registerTool = server.tool.bind(server);
+  for (const name of Object.keys(toolSchemas)) {
+    registerTool(
+      name,
+      toolDescriptions[name],
+      toolSchemas[name],
+      async (args) => toMcpResult(await handlers[name](args))
+    );
+  }
+  return server;
+}
+async function runSignerStdioServer(options = {}) {
+  const { signer, credentials } = await resolveSignerRuntime(options);
+  if (!options.skipConsent) {
+    const decision = await runSignerConsentGate(signer, credentials, options);
+    if (!decision.ok) {
+      const err = new Error(
+        decision.reason === "env_var_mismatch" ? "Haven edge signer consent acknowledgement does not match the current configuration." : "Haven edge signer requires a one-time consent acknowledgement before starting."
+      );
+      err.code = "HAVEN_SIGNER_NO_CONSENT";
+      throw err;
+    }
+  }
+  const server = buildSignerMcpServer(signer, { credentials, auditPath: options.auditPath });
+  await server.connect(new StdioServerTransport());
+}
+async function runSignerConsentGate(signer, credentials, options) {
+  return ensureSignerConsent(
+    {
+      delegateAddress: signer.delegateAddress,
+      safeAddress: credentials?.safeAddress,
+      agentId: credentials?.agentId,
+      chainId: credentials?.chainId,
+      network: credentials?.network,
+      toolNames: registeredSignerToolNames()
+    },
+    {
+      credentialsPath: options.credentialsPath ?? credentials?.sourcePath,
+      writeAck: options.writeAck,
+      env: options.consentEnv,
+      out: options.consentOut
+    }
+  );
+}
+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 === "--ack") {
+      options.writeAck = true;
+    } else if (arg === "--help" || arg === "-h") {
+      process.stdout.write(
+        [
+          "Haven edge signer (local, holds the delegate key)",
+          "",
+          "Runs a local stdio MCP server exposing sign-only tools (haven_sign,",
+          "haven_x402_sign_header). Pair it with the hosted, keyless Haven MCP",
+          "server: the hosted server constructs and relays, this one signs.",
+          "",
+          "Usage:",
+          "  npx @haven_ai/signer --credentials /path/to/agent.json",
+          "",
+          "Options:",
+          "  --credentials <path>   Haven credential JSON (delegate_key is read from it).",
+          "                         Also supported: HAVEN_CREDENTIALS, or HAVEN_DELEGATE_KEY.",
+          "  --ack                  Acknowledge the first-launch consent block and write",
+          "                         a signer sidecar acknowledgement next to the credential.",
+          "",
+          "Consent:",
+          "  On first launch the signer prints the sign-only tool list and delegate",
+          "  address, then refuses to start unless acknowledged. It has no API access,",
+          "  so it cannot show a live allowance summary.",
+          "  Acknowledge with EITHER --ack OR HAVEN_SIGNER_ACK=<hash> in your environment.",
+          ""
+        ].join("\n")
+      );
+      process.exit(0);
+    }
+  }
+  return options;
+}
+async function main() {
+  await runSignerStdioServer(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