@hivefloor/cli 0.1.4 → 0.1.8

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-QGULSOQ2.js

@@ -0,0 +1,142 @@
+#!/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";
+import os from "os";
+import readline from "readline";
+import { spawn } from "child_process";
+var DEFAULT_HOST = "https://hivefloor.worldofz.info";
+function defaultCtx() {
+  const ctx = {
+    out: (s) => void process.stdout.write(s),
+    err: (s) => void process.stderr.write(s),
+    env: process.env,
+    cwd: process.cwd(),
+    fetch: (...args) => fetch(...args),
+    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)
+  };
+  return ctx;
+}
+async function askOnTerminal(question) {
+  if (!process.stdin.isTTY) return "";
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await new Promise((resolve) => rl.question(question, resolve));
+  } finally {
+    rl.close();
+  }
+}
+function webUrl(url) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    throw new Error("not a URL");
+  }
+  if (u.protocol !== "https:" && u.protocol !== "http:") throw new Error(`refusing to open a ${u.protocol} URL`);
+  return u;
+}
+function browserCommand(url, platform = process.platform) {
+  const u = webUrl(url);
+  if (platform === "win32") return { cmd: "rundll32.exe", args: ["url.dll,FileProtocolHandler", u.toString()] };
+  return { cmd: platform === "darwin" ? "open" : "xdg-open", args: [u.toString()] };
+}
+async function openBrowser(url, platform = process.platform) {
+  let target;
+  try {
+    target = browserCommand(url, platform);
+  } catch {
+    return;
+  }
+  await new Promise((resolve) => {
+    try {
+      const child = spawn(target.cmd, target.args, { stdio: "ignore", detached: true });
+      child.on("error", () => resolve());
+      child.unref();
+      setTimeout(resolve, 200);
+    } catch {
+      resolve();
+    }
+  });
+}
+function hostFromEnv(env) {
+  return normalizeHost(env.HIVEFLOOR_URL || DEFAULT_HOST);
+}
+function normalizeHost(input) {
+  const shown = redactUserinfo(input);
+  let h = input.trim();
+  if (!/^https?:\/\//i.test(h)) h = `https://${h}`;
+  let u;
+  try {
+    u = new URL(h);
+  } catch {
+    throw new Error(`"${shown}" is not a valid host. Use a URL such as https://hivefloor.example.com or http://localhost:3000.`);
+  }
+  if (u.hostname === "") throw new Error(`"${shown}" is not a valid host. Use a URL such as https://hivefloor.example.com or http://localhost:3000.`);
+  const bare = u.hostname.replace(/\.+$/, "");
+  if (bare !== "" && bare !== u.hostname) u.hostname = bare;
+  return u.origin;
+}
+function redactUserinfo(raw) {
+  return raw.trim().replace(/^([a-z][a-z0-9+.-]*:\/\/)?[^/?#]*@/i, "$1");
+}
+function hostFromFlag(ctx, raw) {
+  const host = normalizeHost(raw);
+  if (host !== raw.trim()) ctx.err(`hivefloor: using host ${host} (from --host ${redactUserinfo(raw)})
+`);
+  return host;
+}
+function isLoopbackHost(hostname) {
+  const h = hostname.toLowerCase();
+  return h === "localhost" || h === "127.0.0.1" || h === "[::1]" || h === "::1";
+}
+function isSecureUrl(u) {
+  if (u.protocol === "https:") return true;
+  return u.protocol === "http:" && isLoopbackHost(u.hostname);
+}
+function sameOrigin(a, b) {
+  try {
+    return normalizeHost(a) === normalizeHost(b);
+  } catch {
+    return false;
+  }
+}
+function assertTokenTransport(target) {
+  let u;
+  try {
+    u = new URL(target);
+  } catch {
+    throw new Error("not a URL");
+  }
+  if (!isSecureUrl(u)) throw new Error(`https is required (http is only allowed on localhost): ${u.origin}`);
+  return u;
+}
+var machineName = () => os.hostname().split(".")[0] || "machine";
+function runCmd(bin, args, opts = {}) {
+  return new Promise((resolve) => {
+    execFile(bin, args, { cwd: opts.cwd, env: opts.env, timeout: opts.timeoutMs ?? 2e4, maxBuffer: 1 << 20 }, (error, stdout, stderr) => {
+      if (!error) return resolve({ code: 0, stdout: String(stdout), stderr: String(stderr) });
+      const code = typeof error.code === "number" ? error.code : 127;
+      resolve({ code, stdout: String(stdout), stderr: String(stderr) });
+    });
+  });
+}
+
+export {
+  DEFAULT_HOST,
+  defaultCtx,
+  hostFromEnv,
+  normalizeHost,
+  hostFromFlag,
+  sameOrigin,
+  assertTokenTransport,
+  machineName,
+  runCmd
+};