@hivefloor/cli 0.1.5 → 0.1.8

package/dist/{chunk-C627OKTW.js → chunk-K2IRTZH5.js}

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 
 // package.json
 var package_default = {
   name: "@hivefloor/cli",
-  version: "0.1.5",
-  description: "Connect your coding agents (Claude Code, Codex, Cursor, Gemini, Grok) to Hivefloor: live presence, task coordination and usage on one floor.",
+  version: "0.1.8",
+  description: "Connect your coding agents (Claude Code, Codex, Cursor, Gemini, Grok) to HiveFloor: live presence, task coordination and usage on one floor.",
   author: {
     name: "Zan",
     url: "https://github.com/Errr0rr404"
@@ -21,14 +23,13 @@ var package_default = {
   ],
   homepage: "https://hivefloor.worldofz.info",
   bugs: {
-    url: "https://github.com/Errr0rr404/hivefloor/issues"
+    url: "https://github.com/Errr0rr404/hivefloor-cli/issues"
   },
   repository: {
     type: "git",
-    url: "git+https://github.com/Errr0rr404/hivefloor.git",
-    directory: "packages/cli"
+    url: "git+https://github.com/Errr0rr404/hivefloor-cli.git"
   },
-  license: "MIT",
+  license: "UNLICENSED",
   type: "module",
   bin: {
     hivefloor: "dist/index.js"

package/dist/chunk-KQMPCV57.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  atomicWrite,
+  controlFile,
+  isRecord
+} from "./chunk-XPGL7VYE.js";
+
+// src/service/control/config.ts
+import fs from "fs";
+import path from "path";
+var VERBS = ["message", "approve", "deny", "stop", "resume", "peek"];
+var allOff = () => ({ version: 1, enabled: false, verbs: { message: false, approve: false, deny: false, stop: false, resume: false, peek: false }, from: "owner", replies: "after_message", adapters: [], orchestrator: false, orchestrator_full: false });
+var MAX_CONTROL_BYTES = 1024 * 1024;
+function statTrouble(file, st) {
+  if (!st.isFile()) return `${file} is not a regular file`;
+  if (process.platform === "win32") return void 0;
+  if (typeof process.getuid === "function" && st.uid !== process.getuid()) return `${file} is owned by another user`;
+  if ((st.mode & 18) !== 0) return `${file} is writable by group or others (chmod 600 it)`;
+  return void 0;
+}
+function fileTrouble(file) {
+  let st;
+  try {
+    st = fs.lstatSync(file);
+  } catch {
+    return void 0;
+  }
+  if (st.isSymbolicLink()) return `${file} is a symbolic link`;
+  return statTrouble(file, st);
+}
+function dirTrouble(dir) {
+  if (process.platform === "win32") return void 0;
+  let st;
+  try {
+    st = fs.statSync(dir);
+  } catch {
+    return void 0;
+  }
+  if (!st.isDirectory()) return `${dir} is not a folder`;
+  if (typeof process.getuid === "function" && st.uid !== process.getuid()) return `${dir} is owned by another user`;
+  if ((st.mode & 18) !== 0) return `${dir} is writable by group or others (chmod 700 it)`;
+  return void 0;
+}
+function sanitize(j) {
+  const c = allOff();
+  c.enabled = j.enabled === true;
+  const v = isRecord(j.verbs) ? j.verbs : {};
+  for (const k of VERBS) c.verbs[k] = v[k] === true;
+  c.from = j.from === "admins" ? "admins" : "owner";
+  c.orchestrator = j.orchestrator === true;
+  c.orchestrator_full = j.orchestrator_full === true;
+  c.replies = j.replies === "off" || j.replies === "always" ? j.replies : "after_message";
+  if (Array.isArray(j.adapters)) {
+    for (const a of j.adapters) {
+      if (!isRecord(a) || typeof a.name !== "string" || typeof a.exec !== "string") continue;
+      const verbs = Array.isArray(a.verbs) ? a.verbs.filter((x) => VERBS.includes(x)) : [];
+      const tools = Array.isArray(a.tools) ? a.tools.filter((x) => typeof x === "string") : [];
+      c.adapters.push({ name: a.name.slice(0, 60), exec: a.exec, verbs, tools });
+    }
+  }
+  return c;
+}
+function readControl(file = controlFile()) {
+  const bad = (reason) => ({ state: "invalid", reason, config: allOff() });
+  const trouble = dirTrouble(path.dirname(file)) ?? fileTrouble(file);
+  if (trouble) return bad(trouble);
+  let fd;
+  try {
+    fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") return { state: "missing", config: allOff() };
+    if (code === "ELOOP" || code === "EMLINK") return bad(`${file} is a symbolic link`);
+    return bad(`${file} cannot be read`);
+  }
+  let text;
+  try {
+    const st = fs.fstatSync(fd);
+    const t = statTrouble(file, st);
+    if (t) return bad(t);
+    if (st.size > MAX_CONTROL_BYTES) return bad(`${file} is too large`);
+    text = fs.readFileSync(fd, "utf8");
+  } catch {
+    return bad(`${file} cannot be read`);
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    const j = JSON.parse(text);
+    if (!isRecord(j)) return { state: "invalid", reason: `${file} is not a JSON object`, config: allOff() };
+    return { state: "ok", config: sanitize(j) };
+  } catch {
+    return { state: "invalid", reason: `${file} is not valid JSON`, config: allOff() };
+  }
+}
+function activeVerbs(r) {
+  const out = allOff().verbs;
+  if (r.state !== "ok" || !r.config.enabled) return out;
+  for (const k of VERBS) out[k] = r.config.verbs[k];
+  return out;
+}
+var orchestratorOn = (r) => r.state === "ok" && r.config.enabled && r.config.orchestrator;
+var orchestratorFullOn = (r) => orchestratorOn(r) && r.config.orchestrator_full === true;
+var controlOn = (r) => Object.values(activeVerbs(r)).some(Boolean);
+function writeControl(c, file = controlFile()) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 448 });
+  atomicWrite(file, `${JSON.stringify(c, null, 2)}
+`, 384);
+}
+
+export {
+  VERBS,
+  allOff,
+  readControl,
+  activeVerbs,
+  orchestratorOn,
+  orchestratorFullOn,
+  controlOn,
+  writeControl
+};

