@haven_ai/connect 0.1.11-alpha.0 → 0.1.13-alpha.0

package/dist/cli.js

@@ -7,6 +7,7 @@ import { join, resolve, dirname } from 'path';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { registeredToolNames, MCP_VERSION, ensureConsent, computeConsentHash, loadCredentials, consentInputFromClient } from '@haven_ai/mcp';
+import { SKILL_FOLDER_NAME, HAVEN_SKILL_MD } from '@haven_ai/sdk';
 import { ensureSignerConsent, computeSignerConsentHash, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
 
 // src/api.ts
@@ -141,6 +142,7 @@ async function writeCredentialFiles(input) {
       safe_address: input.safeAddress,
       chain_id: input.chainId,
       network: input.network,
+      x402_binding_signer: input.x402BindingSigner,
       note: "Local signer credential. Haven backend never receives this private key."
     },
     input.warn
@@ -207,9 +209,9 @@ var MCP_RUNTIME_MANIFEST = {
   mcpPackage: "@haven_ai/mcp",
   mcpVersion: MCP_VERSION,
   sdkPackage: "@haven_ai/sdk",
-  sdkVersion: "0.1.11-alpha.0",
+  sdkVersion: "0.1.13-alpha.0",
   signerPackage: "@haven_ai/signer",
-  signerVersion: "0.1.11-alpha.0",
+  signerVersion: "0.1.13-alpha.0",
   minimumNodeVersion: "20.0.0",
   supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
   requiredTools: registeredToolNames()
@@ -382,10 +384,16 @@ function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
     headers: { Authorization: `Bearer ${apiKey}` }
   };
 }
