@hivefloor/cli 0.1.4 → 0.1.8

package/dist/chunk-5XXYQQG6.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  PERMISSION_TIMEOUT_SEC
+} from "./chunk-4G362W6G.js";
+import {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  addCreated,
+  addHooks,
+  editJson,
+  enableFeatureHooks,
+  forgetCreated,
+  removeHooks,
+  restoreFeatureHooks,
+  wasCreated
+} from "./chunk-X2KH6AR4.js";
+import {
+  activeVerbs,
+  readControl
+} from "./chunk-KQMPCV57.js";
+import {
+  claudeConfigDirs,
+  codexConfigDir,
+  profileKeys
+} from "./chunk-L6EFW2SJ.js";
+import {
+  atomicWrite,
+  backupOnce,
+  cliDir,
+  cliEntry,
+  dropBackupIfSame,
+  home,
+  isDir,
+  readText,
+  removeFile
+} from "./chunk-XPGL7VYE.js";
+
+// src/machine-hooks.ts
+import fs from "fs";
+import path from "path";
+function installCliCopy(srcDir) {
+  if (!fs.existsSync(path.join(srcDir, "index.js"))) throw new Error(`cannot find the CLI bundle in ${srcDir}`);
+  const dest = cliDir();
+  fs.mkdirSync(dest, { recursive: true, mode: 448 });
+  for (const f of fs.readdirSync(srcDir)) {
+    if (!/\.(?:js|mjs)$/.test(f)) continue;
+    const tmp = path.join(dest, `${f}.${process.pid}.tmp`);
+    fs.copyFileSync(path.join(srcDir, f), tmp);
+    fs.renameSync(tmp, path.join(dest, f));
+  }
+  fs.writeFileSync(path.join(dest, "package.json"), '{"type":"module"}\n');
+}
+var removeCliCopy = () => fs.rmSync(cliDir(), { recursive: true, force: true });
+function claudeMachineSpecs(node, profile, verbs = {}) {
+  const entry = (event, extra) => ({ type: "command", command: node, args: [cliEntry(), "hook", "claude", event, "--profile", profile], ...extra });
+  const specs = CLAUDE_EVENTS.map((event) => ({
+    event,
+    ...event === "Notification" ? { matcher: "permission_prompt|idle_prompt" } : {},
+    // Exec form: no shell, no quoting. async: the hook never slows the agent down.
+    entry: entry(event, { async: true })
+  }));
+  if (verbs.message) specs.push({ event: "PostToolUse", entry: entry("PostToolUse", { async: true }) });
+  if (verbs.approve || verbs.deny) specs.push({ event: "PermissionRequest", entry: entry("PermissionRequest", { timeout: PERMISSION_TIMEOUT_SEC }) });
+  return specs;
+}
+var currentControlVerbs = () => activeVerbs(readControl());
+function applyControlHooks(node, dirs, verbs) {
+  const out = { lines: [], warnings: [] };
+  const existing = distinctSettingsDirs(dirs.filter(isDir));
+  const keys = profileKeys("claude", existing);
+  for (const dir of existing) {
+    const file = path.join(dir, "settings.json");
+    try {
+      editJson(file, (d) => (addHooks(d, "nested", claudeMachineSpecs(node, keys.get(dir), verbs), "machine"), true));
+      out.lines.push(`Claude Code hooks (${keys.get(dir)}): ${file}`);
+    } catch (e) {
+      out.warnings.push(e.message);
+    }
+  }
+  return out;
+}
+var q = (s) => `"${s.replace(/(["\\$`])/g, "\\$1")}"`;
+var CODEX_HOOK_CMD = "codex-hook.cmd";
+var CMD_META = /[&|<>^%!]/;
+var PS_META = /[$`;,']/;
+function isWinPath(s) {
+  return /^[A-Za-z]:[\\/]|^\\\\|\\/.test(s);
+}
+function windowsCmdRules(paths) {
+  return process.platform === "win32" || paths.some(isWinPath);
+}
+function pathMod(s) {
+  return isWinPath(s) ? path.win32 : path;
+}
+function normalizeCmdPath(s) {
+  return isWinPath(s) ? path.win32.normalize(s) : s;
+}
+var hasCmdMeta = (s) => CMD_META.test(s);
+var hasPsMeta = (s) => PS_META.test(s);
+var bareClean = (s) => !/\s/.test(s) && !hasCmdMeta(s) && !hasPsMeta(s);
+var doubleQuotedClean = (s) => !hasCmdMeta(s) && !hasPsMeta(s);
+var qWinBody = (s) => `"${normalizeCmdPath(s).replace(/%/g, "%%").replace(/"/g, '""')}"`;
+function shimCandidates(cliDirectory, homeDir) {
+  const m = pathMod(cliDirectory);
+  const cli = normalizeCmdPath(cliDirectory);
+  return [m.join(cli, CODEX_HOOK_CMD), m.join(m.dirname(cli), "codex-hook", CODEX_HOOK_CMD), m.join(homeDir, ".hivefloor", CODEX_HOOK_CMD)].map(normalizeCmdPath);
+}
+function codexShimPath(cliDirectory, homeDir) {
+  const ranked = shimCandidates(cliDirectory, homeDir);
+  const bare = ranked.find(bareClean);
+  if (bare) return bare;
+  const doubleOk = ranked.find(doubleQuotedClean);
+  if (doubleOk) return doubleOk;
+  const singleOk = ranked.find((p) => !hasCmdMeta(p));
+  if (singleOk) return singleOk;
+  if (windowsCmdRules(ranked)) {
+    throw new Error(
+      `cannot write the Codex Windows hook shim: every candidate contains a cmd metacharacter (& | < > ^ % !): ${ranked.join(", ")}. The shim was not written`
+    );
+  }
+  const beside = ranked[0];
+  if (beside !== void 0) return beside;
+  throw new Error("no Codex shim candidate");
+}
+function shimBesideCli(shim, cliDirectory) {
+  const m = pathMod(cliDirectory);
+  return m.normalize(m.dirname(shim)) === m.normalize(normalizeCmdPath(cliDirectory));
+}
+function codexHookCmd(node, script) {
+  const target = script ? qWinBody(script) : '"%~dp0index.js"';
+  return `@echo off\r
+${qWinBody(node)} ${target} %*\r
+`;
+}
+function codexHookBody(node, cliDirectory, homeDir) {
+  const shim = codexShimPath(cliDirectory, homeDir);
+  const m = pathMod(cliDirectory);
+  const script = shimBesideCli(shim, cliDirectory) ? void 0 : m.join(normalizeCmdPath(cliDirectory), "index.js");
+  return codexHookCmd(node, script);
+}
+function codexCommandWindows(shim, event, profile) {
+  const win = normalizeCmdPath(shim);
+  if (hasCmdMeta(win) && !windowsCmdRules([win])) return void 0;
+  const tail = `hook codex ${event} --profile ${profile}`;
+  if (bareClean(win)) return `${win} ${tail}`;
+  if (!hasPsMeta(win)) return `& "${win.replace(/"/g, '""')}" ${tail}`;
+  return `& '${win.replace(/'/g, "''")}' ${tail}`;
+}
+function codexMachineSpecs(node, profile, shim = codexShimPath(cliDir(), home())) {
+  const tail = (event) => `hook codex ${event} --profile ${profile}`;
+  return CODEX_EVENTS.map((event) => {
+    const commandWindows = codexCommandWindows(shim, event, profile);
+    return {
+      event,
+      entry: {
+        type: "command",
+        command: `${q(node)} ${q(cliEntry())} ${tail(event)}`,
+        ...commandWindows ? { commandWindows } : {}
+      }
+    };
+  });
+}
+function distinctSettingsDirs(dirs) {
+  const seen = /* @__PURE__ */ new Set();
+  return dirs.filter((dir) => {
+    const file = path.join(dir, "settings.json");
+    let real = file;
+    try {
+      real = fs.realpathSync(file);
+    } catch {
+    }
+    if (seen.has(real)) return false;
+    seen.add(real);
+    return true;
+  });
+}
+function installMachineHooks(node, opts) {
+  const res = { claude_dirs: [], lines: [], warnings: [] };
+  const verbs = currentControlVerbs();
+  const dirs = distinctSettingsDirs(claudeConfigDirs(opts.processDirs).filter(isDir));
+  const keys = profileKeys("claude", dirs);
+  for (const dir of dirs) {
+    const file = path.join(dir, "settings.json");
+    try {
+      editJson(file, (d) => (addHooks(d, "nested", claudeMachineSpecs(node, keys.get(dir), verbs), "machine"), true));
+      res.claude_dirs.push(dir);
+      res.lines.push(`Claude Code hooks (${keys.get(dir)}): ${file}`);
+    } catch (e) {
+      res.warnings.push(e.message);
+    }
+  }
+  if (opts.codex && isDir(codexConfigDir(opts.env))) {
+    const dir = codexConfigDir(opts.env);
+    const key = profileKeys("codex", [dir]).get(dir);
+    try {
+      const dirCli = cliDir();
+      const shim = codexShimPath(dirCli, home());
+      fs.mkdirSync(path.dirname(shim), { recursive: true, mode: 448 });
+      atomicWrite(shim, codexHookBody(node, dirCli, home()));
+      const specs = codexMachineSpecs(node, key, shim);
+      editJson(path.join(dir, "hooks.json"), (d) => (addHooks(d, "nested", specs, "machine"), true));
+      editToml(path.join(dir, "config.toml"), (c) => enableFeatureHooks(c));
+      res.codex_dir = dir;
+      res.lines.push(`Codex hooks (${key}): ${path.join(dir, "hooks.json")}`);
+      if (specs.some((s) => s.entry.commandWindows === void 0)) {
+        res.warnings.push("Codex commandWindows was omitted: every shim path contains a cmd metacharacter (& | < > ^ % !). The POSIX hook command was written");
+      }
+    } catch (e) {
+      res.warnings.push(e.message);
+    }
+  }
+  return res;
+}
+function editToml(file, fn) {
+  const before = readText(file);
+  const next = fn(before ?? "");
+  if (next === (before ?? "")) return;
+  if (before === void 0) addCreated(file);
+  else if (!wasCreated(file)) backupOnce(file);
+  atomicWrite(file, next);
+}
+function removeShimFile(file) {
+  removeFile(file);
+  const dir = path.dirname(file);
+  const base = path.basename(dir);
+  if (base !== ".hivefloor" && base !== "codex-hook") return;
+  try {
+    if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+  } catch {
+  }
+}
+function removeMachineHooks(inst) {
+  const lines = [];
+  for (const dir of inst.claude_dirs) {
+    const file = path.join(dir, "settings.json");
+    try {
+      if (editJson(file, (d) => removeHooks(d, "nested", "machine") > 0, { drop: true })) lines.push(`Claude Code hooks: removed from ${file}`);
+    } catch {
+    }
+  }
+  if (inst.codex_dir) {
+    const file = path.join(inst.codex_dir, "hooks.json");
+    try {
+      if (editJson(file, (d) => removeHooks(d, "nested", "machine") > 0, { drop: true })) lines.push(`Codex hooks: removed from ${file}`);
+    } catch {
+    }
+    for (const file2 of shimCandidates(cliDir(), home())) removeShimFile(file2);
+    const cfg = path.join(inst.codex_dir, "config.toml");
+    const before = readText(cfg);
+    if (before !== void 0) {
+      const next = restoreFeatureHooks(before);
+      if (next !== before) {
+        if (wasCreated(cfg) && next.trim() === "") {
+          removeFile(cfg);
+          forgetCreated(cfg);
+        } else {
+          atomicWrite(cfg, next);
+          dropBackupIfSame(cfg);
+        }
+      }
+    }
+  }
+  return lines;
+}
+
+export {
+  installCliCopy,
+  removeCliCopy,
+  applyControlHooks,
+  installMachineHooks,
+  removeMachineHooks
+};