package/dist/{chunk-J36OIJBM.js → chunk-L6EFW2SJ.js}

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   home,
   isDir,
   isRecord,
   readText
-} from "./chunk-TPMFQUAW.js";
+} from "./chunk-XPGL7VYE.js";
 import {
   PROFILE_KEY_RE
-} from "./chunk-4DRHR7LR.js";
+} from "./chunk-HWBUESB4.js";
 
 // src/profiles.ts
 import fs from "fs";
@@ -121,14 +123,16 @@ function codexConfigDir(env = process.env) {
   return env.CODEX_HOME ? path.resolve(env.CODEX_HOME) : path.join(home(), ".codex");
 }
 var PLAN = { max: "Max", pro: "Pro", team: "Team", enterprise: "Enterprise", free: "Free" };
-function claudeLabel(dir, key) {
-  let plan;
-  try {
-    const j = JSON.parse(fs.readFileSync(path.join(dir, ".credentials.json"), "utf8"));
-    const oauth = isRecord(j) ? j.claudeAiOauth : void 0;
-    const t = isRecord(oauth) ? oauth.subscriptionType : void 0;
-    if (typeof t === "string") plan = PLAN[t.toLowerCase()];
-  } catch {
+function claudeLabel(dir, key, tokenPlan) {
+  let plan = tokenPlan;
+  if (!plan) {
+    try {
+      const j = JSON.parse(fs.readFileSync(path.join(dir, ".credentials.json"), "utf8"));
+      const oauth = isRecord(j) ? j.claudeAiOauth : void 0;
+      const t = isRecord(oauth) ? oauth.subscriptionType : void 0;
+      if (typeof t === "string") plan = PLAN[t.toLowerCase()];
+    } catch {
+    }
   }
   return `Claude${plan ? ` ${plan}` : ""} (${key})`;
 }

package/dist/{chunk-IJRHCDIG.js → chunk-LX5A25O6.js}

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   atomicWrite,
   configDir,
@@ -6,7 +8,7 @@ import {
   machineFile,
   readText,
   serviceStateFile
-} from "./chunk-TPMFQUAW.js";
+} from "./chunk-XPGL7VYE.js";
 
 // src/machine.ts
 import fs from "fs";
@@ -61,7 +63,7 @@ async function secureWindowsMachine(run, username = os.userInfo().username) {
     if (f.code === 0) return;
   }
   removeMachineFile();
-  throw new Error("could not restrict the Hivefloor config to your Windows user with icacls; the machine token was not kept");
+  throw new Error("could not restrict the HiveFloor config to your Windows user with icacls; the machine token was not kept");
 }
 var SERVICE_ALIVE_MS = 9e4;
 function readServiceState() {

package/dist/{chunk-MZGGJ6ZS.js → chunk-MYJCU5JL.js}

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   claudeConfigDirs,
   claudeLabel,
   codexConfigDir,
   codexLabel,
   profileKeys
-} from "./chunk-J36OIJBM.js";
+} from "./chunk-L6EFW2SJ.js";
 import {
   agentIsCursor,
   findBin
-} from "./chunk-TPMFQUAW.js";
+} from "./chunk-XPGL7VYE.js";
 
 // src/osinfo.ts
 import os from "os";

