@keeperhub/wallet 0.1.10 → 0.1.12

package/dist/cli.cjs

@@ -111,75 +111,247 @@ function fund(walletAddress) {
   };
 }
 
-// src/skill-install.ts
-var import_node_child_process = require("child_process");
+// src/storage.ts
+var import_node_crypto = require("crypto");
 var import_promises = require("fs/promises");
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
-var import_node_url = require("url");
+var import_node_os = require("os");
+var import_node_path = require("path");
+
+// src/types.ts
+var WalletConfigMissingError = class extends Error {
+  constructor() {
+    super(
+      "Wallet config not found at ~/.keeperhub/wallet.json. Run `npx @keeperhub/wallet add` to provision."
+    );
+    this.name = "WalletConfigMissingError";
+  }
+};
+var WalletConfigCorruptError = class extends Error {
+  path;
+  constructor(path, reason) {
+    super(
+      `Wallet config at ${path} is unreadable: ${reason}. Repair the file by hand or delete it to re-provision a new wallet (this will abandon any funds held in the current wallet).`
+    );
+    this.name = "WalletConfigCorruptError";
+    this.path = path;
+  }
+};
+
+// src/storage.ts
+async function readWalletConfig() {
+  const walletPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".keeperhub", "wallet.json");
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(walletPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new WalletConfigMissingError();
+    }
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new WalletConfigCorruptError(walletPath, reason);
+  }
+  if (!(parsed.subOrgId && parsed.walletAddress && parsed.hmacSecret)) {
+    throw new WalletConfigCorruptError(walletPath, "missing required fields");
+  }
+  return parsed;
+}
+async function writeWalletConfig(config) {
+  const walletPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".keeperhub", "wallet.json");
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(walletPath), { recursive: true, mode: 448 });
+  const suffix = (0, import_node_crypto.randomBytes)(8).toString("hex");
+  const tmpPath = `${walletPath}.${process.pid}.${suffix}.tmp`;
+  await (0, import_promises.writeFile)(tmpPath, JSON.stringify(config, null, 2), { mode: 384 });
+  await (0, import_promises.chmod)(tmpPath, 384);
+  await (0, import_promises.rename)(tmpPath, walletPath);
+}
+function getWalletConfigPath() {
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".keeperhub", "wallet.json");
+}
+
+// src/provision.ts
+var TRAILING_SLASH = /\/$/;
+var WALLET_ADDRESS_PATTERN = /^0x[a-fA-F0-9]{40}$/;
+var ProvisionResponseInvalidError = class extends Error {
+  code = "PROVISION_RESPONSE_INVALID";
+  constructor(message) {
+    super(message);
+    this.name = "ProvisionResponseInvalidError";
+  }
+};
+var ProvisionHttpError = class extends Error {
+  code = "PROVISION_HTTP_ERROR";
+  status;
+  body;
+  constructor(status, body) {
+    super(`provision failed: HTTP ${status}: ${body}`);
+    this.name = "ProvisionHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function resolveBaseUrl(override) {
+  const candidate = override ?? process.env.KEEPERHUB_API_URL ?? "https://app.keeperhub.com";
+  return candidate.replace(TRAILING_SLASH, "");
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function validateProvisionResponse(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new ProvisionResponseInvalidError(
+      "provision response is not an object"
+    );
+  }
+  const { subOrgId, walletAddress, hmacSecret } = data;
+  if (!(isNonEmptyString(subOrgId) && isNonEmptyString(walletAddress) && isNonEmptyString(hmacSecret))) {
+    throw new ProvisionResponseInvalidError(
+      "provision response missing subOrgId, walletAddress, or hmacSecret"
+    );
+  }
+  if (!WALLET_ADDRESS_PATTERN.test(walletAddress)) {
+    throw new ProvisionResponseInvalidError(
+      `provision response walletAddress is not a valid 0x-prefixed 40-hex address: ${walletAddress}`
+    );
+  }
+  return {
+    subOrgId,
+    walletAddress,
+    hmacSecret
+  };
+}
+async function provisionWallet(options = {}) {
+  const baseUrl = resolveBaseUrl(options.baseUrl);
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const response = await fetchImpl(`${baseUrl}/api/agentic-wallet/provision`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: "{}",
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new ProvisionHttpError(response.status, text);
+  }
+  const raw = await response.json();
+  const data = validateProvisionResponse(raw);
+  await writeWalletConfig(data);
+  return data;
+}
+
+// src/skill-install.ts
+var import_node_crypto3 = require("crypto");
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_node_url2 = require("url");
 
 // src/agent-detect.ts
 var import_node_fs = require("fs");
-var import_node_os = require("os");
-var import_node_path = require("path");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
 var AGENT_SPECS = [
   {
     agent: "claude-code",
     skillsRel: [".claude", "skills"],
     settingsRel: [".claude", "settings.json"],
-    hookSupport: "claude-code"
+    hookSupport: "claude-code",
+    // ~/.claude.json is at HOME root (not under .claude/) and is large
+    // (100+KB on real installs). registerMcpServer reads/parses/rewrites it
+    // while preserving every other top-level key byte-for-byte.
+    mcpConfigRel: [".claude.json"],
+    mcpSupport: "claude-code"
   },
   {
     agent: "cursor",
     skillsRel: [".cursor", "skills"],
     settingsRel: [".cursor", "settings.json"],
-    hookSupport: "notice"
+    hookSupport: "notice",
+    mcpConfigRel: [".cursor", "mcp.json"],
+    mcpSupport: "cursor"
   },
   {
     agent: "cline",
     skillsRel: [".cline", "skills"],
     settingsRel: [".cline", "settings.json"],
-    hookSupport: "notice"
+    hookSupport: "notice",
+    // Cline keeps MCP state in a per-VS-Code-variant globalStorage path
+    // (e.g. ~/Library/Application Support/Code/User/globalStorage/
+    // saoudrizwan.claude-dev/settings/cline_mcp_settings.json) that is too
+    // fragile to auto-detect. Ship "notice" with a copy-paste entry shape
+    // instead of guessing the variant.
+    mcpSupport: "notice"
   },
   {
     agent: "windsurf",
     skillsRel: [".windsurf", "skills"],
     settingsRel: [".windsurf", "settings.json"],
-    hookSupport: "notice"
+    hookSupport: "notice",
+    mcpConfigRel: [".codeium", "windsurf", "mcp_config.json"],
+    mcpSupport: "windsurf",
+    // Windsurf historically ships under both `.windsurf/` and the legacy
+    // `.codeium/windsurf/`; detect either.
+    extraDetect: [[".codeium", "windsurf"]]
   },
   {
     agent: "opencode",
     skillsRel: [".config", "opencode", "skills"],
     settingsRel: [".config", "opencode", "settings.json"],
-    hookSupport: "notice"
+    hookSupport: "notice",
+    mcpConfigRel: [".config", "opencode", "opencode.json"],
+    mcpSupport: "opencode"
   }
 ];
 function detectAgents(homeOverride) {
-  const home = homeOverride ?? (0, import_node_os.homedir)();
+  const home = homeOverride ?? (0, import_node_os2.homedir)();
   const results = [];
   for (const spec of AGENT_SPECS) {
-    const skillsDir = (0, import_node_path.join)(home, ...spec.skillsRel);
-    const settingsFile = (0, import_node_path.join)(home, ...spec.settingsRel);
-    if ((0, import_node_fs.existsSync)((0, import_node_path.dirname)(skillsDir))) {
-      results.push({
-        agent: spec.agent,
-        skillsDir,
-        settingsFile,
-        hookSupport: spec.hookSupport
-      });
+    const skillsDir = (0, import_node_path2.join)(home, ...spec.skillsRel);
+    const settingsFile = (0, import_node_path2.join)(home, ...spec.settingsRel);
+    let detected = (0, import_node_fs.existsSync)((0, import_node_path2.dirname)(skillsDir));
+    if (!detected && spec.extraDetect) {
+      for (const seg of spec.extraDetect) {
+        if ((0, import_node_fs.existsSync)((0, import_node_path2.join)(home, ...seg))) {
+          detected = true;
+          break;
+        }
+      }
+    }
+    if (!detected) {
+      continue;
     }
+    results.push({
+      agent: spec.agent,
+      skillsDir,
+      settingsFile,
+      hookSupport: spec.hookSupport,
+      mcpConfigRel: spec.mcpConfigRel,
+      mcpSupport: spec.mcpSupport
+    });
   }
   return results;
 }
 
-// src/skill-install.ts
-var HOOK_BIN = "keeperhub-wallet-hook";
-var HOOK_COMMAND_BARE = HOOK_BIN;
+// src/mcp-register.ts
+var import_node_crypto2 = require("crypto");
+var import_promises2 = require("fs/promises");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+
+// src/runtime-detect.ts
+var import_node_child_process = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var import_node_url = require("url");
 var PACKAGE_NAME = "@keeperhub/wallet";
 function readPackageVersion() {
   try {
-    const here = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(__filename));
-    const pkgPath = (0, import_node_path2.join)(here, "..", "package.json");
+    const here = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(__filename));
+    const pkgPath = (0, import_node_path3.join)(here, "..", "package.json");
     const raw = (0, import_node_fs2.readFileSync)(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version === "string" && parsed.version.length > 0) {
@@ -189,9 +361,171 @@ function readPackageVersion() {
   }
   return "latest";
 }
-function buildNpxCommand(version) {
-  return `npx -y -p ${PACKAGE_NAME}@${version} ${HOOK_BIN}`;
+function isNpxExecution() {
+  const execPath = process.env.npm_execpath;
+  if (typeof execPath !== "string" || execPath.length === 0) {
+    return false;
+  }
+  if (/(?:^|[\\/])npx-cli\.(?:js|cjs|mjs)$/i.test(execPath)) {
+    return true;
+  }
+  if (/(?:^|[\\/])npx(?:\.cmd|\.exe|\.ps1)?$/i.test(execPath)) {
+    return true;
+  }
+  return false;
+}
+var TRANSIENT_CACHE_PATTERNS = [
+  /[\\/]_npx[\\/]/,
+  /[\\/]dlx-[A-Za-z0-9]+[\\/]/,
+  /[\\/]xfs-[A-Za-z0-9]+[\\/]/,
+  /[\\/]\.bun[\\/]install[\\/]cache[\\/]/
+];
+function isPathUnderTransientCache(resolvedPath) {
+  for (const re of TRANSIENT_CACHE_PATTERNS) {
+    if (re.test(resolvedPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveBinCommand(binName) {
+  const version = readPackageVersion();
+  const npxArgs = ["-y", "-p", `${PACKAGE_NAME}@${version}`, binName];
+  const npxCommandString = `npx ${npxArgs.join(" ")}`;
+  if (isNpxExecution()) {
+    return {
+      commandString: npxCommandString,
+      command: "npx",
+      args: npxArgs
+    };
+  }
+  try {
+    const resolved = (0, import_node_child_process.execFileSync)("/bin/sh", ["-c", `command -v ${binName}`], {
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    if (resolved.length > 0 && !isPathUnderTransientCache(resolved)) {
+      return {
+        commandString: binName,
+        command: binName,
+        args: []
+      };
+    }
+  } catch {
+  }
+  return {
+    commandString: npxCommandString,
+    command: "npx",
+    args: npxArgs
+  };
+}
+
+// src/mcp-register.ts
+var MCP_BIN = "keeperhub-wallet-mcp";
+var MCP_SERVER_NAME = "keeperhub-wallet";
+function resolveMcpCommand() {
+  const envOverride = process.env.KEEPERHUB_WALLET_MCP_COMMAND;
+  if (envOverride && envOverride.length > 0) {
+    const parts = envOverride.trim().split(/\s+/);
+    const head = parts[0] ?? envOverride;
+    return { command: head, args: parts.slice(1) };
+  }
+  const resolved = resolveBinCommand(MCP_BIN);
+  return { command: resolved.command, args: resolved.args };
+}
+function buildStandardEntry(cmd) {
+  const entry = {
+    command: cmd.command,
+    args: cmd.args
+  };
+  if (cmd.env && Object.keys(cmd.env).length > 0) {
+    entry.env = cmd.env;
+  }
+  return entry;
+}
+function buildOpencodeEntry(cmd) {
+  return {
+    type: "local",
+    command: [cmd.command, ...cmd.args],
+    enabled: true,
+    environment: cmd.env ?? {}
+  };
+}
+async function readJsonOrEmpty(path) {
+  let raw = null;
+  try {
+    raw = await (0, import_promises2.readFile)(path, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  if (raw === null) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `MCP config at ${path} is not valid JSON; aborting MCP registration`
+    );
+  }
+}
+async function writeJsonAtomic(path, payload) {
+  await (0, import_promises2.mkdir)((0, import_node_path4.dirname)(path), { recursive: true, mode: 448 });
+  const suffix = (0, import_node_crypto2.randomBytes)(8).toString("hex");
+  const tmpPath = `${path}.${process.pid}.${suffix}.tmp`;
+  try {
+    await (0, import_promises2.writeFile)(tmpPath, payload, { mode: 384 });
+    await (0, import_promises2.chmod)(tmpPath, 384);
+    await (0, import_promises2.rename)(tmpPath, path);
+  } catch (err) {
+    await (0, import_promises2.unlink)(tmpPath).catch(() => {
+    });
+    throw err;
+  }
+}
+async function writeStandardMcp(path, entry) {
+  const config = await readJsonOrEmpty(path);
+  const servers = typeof config.mcpServers === "object" && config.mcpServers !== null ? config.mcpServers : {};
+  servers[MCP_SERVER_NAME] = entry;
+  config.mcpServers = servers;
+  const payload = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(path, payload);
+}
+async function writeOpencodeMcp(path, entry) {
+  const config = await readJsonOrEmpty(path);
+  const servers = typeof config.mcp === "object" && config.mcp !== null ? config.mcp : {};
+  servers[MCP_SERVER_NAME] = entry;
+  config.mcp = servers;
+  const payload = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(path, payload);
 }
+async function registerMcpServer(target, options = {}) {
+  if (target.mcpSupport === "notice") {
+    throw new Error(
+      `agent ${target.agent} does not support auto-registered MCP servers; surface a notice instead`
+    );
+  }
+  if (!target.mcpConfigRel) {
+    throw new Error(
+      `agent ${target.agent} has mcpSupport=${target.mcpSupport} but no mcpConfigRel path`
+    );
+  }
+  const home = options.homeOverride ?? (0, import_node_os3.homedir)();
+  const path = (0, import_node_path4.join)(home, ...target.mcpConfigRel);
+  const cmd = options.command ?? resolveMcpCommand();
+  if (target.mcpSupport === "opencode") {
+    await writeOpencodeMcp(path, buildOpencodeEntry(cmd));
+  } else {
+    await writeStandardMcp(path, buildStandardEntry(cmd));
+  }
+  return { path, name: MCP_SERVER_NAME };
+}
+
+// src/skill-install.ts
+var HOOK_BIN = "keeperhub-wallet-hook";
 var KEEPERHUB_HOOK_MARKER = HOOK_BIN;
 function filterKeeperhubHooksFromEntry(entry) {
   if (typeof entry !== "object" || entry === null) {
@@ -218,14 +552,7 @@ function resolveHookCommand() {
   if (envOverride && envOverride.length > 0) {
     return envOverride;
   }
-  try {
-    (0, import_node_child_process.execFileSync)("/bin/sh", ["-c", `command -v ${HOOK_BIN}`], {
-      stdio: "ignore"
-    });
-    return HOOK_COMMAND_BARE;
-  } catch {
-    return buildNpxCommand(readPackageVersion());
-  }
+  return resolveBinCommand(HOOK_BIN).commandString;
 }
 function buildKeeperhubEntry(command) {
   return {
@@ -234,8 +561,8 @@ function buildKeeperhubEntry(command) {
   };
 }
 function resolveDefaultSkillSource() {
-  const here = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(__filename));
-  return (0, import_node_path2.join)(here, "..", "skill", "keeperhub-wallet.skill.md");
+  const here = (0, import_node_path5.dirname)((0, import_node_url2.fileURLToPath)(__filename));
+  return (0, import_node_path5.join)(here, "..", "skill", "keeperhub-wallet.skill.md");
 }
 function defaultNotice(msg) {
   process.stderr.write(`${msg}
@@ -245,7 +572,7 @@ async function registerClaudeCodeHook(settingsPath, options = {}) {
   const command = options.hookCommand ?? resolveHookCommand();
   let raw = null;
   try {
-    raw = await (0, import_promises.readFile)(settingsPath, "utf-8");
+    raw = await (0, import_promises3.readFile)(settingsPath, "utf-8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw err;
@@ -273,158 +600,136 @@ async function registerClaudeCodeHook(settingsPath, options = {}) {
   filtered.push(buildKeeperhubEntry(command));
   hooks.PreToolUse = filtered;
   config.hooks = hooks;
-  await (0, import_promises.mkdir)((0, import_node_path2.dirname)(settingsPath), { recursive: true, mode: 448 });
+  await (0, import_promises3.mkdir)((0, import_node_path5.dirname)(settingsPath), { recursive: true, mode: 448 });
   const payload = `${JSON.stringify(config, null, 2)}
 `;
-  await (0, import_promises.writeFile)(settingsPath, payload, { mode: 384 });
-  await (0, import_promises.chmod)(settingsPath, 384);
+  const suffix = (0, import_node_crypto3.randomBytes)(8).toString("hex");
+  const tmpPath = `${settingsPath}.${process.pid}.${suffix}.tmp`;
+  try {
+    await (0, import_promises3.writeFile)(tmpPath, payload, { mode: 384 });
+    await (0, import_promises3.chmod)(tmpPath, 384);
+    await (0, import_promises3.rename)(tmpPath, settingsPath);
+  } catch (err) {
+    await (0, import_promises3.unlink)(tmpPath).catch(() => {
+    });
+    throw err;
+  }
 }
 async function writeSkillToAgent(agent, skillSource) {
-  await (0, import_promises.mkdir)(agent.skillsDir, { recursive: true, mode: 493 });
-  const target = (0, import_node_path2.join)(agent.skillsDir, "keeperhub-wallet.skill.md");
-  await (0, import_promises.copyFile)(skillSource, target);
-  await (0, import_promises.chmod)(target, 420);
+  await (0, import_promises3.mkdir)(agent.skillsDir, { recursive: true, mode: 493 });
+  const target = (0, import_node_path5.join)(agent.skillsDir, "keeperhub-wallet.skill.md");
+  await (0, import_promises3.copyFile)(skillSource, target);
+  await (0, import_promises3.chmod)(target, 420);
   return { agent: agent.agent, path: target, status: "written" };
 }
-function buildNoticeMessage(agent, command) {
+function buildHookNoticeMessage(agent, command) {
   return `${agent.agent} does not support auto-registered PreToolUse hooks; run \`${command}\` on every tool use via ${agent.agent}'s settings file at ${agent.settingsFile}`;
 }
+function buildMcpNoticeMessage(agent, command) {
+  const cmd = [command.command, ...command.args].join(" ");
+  return `${agent.agent} does not support auto-registered MCP servers; add an entry named \`keeperhub-wallet\` running \`${cmd}\` to your MCP config manually`;
+}
 async function installSkill(options = {}) {
   const agents = detectAgents(options.homeOverride);
   const skillSource = options.skillSourcePath ?? resolveDefaultSkillSource();
   const onNotice = options.onNotice ?? defaultNotice;
   const hookCommand = options.hookCommand ?? resolveHookCommand();
+  const mcpCommand = options.mcpCommand ?? resolveMcpCommand();
   const skillWrites = [];
   const hookRegistrations = [];
+  const mcpRegistrations = [];
   for (const agent of agents) {
-    const write = await writeSkillToAgent(agent, skillSource);
-    skillWrites.push(write);
-    if (agent.hookSupport === "claude-code") {
-      await registerClaudeCodeHook(agent.settingsFile, { hookCommand });
-      hookRegistrations.push({
+    try {
+      const write = await writeSkillToAgent(agent, skillSource);
+      skillWrites.push(write);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      skillWrites.push({
         agent: agent.agent,
-        status: "registered"
+        path: "",
+        status: "skipped"
       });
+      onNotice(`${agent.agent}: skill copy failed (${message})`);
+      continue;
+    }
+    if (agent.hookSupport === "claude-code") {
+      try {
+        await registerClaudeCodeHook(agent.settingsFile, { hookCommand });
+        hookRegistrations.push({
+          agent: agent.agent,
+          status: "registered"
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        hookRegistrations.push({
+          agent: agent.agent,
+          status: "failed",
+          message
+        });
+        onNotice(`${agent.agent}: hook registration failed (${message})`);
+      }
     } else {
-      const message = buildNoticeMessage(agent, hookCommand);
+      const noticeMessage = buildHookNoticeMessage(agent, hookCommand);
       hookRegistrations.push({
         agent: agent.agent,
         status: "notice",
-        message
+        message: noticeMessage
       });
-      onNotice(message);
+      onNotice(noticeMessage);
     }
-  }
-  return { skillWrites, hookRegistrations };
-}
-
-// src/storage.ts
-var import_promises2 = require("fs/promises");
-var import_node_os2 = require("os");
-var import_node_path3 = require("path");
-
-// src/types.ts
-var WalletConfigMissingError = class extends Error {
-  constructor() {
-    super(
-      "Wallet config not found at ~/.keeperhub/wallet.json. Run `npx @keeperhub/wallet add` to provision."
-    );
-    this.name = "WalletConfigMissingError";
-  }
-};
-
-// src/storage.ts
-async function readWalletConfig() {
-  const walletPath = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".keeperhub", "wallet.json");
-  let raw;
-  try {
-    raw = await (0, import_promises2.readFile)(walletPath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      throw new WalletConfigMissingError();
+    if (agent.mcpSupport === "notice") {
+      const noticeMessage = buildMcpNoticeMessage(agent, mcpCommand);
+      mcpRegistrations.push({
+        agent: agent.agent,
+        status: "notice",
+        message: noticeMessage
+      });
+      onNotice(noticeMessage);
+      continue;
+    }
+    try {
+      const mcpResult = await registerMcpServer(agent, {
+        homeOverride: options.homeOverride,
+        command: mcpCommand
+      });
+      mcpRegistrations.push({
+        agent: agent.agent,
+        status: "registered",
+        path: mcpResult.path
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      mcpRegistrations.push({
+        agent: agent.agent,
+        status: "failed",
+        message
+      });
+      onNotice(`${agent.agent}: MCP registration failed (${message})`);
     }
-    throw err;
-  }
-  const parsed = JSON.parse(raw);
-  if (!(parsed.subOrgId && parsed.walletAddress && parsed.hmacSecret)) {
-    throw new Error(`Malformed wallet.json at ${walletPath}`);
   }
-  return parsed;
-}
-async function writeWalletConfig(config) {
-  const walletPath = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".keeperhub", "wallet.json");
-  await (0, import_promises2.mkdir)((0, import_node_path3.dirname)(walletPath), { recursive: true, mode: 448 });
-  await (0, import_promises2.writeFile)(walletPath, JSON.stringify(config, null, 2), { mode: 384 });
-  await (0, import_promises2.chmod)(walletPath, 384);
-}
-function getWalletConfigPath() {
-  return (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".keeperhub", "wallet.json");
+  return { skillWrites, hookRegistrations, mcpRegistrations };
 }
 
 // src/cli.ts
-var TRAILING_SLASH = /\/$/;
-var WALLET_ADDRESS_PATTERN = /^0x[a-fA-F0-9]{40}$/;
-function resolveBaseUrl(override) {
-  const candidate = override ?? process.env.KEEPERHUB_API_URL ?? "https://app.keeperhub.com";
-  return candidate.replace(TRAILING_SLASH, "");
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function provisionInvalidError(message) {
-  const err = new Error(message);
-  err.code = "PROVISION_RESPONSE_INVALID";
-  return err;
-}
-function validateProvisionResponse(data) {
-  if (typeof data !== "object" || data === null) {
-    throw provisionInvalidError("provision response is not an object");
-  }
-  const { subOrgId, walletAddress, hmacSecret } = data;
-  if (!(isNonEmptyString(subOrgId) && isNonEmptyString(walletAddress) && isNonEmptyString(hmacSecret))) {
-    throw provisionInvalidError(
-      "provision response missing subOrgId, walletAddress, or hmacSecret"
-    );
-  }
-  if (!WALLET_ADDRESS_PATTERN.test(walletAddress)) {
-    throw provisionInvalidError(
-      `provision response walletAddress is not a valid 0x-prefixed 40-hex address: ${walletAddress}`
-    );
-  }
-  return {
-    subOrgId,
-    walletAddress,
-    hmacSecret
-  };
-}
 async function cmdAdd(opts = {}) {
-  const baseUrl = resolveBaseUrl(opts.baseUrl);
-  const response = await fetch(`${baseUrl}/api/agentic-wallet/provision`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: "{}"
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    process.stderr.write(
-      `[keeperhub-wallet] provision failed: HTTP ${response.status}: ${text}
-`
-    );
-    process.exit(1);
-  }
-  const raw = await response.json();
-  const data = validateProvisionResponse(raw);
-  await writeWalletConfig({
-    subOrgId: data.subOrgId,
-    walletAddress: data.walletAddress,
-    hmacSecret: data.hmacSecret
-  });
-  process.stdout.write(`subOrgId: ${data.subOrgId}
+  try {
+    const data = await provisionWallet({ baseUrl: opts.baseUrl });
+    process.stdout.write(`subOrgId: ${data.subOrgId}
 `);
-  process.stdout.write(`walletAddress: ${data.walletAddress}
+    process.stdout.write(`walletAddress: ${data.walletAddress}
 `);
-  process.stdout.write(`config written to ${getWalletConfigPath()}
+    process.stdout.write(`config written to ${getWalletConfigPath()}
 `);
+  } catch (err) {
+    if (err instanceof ProvisionHttpError) {
+      process.stderr.write(
+        `[keeperhub-wallet] provision failed: HTTP ${err.status}: ${err.body}
+`
+      );
+      process.exit(1);
+    }
+    throw err;
+  }
 }
 async function cmdFund() {
   const wallet = await readWalletConfig();
@@ -492,6 +797,29 @@ async function runCli(argv = process.argv) {
         } else if (reg.status === "notice") {
           process.stderr.write(
             `notice: ${reg.agent} -> ${reg.message ?? ""}
+`
+          );
+        } else if (reg.status === "failed") {
+          process.stderr.write(
+            `hook: ${reg.agent} -> FAILED (${reg.message ?? "unknown error"})
+`
+          );
+        }
+      }
+      for (const reg of result.mcpRegistrations) {
+        if (reg.status === "registered") {
+          process.stdout.write(
+            `mcp: ${reg.agent} -> registered at ${reg.path ?? "(unknown path)"}
+`
+          );
+        } else if (reg.status === "notice") {
+          process.stderr.write(
+            `notice: ${reg.agent} mcp -> ${reg.message ?? ""}
+`
+          );
+        } else if (reg.status === "failed") {
+          process.stderr.write(
+            `mcp: ${reg.agent} -> FAILED (${reg.message ?? "unknown error"})
 `
           );
         }