@hivefloor/cli 0.1.4 → 0.1.8

package/dist/{chunk-QHYZBHXO.js → chunk-X2KH6AR4.js}

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
-  findBin
-} from "./chunk-2IMJECYD.js";
+  ApiError
+} from "./chunk-NRJONTFT.js";
 import {
   atomicWrite,
   backupOnce,
   dropBackupIfSame,
+  findBin,
   home,
   isRecord,
   manifestFile,
@@ -13,11 +16,11 @@ import {
   readText,
   removeFile,
   serializeJson
-} from "./chunk-VNCQFFQO.js";
+} from "./chunk-XPGL7VYE.js";
 import {
-  cliNpxCommand,
-  runCmd
-} from "./chunk-ZC2DAKB5.js";
+  runCmd,
+  sameOrigin
+} from "./chunk-QGULSOQ2.js";
 
 // src/manifest.ts
 function readManifest() {
@@ -53,65 +56,32 @@ var wasCreated = (file) => readManifest().created.includes(file);
 var forgetCreated = (file) => updateManifest((m) => {
   m.created = m.created.filter((f) => f !== file);
 });
-
-// src/shellrc.ts
-import fs from "fs";
-import path from "path";
-var RC_MARK = "# hivefloor";
-var RC_LINE = `export HIVEFLOOR_TOKEN="$(hivefloor token)" ${RC_MARK}`;
-function rcFileFor(env) {
-  const shell = path.basename(env.SHELL ?? "");
-  if (shell === "zsh") return path.join(home(), ".zshrc");
-  if (shell === "bash") {
-    const profile = path.join(home(), ".bash_profile");
-    return process.platform === "darwin" && fs.existsSync(profile) ? profile : path.join(home(), ".bashrc");
-  }
-  return void 0;
-}
-function hasRcLine(file) {
-  return (readText(file) ?? "").split("\n").some((l) => {
-    const t = l.trim();
-    return !t.startsWith("#") && t.includes("HIVEFLOOR_TOKEN") && t.includes("hivefloor token") && t.endsWith(RC_MARK);
+function toolReadsEnvToken(name, entry, shellExportsToken) {
+  if (!entry) return false;
+  if (typeof entry.envToken === "boolean") return entry.envToken;
+  return name === "codex" || shellExportsToken;
+}
+function envTokenSharedWith(host, tool, shellExportsToken) {
+  const manifest = readManifest();
+  return Object.entries(manifest.tools).every(([name, entry]) => {
+    if (name === tool) return true;
+    if (!toolReadsEnvToken(name, entry, shellExportsToken)) return true;
+    return typeof entry?.host === "string" && entry.host.length > 0 && sameOrigin(entry.host, host);
   });
 }
-function addRcLine(file) {
-  if (hasRcLine(file)) return false;
-  const cur = readText(file);
-  if (cur === void 0) addCreated(file);
-  const sep = cur && !cur.endsWith("\n") ? "\n" : "";
-  atomicWrite(file, `${cur ?? ""}${sep}${RC_LINE}
-`);
-  return true;
-}
-function removeRcLine(file) {
-  const cur = readText(file);
-  if (cur === void 0) return false;
-  const lines = cur.split("\n");
-  const kept = lines.filter((l) => l.trim() !== RC_LINE);
-  if (kept.length === lines.length) return false;
-  const next = kept.join("\n");
-  if (next.trim() === "" && wasCreated(file)) {
-    fs.rmSync(file, { force: true });
-    forgetCreated(file);
-  } else {
-    atomicWrite(file, next);
-  }
-  return true;
-}
-
-// src/writers/claude.ts
-import path2 from "path";
 
 // src/writers/common.ts
-import fs2 from "fs";
+import fs from "fs";
 var emptyReport = () => ({ lines: [], warnings: [] });
 var CLI_COPY_RE = /hivefloor[/\\]cli[/\\]index\.js$/;
+var MACHINE_CMD_RE = /hivefloor[/\\]+cli[/\\]+index\.js"?\s+hook\s/;
 function isMachineHook(h) {
   if (!isRecord(h)) return false;
   const cmd = h.command;
   if (typeof cmd !== "string") return false;
   if (Array.isArray(h.args) && h.args[1] === "hook" && typeof h.args[0] === "string" && CLI_COPY_RE.test(h.args[0])) return true;
-  return /hivefloor[/\\]cli[/\\]index\.js"?\s+hook\s/.test(cmd);
+  if (MACHINE_CMD_RE.test(cmd)) return true;
+  return typeof h.commandWindows === "string" && MACHINE_CMD_RE.test(h.commandWindows);
 }
 function isAgentHook(h) {
   if (!isRecord(h) || isMachineHook(h)) return false;
@@ -180,7 +150,7 @@ function editJson(file, mutate, opts = {}) {
 function secureFile(file) {
   for (const f of [file, `${file}.hivefloor.bak`]) {
     try {
-      fs2.chmodSync(f, 384);
+      fs.chmodSync(f, 384);
     } catch {
     }
   }
@@ -197,9 +167,10 @@ function dropBackupWithEntry(file, name) {
 }
 
 // src/writers/claude.ts
+import path from "path";
 var CLAUDE_EVENTS = ["SessionStart", "SessionEnd", "UserPromptSubmit", "Stop", "Notification", "SubagentStart", "SubagentStop"];
-var claudeJson = () => path2.join(home(), ".claude.json");
-var claudeSettings = () => path2.join(home(), ".claude", "settings.json");
+var claudeJson = () => path.join(home(), ".claude.json");
+var claudeSettings = () => path.join(home(), ".claude", "settings.json");
 var MCP_NAME = "hivefloor";
 function claudeHookSpecs() {
   return CLAUDE_EVENTS.map((event) => ({
@@ -214,13 +185,16 @@ async function installClaude(i) {
   const report = emptyReport();
   const auth = i.useEnvToken ? "Bearer ${HIVEFLOOR_TOKEN}" : `Bearer ${i.token}`;
   let mcp = "file";
-  const bin = i.noCli || !i.useEnvToken ? void 0 : findBin("claude", i.ctx.env);
-  if (bin) {
+  const priorCli = !i.useEnvToken && readManifest().tools.claude?.mcp === "cli";
+  const bin = i.noCli ? void 0 : findBin("claude", i.ctx.env);
+  if (bin && (i.useEnvToken || priorCli)) {
     await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: i.ctx.env });
-    const r = await runCmd(bin, ["mcp", "add", "--transport", "http", MCP_NAME, i.mcpUrl, "--header", `Authorization: ${auth}`, "-s", "user"], { env: i.ctx.env });
-    if (r.code === 0) {
-      mcp = "cli";
-      report.lines.push(`Claude Code MCP: claude mcp add (user scope) -> ${i.mcpUrl}`);
+    if (i.useEnvToken) {
+      const r = await runCmd(bin, ["mcp", "add", "--transport", "http", MCP_NAME, i.mcpUrl, "--header", `Authorization: ${auth}`, "-s", "user"], { env: i.ctx.env });
+      if (r.code === 0) {
+        mcp = "cli";
+        report.lines.push(`Claude Code MCP: claude mcp add (user scope) -> ${i.mcpUrl}`);
+      }
     }
   }
   if (mcp === "file") {
@@ -237,10 +211,12 @@ async function installClaude(i) {
     report.lines.push(`Claude Code MCP: ${claudeJson()} (mcpServers.${MCP_NAME})`);
   }
   i.onMcpRegistered?.(mcp);
-  if (i.skipHooks) report.lines.push("Claude Code hooks: the machine connection already forwards them");
-  else {
-    editJson(claudeSettings(), (d) => (addHooks(d, "nested", claudeHookSpecs()), true));
-    report.lines.push(`Claude Code hooks: ${claudeSettings()} (${CLAUDE_EVENTS.join(", ")})`);
+  if (!i.mcpOnly) {
+    if (i.skipHooks) report.lines.push("Claude Code hooks: the machine connection already forwards them");
+    else {
+      editJson(claudeSettings(), (d) => (addHooks(d, "nested", claudeHookSpecs()), true));
+      report.lines.push(`Claude Code hooks: ${claudeSettings()} (${CLAUDE_EVENTS.join(", ")})`);
+    }
   }
   return { report, mcp };
 }
@@ -272,7 +248,7 @@ async function removeClaude(ctx, viaCli, keepHooks = false, viaFile = false) {
 }
 
 // src/writers/codex.ts
-import path3 from "path";
+import path2 from "path";
 
 // src/writers/toml.ts
 var BEGIN = (name, sep) => `# hivefloor:begin ${name} sep=${sep}`;
@@ -312,6 +288,60 @@ function hasTable(content, table) {
   const re = new RegExp(`^\\s*\\[\\s*${table.replace(/\./g, "\\s*\\.\\s*")}\\s*\\]`, "m");
   return re.test(stripped);
 }
+var tableName = (header) => /^\s*\[\s*([^\]]+?)\s*\]/.exec(header)?.[1]?.replace(/\s+/g, "");
+function isNamedTable(name, table) {
+  const want = table.replace(/\s+/g, "");
+  return name === want || name.startsWith(`${want}.`);
+}
+function removeOutsideTable(content, table) {
+  const lines = content.split("\n");
+  const out = [];
+  const pending = [];
+  let inFence = false;
+  let skipping = false;
+  const dropPending = () => {
+    pending.length = 0;
+  };
+  const flushPending = () => {
+    out.push(...pending);
+    dropPending();
+  };
+  for (const line of lines) {
+    const bare = line.replace(/\r$/, "");
+    if (!inFence && /^# hivefloor:begin /.test(bare)) {
+      if (skipping) dropPending();
+      inFence = true;
+    }
+    if (inFence) {
+      out.push(line);
+      if (/^# hivefloor:end /.test(bare)) inFence = false;
+      continue;
+    }
+    const name = tableName(bare);
+    if (name !== void 0) {
+      if (isNamedTable(name, table)) {
+        skipping = true;
+        dropPending();
+        continue;
+      }
+      if (skipping) flushPending();
+      skipping = false;
+      out.push(line);
+      continue;
+    }
+    if (skipping) {
+      if (bare.trim() === "" || /^\s*#/.test(bare)) pending.push(line);
+      else dropPending();
+      continue;
+    }
+    out.push(line);
+  }
+  if (skipping && pending.some((l) => /^\s*#/.test(l.replace(/\r$/, "")))) flushPending();
+  return out.join("\n");
+}
+function hasOutsideTable(content, table) {
+  return removeOutsideTable(content, table) !== content;
+}
 var FEATURE_TAG = "# hivefloor";
 function enableFeatureHooks(content) {
   const lines = content.split("\n");
@@ -346,9 +376,9 @@ function restoreFeatureHooks(content) {
 
 // src/writers/codex.ts
 var CODEX_EVENTS = ["SessionStart", "SessionEnd", "UserPromptSubmit", "Stop", "SubagentStart", "SubagentStop"];
-var codexDir = () => path3.join(process.env.CODEX_HOME || path3.join(home(), ".codex"));
-var codexConfig = () => path3.join(codexDir(), "config.toml");
-var codexHooks = () => path3.join(codexDir(), "hooks.json");
+var codexDir = () => path2.join(process.env.CODEX_HOME || path2.join(home(), ".codex"));
+var codexConfig = () => path2.join(codexDir(), "config.toml");
+var codexHooks = () => path2.join(codexDir(), "hooks.json");
 function codexHookSpecs() {
   return CODEX_EVENTS.map((event) => ({ event, entry: { type: "command", command: `hivefloor hook codex ${event}` } }));
 }
@@ -364,44 +394,98 @@ function editToml(fn, opts = {}) {
   }
   if (before === void 0) addCreated(file);
   else if (!wasCreated(file)) backupOnce(file);
-  atomicWrite(file, next);
+  atomicWrite(file, next, opts.mode);
   if (opts.drop) dropBackupIfSame(file);
   return true;
 }
+var CODEX_TABLE = `mcp_servers.${MCP_NAME}`;
+function codexEnvBlock(mcpUrl) {
+  return `[mcp_servers.${MCP_NAME}]
+url = ${tomlString(mcpUrl)}
+bearer_token_env_var = "HIVEFLOOR_TOKEN"`;
+}
+function codexLiteralBlock(mcpUrl, token) {
+  return `[mcp_servers.${MCP_NAME}]
+url = ${tomlString(mcpUrl)}
+http_headers = { Authorization = ${tomlString(`Bearer ${token}`)} }`;
+}
+async function writeCodexLiteral(i) {
+  const prior = readManifest().tools.codex;
+  const ownedCli = prior?.mcp === "cli";
+  if (ownedCli && !i.noCli) {
+    const bin = findBin("codex", i.ctx.env);
+    if (bin) await runCmd(bin, ["mcp", "remove", MCP_NAME], { env: i.ctx.env });
+  }
+  const body = codexLiteralBlock(i.mcpUrl, i.token);
+  let blocked = false;
+  const wrote = editToml(
+    (c) => {
+      if (hasTable(c, CODEX_TABLE) && !ownedCli) {
+        blocked = true;
+        return c;
+      }
+      return setBlock(ownedCli ? removeOutsideTable(c, CODEX_TABLE) : c, "mcp", body);
+    },
+    { mode: 384 }
+  );
+  const file = codexConfig();
+  if (blocked || !wrote && !(readText(file) ?? "").includes(body)) return false;
+  secureFile(file);
+  return true;
+}
 async function installCodex(i) {
   const report = emptyReport();
   let mcp = "file";
-  const bin = i.noCli ? void 0 : findBin("codex", i.ctx.env);
-  if (bin) {
-    await runCmd(bin, ["mcp", "remove", MCP_NAME], { env: i.ctx.env });
-    const r = await runCmd(bin, ["mcp", "add", MCP_NAME, "--url", i.mcpUrl, "--bearer-token-env-var", "HIVEFLOOR_TOKEN"], { env: i.ctx.env });
-    if (r.code === 0) {
-      mcp = "cli";
-      report.lines.push(`Codex MCP: codex mcp add -> ${i.mcpUrl}`);
+  if (i.useEnvToken) {
+    const bin = i.noCli ? void 0 : findBin("codex", i.ctx.env);
+    if (bin) {
+      await runCmd(bin, ["mcp", "remove", MCP_NAME], { env: i.ctx.env });
+      const r = await runCmd(bin, ["mcp", "add", MCP_NAME, "--url", i.mcpUrl, "--bearer-token-env-var", "HIVEFLOOR_TOKEN"], { env: i.ctx.env });
+      if (r.code === 0) {
+        mcp = "cli";
+        report.lines.push(`Codex MCP: codex mcp add -> ${i.mcpUrl}`);
+      }
     }
-  }
-  if (mcp === "file") {
-    editToml((c) => {
-      if (hasTable(c, `mcp_servers.${MCP_NAME}`)) {
-        report.warnings.push(`${codexConfig()} already defines [mcp_servers.${MCP_NAME}]; left as it is`);
-        return c;
+    if (mcp === "file") {
+      let wrote = false;
+      editToml((c) => {
+        if (hasTable(c, CODEX_TABLE)) {
+          report.warnings.push(`${codexConfig()} already defines [mcp_servers.${MCP_NAME}]; left as it is`);
+          return c;
+        }
+        wrote = true;
+        return setBlock(c, "mcp", codexEnvBlock(i.mcpUrl));
+      });
+      if (wrote) report.lines.push(`Codex MCP: ${codexConfig()} ([mcp_servers.${MCP_NAME}])`);
+    }
+  } else {
+    const wrote = await writeCodexLiteral(i);
+    if (!wrote) {
+      const file = codexConfig();
+      if (i.requireStoredToken) {
+        throw new ApiError(
+          0,
+          "codex_config",
+          `${file} already defines [mcp_servers.hivefloor], and Codex cannot store this host's token apart from HIVEFLOOR_TOKEN. Remove that table and run connect again.`
+        );
       }
-      return setBlock(c, "mcp", `[mcp_servers.${MCP_NAME}]
-url = ${tomlString(i.mcpUrl)}
-bearer_token_env_var = "HIVEFLOOR_TOKEN"`);
-    });
-    report.lines.push(`Codex MCP: ${codexConfig()} ([mcp_servers.${MCP_NAME}])`);
+      report.warnings.push(`${file} already defines [mcp_servers.${MCP_NAME}]; left as it is`);
+      report.warnings.push('Codex reads the token from HIVEFLOOR_TOKEN: add export HIVEFLOOR_TOKEN="$(hivefloor token)" to your shell rc.');
+    } else {
+      report.lines.push(`Codex MCP: ${codexConfig()} ([mcp_servers.${MCP_NAME}], token stored in the file)`);
+    }
   }
   i.onMcpRegistered?.(mcp);
-  if (i.skipHooks) report.lines.push("Codex hooks: the machine connection already forwards them");
-  else {
-    editJson(codexHooks(), (d) => (addHooks(d, "nested", codexHookSpecs()), true));
-    report.lines.push(`Codex hooks: ${codexHooks()} (${CODEX_EVENTS.join(", ")})`);
-    editToml(enableFeatureHooks);
-    report.lines.push(`Codex: features.hooks = true in ${codexConfig()}`);
-    report.warnings.push("Codex asks you to trust new hooks: run codex, open /hooks and approve the Hivefloor hooks once.");
+  if (!i.mcpOnly) {
+    if (i.skipHooks) report.lines.push("Codex hooks: the machine connection already forwards them");
+    else {
+      editJson(codexHooks(), (d) => (addHooks(d, "nested", codexHookSpecs()), true));
+      report.lines.push(`Codex hooks: ${codexHooks()} (${CODEX_EVENTS.join(", ")})`);
+      editToml(enableFeatureHooks);
+      report.lines.push(`Codex: features.hooks = true in ${codexConfig()}`);
+      report.warnings.push("Codex asks you to trust new hooks: run codex, open /hooks and approve the HiveFloor hooks once.");
+    }
   }
-  if (!i.useEnvToken) report.warnings.push('Codex reads the token from HIVEFLOOR_TOKEN: add export HIVEFLOOR_TOKEN="$(hivefloor token)" to your shell rc.');
   return { report, mcp };
 }
 async function removeCodex(ctx, viaCli, keepHooks = false) {
@@ -421,174 +505,34 @@ async function removeCodex(ctx, viaCli, keepHooks = false) {
   return report;
 }
 
-// src/writers/cursor.ts
-import path4 from "path";
-var CURSOR_EVENTS = ["sessionStart", "sessionEnd", "beforeSubmitPrompt", "stop", "subagentStart", "subagentStop"];
-var cursorMcp = () => path4.join(home(), ".cursor", "mcp.json");
-var cursorHooks = () => path4.join(home(), ".cursor", "hooks.json");
-function cursorHookSpecs() {
-  return CURSOR_EVENTS.map((event) => ({ event, entry: { command: `hivefloor hook cursor ${event}` } }));
-}
-async function installCursor(i) {
-  const report = emptyReport();
-  const auth = i.useEnvToken ? "Bearer ${env:HIVEFLOOR_TOKEN}" : `Bearer ${i.token}`;
-  editJson(
-    cursorMcp(),
-    (d) => {
-      const servers = isRecord(d.mcpServers) ? d.mcpServers : d.mcpServers = {};
-      servers[MCP_NAME] = { url: i.mcpUrl, headers: { Authorization: auth } };
-      return true;
-    },
-    i.useEnvToken ? {} : { mode: 384 }
-  );
-  report.lines.push(`Cursor MCP: ${cursorMcp()} (mcpServers.${MCP_NAME})`);
-  i.onMcpRegistered?.("file");
-  editJson(cursorHooks(), (d) => {
-    if (d.version === void 0) d.version = 1;
-    addHooks(d, "flat", cursorHookSpecs());
-    return true;
-  });
-  report.lines.push(`Cursor hooks: ${cursorHooks()} (${CURSOR_EVENTS.join(", ")})`);
-  return { report, mcp: "file" };
-}
-async function removeCursor() {
-  const report = emptyReport();
-  const changed = editJson(
-    cursorMcp(),
-    (d) => {
-      if (!isRecord(d.mcpServers) || !(MCP_NAME in d.mcpServers)) return false;
-      delete d.mcpServers[MCP_NAME];
-      if (Object.keys(d.mcpServers).length === 0) delete d.mcpServers;
-      return true;
-    },
-    { drop: true }
-  );
-  if (changed) report.lines.push(`Cursor MCP: removed from ${cursorMcp()}`);
-  if (editJson(cursorHooks(), (d) => removeHooks(d, "flat") > 0, { drop: true })) report.lines.push(`Cursor hooks: removed from ${cursorHooks()}`);
-  return report;
-}
-
-// src/writers/gemini.ts
-import path5 from "path";
-var GEMINI_EVENTS = ["SessionStart", "SessionEnd", "AfterAgent"];
-var geminiSettings = () => path5.join(home(), ".gemini", "settings.json");
-function geminiHookSpecs() {
-  return GEMINI_EVENTS.map((event) => ({
-    event,
-    // Gemini hook entries carry a name: ours is "hivefloor", which is also how disconnect finds them.
-    entry: { name: "hivefloor", type: "command", command: `hivefloor hook gemini ${event}` }
-  }));
-}
-async function installGemini(i) {
-  const report = emptyReport();
-  const auth = i.useEnvToken ? "Bearer $HIVEFLOOR_TOKEN" : `Bearer ${i.token}`;
-  let mcp = "file";
-  const bin = i.noCli || !i.useEnvToken ? void 0 : findBin("gemini", i.ctx.env);
-  if (bin) {
-    await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: i.ctx.env });
-    const r = await runCmd(bin, ["mcp", "add", MCP_NAME, i.mcpUrl, "-t", "http", "-s", "user", "-H", `Authorization: ${auth}`], { env: i.ctx.env });
-    if (r.code === 0) {
-      mcp = "cli";
-      report.lines.push(`Gemini MCP: gemini mcp add (user scope) -> ${i.mcpUrl}`);
-    }
-  }
-  if (mcp === "file") {
-    editJson(
-      geminiSettings(),
-      (d) => {
-        const servers = isRecord(d.mcpServers) ? d.mcpServers : d.mcpServers = {};
-        servers[MCP_NAME] = { httpUrl: i.mcpUrl, headers: { Authorization: auth } };
-        return true;
-      },
-      i.useEnvToken ? {} : { mode: 384 }
-    );
-    if (!i.useEnvToken) secureFile(geminiSettings());
-    report.lines.push(`Gemini MCP: ${geminiSettings()} (mcpServers.${MCP_NAME})`);
-  }
-  i.onMcpRegistered?.(mcp);
-  editJson(geminiSettings(), (d) => (addHooks(d, "nested", geminiHookSpecs()), true), i.useEnvToken ? {} : { mode: 384 });
-  report.lines.push(`Gemini hooks: ${geminiSettings()} (${GEMINI_EVENTS.join(", ")})`);
-  return { report, mcp };
-}
-async function removeGemini(ctx, viaCli, viaFile = false) {
-  const report = emptyReport();
-  if (viaCli) {
-    const bin = findBin("gemini", ctx.env);
-    if (bin && (await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: ctx.env })).code === 0) report.lines.push("Gemini MCP: gemini mcp remove");
-  }
-  const changed = editJson(
-    geminiSettings(),
-    (d) => {
-      let did = removeHooks(d, "nested") > 0;
-      if (viaFile && isRecord(d.mcpServers) && MCP_NAME in d.mcpServers) {
-        delete d.mcpServers[MCP_NAME];
-        if (Object.keys(d.mcpServers).length === 0) delete d.mcpServers;
-        did = true;
-      }
-      return did;
-    },
-    { drop: true }
-  );
-  if (changed) report.lines.push(`Gemini: removed our entries from ${geminiSettings()}`);
-  dropBackupWithEntry(geminiSettings(), MCP_NAME);
-  return report;
-}
-
-// src/writers/grok.ts
-async function installGrok(i) {
-  const report = emptyReport();
-  const auth = i.useEnvToken ? "Bearer ${HIVEFLOOR_TOKEN}" : `Bearer ${i.token}`;
-  const bin = i.noCli ? void 0 : findBin("grok", i.ctx.env);
-  if (bin) {
-    await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: i.ctx.env });
-    const r = await runCmd(bin, ["mcp", "add", "--transport", "http", MCP_NAME, i.mcpUrl, "-s", "user", "--header", `Authorization: ${auth}`], { env: i.ctx.env });
-    if (r.code === 0) {
-      report.lines.push(`Grok MCP: grok mcp add (user scope) -> ${i.mcpUrl}`);
-      report.lines.push("Grok hooks: none needed (Grok reads the Claude Code hooks in ~/.claude/settings.json; connect Claude Code too for live sessions)");
-      i.onMcpRegistered?.("cli");
-      return { report, mcp: "cli" };
-    }
-  }
-  report.warnings.push(`Could not run the grok CLI. Add the server by hand: grok mcp add --transport http ${MCP_NAME} ${i.mcpUrl} -s user --header "Authorization: Bearer <token from ${cliNpxCommand("token --reveal")}>"`);
-  return { report, mcp: "manual" };
-}
-async function removeGrok(ctx, viaCli) {
-  const report = emptyReport();
-  if (viaCli) {
-    const bin = findBin("grok", ctx.env);
-    if (bin && (await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: ctx.env })).code === 0) report.lines.push("Grok MCP: grok mcp remove");
-  }
-  return report;
-}
-
 export {
   readManifest,
   updateManifest,
   addCreated,
   wasCreated,
   forgetCreated,
-  RC_LINE,
-  rcFileFor,
-  hasRcLine,
-  addRcLine,
-  removeRcLine,
+  toolReadsEnvToken,
+  envTokenSharedWith,
+  emptyReport,
   addHooks,
   removeHooks,
   editJson,
+  secureFile,
+  dropBackupWithEntry,
   CLAUDE_EVENTS,
   claudeJson,
+  MCP_NAME,
   installClaude,
   removeClaude,
+  tomlString,
+  setBlock,
+  removeBlock,
+  hasBlock,
+  removeOutsideTable,
+  hasOutsideTable,
   enableFeatureHooks,
   restoreFeatureHooks,
   CODEX_EVENTS,
   installCodex,
-  removeCodex,
-  installCursor,
-  removeCursor,
-  geminiSettings,
-  installGemini,
-  removeGemini,
-  installGrok,
-  removeGrok
+  removeCodex
 };

package/dist/chunk-XAXKZ572.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  findBin,
+  home
+} from "./chunk-XPGL7VYE.js";
+
+// src/service/control/proc.ts
+import { execFile } from "child_process";
+function runFile(file, args, opts = {}) {
+  return new Promise((resolve) => {
+    try {
+      const child = execFile(file, args, { timeout: opts.timeoutMs ?? 5e3, maxBuffer: 1024 * 1024, windowsHide: true, ...opts.env ? { env: opts.env } : {} }, (err, stdout, stderr) => {
+        if (!err) return resolve({ code: 0, stdout: String(stdout), stderr: String(stderr) });
+        const e = err;
+        const spawnError = typeof e.code === "string";
+        resolve({ code: typeof e.code === "number" ? e.code : null, stdout: String(stdout ?? ""), stderr: String(stderr ?? ""), ...spawnError ? { spawnError: true } : {} });
+      });
+      if (opts.input !== void 0) {
+        child.stdin?.on("error", () => void 0);
+        child.stdin?.end(opts.input);
+      }
+    } catch {
+      resolve({ code: null, stdout: "", stderr: "", spawnError: true });
+    }
+  });
+}
+
+// src/service/claude-bin.ts
+import fs from "fs";
+import path from "path";
+var CLAUDE_BIN_ENV = "HIVEFLOOR_CLAUDE_BIN";
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "fish", "dash", "ksh"]);
+var NOT_FOUND_TTL_MS = 6e4;
+var LOGIN_SHELL_TIMEOUT_MS = 3e3;
+function userBinDirs(homeDir = home()) {
+  return [path.join(homeDir, ".local", "bin"), path.join(homeDir, ".claude", "local"), "/opt/homebrew/bin", "/usr/local/bin"];
+}
+function claudeFallbackPaths(homeDir = home()) {
+  return userBinDirs(homeDir).map((d) => path.join(d, "claude"));
+}
+var isExecutableFile = (p) => {
+  try {
+    if (!fs.statSync(p).isFile()) return false;
+    fs.accessSync(p, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var lastAbsLine = (out) => {
+  const lines = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) if (path.isAbsolute(lines[i])) return lines[i];
+  return void 0;
+};
+function createClaudeResolver(deps = {}) {
+  const isExec = deps.isExecutable ?? isExecutableFile;
+  const now = deps.now ?? Date.now;
+  let found;
+  let missAt = -Infinity;
+  let warnedBadEnv = false;
+  const search = async () => {
+    const env = deps.env ?? process.env;
+    const homeDir = deps.home ?? home();
+    if ((deps.platform ?? process.platform) === "win32") {
+      return findBin("claude", env);
+    }
+    const explicit = env[CLAUDE_BIN_ENV];
+    if (explicit) {
+      if (path.isAbsolute(explicit) && isExec(explicit)) return explicit;
+      if (!warnedBadEnv) {
+        warnedBadEnv = true;
+        (deps.log ?? ((m) => console.error(m)))(`hivefloor: ${CLAUDE_BIN_ENV} is set but is not an absolute path to an executable file; ignoring it and searching for claude`);
+      }
+    }
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+      if (!dir || !path.isAbsolute(dir)) continue;
+      const p2 = path.join(dir, "claude");
+      if (isExec(p2)) return p2;
+    }
+    for (const p2 of claudeFallbackPaths(homeDir)) if (isExec(p2)) return p2;
+    const shell = env.SHELL;
+    if (!shell || !path.isAbsolute(shell) || !SHELLS.has(path.basename(shell)) || !isExec(shell)) return void 0;
+    const r = await (deps.run ?? runFile)(shell, ["-lc", "command -v claude"], { timeoutMs: LOGIN_SHELL_TIMEOUT_MS });
+    if (r.code !== 0) return void 0;
+    const p = lastAbsLine(r.stdout);
+    return p && isExec(p) ? p : void 0;
+  };
+  return async () => {
+    if (found && isExec(found)) return found;
+    found = void 0;
+    if (now() - missAt < NOT_FOUND_TTL_MS) return void 0;
+    found = await search();
+    if (!found) missAt = now();
+    return found;
+  };
+}
+var shared;
+var resolveClaudeBin = () => (shared ??= createClaudeResolver())();
+
+export {
+  runFile,
+  userBinDirs,
+  resolveClaudeBin
+};