package/dist/{chunk-H6NYMF2D.js → chunk-NMUH5NXN.js}

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   TOKEN_FP_HEX,
   defaultHost,
@@ -6,18 +8,18 @@ import {
   loadToken,
   readCredentials,
   tokenFingerprint
-} from "./chunk-6MDJB3BV.js";
+} from "./chunk-QLMLB7RB.js";
 import {
   flagStr
-} from "./chunk-TKMIV7BG.js";
+} from "./chunk-QPAFN47B.js";
 import {
   isTool
-} from "./chunk-TPMFQUAW.js";
+} from "./chunk-XPGL7VYE.js";
 import {
   hostFromEnv,
   hostFromFlag,
   sameOrigin
-} from "./chunk-SOXRITAW.js";
+} from "./chunk-QGULSOQ2.js";
 
 // src/session.ts
 function envTokenForHost(env, host) {

package/dist/{chunk-VX7SCIF2.js → chunk-NRJONTFT.js}

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   assertTokenTransport
-} from "./chunk-SOXRITAW.js";
+} from "./chunk-QGULSOQ2.js";
 
 // src/api.ts
 var ApiError = class extends Error {

package/dist/chunk-QBBKGORP.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  MCP_NAME,
+  addCreated,
+  addHooks,
+  dropBackupWithEntry,
+  editJson,
+  emptyReport,
+  forgetCreated,
+  hasBlock,
+  hasOutsideTable,
+  readManifest,
+  removeBlock,
+  removeHooks,
+  removeOutsideTable,
+  secureFile,
+  setBlock,
+  tomlString,
+  wasCreated
+} from "./chunk-X2KH6AR4.js";
+import {
+  atomicWrite,
+  backupOnce,
+  dropBackupIfSame,
+  findBin,
+  home,
+  isRecord,
+  readText,
+  removeFile
+} from "./chunk-XPGL7VYE.js";
+import {
+  runCmd
+} from "./chunk-QGULSOQ2.js";
+import {
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
+
+// 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 isRcLine(line) {
+  const t = line.trim();
+  return !t.startsWith("#") && t.includes("HIVEFLOOR_TOKEN") && t.includes("hivefloor token") && t.endsWith(RC_MARK);
+}
+function hasRcLine(file) {
+  return (readText(file) ?? "").split("\n").some(isRcLine);
+}
+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) => !isRcLine(l));
+  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/cursor.ts
+import path2 from "path";
+var CURSOR_EVENTS = ["sessionStart", "sessionEnd", "beforeSubmitPrompt", "stop", "subagentStart", "subagentStop"];
+var cursorMcp = () => path2.join(home(), ".cursor", "mcp.json");
+var cursorHooks = () => path2.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");
+  if (!i.mcpOnly) {
+    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 path3 from "path";
+var GEMINI_EVENTS = ["SessionStart", "SessionEnd", "AfterAgent"];
+var geminiSettings = () => path3.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 priorCli = !i.useEnvToken && readManifest().tools.gemini?.mcp === "cli";
+  const bin = i.noCli ? void 0 : findBin("gemini", i.ctx.env);
+  if (bin && (i.useEnvToken || priorCli)) {
+    await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env: i.ctx.env });
+    if (i.useEnvToken) {
+      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);
+  if (!i.mcpOnly) {
+    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
+import path4 from "path";
+var grokConfig = () => path4.join(home(), ".grok", "config.toml");
+var HOOKS_LINE = "Grok hooks: none needed (Grok reads the Claude Code hooks in ~/.claude/settings.json; connect Claude Code too for live sessions)";
+function editGrokToml(fn, opts = {}) {
+  const file = grokConfig();
+  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, opts.mode);
+  if (opts.drop) dropBackupIfSame(file);
+  return true;
+}
+function grokMcpBlock(mcpUrl, auth) {
+  return `[mcp_servers.${MCP_NAME}]
+url = ${tomlString(mcpUrl)}
+enabled = true
+
+[mcp_servers.${MCP_NAME}.headers]
+Authorization = ${tomlString(auth)}`;
+}
+var GROK_TABLE = `mcp_servers.${MCP_NAME}`;
+var ENV_AUTH = "Bearer ${HIVEFLOOR_TOKEN}";
+function outsideHasRawAuthorization(content) {
+  const stripped = content.replace(/# hivefloor:begin[\s\S]*?# hivefloor:end [^\n]*(?:\n|$)/g, "");
+  let inTable = false;
+  for (const line of stripped.split("\n")) {
+    const bare = line.replace(/\r$/, "");
+    const header = /^\s*\[\s*([^\]]+?)\s*\]/.exec(bare);
+    if (header) {
+      const name = header[1].replace(/\s+/g, "");
+      inTable = name === GROK_TABLE || name.startsWith(`${GROK_TABLE}.`);
+      continue;
+    }
+    if (!inTable) continue;
+    const auth = /Authorization\s*=\s*["']([^"']*)["']/.exec(bare);
+    if (auth && auth[1] !== ENV_AUTH) return true;
+  }
+  return false;
+}
+async function dropOutsideServer(env, bin) {
+  const file = grokConfig();
+  const bak = `${file}.hivefloor.bak`;
+  const before = readText(file);
+  const beforeBak = readText(bak);
+  const staleLive = before !== void 0 && hasOutsideTable(before, GROK_TABLE);
+  const staleBak = beforeBak !== void 0 && hasOutsideTable(beforeBak, GROK_TABLE);
+  if (!staleLive && !staleBak) return false;
+  if (bin && staleLive) await runCmd(bin, ["mcp", "remove", MCP_NAME, "-s", "user"], { env });
+  for (const f of [file, bak]) {
+    const cur = readText(f);
+    if (cur === void 0 || !hasOutsideTable(cur, GROK_TABLE)) continue;
+    const next = removeOutsideTable(cur, GROK_TABLE);
+    if (next.trim() === "") removeFile(f);
+    else atomicWrite(f, next);
+  }
+  const left = readText(file);
+  if (left !== void 0 && left.trim() === "") removeFile(file);
+  return true;
+}
+async function installGrok(i) {
+  const report = emptyReport();
+  const auth = i.useEnvToken ? ENV_AUTH : `Bearer ${i.token}`;
+  const bin = i.noCli ? void 0 : findBin("grok", i.ctx.env);
+  const liveBefore = readText(grokConfig());
+  const bakBefore = readText(`${grokConfig()}.hivefloor.bak`);
+  const hadRaw = [liveBefore, bakBefore].some((t) => t !== void 0 && outsideHasRawAuthorization(t));
+  const removed = await dropOutsideServer(i.ctx.env, bin);
+  if (removed && hadRaw) report.warnings.push(`${grokConfig()} had [${GROK_TABLE}] outside our block; removed it so an older token does not stay on disk`);
+  if (bin && i.useEnvToken) {
+    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}`);
+      if (!i.mcpOnly) report.lines.push(HOOKS_LINE);
+      i.onMcpRegistered?.("cli");
+      return { report, mcp: "cli" };
+    }
+  }
+  const file = grokConfig();
+  const changed = editGrokToml((c) => setBlock(c, "mcp", grokMcpBlock(i.mcpUrl, auth)), i.useEnvToken ? {} : { mode: 384 });
+  if (!i.useEnvToken && (changed || (readText(file) ?? "").includes(i.token))) secureFile(file);
+  if (changed || hasBlock(readText(file) ?? "", "mcp")) {
+    report.lines.push(`Grok MCP: ${file} ([${GROK_TABLE}])`);
+    if (!i.mcpOnly) report.lines.push(HOOKS_LINE);
+    i.onMcpRegistered?.("file");
+    return { report, mcp: "file" };
+  }
+  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, viaFile = false) {
+  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");
+  }
+  if (viaFile && editGrokToml((c) => removeBlock(c, "mcp"), { drop: true })) report.lines.push(`Grok MCP: removed from ${grokConfig()}`);
+  return report;
+}
+
+export {
+  RC_LINE,
+  rcFileFor,
+  hasRcLine,
+  addRcLine,
+  removeRcLine,
+  installCursor,
+  removeCursor,
+  geminiSettings,
+  installGemini,
+  removeGemini,
+  installGrok,
+  removeGrok
+};

package/dist/{chunk-SOXRITAW.js → chunk-QGULSOQ2.js}

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 
 // src/ctx.ts
 import { execFile } from "child_process";
@@ -16,6 +18,7 @@ function defaultCtx() {
     sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
     now: () => Date.now(),
     stdoutIsTTY: Boolean(process.stdout.isTTY),
+    stdinIsTTY: Boolean(process.stdin.isTTY),
     ask: askOnTerminal,
     open: async (url) => openBrowser(url, ctx.platform ?? process.platform)
   };