@haven_ai/connect 0.1.15-alpha.0 → 0.1.17-alpha.0

package/dist/cli.cjs

@@ -137,8 +137,10 @@ async function writeCredentialFiles(input) {
   await restrictPermissions(directory, 448, input.warn);
   const identityPath = path.join(directory, "identity.json");
   const signerPath = path.join(directory, "signer.json");
+  const agentPath = path.join(directory, "agent.json");
   await assertDoesNotExist(identityPath);
   await assertDoesNotExist(signerPath);
+  await assertDoesNotExist(agentPath);
   await writeOwnerOnlyJson(
     signerPath,
     {
@@ -173,7 +175,26 @@ async function writeCredentialFiles(input) {
     await promises.rm(signerPath, { force: true }).catch(() => void 0);
     throw err;
   }
-  return { directory, identityPath, signerPath };
+  try {
+    await writeOwnerOnlyJson(
+      agentPath,
+      {
+        agent_id: input.agentId,
+        safe_address: input.safeAddress,
+        chain_id: input.chainId,
+        network: input.network,
+        agent_budget: input.agentBudget,
+        note: "Non-secret orientation for the agent: identity + configured budget. Contains no API key or signing key. For the live remaining budget, call haven_get_allowances."
+      },
+      input.warn
+    );
+  } catch (err) {
+    await promises.rm(signerPath, { force: true }).catch(() => void 0);
+    await promises.rm(identityPath, { force: true }).catch(() => void 0);
+    await promises.rm(agentPath, { force: true }).catch(() => void 0);
+    throw err;
+  }
+  return { directory, identityPath, signerPath, agentPath };
 }
 function defaultAgentDirectory(agentId, baseDir = path.join(os.homedir(), ".haven", "agents")) {
   return path.resolve(defaultCredentialRoot(baseDir), safePathPart(agentId));
@@ -215,9 +236,9 @@ var MCP_RUNTIME_MANIFEST = {
   mcpPackage: "@haven_ai/mcp",
   mcpVersion: mcp.MCP_VERSION,
   sdkPackage: "@haven_ai/sdk",
-  sdkVersion: "0.1.15-alpha.0",
+  sdkVersion: "0.1.17-alpha.0",
   signerPackage: "@haven_ai/signer",
-  signerVersion: "0.1.15-alpha.0",
+  signerVersion: "0.1.17-alpha.0",
   minimumNodeVersion: "20.0.0",
   supportedClients: ["codex-cli", "codex-desktop", "claude-code"],
   requiredTools: mcp.registeredToolNames()
@@ -232,117 +253,6 @@ function signerPackageSpec() {
   return `${MCP_RUNTIME_MANIFEST.signerPackage}@${MCP_RUNTIME_MANIFEST.signerVersion}`;
 }
 
-// src/runtime-registry.ts
-var RUNTIME_PROFILES = {
-  "claude-code": {
-    id: "claude-code",
-    label: "Claude Code",
-    restartMode: "restart-session",
-    canWriteRuntimeConfig: true
-  },
-  "codex-cli": {
-    id: "codex-cli",
-    label: "Codex CLI",
-    restartMode: "restart-session",
-    canWriteRuntimeConfig: true
-  },
-  "codex-desktop": {
-    id: "codex-desktop",
-    label: "Codex Desktop",
-    restartMode: "restart-session",
-    canWriteRuntimeConfig: true
-  },
-  cursor: {
-    id: "cursor",
-    label: "Cursor",
-    restartMode: "hot-reload",
-    canWriteRuntimeConfig: true
-  },
-  vscode: {
-    id: "vscode",
-    label: "VS Code",
-    restartMode: "hot-reload",
-    canWriteRuntimeConfig: true
-  },
-  "vscode-insiders": {
-    id: "vscode-insiders",
-    label: "VS Code Insiders",
-    restartMode: "hot-reload",
-    canWriteRuntimeConfig: true
-  },
-  "claude-desktop": {
-    id: "claude-desktop",
-    label: "Claude Desktop",
-    restartMode: "restart-app",
-    canWriteRuntimeConfig: true
-  },
-  other: {
-    id: "other",
-    label: "Other agent runtime",
-    restartMode: "manual",
-    canWriteRuntimeConfig: false
-  }
-};
-var RUNTIME_ALIASES = {
-  claude: "claude-code",
-  "claude-code": "claude-code",
-  claudecode: "claude-code",
-  "claude_code": "claude-code",
-  codex: "codex-cli",
-  "codex-cli": "codex-cli",
-  codexcli: "codex-cli",
-  "codex_cli": "codex-cli",
-  "codex-desktop": "codex-desktop",
-  "codex_desktop": "codex-desktop",
-  codexdesktop: "codex-desktop",
-  "codex-app": "codex-desktop",
-  "codex_app": "codex-desktop",
-  codexapp: "codex-desktop",
-  cursor: "cursor",
-  vscode: "vscode",
-  "vs-code": "vscode",
-  "vs_code": "vscode",
-  code: "vscode",
-  "vscode-insiders": "vscode-insiders",
-  "vscode_insiders": "vscode-insiders",
-  vscodeinsiders: "vscode-insiders",
-  "vs-code-insiders": "vscode-insiders",
-  "code-insiders": "vscode-insiders",
-  insiders: "vscode-insiders",
-  "claude-desktop": "claude-desktop",
-  "claude_desktop": "claude-desktop",
-  claudesktop: "claude-desktop",
-  desktop: "claude-desktop",
-  other: "other",
-  manual: "other"
-};
-function runtimeProfile(runtime, env = process.env) {
-  return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
-}
-function normalizeRuntime(runtime, env = process.env) {
-  const explicit = normalizeRuntimeName(runtime);
-  if (explicit) return explicit;
-  return detectRuntime(env) ?? "other";
-}
-function restartRequiredForRuntime(runtime, env = process.env) {
-  const mode = runtimeProfile(runtime, env).restartMode;
-  return mode === "restart-session" || mode === "restart-app";
-}
-function runtimeRequiresHardRestart(runtime) {
-  return runtime === "claude-desktop" || runtime === "codex-desktop";
-}
-function normalizeRuntimeName(runtime) {
-  const key = runtime?.trim().toLowerCase();
-  if (!key) return null;
-  return RUNTIME_ALIASES[key.replace(/\s+/g, "-")] ?? null;
-}
-function detectRuntime(env) {
-  if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDECODE_CWD) return "claude-code";
-  if (env.CODEX_SANDBOX || env.CODEX_HOME || env.CODEX_CWD) return "codex-cli";
-  if (env.VSCODE_CWD || env.VSCODE_IPC_HOOK_CLI || env.TERM_PROGRAM === "vscode") return "vscode";
-  return null;
-}
-
 // src/config-writers.ts
 var InvalidCodexTomlError = class extends Error {
   constructor(message) {
@@ -489,7 +399,6 @@ 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 (local) {
@@ -507,11 +416,7 @@ async function writeCodexConfig(input) {
         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
+          `Updated local Haven MCP entry in ${configTargetLabel(input.runtime)}.`
         ]
       };
     }
@@ -526,8 +431,7 @@ async function writeCodexConfig(input) {
       changed: existing !== merged,
       restartRequired: true,
       messages: [
-        `Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`,
-        restartMessage
+        `Updated Haven MCP entries in ${configTargetLabel(input.runtime)}.`
       ]
     };
   } catch (err) {
@@ -1080,23 +984,29 @@ function parseNodeVersion(value) {
   ];
 }
 async function installRuntimePackages(runtimeDirectory, npmCacheDirectory, runCommand) {
-  const args = [
+  const baseArgs = [
     "install",
     "--prefix",
     runtimeDirectory,
-    "--cache",
-    npmCacheDirectory,
     "--no-audit",
     "--no-fund",
     "--omit=dev",
+    "--prefer-offline",
     mcpPackageSpec(),
     sdkPackageSpec()
   ];
-  try {
+  const run = async (args) => {
     if (runCommand) await runCommand("npm", args);
     else await execFileAsync("npm", args, { timeout: 12e4, maxBuffer: 1024 * 1024 });
-  } catch (err) {
-    throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
+  };
+  try {
+    await run(baseArgs);
+  } catch {
+    try {
+      await run([...baseArgs, "--cache", npmCacheDirectory]);
+    } catch (err) {
+      throw new Error(`Could not install local Haven MCP runtime ${mcpPackageSpec()}: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
 }
 async function installedRuntimeMatches(runtimeDirectory, cliPath) {
@@ -1200,25 +1110,31 @@ async function prepareSignerRuntime(input, deps = {}) {
   };
 }
 async function installRuntimePackages2(runtimeDirectory, npmCacheDirectory, runCommand) {
-  const args = [
+  const baseArgs = [
     "install",
     "--prefix",
     runtimeDirectory,
-    "--cache",
-    npmCacheDirectory,
     "--no-audit",
     "--no-fund",
     "--omit=dev",
+    "--prefer-offline",
     signerPackageSpec(),
     sdkPackageSpec()
   ];
-  try {
+  const run = async (args) => {
     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)}`
-    );
+  };
+  try {
+    await run(baseArgs);
+  } catch {
+    try {
+      await run([...baseArgs, "--cache", npmCacheDirectory]);
+    } 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) {
@@ -1281,6 +1197,117 @@ async function assertFileExists2(path, label) {
     throw new Error(`Missing ${label}: ${path}`);
   }
 }
+
+// src/runtime-registry.ts
+var RUNTIME_PROFILES = {
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code",
+    restartMode: "restart-session",
+    canWriteRuntimeConfig: true
+  },
+  "codex-cli": {
+    id: "codex-cli",
+    label: "Codex CLI",
+    restartMode: "restart-session",
+    canWriteRuntimeConfig: true
+  },
+  "codex-desktop": {
+    id: "codex-desktop",
+    label: "Codex Desktop",
+    restartMode: "restart-session",
+    canWriteRuntimeConfig: true
+  },
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    restartMode: "hot-reload",
+    canWriteRuntimeConfig: true
+  },
+  vscode: {
+    id: "vscode",
+    label: "VS Code",
+    restartMode: "hot-reload",
+    canWriteRuntimeConfig: true
+  },
+  "vscode-insiders": {
+    id: "vscode-insiders",
+    label: "VS Code Insiders",
+    restartMode: "hot-reload",
+    canWriteRuntimeConfig: true
+  },
+  "claude-desktop": {
+    id: "claude-desktop",
+    label: "Claude Desktop",
+    restartMode: "restart-app",
+    canWriteRuntimeConfig: true
+  },
+  other: {
+    id: "other",
+    label: "Other agent runtime",
+    restartMode: "manual",
+    canWriteRuntimeConfig: false
+  }
+};
+var RUNTIME_ALIASES = {
+  claude: "claude-code",
+  "claude-code": "claude-code",
+  claudecode: "claude-code",
+  "claude_code": "claude-code",
+  codex: "codex-cli",
+  "codex-cli": "codex-cli",
+  codexcli: "codex-cli",
+  "codex_cli": "codex-cli",
+  "codex-desktop": "codex-desktop",
+  "codex_desktop": "codex-desktop",
+  codexdesktop: "codex-desktop",
+  "codex-app": "codex-desktop",
+  "codex_app": "codex-desktop",
+  codexapp: "codex-desktop",
+  cursor: "cursor",
+  vscode: "vscode",
+  "vs-code": "vscode",
+  "vs_code": "vscode",
+  code: "vscode",
+  "vscode-insiders": "vscode-insiders",
+  "vscode_insiders": "vscode-insiders",
+  vscodeinsiders: "vscode-insiders",
+  "vs-code-insiders": "vscode-insiders",
+  "code-insiders": "vscode-insiders",
+  insiders: "vscode-insiders",
+  "claude-desktop": "claude-desktop",
+  "claude_desktop": "claude-desktop",
+  claudesktop: "claude-desktop",
+  desktop: "claude-desktop",
+  other: "other",
+  manual: "other"
+};
+function runtimeProfile(runtime, env = process.env) {
+  return RUNTIME_PROFILES[normalizeRuntime(runtime, env)];
+}
+function normalizeRuntime(runtime, env = process.env) {
+  const explicit = normalizeRuntimeName(runtime);
+  if (explicit) return explicit;
+  return detectRuntime(env) ?? "other";
+}
+function restartRequiredForRuntime(runtime, env = process.env) {
+  const mode = runtimeProfile(runtime, env).restartMode;
+  return mode === "restart-session" || mode === "restart-app";
+}
+function runtimeRequiresHardRestart(runtime) {
+  return runtime === "claude-desktop" || runtime === "codex-desktop";
+}
+function normalizeRuntimeName(runtime) {
+  const key = runtime?.trim().toLowerCase();
+  if (!key) return null;
+  return RUNTIME_ALIASES[key.replace(/\s+/g, "-")] ?? null;
+}
+function detectRuntime(env) {
+  if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDECODE_CWD) return "claude-code";
+  if (env.CODEX_SANDBOX || env.CODEX_HOME || env.CODEX_CWD) return "codex-cli";
+  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);
@@ -1356,6 +1383,7 @@ var execFileAsync3 = util.promisify(child_process.execFile);
 async function installRuntime(input, deps = {}) {
   const runtime = normalizeRuntime(input.runtime, deps.env);
   const profile = runtimeProfile(runtime, deps.env);
+  const progress = deps.onProgress ?? (() => void 0);
   const localRuntime = input.localMcp === true && supportsLocalMcp(runtime);
   const consentMessages = [];
   const localMcpConsent = localRuntime ? await resolveLocalMcpConsent(input, consentMessages) : void 0;
@@ -1415,6 +1443,7 @@ async function installRuntime(input, deps = {}) {
   }
   let signerCommand;
   if (!localRuntime) {
+    progress("Getting the signer ready\u2026");
     try {
       const signerRuntime = await prepareSignerForRuntime(input, deps);
       signerCommand = { command: signerRuntime.command, args: signerRuntime.args };
@@ -1426,6 +1455,7 @@ async function installRuntime(input, deps = {}) {
     }
   }
   const signerRuntimePrepared = localRuntime ? void 0 : signerCommand !== void 0;
+  progress("Setting up your Haven tools\u2026");
   const configResult = runtime === "claude-code" ? localRuntime ? await configureClaudeCode(deps, localRuntimeInstall?.command ?? "") : await configureClaudeCodeHosted(deps, input, signerCommand) : await writeRuntimeConfig({
     runtime,
     hostedMcpUrl: input.hostedMcpUrl,
@@ -1438,6 +1468,7 @@ async function installRuntime(input, deps = {}) {
     homeDir: deps.homeDir,
     mode: localRuntime ? "local" : "hosted"
   });
+  progress("Almost there \u2014 just confirming everything connects\u2026");
   const localProbePromise = configResult.runtimeMcpMode === "local_stdio" && localRuntimeInstall ? runLocalMcpProbe(localRuntimeInstall, deps) : Promise.resolve(void 0);
   const [hostedProbe, signerCredentialReady, localMcpProbe] = await Promise.all([
     configResult.hostedConfigured ? probeHostedMcpTools(input.apiKey, input.hostedMcpUrl, deps.fetch) : Promise.resolve({ status: "bad_response" }),
@@ -1502,8 +1533,7 @@ async function configureClaudeCode(deps, localMcpCommand) {
       restartRequired: true,
       messages: [
         "Updated local Haven MCP entry 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."
+        ...verified ? ["Verified Claude Code MCP entry."] : []
       ]
     };
   } catch (err) {
@@ -1552,8 +1582,7 @@ async function configureClaudeCodeHosted(deps, input, signerCommand) {
       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."
+        ...verified ? ["Verified Claude Code MCP entry."] : []
       ]
     };
   } catch (err) {
@@ -1681,7 +1710,7 @@ function localRuntimePrepareErrorCode(err) {
 }
 
 // src/runtime.ts
-var CONNECTOR_VERSION = "0.1.15-alpha.0";
+var CONNECTOR_VERSION = "0.1.17-alpha.0";
 async function runConnect(options, deps = {}) {
   const connectorVersion = options.connectorVersion ?? CONNECTOR_VERSION;
   const api = deps.api ?? createConnectApiClient(options.apiBaseUrl);
@@ -1701,6 +1730,7 @@ async function runConnect(options, deps = {}) {
       );
     }
   }
+  log("Warming up your connection to Haven\u2026");
   const setup = await api.resolveSetup({
     setupToken: options.setupToken,
     connectorVersion,
@@ -1708,12 +1738,12 @@ async function runConnect(options, deps = {}) {
   });
   printSetupSummary(setup, log);
   await preflightStorage({ baseDir: options.credentialsDir, warn: log });
-  log("Checked local credential storage.");
+  log("Checked local credential storage \u2014 all clear.");
   const localKey = generateKey();
   const localApiKey = generateLocalApiKey();
-  log("Generated local signing key.");
-  log("Generated local Haven API key.");
+  log("Minting a fresh signing key and API key \u2014 both stay on this machine.");
   const proofSignature = await localKey.signChallenge(setup.challenge.message);
+  log("Introducing your agent to Haven\u2026");
   const registration = await api.registerSetup({
     setupToken: options.setupToken,
     connectorVersion,
@@ -1730,6 +1760,7 @@ async function runConnect(options, deps = {}) {
     installCapabilities
   });
   log(`Registered signing address with Haven: ${shortAddress(registration.delegate_address)}.`);
+  log("Tucking your credentials away safely on disk\u2026");
   const credentialPaths = await writeCredentials({
     baseDir: options.credentialsDir,
     agentId: registration.agent_id,
@@ -1751,6 +1782,7 @@ async function runConnect(options, deps = {}) {
   });
   log(`Stored Haven identity credential locally: ${credentialPaths.identityPath}`);
   log(`Stored local signer credential locally: ${credentialPaths.signerPath}`);
+  log(`Stored non-secret agent orientation locally: ${credentialPaths.agentPath}`);
   if (setup.x402_binding_signer) {
     log("Configured x402 binding signer for the local signer.");
   } else {
@@ -1769,8 +1801,14 @@ async function runConnect(options, deps = {}) {
     ackSigner: options.ackSigner,
     ackLocalTools: options.ackLocalTools,
     localMcp: options.localMcp
-  });
+  }, { onProgress: log });
   printRuntimeInstall(runtimeInstall, log);
+  if (runtimeInstall.errorCode) {
+    log("Haven setup needs a couple more steps on this machine \u2014 see the notes above.");
+  } else {
+    log("Haven setup on this machine is complete.");
+  }
+  printNextSteps(runtimeInstall, log);
   try {
     await api.updateInstallStatus(registration.setup_id, localApiKey, {
       runtime: runtimeInstall.runtime,
@@ -1793,14 +1831,6 @@ async function runConnect(options, deps = {}) {
   } catch (err) {
     log(`Could not report install status to Haven: ${err instanceof Error ? err.message : String(err)}`);
   }
-  log("Return to Haven to approve the agent rules.");
-  if (runtimeInstall.restartRequired) {
-    if (runtimeRequiresHardRestart(runtimeInstall.runtime)) {
-      log("After approval, restart this agent so it can load Haven tools.");
-    } else {
-      log("After approval, Haven tools should appear in your next message. If they don't, restart this agent to load them.");
-    }
-  }
   return {
     setupId: registration.setup_id,
     agentId: registration.agent_id,
@@ -1838,6 +1868,18 @@ function printRuntimeInstall(result, log) {
     log("Local Haven signer still needs runtime setup.");
   }
 }
+function printNextSteps(result, log) {
+  log("Next: approve the agent rules in Haven. No Haven tools appear until you approve \u2014 restart or not.");
+  if (result.restartRequired) {
+    if (runtimeRequiresHardRestart(result.runtime)) {
+      log("After you approve, restart this agent so it can load Haven tools.");
+    } else {
+      log("After you approve, restart this agent \u2014 your current session won't load the Haven tools until you do.");
+    }
+  } else {
+    log("After you approve, the Haven tools should appear in this runtime shortly.");
+  }
+}
 
 // src/args.ts
 function parseArgs(argv, env = process.env) {