@haven_ai/connect 0.1.5-alpha → 0.1.10-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
@@ -54,6 +55,7 @@ function createConnectApiClient(baseUrl, fetchImpl = fetch) {
           signer_acknowledged: input.signerAcknowledged,
           local_mcp_acknowledged: input.localMcpAcknowledged,
           activation_command_available: input.activationCommandAvailable,
+          skill_installed: input.skillInstalled,
           probe_result: input.probeResult,
           restart_required: input.restartRequired,
           next_user_action: input.nextUserAction,
@@ -206,9 +208,9 @@ var MCP_RUNTIME_MANIFEST = {
   mcpPackage: "@haven_ai/mcp",
   mcpVersion: MCP_VERSION,
   sdkPackage: "@haven_ai/sdk",
-  sdkVersion: "0.1.8",
+  sdkVersion: "0.1.10-alpha.0",
   signerPackage: "@haven_ai/signer",
-  signerVersion: "0.1.2-alpha",
+  signerVersion: "0.1.10-alpha.0",
   minimumNodeVersion: "20.0.0",
   supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
   requiredTools: registeredToolNames()
@@ -413,6 +415,26 @@ function mergeCodexToml(existingToml, localMcpCommand) {
   validateCodexToml(block, "Generated Codex Haven config");
   const merged = `${next ? `${next}
 
+` : ""}${block}
+`;
+  return merged;
+}
+function mergeCodexTomlHosted(existingToml, hostedMcpUrl, apiKey, signerPath) {
+  let next = removeTomlTableTree(removeTomlTableTree(existingToml, "mcp_servers.haven"), "mcp_servers.haven_signer");
+  next = next.trimEnd();
+  const block = [
+    "[mcp_servers.haven]",
+    `url = ${tomlString(hostedMcpUrl)}`,
+    `http_headers = { "Authorization" = ${tomlString(`Bearer ${apiKey}`)} }`,
+    "",
+    "[mcp_servers.haven_signer]",
+    'command = "npx"',
+    `args = ["-y", ${tomlString(signerPackageSpec())}, "--credentials", ${tomlString(signerPath)}]`,
+    "startup_timeout_sec = 120"
+  ].join("\n");
+  validateCodexToml(block, "Generated Codex Haven config");
+  const merged = `${next ? `${next}
+
 ` : ""}${block}
 `;
   return merged;
@@ -453,27 +475,46 @@ async function writeJsonRuntimeConfig(input, target, serverRoot) {
 }
 async function writeCodexConfig(input) {
   const target = codexConfigPath(input.homeDir);
+  const local = input.mode === "local";
+  const restartMessage = runtimeRequiresHardRestart(input.runtime) ? "After Haven approval, restart Codex Desktop so it can load Haven tools." : "After Haven approval, Haven tools should appear in your next Codex message. If they don't, restart Codex to load them.";
   try {
     const existing = await readOptional(target);
-    if (!input.localMcpCommand) {
-      throw new Error("local MCP wrapper command is required");
+    if (local) {
+      if (!input.localMcpCommand) {
+        throw new Error("local MCP wrapper command is required");
+      }
+      const merged2 = mergeCodexToml(existing ?? "", input.localMcpCommand);
+      await writeOwnerOnlyText(target, merged2);
+      return {
+        hostedConfigured: false,
+        signerConfigured: true,
+        localMcpConfigured: true,
+        runtimeMcpMode: "local_stdio",
+        target: configTargetLabel(input.runtime),
+        changed: existing !== merged2,
+        restartRequired: true,
+        messages: [
+          `Updated local Haven MCP entry in ${configTargetLabel(input.runtime)}.`,
+          // Codex Desktop loads MCP servers at app launch; Codex CLI typically
+          // picks them up in the next session. Branch the copy so desktop users
+          // get the unambiguous instruction.
+          restartMessage
+        ]
+      };
     }
-    const merged = mergeCodexToml(existing ?? "", input.localMcpCommand);
+    const merged = mergeCodexTomlHosted(existing ?? "", input.hostedMcpUrl, input.apiKey, input.signerPath);
     await writeOwnerOnlyText(target, merged);
     return {
-      hostedConfigured: false,
+      hostedConfigured: true,
       signerConfigured: true,
-      localMcpConfigured: true,
-      runtimeMcpMode: "local_stdio",
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
       target: configTargetLabel(input.runtime),
       changed: existing !== merged,
       restartRequired: true,
       messages: [
-        `Updated local Haven MCP entry in ${configTargetLabel(input.runtime)}.`,
-        // Codex Desktop loads MCP servers at app launch; Codex CLI typically
-        // picks them up in the next session. Branch the copy so desktop users
-        // get the unambiguous instruction.
-        runtimeRequiresHardRestart(input.runtime) ? "After Haven approval, restart Codex Desktop so it can load Haven tools." : "After Haven approval, Haven tools should appear in your next Codex message. If they don't, restart Codex to load them."
+        `Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`,
+        restartMessage
       ]
     };
   } catch (err) {
@@ -482,7 +523,7 @@ async function writeCodexConfig(input) {
       hostedConfigured: false,
       signerConfigured: false,
       localMcpConfigured: false,
-      runtimeMcpMode: "local_stdio",
+      runtimeMcpMode: local ? "local_stdio" : "hosted_plus_signer",
       target: configTargetLabel(input.runtime),
       changed: false,
       restartRequired: true,
@@ -862,7 +903,7 @@ async function probeLocalSignerCredential(signerPath) {
   }
 }
 async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
     let stdout = "";
     let settled = false;
@@ -872,7 +913,7 @@ async function probeLocalMcpTools(command, args, requiredTools, timeoutMs = 1e4)
       settled = true;
       clearTimeout(timeout);
       child.kill();
-      resolve6(result);
+      resolve7(result);
     };
     const timeout = setTimeout(() => finish({ status: "timeout" }), timeoutMs);
     child.on("error", () => finish({ status: "process_error" }));
@@ -1185,7 +1226,7 @@ var execFileAsync2 = promisify(execFile);
 async function installRuntime(input, deps = {}) {
   const runtime = normalizeRuntime(input.runtime, deps.env);
   const profile = runtimeProfile(runtime, deps.env);
-  const localRuntime = usesLocalMcp(runtime);
+  const localRuntime = input.localMcp === true && supportsLocalMcp(runtime);
   const consentMessages = [];
   const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
   const signerConsent = localRuntime ? void 0 : await resolveSignerConsent(input, consentMessages);
@@ -1242,7 +1283,7 @@ async function installRuntime(input, deps = {}) {
       ]
     };
   }
-  const configResult = runtime === "claude-code" ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await writeRuntimeConfig({
+  const configResult = runtime === "claude-code" ? localRuntime ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await configureClaudeCodeHosted(deps, input) : await writeRuntimeConfig({
     runtime,
     hostedMcpUrl: input.hostedMcpUrl,
     apiKey: input.apiKey,
@@ -1250,7 +1291,8 @@ async function installRuntime(input, deps = {}) {
     signerPath: input.signerPath,
     credentialDirectory: input.credentialDirectory,
     localMcpCommand: localRuntimeInstall?.command,
-    homeDir: deps.homeDir
+    homeDir: deps.homeDir,
+    mode: localRuntime ? "local" : "hosted"
   });
   const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
   const [hostedProbe, signerCredentialReady, localMcpProbe] = await Promise.all([
@@ -1264,6 +1306,7 @@ async function installRuntime(input, deps = {}) {
   const restartRequired = configResult.restartRequired || restartRequiredForRuntime(runtime, deps.env);
   const errorCode = configResult.errorCode ?? (configResult.runtimeMcpMode === "local_stdio" ? localMcpErrorCode(signerCredentialReady, localMcpConsent, localMcpProbe?.status) : signerConsentErrorCode(signerCredentialReady, signerConsent));
   const localProbeMessages = localMcpProbe && localMcpProbe.status !== "ok" ? [`Local Haven MCP handshake failed: ${localMcpProbe.status}.`] : localMcpProbe?.status === "ok" ? ["Verified local Haven MCP tools with a stdio handshake."] : [];
+  const skillInstall = runtime === "claude-code" && !configResult.errorCode ? await installClaudeSkill(deps.homeDir) : void 0;
   return {
     runtime,
     runtimeMcpMode: configResult.runtimeMcpMode,
@@ -1278,7 +1321,8 @@ async function installRuntime(input, deps = {}) {
     signerAcknowledged: signerConsent?.acknowledged,
     localMcpAcknowledged: localMcpConsent?.acknowledged,
     activationCommand: configResult.activationCommand,
-    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...localProbeMessages]
+    skillInstalled: skillInstall?.installed,
+    messages: [...consentMessages, ...localRuntimeInstall?.messages ?? [], ...configResult.messages, ...localProbeMessages, ...skillInstall?.messages ?? []]
   };
 }
 function runtimeInstallCapabilities(runtime, env = process.env) {
@@ -1334,9 +1378,75 @@ async function configureClaudeCode(deps, localMcpCommand) {
     };
   }
 }
+async function configureClaudeCodeHosted(deps, input) {
+  const runCommand = deps.runCommand ?? defaultRunCommand;
+  const hostedJson = JSON.stringify({
+    type: "http",
+    url: input.hostedMcpUrl,
+    headers: { Authorization: `Bearer ${input.apiKey}` }
+  });
+  const signerJson = JSON.stringify({
+    type: "stdio",
+    command: "npx",
+    args: ["-y", signerPackageSpec(), "--credentials", input.signerPath],
+    env: {}
+  });
+  try {
+    await runCommand("claude", ["mcp", "remove", "haven"]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "remove", "haven-signer"]).catch(() => void 0);
+    await runCommand("claude", ["mcp", "add-json", "haven", hostedJson, "--scope", "user"]);
+    await runCommand("claude", ["mcp", "add-json", "haven-signer", signerJson, "--scope", "user"]);
+    const verified = await runCommand("claude", ["mcp", "get", "haven"]).then(() => true).catch(() => false);
+    return {
+      hostedConfigured: true,
+      signerConfigured: true,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Claude Code MCP config",
+      changed: true,
+      restartRequired: true,
+      messages: [
+        "Updated hosted Haven MCP and local signer entries with Claude Code.",
+        ...verified ? ["Verified Claude Code MCP entry."] : [],
+        "After Haven approval, Haven tools should appear in your next Claude Code message. If they don't, restart the session to load them."
+      ]
+    };
+  } catch (err) {
+    return {
+      hostedConfigured: false,
+      signerConfigured: false,
+      localMcpConfigured: false,
+      runtimeMcpMode: "hosted_plus_signer",
+      target: "Claude Code MCP config",
+      changed: false,
+      restartRequired: true,
+      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"
+    };
+  }
+}
 async function defaultRunCommand(command, args) {
   await execFileAsync2(command, args, { timeout: 1e4 });
 }
+async function installClaudeSkill(homeDir) {
+  try {
+    const skillDir = resolve(homeDir ?? homedir(), ".claude", "skills", SKILL_FOLDER_NAME);
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(join(skillDir, "SKILL.md"), HAVEN_SKILL_MD, "utf8");
+    return {
+      installed: true,
+      messages: ["Installed the generic Haven payment skill (~/.claude/skills/haven-pay). It contains no secrets."]
+    };
+  } catch (err) {
+    return {
+      installed: false,
+      messages: [`Could not install the Haven payment skill: ${err instanceof Error ? err.message : String(err)}. Download it from the Haven dashboard instead.`]
+    };
+  }
+}
 function buildProbeResult(mode, hostedConfigured, hostedStatus, signerReady, localMcpReady, localMcpProbeStatus) {
   if (mode === "local_stdio") {
     if (localMcpReady) return "local_stdio_mcp_ready";
@@ -1390,7 +1500,7 @@ function nextAction(runtime, restartMode, errorCode) {
   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 usesLocalMcp(runtime) {
+function supportsLocalMcp(runtime) {
   return runtime === "codex-cli" || runtime === "codex-desktop" || runtime === "claude-code";
 }
 async function prepareRuntimeForLocalMcp(input, deps) {
@@ -1430,6 +1540,14 @@ async function runConnect(options, deps = {}) {
   const generateKey = deps.generateKey ?? generateDelegateKey;
   const generateLocalApiKey = deps.generateApiKey ?? generateAgentApiKey;
   const installCapabilities = runtimeInstallCapabilities(options.runtime);
+  if (options.localMcp) {
+    const resolvedRuntime = normalizeRuntime(options.runtime);
+    if (!supportsLocalMcp(resolvedRuntime)) {
+      throw new Error(
+        `--local (fully-local Haven MCP) is only available for Claude Code and Codex. The detected runtime is ${runtimeProfile(resolvedRuntime).label}. Re-run without --local to use the default hosted MCP + local signer setup.`
+      );
+    }
+  }
   const setup = await api.resolveSetup({
     setupToken: options.setupToken,
     connectorVersion,
@@ -1488,7 +1606,8 @@ async function runConnect(options, deps = {}) {
     credentialDirectory: credentialPaths.directory,
     environmentLabel: options.environmentLabel ?? "Local workspace",
     ackSigner: options.ackSigner,
-    ackLocalTools: options.ackLocalTools
+    ackLocalTools: options.ackLocalTools,
+    localMcp: options.localMcp
   });
   printRuntimeInstall(runtimeInstall, log);
   try {
@@ -1503,6 +1622,7 @@ async function runConnect(options, deps = {}) {
       signerAcknowledged: runtimeInstall.signerAcknowledged,
       localMcpAcknowledged: runtimeInstall.localMcpAcknowledged,
       activationCommandAvailable: Boolean(runtimeInstall.activationCommand),
+      skillInstalled: runtimeInstall.skillInstalled,
       probeResult: runtimeInstall.probeResult,
       restartRequired: runtimeInstall.restartRequired,
       nextUserAction: runtimeInstall.nextUserAction,
@@ -1584,6 +1704,8 @@ function parseArgs(argv, env = process.env) {
     } else if (arg === "--ack-signer") {
       options.ackSigner = true;
       options.ackLocalTools = true;
+    } else if (arg === "--local" || arg === "--local-mcp") {
+      options.localMcp = true;
     } else if (arg === "--version") {
       process.stdout.write(`${CONNECTOR_VERSION}
 `);
@@ -1622,6 +1744,8 @@ function helpText() {
     "  --environment-label <text> Non-sensitive label shown in Haven setup review.",
     "  --ack-local-tools          Write the one-time local Haven tools acknowledgement during setup.",
     "  --ack-signer               Backward-compatible alias for --ack-local-tools.",
+    "  --local                    Advanced: install the fully-local Haven MCP (no hosted dependency).",
+    "                             Only available for Claude Code and Codex. Default is hosted MCP + local signer.",
     "  --help                     Show this help.",
     "",
     "The connector never prints the private key and never sends it to Haven."