@haven_ai/connect 0.1.0-alpha → 0.1.1-alpha

package/dist/cli.js

@@ -6,6 +6,7 @@ import { homedir, platform } from 'os';
 import { join, resolve, dirname } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
+import { ensureSignerConsent, computeSignerConsentHash, SIGNER_VERSION, loadSignerCredentials, createEdgeSigner, toolSchemas } from '@haven_ai/signer';
 
 // src/api.ts
 function createConnectApiClient(baseUrl, fetchImpl = fetch) {
@@ -47,6 +48,8 @@ function createConnectApiClient(baseUrl, fetchImpl = fetch) {
           hosted_mcp_configured: input.hostedMcpConfigured,
           local_signer_configured: input.localSignerConfigured,
           credential_files_written: input.credentialFilesWritten,
+          signer_acknowledged: input.signerAcknowledged,
+          activation_command_available: input.activationCommandAvailable,
           probe_result: input.probeResult,
           restart_required: input.restartRequired,
           next_user_action: input.nextUserAction,
@@ -231,7 +234,7 @@ function buildHostedServer(hostedMcpUrl, apiKey, runtime) {
 function buildSignerServer(signerPath, runtime) {
   const server = {
     command: "npx",
-    args: ["-y", "@haven_ai/signer", "--credentials", signerPath]
+    args: ["-y", signerPackageName(), "--credentials", signerPath]
   };
   if (runtime === "vscode") return { type: "stdio", ...server };
   return server;
@@ -258,7 +261,7 @@ function mergeCodexToml(existingToml, hostedMcpUrl, signerPath) {
     "",
     "[mcp_servers.haven_signer]",
     'command = "npx"',
-    `args = ["-y", "@haven_ai/signer", "--credentials", ${tomlString(signerPath)}]`
+    `args = ["-y", ${tomlString(signerPackageName())}, "--credentials", ${tomlString(signerPath)}]`
   ].join("\n");
   return `${next ? `${next}
 
@@ -298,23 +301,35 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
 async function writeCodexConfig(input) {
   const target = codexConfigPath(input.homeDir);
   const envTarget = join(input.credentialDirectory, "identity.env");
+  const launchTarget = join(input.credentialDirectory, "start-codex.sh");
   try {
     const existing = await readOptional(target);
     const merged = mergeCodexToml(existing ?? "", input.hostedMcpUrl, input.signerPath);
     await writeOwnerOnlyText(target, merged);
-    await writeOwnerOnlyText(envTarget, `HAVEN_TOKEN=${shellToken(input.apiKey)}
+    await writeOwnerOnlyText(envTarget, `export HAVEN_TOKEN=${shellToken(input.apiKey)}
 `);
+    await writeOwnerExecutableText(
+      launchTarget,
+      [
+        "#!/bin/sh",
+        "set -eu",
+        `. ${shellToken(envTarget)}`,
+        'exec codex "$@"',
+        ""
+      ].join("\n")
+    );
     return {
-      hostedConfigured: false,
+      hostedConfigured: true,
       signerConfigured: true,
       target: "Codex CLI config",
       changed: existing !== merged,
       restartRequired: true,
+      activationCommand: shellToken(launchTarget),
       messages: [
         "Updated Haven MCP entries in Codex CLI config.",
-        "Wrote the hosted MCP token to a private env file. Launch Codex with that env file before using Haven tools."
-      ],
-      errorCode: "codex_env_activation_required"
+        "Wrote the hosted MCP token to a private env file.",
+        `Restart Codex with: ${shellToken(launchTarget)}`
+      ]
     };
   } catch (err) {
     return {
@@ -341,6 +356,11 @@ async function writeOwnerOnlyText(path, value) {
   await writeFile(path, value, { mode: 384 });
   await chmod(path, 384).catch(() => void 0);
 }
+async function writeOwnerExecutableText(path, value) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, value, { mode: 448 });
+  await chmod(path, 448).catch(() => void 0);
+}
 function parseJsonObject(value) {
   const parsed = JSON.parse(value);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -406,6 +426,9 @@ function configTargetLabel(runtime) {
       return "runtime MCP config";
   }
 }
+function signerPackageName() {
+  return `@haven_ai/signer@${SIGNER_VERSION}`;
+}
 async function probeHostedMcpTools(apiKey, hostedMcpUrl, fetchImpl = fetch) {
   let response;
   try {
@@ -554,24 +577,100 @@ function detectRuntime(env) {
   if (env.VSCODE_CWD || env.VSCODE_IPC_HOOK_CLI || env.TERM_PROGRAM === "vscode") return "vscode";
   return null;
 }
+async function acknowledgeLocalSignerConsent(signerPath, log) {
+  try {
+    const input = await buildSignerConsentInput(signerPath);
+    const decision = await ensureSignerConsent(input, {
+      credentialsPath: signerPath,
+      writeAck: true,
+      out: log ? { write: (chunk) => writeLogChunk(log, chunk) } : void 0
+    });
+    return {
+      acknowledged: decision.ok,
+      hash: decision.hash,
+      reason: decision.reason
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function getLocalSignerConsentStatus(signerPath) {
+  try {
+    const input = await buildSignerConsentInput(signerPath);
+    const hash = computeSignerConsentHash(input);
+    const stored = await readSignerAckFile(signerAckPath(signerPath));
+    if (stored === hash) {
+      return { acknowledged: true, hash, reason: "ack_file_match" };
+    }
+    return {
+      acknowledged: false,
+      hash,
+      reason: stored ? "ack_file_mismatch" : "ack_file_missing"
+    };
+  } catch (err) {
+    return {
+      acknowledged: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function signerAckPath(signerPath) {
+  return resolve(`${signerPath}.signer-ack.json`);
+}
+async function buildSignerConsentInput(signerPath) {
+  const credentials = await loadSignerCredentials(signerPath);
+  const signer = createEdgeSigner(credentials.delegateKey, {
+    x402BindingSigner: credentials.x402BindingSigner
+  });
+  return {
+    delegateAddress: signer.delegateAddress,
+    safeAddress: credentials.safeAddress,
+    agentId: credentials.agentId,
+    chainId: credentials.chainId,
+    network: credentials.network,
+    toolNames: Object.keys(toolSchemas)
+  };
+}
+async function readSignerAckFile(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed.ack === "string" ? parsed.ack : null;
+  } catch {
+    return null;
+  }
+}
+function writeLogChunk(log, chunk) {
+  const message = String(chunk).trimEnd();
+  if (message) log(message);
+}
 
 // src/runtime-install.ts
 var execFileAsync = promisify(execFile);
 async function installRuntime(input, deps = {}) {
   const runtime = normalizeRuntime(input.runtime, deps.env);
   const profile = runtimeProfile(runtime, deps.env);
+  const signerConsentMessages = [];
+  const signerConsent = await resolveSignerConsent(input, signerConsentMessages);
   if (runtime === "other") {
-    const signerReady2 = await probeLocalSignerCredential(input.signerPath);
+    const signerCredentialReady2 = await probeLocalSignerCredential(input.signerPath);
+    const signerReady = signerCredentialReady2 && signerConsent.acknowledged;
     return {
       runtime,
       hostedMcpConfigured: false,
       localSignerConfigured: false,
-      probeResult: signerReady2 ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
+      probeResult: signerReady ? "manual_runtime_setup_required_local_signer_ready" : "manual_runtime_setup_required_local_signer_unavailable",
       restartRequired: true,
       nextUserAction: "return_to_haven_for_wallet_approval_then_configure_runtime",
       errorCode: "manual_runtime_setup_required",
       configTarget: "manual runtime setup",
-      messages: ["Runtime was not recognized. Keep the local credentials and add Haven MCP entries manually after wallet approval."]
+      signerAcknowledged: signerConsent.acknowledged,
+      messages: [
+        ...signerConsentMessages,
+        "Runtime was not recognized. Keep the local credentials and add Haven MCP entries manually after wallet approval."
+      ]
     };
   }
   const configResult = runtime === "claude-code" ? await configureClaudeCode(input, deps) : await writeRuntimeConfig({
@@ -582,23 +681,26 @@ async function installRuntime(input, deps = {}) {
     credentialDirectory: input.credentialDirectory,
     homeDir: deps.homeDir
   });
-  const [hostedProbe, signerReady] = await Promise.all([
+  const [hostedProbe, signerCredentialReady] = await Promise.all([
     configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
     probeLocalSignerCredential(input.signerPath)
   ]);
   const hostedOk = configResult.hostedConfigured && hostedProbe.status !== "unauthorized";
-  const signerOk = configResult.signerConfigured && signerReady;
+  const signerOk = configResult.signerConfigured && signerCredentialReady && signerConsent.acknowledged;
   const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
+  const errorCode = configResult.errorCode ?? signerConsentErrorCode(signerCredentialReady, signerConsent);
   return {
     runtime,
     hostedMcpConfigured: hostedOk,
     localSignerConfigured: signerOk,
     probeResult: buildProbeResult(configResult.hostedConfigured, hostedProbe.status, signerOk),
     restartRequired,
-    nextUserAction: nextAction(profile.restartMode, configResult.errorCode),
-    errorCode: configResult.errorCode,
+    nextUserAction: nextAction(runtime, profile.restartMode, errorCode),
+    errorCode,
     configTarget: configResult.target,
-    messages: configResult.messages
+    signerAcknowledged: signerConsent.acknowledged,
+    activationCommand: configResult.activationCommand,
+    messages: [...signerConsentMessages, ...configResult.messages]
   };
 }
 function runtimeInstallCapabilities(runtime, env = process.env) {
@@ -625,9 +727,10 @@ async function configureClaudeCode(input, deps) {
       "mcp",
       "add",
       "haven-signer",
+      "--",
       "npx",
       "-y",
-      "@haven_ai/signer",
+      signerPackageName2(),
       "--credentials",
       input.signerPath
     ]);
@@ -637,7 +740,10 @@ async function configureClaudeCode(input, deps) {
       target: "Claude Code MCP config",
       changed: true,
       restartRequired: true,
-      messages: ["Updated Haven MCP entries with Claude Code."]
+      messages: [
+        "Updated Haven MCP entries with Claude Code.",
+        "Restart Claude Code after Haven approval so it can load the Haven tools."
+      ]
     };
   } catch (err) {
     return {
@@ -646,7 +752,10 @@ async function configureClaudeCode(input, deps) {
       target: "Claude Code MCP config",
       changed: false,
       restartRequired: true,
-      messages: [`Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`],
+      messages: [
+        `Could not update Claude Code MCP config: ${err instanceof Error ? err.message : String(err)}`,
+        "Install Claude Code or rerun the Haven setup command inside a Claude Code terminal."
+      ],
       errorCode: "claude_code_config_failed"
     };
   }
@@ -659,16 +768,38 @@ function buildProbeResult(hostedConfigured, hostedStatus, signerReady) {
   const signerPart = signerReady ? "local_signer_ready" : "local_signer_unavailable";
   return `${hostedPart}_${signerPart}`.slice(0, 120);
 }
-function nextAction(restartMode, errorCode) {
+async function resolveSignerConsent(input, messages) {
+  if (input.ackSigner) {
+    const status = await acknowledgeLocalSignerConsent(input.signerPath, (message) => messages.push(message));
+    if (status.acknowledged) {
+      messages.push("Prepared the local Haven signer acknowledgement.");
+    } else {
+      messages.push("Local Haven signer acknowledgement still needs attention.");
+    }
+    return status;
+  }
+  return getLocalSignerConsentStatus(input.signerPath);
+}
+function signerConsentErrorCode(signerCredentialReady, signerConsent) {
+  if (!signerCredentialReady) return "local_signer_credential_unavailable";
+  if (!signerConsent.acknowledged) return "local_signer_ack_required";
+  return void 0;
+}
+function nextAction(runtime, restartMode, errorCode) {
   if (errorCode) return "return_to_haven_for_wallet_approval_then_finish_runtime_setup";
   if (restartMode === "hot-reload") return "return_to_haven_for_wallet_approval";
+  if (runtime === "codex-cli") return "return_to_haven_for_wallet_approval_then_restart_codex_with_haven_env";
+  if (runtime === "claude-code") return "return_to_haven_for_wallet_approval_then_restart_claude_code";
   if (restartMode === "restart-app") return "return_to_haven_for_wallet_approval_then_restart_app";
   if (restartMode === "restart-session") return "return_to_haven_for_wallet_approval_then_restart_agent_session";
   return "return_to_haven_for_wallet_approval_then_configure_runtime";
 }
+function signerPackageName2() {
+  return `@haven_ai/signer@${SIGNER_VERSION}`;
+}
 
 // src/runtime.ts
-var CONNECTOR_VERSION = "0.1.0";
+var CONNECTOR_VERSION = "0.1.1-alpha";
 async function runConnect(options, deps = {}) {
   const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
   const api = deps.api ?? createConnectApiClient(options.apiBaseUrl);
@@ -730,7 +861,8 @@ async function runConnect(options, deps = {}) {
     signerPath: credentialPaths.signerPath,
     identityPath: credentialPaths.identityPath,
     credentialDirectory: credentialPaths.directory,
-    environmentLabel: options.environmentLabel ?? "Local workspace"
+    environmentLabel: options.environmentLabel ?? "Local workspace",
+    ackSigner: options.ackSigner
   });
   printRuntimeInstall(runtimeInstall, log);
   try {
@@ -740,6 +872,8 @@ async function runConnect(options, deps = {}) {
       hostedMcpConfigured: runtimeInstall.hostedMcpConfigured,
       localSignerConfigured: runtimeInstall.localSignerConfigured,
       credentialFilesWritten: true,
+      signerAcknowledged: runtimeInstall.signerAcknowledged,
+      activationCommandAvailable: Boolean(runtimeInstall.activationCommand),
       probeResult: runtimeInstall.probeResult,
       restartRequired: runtimeInstall.restartRequired,
       nextUserAction: runtimeInstall.nextUserAction,
@@ -810,6 +944,8 @@ function parseArgs(argv, env = process.env) {
       options.credentialsDir = requireValue(argv, ++i, arg);
     } else if (arg === "--environment-label") {
       options.environmentLabel = requireValue(argv, ++i, arg);
+    } else if (arg === "--ack-signer") {
+      options.ackSigner = true;
     } else if (arg === "--version") {
       process.stdout.write(`${CONNECTOR_VERSION}
 `);
@@ -838,7 +974,7 @@ function helpText() {
     "sends Haven only the public signing address plus a proof signature.",
     "",
     "Usage:",
-    "  npx -y @haven_ai/connect --setup hv_setup_... --api https://api.haven.example --runtime claude-code",
+    "  npx -y @haven_ai/connect --setup hv_setup_... --api https://api.haven.example --ack-signer --runtime claude-code",
     "",
     "Options:",
     "  --setup <token>            Short-lived setup token from Haven.",
@@ -846,6 +982,7 @@ function helpText() {
     "  --runtime <name>           Agent runtime hint, such as claude-code, codex-cli, cursor, vscode, or claude-desktop.",
     "  --credentials-dir <path>   Credential directory fallback. Defaults to ~/.haven/agents.",
     "  --environment-label <text> Non-sensitive label shown in Haven setup review.",
+    "  --ack-signer               Write the one-time local signer acknowledgement during setup.",
     "  --help                     Show this help.",
     "",
     "The connector never prints the private key and never sends it to Haven."