@hivefloor/cli 0.0.0-stage → 0.1.1

package/dist/chunk-YCZ7XJJF.js

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+import {
+  findBin
+} from "./chunk-2IMJECYD.js";
+import {
+  atomicWrite,
+  backupOnce,
+  dropBackupIfSame,
+  home,
+  isRecord,
+  manifestFile,
+  readJsonFile,
+  readText,
+  removeFile,
+  serializeJson
+} from "./chunk-WNDUGQDX.js";
+import {
+  cliNpxCommand,
+  runCmd
+} from "./chunk-ZYRPQPGL.js";
+
+// src/manifest.ts
+function readManifest() {
+  const text = readText(manifestFile());
+  const base = { version: 1, created: [], tools: {}, rc: [] };
+  if (!text) return base;
+  try {
+    const j = JSON.parse(text);
+    if (isRecord(j)) {
+      return {
+        version: 1,
+        created: Array.isArray(j.created) ? j.created.filter((x) => typeof x === "string") : [],
+        tools: isRecord(j.tools) ? j.tools : {},
+        rc: Array.isArray(j.rc) ? j.rc.filter((x) => typeof x === "string") : []
+      };
+    }
+  } catch {
+  }
+  return base;
+}
+function writeManifest(m) {
+  atomicWrite(manifestFile(), JSON.stringify(m, null, 2) + "\n", 384);
+}
+function updateManifest(f) {
+  const m = readManifest();
+  f(m);
+  writeManifest(m);
+}
+var addCreated = (file) => updateManifest((m) => {
+  if (!m.created.includes(file)) m.created.push(file);
+});
+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 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";
+var emptyReport = () => ({ lines: [], warnings: [] });
+var CLI_COPY_RE = /hivefloor[/\\]cli[/\\]index\.js$/;
+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);
+}
+function isAgentHook(h) {
+  if (!isRecord(h) || isMachineHook(h)) return false;
+  if (h.hivefloor === true || h.name === "hivefloor") return true;
+  const cmd = h.command;
+  if (typeof cmd !== "string") return false;
+  if (/^\s*(?:\S*[/\\])?hivefloor(?:\.cmd|\.exe)?\s+hook\s/.test(cmd)) return true;
+  return /^(?:\S*[/\\])?hivefloor(?:\.cmd|\.exe)?$/.test(cmd) && Array.isArray(h.args) && h.args[0] === "hook";
+}
+var ofKind = (kind) => (h) => kind === "machine" ? isMachineHook(h) : isAgentHook(h);
+function addHooks(data, shape, specs, kind = "agent") {
+  removeHooks(data, shape, kind);
+  const hooks = isRecord(data.hooks) ? data.hooks : data.hooks = {};
+  for (const s of specs) {
+    const list = Array.isArray(hooks[s.event]) ? hooks[s.event] : hooks[s.event] = [];
+    list.push(shape === "flat" ? { ...s.entry, ...s.matcher ? { matcher: s.matcher } : {} } : { ...s.matcher ? { matcher: s.matcher } : {}, hooks: [s.entry] });
+  }
+}
+function removeHooks(data, shape, kind = "agent") {
+  const ours = ofKind(kind);
+  const hooks = data.hooks;
+  if (!isRecord(hooks)) return 0;
+  let removed = 0;
+  for (const [event, list] of Object.entries(hooks)) {
+    if (!Array.isArray(list)) continue;
+    const before = removed;
+    const kept = [];
+    for (const item of list) {
+      if (shape === "flat") {
+        if (ours(item)) removed += 1;
+        else kept.push(item);
+      } else if (isRecord(item) && Array.isArray(item.hooks)) {
+        const inner = item.hooks.filter((h) => !ours(h));
+        const gone = item.hooks.length - inner.length;
+        removed += gone;
+        if (gone === 0) kept.push(item);
+        else if (inner.length > 0) kept.push({ ...item, hooks: inner });
+      } else {
+        kept.push(item);
+      }
+    }
+    if (removed === before) continue;
+    if (kept.length > 0) hooks[event] = kept;
+    else delete hooks[event];
+  }
+  if (removed > 0 && Object.keys(hooks).length === 0) delete data.hooks;
+  return removed;
+}
+function isEmptyConfig(data) {
+  return Object.keys(data).every((k) => k === "version");
+}
+function editJson(file, mutate, opts = {}) {
+  const f = readJsonFile(file);
+  if (!mutate(f.data)) return false;
+  if (opts.drop && wasCreated(file) && isEmptyConfig(f.data)) {
+    removeFile(file);
+    forgetCreated(file);
+    return true;
+  }
+  if (!f.existed) addCreated(file);
+  else if (!wasCreated(file)) backupOnce(file);
+  atomicWrite(file, serializeJson(f.data, f.style), opts.mode);
+  if (opts.drop) dropBackupIfSame(file);
+  return true;
+}
+function secureFile(file) {
+  for (const f of [file, `${file}.hivefloor.bak`]) {
+    try {
+      fs2.chmodSync(f, 384);
+    } catch {
+    }
+  }
+}
+function dropBackupWithEntry(file, name) {
+  const bak = `${file}.hivefloor.bak`;
+  const text = readText(bak);
+  if (text === void 0) return;
+  try {
+    const data = JSON.parse(text);
+    if (isRecord(data) && isRecord(data.mcpServers) && name in data.mcpServers) removeFile(bak);
+  } catch {
+  }
+}
+
+// src/writers/claude.ts
+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 MCP_NAME = "hivefloor";
+function claudeHookSpecs() {
+  return CLAUDE_EVENTS.map((event) => ({
+    event,
+    // A permission or idle prompt marks the session "waiting on you"; other notifications are not sent.
+    ...event === "Notification" ? { matcher: "permission_prompt|idle_prompt" } : {},
+    // Exec form: no shell. async: the hook never slows the agent down.
+    entry: { type: "command", command: "hivefloor", args: ["hook", "claude", event], async: true }
+  }));
+}
+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) {
+    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 (mcp === "file") {
+    editJson(
+      claudeJson(),
+      (d) => {
+        const servers = isRecord(d.mcpServers) ? d.mcpServers : d.mcpServers = {};
+        servers[MCP_NAME] = { type: "http", url: i.mcpUrl, headers: { Authorization: auth } };
+        return true;
+      },
+      i.useEnvToken ? {} : { mode: 384 }
+    );
+    if (!i.useEnvToken) secureFile(claudeJson());
+    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(", ")})`);
+  }
+  return { report, mcp };
+}
+async function removeClaude(ctx, viaCli, keepHooks = false, viaFile = false) {
+  const report = emptyReport();
+  if (viaCli) {
+    const bin = findBin("claude", ctx.env);
+    if (bin) {
+      const r = await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: ctx.env });
+      if (r.code === 0) report.lines.push("Claude Code MCP: claude mcp remove");
+    }
+  }
+  if (viaFile) {
+    const changed = editJson(
+      claudeJson(),
+      (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(`Claude Code MCP: removed from ${claudeJson()}`);
+  }
+  dropBackupWithEntry(claudeJson(), MCP_NAME);
+  if (!keepHooks && editJson(claudeSettings(), (d) => removeHooks(d, "nested") > 0, { drop: true })) report.lines.push(`Claude Code hooks: removed from ${claudeSettings()}`);
+  return report;
+}
+
+// src/writers/codex.ts
+import path3 from "path";
+
+// src/writers/toml.ts
+var BEGIN = (name, sep) => `# hivefloor:begin ${name} sep=${sep}`;
+var END = (name) => `# hivefloor:end ${name}`;
+var blockRe = (name) => new RegExp(`(?:\\r?\\n)*# hivefloor:begin ${name} sep=(\\d+)\\r?\\n[\\s\\S]*?# hivefloor:end ${name}\\r?\\n?`);
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+var tomlString = (s) => `"${esc(s)}"`;
+function setBlock(content, name, body) {
+  const without = removeBlock(content, name);
+  if (without === "") return `${BEGIN(name, 0)}
+${body}
+${END(name)}
+`;
+  const sep = without.endsWith("\n") ? 1 : 2;
+  return `${without}${"\n".repeat(sep)}${BEGIN(name, sep)}
+${body}
+${END(name)}
+`;
+}
+function removeBlock(content, name) {
+  const m = blockRe(name).exec(content);
+  if (!m) return content;
+  const sep = Number(m[1]);
+  const before = content.slice(0, m.index);
+  const after = content.slice(m.index + m[0].length);
+  const swallowed = m[0].length - m[0].replace(/^(?:\r?\n)*/, "").length;
+  const keep = Math.max(0, swallowed - sep);
+  return before + "\n".repeat(keep) + after;
+}
+function hasBlock(content, name) {
+  return blockRe(name).test(content);
+}
+function hasTable(content, table) {
+  const stripped = content.replace(/# hivefloor:begin[\s\S]*?# hivefloor:end [^\n]*\n?/g, "");
+  const re = new RegExp(`^\\s*\\[\\s*${table.replace(/\./g, "\\s*\\.\\s*")}\\s*\\]`, "m");
+  return re.test(stripped);
+}
+var FEATURE_TAG = "# hivefloor";
+function enableFeatureHooks(content) {
+  const lines = content.split("\n");
+  const header = lines.findIndex((l) => /^\s*\[features\]\s*(#.*)?\r?$/.test(l));
+  if (header === -1) {
+    if (/^\s*features\.hooks\s*=\s*true\b/m.test(content)) return content;
+    return setBlock(content, "features", "[features]\nhooks = true");
+  }
+  let end = lines.length;
+  for (let k = header + 1; k < lines.length; k++) {
+    if (/^\s*\[/.test(lines[k])) {
+      end = k;
+      break;
+    }
+  }
+  for (let k = header + 1; k < end; k++) {
+    const m = /^(\s*hooks\s*=\s*)(true|false)(\s*(?:#.*)?)(\r?)$/.exec(lines[k]);
+    if (!m) continue;
+    if (m[2] === "true") return content;
+    lines[k] = `${m[1]}true ${FEATURE_TAG}:was=false${m[4]}`;
+    return lines.join("\n");
+  }
+  const cr = lines[header].endsWith("\r") ? "\r" : "";
+  lines.splice(header + 1, 0, `hooks = true ${FEATURE_TAG}${cr}`);
+  return lines.join("\n");
+}
+function restoreFeatureHooks(content) {
+  let out = removeBlock(content, "features");
+  out = out.split("\n").filter((l) => !/^\s*hooks\s*=\s*true\s+# hivefloor\s*\r?$/.test(l)).map((l) => l.replace(/^(\s*hooks\s*=\s*)true\s+# hivefloor:was=false(\r?)$/, "$1false$2")).join("\n");
+  return out;
+}
+
+// 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");
+function codexHookSpecs() {
+  return CODEX_EVENTS.map((event) => ({ event, entry: { type: "command", command: `hivefloor hook codex ${event}` } }));
+}
+function editToml(fn, opts = {}) {
+  const file = codexConfig();
+  const before = readText(file);
+  const next = fn(before ?? "");
+  if (next === (before ?? "")) return false;
+  if (opts.drop && wasCreated(file) && next.trim() === "") {
+    removeFile(file);
+    forgetCreated(file);
+    return true;
+  }
+  if (before === void 0) addCreated(file);
+  else if (!wasCreated(file)) backupOnce(file);
+  atomicWrite(file, next);
+  if (opts.drop) dropBackupIfSame(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 (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;
+      }
+      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}])`);
+  }
+  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.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) {
+  const report = emptyReport();
+  if (viaCli) {
+    const bin = findBin("codex", ctx.env);
+    if (bin && (await runCmd(bin, ["mcp", "remove", MCP_NAME], { env: ctx.env })).code === 0) report.lines.push("Codex MCP: codex mcp remove");
+  }
+  const text = readText(codexConfig());
+  if (text !== void 0) {
+    const had = hasBlock(text, "mcp");
+    if (editToml((c) => keepHooks ? removeBlock(c, "mcp") : restoreFeatureHooks(removeBlock(c, "mcp")), { drop: true })) {
+      report.lines.push(`Codex: removed our entries from ${codexConfig()}${had ? " (MCP server, features.hooks)" : " (features.hooks)"}`);
+    }
+  }
+  if (!keepHooks && editJson(codexHooks(), (d) => removeHooks(d, "nested") > 0, { drop: true })) report.lines.push(`Codex hooks: removed from ${codexHooks()}`);
+  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,
+  addHooks,
+  removeHooks,
+  editJson,
+  CLAUDE_EVENTS,
+  claudeJson,
+  installClaude,
+  removeClaude,
+  enableFeatureHooks,
+  restoreFeatureHooks,
+  CODEX_EVENTS,
+  installCodex,
+  removeCodex,
+  installCursor,
+  removeCursor,
+  geminiSettings,
+  installGemini,
+  removeGemini,
+  installGrok,
+  removeGrok
+};