-function buildSignerServer(signerPath, runtime) {
-  const server = {
+function resolveSignerLaunchSpec(input) {
+  return input.signerCommand ?? {
     command: "npx",
-    args: ["-y", signerPackageName(), "--credentials", signerPath]
+    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath]
+  };
+}
+function buildSignerServer(spec, runtime) {
+  const server = {
+    command: spec.command,
+    args: spec.args
   };
   if (runtime === "vscode" || runtime === "vscode-insiders") return { type: "stdio", ...server };
   return server;
@@ -418,7 +426,7 @@ function mergeCodexToml(existingToml, localMcpCommand) {
 `;
   return merged;
 }
-function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerPath) {
+function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerSpec) {
   let next = removeTomlTableTree(removeTomlTableTree(existingToml, "mcp_servers.haven"), "mcp_servers.haven_signer");
   next = next.trimEnd();
   const block = [
@@ -427,8 +435,8 @@ function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerPath) {
     `http_headers = { "Authorization" = ${tomlString(`Bearer ${apiKey}`)} }`,
     "",
     "[mcp_servers.haven_signer]",
-    'command = "npx"',
-    `args = ["-y", ${tomlString(signerPackageSpec())}, "--credentials", ${tomlString(signerPath)}]`,
+    `command = ${tomlString(signerSpec.command)}`,
+    `args = [${signerSpec.args.map((arg) => tomlString(arg)).join(", ")}]`,
     "startup_timeout_sec = 120"
   ].join("\n");
   validateCodexToml(block, "Generated Codex Haven config");
@@ -445,7 +453,7 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
       existing,
       serverRoot,
       buildHostedServer(input.hostedMcpUrl, input.apiKey, input.runtime),
-      buildSignerServer(input.signerPath, input.runtime)
+      buildSignerServer(resolveSignerLaunchSpec(input), input.runtime)
     );
     await writeOwnerOnlyText(target, merged);
     return {
@@ -501,7 +509,7 @@ async function writeCodexConfig(input) {
         ]
       };
     }
-    const merged = mergeCodexTomlHosted(existing ?? "", input.hostedMcpUrl, input.apiKey, input.signerPath);
+    const merged = mergeCodexTomlHosted(existing ?? "", input.hostedMcpUrl, input.apiKey, resolveSignerLaunchSpec(input));
     await writeOwnerOnlyText(target, merged);
     return {
       hostedConfigured: true,
@@ -786,9 +794,6 @@ function configTargetLabel(runtime) {
       return "runtime MCP config";
   }
 }
-function signerPackageName() {
-  return signerPackageSpec();
-}
 async function acknowledgeLocalMcpConsent(identityPath, signerPath, log) {
   try {
     const input = await buildLocalMcpConsentInput(identityPath, signerPath);
@@ -902,7 +907,7 @@ async function probeLocalSignerCredential(signerPath) {
   }
 }
 async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
     let stdout = "";
     let settled = false;
@@ -912,7 +917,7 @@ async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4)
       settled = true;
       clearTimeout(timeout);
       child.kill();
-      resolve7(result);
+      resolve8(result);
     };
     const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
     child.on("error", () => finish({ status: "process_error" }));
@@ -1150,75 +1155,126 @@ async function assertFileExists(path, label) {
     throw new Error(`Missing ${label}: ${path}`);
   }
 }
-
-// src/skill-content.ts
-var HAVEN_SKILL_MD = `---
-name: haven-pay
-description: Pay for things from the user's Haven wallet within their agent rules. Use when the user asks to send, pay, tip, or transfer crypto \u2014 or when a request hits an HTTP 402 (x402) paywall.
----
-
-# Haven: pay from a Haven wallet
-
-This skill lets the agent make payments from the user's Haven wallet through
-the Haven MCP tools. Every payment is checked against the agent's on-chain
-budget before money moves; payments above the remaining budget wait for the
-user's approval in Haven.
-
-## When to use this skill
-
-- The user asks to send money, pay someone, tip, donate, or transfer tokens.
-- A request returns HTTP 402 (x402): use the Haven pay tools to settle it,
-  then retry the original request.
-
-## Identity and budget come from the tools \u2014 never assume them
-
-Do not guess the wallet address, network, or budget. Read them live:
-
-- \`haven_get_agent\` \u2014 agent identity, Haven wallet address, network.
-- \`haven_get_allowances\` \u2014 current per-token budgets and what remains.
-
-Budgets reset on a period the user chose. If a payment exceeds the remaining
-budget it is queued for the user to approve in the Haven dashboard \u2014 this is
-normal, not an error.
-
-## Paying
-
-- **Direct transfer:** \`haven_pay\` with recipient, amount, and token.
-- **x402 paywall:** \`haven_quote_x402\` to get a quote, then
-  \`haven_pay_x402_quote\`. In the hosted setup the signing step happens in
-  the local Haven signer; follow the tool results \u2014 they tell you the next
-  action at every step. Retry the original request only when the result says
-  \`retry_original_x402_request\`.
-- **Status:** \`haven_get_payment_status\` with a \`payment_id\` to check on
-  queued or in-flight payments. Do not poll in a tight loop.
-
-## Approval semantics
-
-- A result with \`pending_approval\` means the payment exceeded the remaining
-  budget and is waiting for the user in Haven. Tell the user, then check
-  status later.
-- Never ask the user for private keys and never try to sign anything
-  yourself \u2014 Haven signs. If a tool reports a missing or invalid credential,
-  tell the user to re-run the Haven setup command.
-
-## Failure handling
-
-Haven errors are shaped \`{ error, status, details? }\` and written for
-humans \u2014 surface the message verbatim. Common cases:
-
-- \`pending_approval\`: queued for the user's approval (see above).
-- \`insufficient_funds\`: the Haven wallet doesn't hold enough of that token.
-  Suggest the user add funds in the Haven dashboard.
-- Budget exceeded: tell the user how much remains (from
-  \`haven_get_allowances\`) and that they can raise the budget in Haven.
-
-## Revoke
-
-If this agent's credential may have leaked, tell the user to pause or revoke
-the agent in the Haven dashboard under Agents. New requests stop immediately
-for that credential.
-`;
-var SKILL_FOLDER_NAME = "haven-pay";
+var execFileAsync2 = promisify(execFile);
+async function prepareSignerRuntime(input, deps = {}) {
+  const homeDir = input.homeDir ?? homedir();
+  const runtimeDirectory = resolve(homeDir, ".haven", "signer-runtime", MCP_RUNTIME_MANIFEST.signerVersion);
+  const npmCacheDirectory = resolve(homeDir, ".haven", "npm-cache");
+  const cliPath = join(runtimeDirectory, "node_modules", "@haven_ai", "signer", "dist", "cli.js");
+  const messages = [];
+  await mkdir(runtimeDirectory, { recursive: true, mode: 448 });
+  await chmod(runtimeDirectory, 448).catch(() => void 0);
+  await mkdir(npmCacheDirectory, { recursive: true, mode: 448 });
+  await chmod(npmCacheDirectory, 448).catch(() => void 0);
+  if (await installedRuntimeMatches2(runtimeDirectory, cliPath)) {
+    messages.push(`Using existing local Haven signer runtime ${signerPackageSpec()}.`);
+  } else {
+    await installRuntimePackages2(runtimeDirectory, npmCacheDirectory, deps.runCommand);
+    messages.push(`Installed local Haven signer runtime ${signerPackageSpec()}.`);
+  }
+  await assertFileExists2(cliPath, "local Haven signer CLI");
+  const wrapperPath = join(input.credentialDirectory, "bin", "haven-signer.mjs");
+  await writeWrapper2({ wrapperPath, cliPath, signerPath: input.signerPath });
+  await writeRuntimeSidecar2({
+    path: join(input.credentialDirectory, "signer-runtime.json"),
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath
+  });
+  messages.push(`Prepared stable local Haven signer wrapper: ${wrapperPath}`);
+  return {
+    command: wrapperPath,
+    args: [],
+    wrapperPath,
+    runtimeDirectory,
+    npmCacheDirectory,
+    cliPath,
+    messages
+  };
+}
+async function installRuntimePackages2(runtimeDirectory, npmCacheDirectory, runCommand) {
+  const args = [
+    "install",
+    "--prefix",
+    runtimeDirectory,
+    "--cache",
+    npmCacheDirectory,
+    "--no-audit",
+    "--no-fund",
+    "--omit=dev",
+    signerPackageSpec(),
+    sdkPackageSpec()
+  ];
+  try {
+    if (runCommand) await runCommand("npm", args);
+    else await execFileAsync2("npm", args, { timeout: 12e4, maxBuffer: 1024 * 1024 });
+  } catch (err) {
+    throw new Error(
+      `Could not install local Haven signer runtime ${signerPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function installedRuntimeMatches2(runtimeDirectory, cliPath) {
+  try {
+    await assertFileExists2(cliPath, "local Haven signer CLI");
+    const [signerPackage, sdkPackage] = await Promise.all([
+      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "signer", "package.json")),
+      readPackageJson2(join(runtimeDirectory, "node_modules", "@haven_ai", "sdk", "package.json"))
+    ]);
+    return signerPackage.version === MCP_RUNTIME_MANIFEST.signerVersion && sdkPackage.version === MCP_RUNTIME_MANIFEST.sdkVersion;
+  } catch {
+    return false;
+  }
+}
+async function readPackageJson2(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+async function writeWrapper2(input) {
+  await mkdir(dirname(input.wrapperPath), { recursive: true, mode: 448 });
+  await chmod(dirname(input.wrapperPath), 448).catch(() => void 0);
+  const source = [
+    "#!/usr/bin/env node",
+    "import { spawn } from 'node:child_process'",
+    "",
+    `const cliPath = ${JSON.stringify(input.cliPath)}`,
+    `const signerPath = ${JSON.stringify(input.signerPath)}`,
+    "",
+    "const child = spawn(process.execPath, [cliPath, '--credentials', signerPath, ...process.argv.slice(2)], {",
+    "  stdio: 'inherit',",
+    "})",
+    "",
+    "child.on('exit', (code, signal) => {",
+    "  if (signal) process.kill(process.pid, signal)",
+    "  else process.exit(code ?? 1)",
+    "})",
+    ""
+  ].join("\n");
+  await writeFile(input.wrapperPath, source, { mode: 448 });
+  await chmod(input.wrapperPath, 448).catch(() => void 0);
+}
+async function writeRuntimeSidecar2(input) {
+  const value = {
+    signer_package: MCP_RUNTIME_MANIFEST.signerPackage,
+    signer_version: MCP_RUNTIME_MANIFEST.signerVersion,
+    sdk_package: MCP_RUNTIME_MANIFEST.sdkPackage,
+    sdk_version: MCP_RUNTIME_MANIFEST.sdkVersion,
+    wrapper_path: input.wrapperPath,
+    runtime_directory: input.runtimeDirectory,
+    npm_cache_directory: input.npmCacheDirectory,
+    cli_path: input.cliPath
+  };
+  await writeFile(input.path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await chmod(input.path, 384).catch(() => void 0);
+}
+async function assertFileExists2(path, label) {
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`Missing ${label}: ${path}`);
+  }
+}
 async function acknowledgeLocalSignerConsent(signerPath, log) {
   try {
     const input = await buildSignerConsentInput(signerPath);
@@ -1290,7 +1346,7 @@ function writeLogChunk2(log, chunk) {
 }
 
 // src/runtime-install.ts
-var execFileAsync2 = promisify(execFile);
+var execFileAsync3 = promisify(execFile);
 async function installRuntime(input, deps = {}) {
   const runtime = normalizeRuntime(input.runtime, deps.env);
   const profile = runtimeProfile(runtime, deps.env);
@@ -1351,7 +1407,20 @@ async function installRuntime(input, deps = {}) {
       ]
     };
   }
-  const configResult = runtime === "claude-code" ? localRuntime ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await configureClaudeCodeHosted(deps, input) : await writeRuntimeConfig({
+  let signerCommand;
+  if (!localRuntime) {
+    try {
+      const signerRuntime = await prepareSignerForRuntime(input, deps);
+      signerCommand = { command: signerRuntime.command, args: signerRuntime.args };
+      consentMessages.push(...signerRuntime.messages);
+    } catch (err) {
+      consentMessages.push(
+        `Could not pre-install the local Haven signer; falling back to npx launch: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const signerRuntimePrepared = localRuntime ? void 0 : signerCommand !== void 0;
+  const configResult = runtime === "claude-code" ? localRuntime ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await configureClaudeCodeHosted(deps, input, signerCommand) : await writeRuntimeConfig({
     runtime,
     hostedMcpUrl: input.hostedMcpUrl,
     apiKey: input.apiKey,
@@ -1359,6 +1428,7 @@ async function installRuntime(input, deps = {}) {
     signerPath: input.signerPath,
     credentialDirectory: input.credentialDirectory,
     localMcpCommand: localRuntimeInstall?.command,
+    signerCommand,
     homeDir: deps.homeDir,
     mode: localRuntime ? "local" : "hosted"
   });
@@ -1390,6 +1460,7 @@ async function installRuntime(input, deps = {}) {
     localMcpAcknowledged: localMcpConsent?.acknowledged,
     activationCommand: configResult.activationCommand,
     skillInstalled: skillInstall?.installed,
+    signerRuntimePrepared,
     messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...localProbeMessages, ...skillInstall?.messages ?? []]
   };
 }
@@ -1446,7 +1517,7 @@ async function configureClaudeCode(deps, localMcpCommand) {
     };
   }
 }
-async function configureClaudeCodeHosted(deps, input) {
+async function configureClaudeCodeHosted(deps, input, signerCommand) {
   const runCommand = deps.runCommand ?? defaultRunCommand;
   const hostedJson = JSON.stringify({
     type: "http",
@@ -1455,8 +1526,8 @@ async function configureClaudeCodeHosted(deps, input) {
   });
   const signerJson = JSON.stringify({
     type: "stdio",
-    command: "npx",
-    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath],
+    command: signerCommand?.command ?? "npx",
+    args: signerCommand?.args ?? ["-y", signerPackageSpec(), "--credentials", input.signerPath],
     env: {}
   });
   try {
@@ -1497,7 +1568,7 @@ async function configureClaudeCodeHosted(deps, input) {
   }
 }
 async function defaultRunCommand(command, args) {
-  await execFileAsync2(command, args, { timeout: 1e4 });
+  await execFileAsync3(command, args, { timeout: 1e4 });
 }
 async function installClaudeSkill(homeDir) {
   try {
@@ -1580,6 +1651,14 @@ async function prepareRuntimeForLocalMcp(input, deps) {
     homeDir: deps.homeDir
   });
 }
+async function prepareSignerForRuntime(input, deps) {
+  const prepare = deps.prepareSignerRuntime ?? ((runtimeInput) => prepareSignerRuntime(runtimeInput, { runCommand: deps.runCommand }));
+  return prepare({
+    credentialDirectory: input.credentialDirectory,
+    signerPath: input.signerPath,
+    homeDir: deps.homeDir
+  });
+}
 async function runLocalMcpProbe(runtimeInstall, deps) {
   const probe = deps.probeLocalMcpTools ?? probeLocalMcpTools;
   try {
@@ -1596,7 +1675,7 @@ function localRuntimePrepareErrorCode(err) {
 }
 
 // src/runtime.ts
-var CONNECTOR_VERSION = "0.1.11-alpha.0";
+var CONNECTOR_VERSION = "0.1.13-alpha.0";
 async function runConnect(options, deps = {}) {
   const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
   const api = deps.api ?? createConnectApiClient(options.apiBaseUrl);
@@ -1661,10 +1740,18 @@ async function runConnect(options, deps = {}) {
     })),
     apiUrl: options.apiBaseUrl,
     hostedMcpUrl: registration.hosted_mcp_url,
+    x402BindingSigner: setup.x402_binding_signer ?? void 0,
     warn: log
   });
   log(`Stored Haven identity credential locally: ${credentialPaths.identityPath}`);
   log(`Stored local signer credential locally: ${credentialPaths.signerPath}`);
+  if (setup.x402_binding_signer) {
+    log("Configured x402 binding signer for the local signer.");
+  } else {
+    log(
+      "Warning: Haven did not provide an x402 binding signer, so x402 payments will not sign until HAVEN_X402_BINDING_SIGNER is set for the signer. Non-x402 payments are unaffected."
+    );
+  }
   const runtimeInstall = await runRuntimeInstall({
     runtime: options.runtime,
     hostedMcpUrl: registration.hosted_mcp_url,