@hivefloor/cli 0.1.3 → 0.1.5

package/dist/{chunk-VNCQFFQO.js → chunk-TPMFQUAW.js}

@@ -117,6 +117,100 @@ function serializeJson(data, style) {
 }
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 
+// src/tools.ts
+import fs2 from "fs";
+import path2 from "path";
+var REAL_TOOLS = ["claude", "codex", "cursor", "gemini", "grok"];
+var TOOL_LABEL = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor",
+  gemini: "Gemini CLI",
+  grok: "Grok CLI",
+  other: "Other"
+};
+var BINARIES = {
+  claude: ["claude"],
+  codex: ["codex"],
+  gemini: ["gemini"],
+  grok: ["grok"]
+};
+function isTool(s) {
+  return s === "other" || REAL_TOOLS.includes(s);
+}
+function findBin(name, env) {
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of (env.PATH ?? "").split(path2.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const p = path2.join(dir, name + ext);
+      try {
+        if (fs2.statSync(p).isFile()) {
+          fs2.accessSync(p, fs2.constants.X_OK);
+          return p;
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function firstBin(names, env) {
+  for (const name of names) {
+    const bin = findBin(name, env);
+    if (bin) return bin;
+  }
+  return void 0;
+}
+function sameFile(a, b) {
+  try {
+    return fs2.realpathSync(a) === fs2.realpathSync(b);
+  } catch {
+    return false;
+  }
+}
+function agentIsGrok(agentPath, env) {
+  const grok = findBin("grok", env);
+  if (grok && sameFile(agentPath, grok)) return true;
+  return /(?:^|\/)\.grok(?:\/|$)/.test(agentPath.replace(/\\/g, "/").toLowerCase());
+}
+function hasCursorSignal(agentPath) {
+  let resolved = agentPath;
+  try {
+    resolved = fs2.realpathSync(agentPath);
+  } catch {
+  }
+  return resolved.replace(/\\/g, "/").toLowerCase().includes("cursor");
+}
+function agentIsCursor(agentPath, env) {
+  if (agentIsGrok(agentPath, env)) return false;
+  const cursor = findBin("cursor-agent", env);
+  if (cursor && sameFile(agentPath, cursor)) return true;
+  return hasCursorSignal(agentPath);
+}
+function cursorBin(env) {
+  const linked = findBin("cursor-agent", env);
+  if (linked) return linked;
+  const agent = findBin("agent", env);
+  return agent && agentIsCursor(agent, env) ? agent : void 0;
+}
+function detectTools(env) {
+  const found = [];
+  for (const tool of REAL_TOOLS) {
+    const bin = tool === "cursor" ? cursorBin(env) : firstBin(BINARIES[tool], env);
+    if (bin) found.push({ tool, bin });
+  }
+  return found;
+}
+function toolFromEnv(env) {
+  if (env.GROK_SESSION_ID) return "grok";
+  if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT) return "claude";
+  if (env.CODEX_SANDBOX || env.CODEX_SESSION_ID || env.CODEX_THREAD_ID || env.CODEX_CI) return "codex";
+  if (env.CURSOR_AGENT || env.CURSOR_TRACE_ID || env.CURSOR_SESSION_ID) return "cursor";
+  if (env.GEMINI_CLI || env.GEMINI_SESSION_ID) return "gemini";
+  return void 0;
+}
+
 export {
   home,
   configDir,
@@ -139,5 +233,12 @@ export {
   ConfigError,
   readJsonFile,
   serializeJson,
-  isRecord
+  isRecord,
+  REAL_TOOLS,
+  TOOL_LABEL,
+  isTool,
+  findBin,
+  agentIsCursor,
+  detectTools,
+  toolFromEnv
 };

package/dist/chunk-U6RRUAC2.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+import {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  addCreated,
+  addHooks,
+  editJson,
+  enableFeatureHooks,
+  forgetCreated,
+  removeHooks,
+  restoreFeatureHooks,
+  wasCreated
+} from "./chunk-6XVIEX75.js";
+import {
+  claudeConfigDirs,
+  codexConfigDir,
+  profileKeys
+} from "./chunk-J36OIJBM.js";
+import {
+  atomicWrite,
+  backupOnce,
+  cliDir,
+  cliEntry,
+  dropBackupIfSame,
+  home,
+  isDir,
+  readText,
+  removeFile
+} from "./chunk-TPMFQUAW.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) {
+  return 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: { type: "command", command: node, args: [cliEntry(), "hook", "claude", event, "--profile", profile], async: true }
+  }));
+}
+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 installMachineHooks(node, opts) {
+  const res = { claude_dirs: [], lines: [], warnings: [] };
+  const dirs = 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)), "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,
+  installMachineHooks,
+  removeMachineHooks
+};

package/dist/chunk-VX7SCIF2.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import {
+  assertTokenTransport
+} from "./chunk-SOXRITAW.js";
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+async function apiRequest(ctx, host, path, opts = {}) {
+  if (opts.token) assertTokenTransport(host);
+  const headers = { accept: "application/json", ...opts.headers };
+  if (opts.token) headers.authorization = `Bearer ${opts.token}`;
+  if (opts.body !== void 0) headers["content-type"] = "application/json";
+  let res;
+  try {
+    res = await ctx.fetch(`${host}${path}`, {
+      method: opts.method ?? (opts.body !== void 0 ? "POST" : "GET"),
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+      redirect: "error",
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 15e3)
+    });
+  } catch (e) {
+    throw networkError(host, e);
+  }
+  const text = await res.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    json = null;
+  }
+  return { status: res.status, json };
+}
+function networkError(host, e) {
+  const err = e;
+  let why;
+  if (err?.name === "TimeoutError" || err?.name === "AbortError") why = "timed out";
+  else if (err?.cause?.code) why = err.cause.code;
+  else if (err?.code) why = err.code;
+  else why = err?.cause?.message ?? err?.message ?? "network error";
+  let name = host;
+  try {
+    name = new URL(host).host;
+  } catch {
+  }
+  return new ApiError(0, "network", `cannot reach ${name}: ${why}. Check --host or HIVEFLOOR_URL.`);
+}
+function errorOf(r) {
+  const j = r.json ?? {};
+  return new ApiError(r.status, typeof j.error === "string" ? j.error : "error", typeof j.message === "string" ? j.message : `HTTP ${r.status}`);
+}
+
+export {
+  ApiError,
+  apiRequest,
+  errorOf
+};

package/dist/{chunk-O2TC3WSS.js → chunk-X6B6R32A.js}

@@ -5,7 +5,7 @@ import {
   removeFile,
   serviceLogFile,
   spoolFile
-} from "./chunk-VNCQFFQO.js";
+} from "./chunk-TPMFQUAW.js";
 
 // src/spool.ts
 import fs from "fs";

package/dist/cli-JCBZICR3.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-TKMIV7BG.js";
+import {
+  VERSION
+} from "./chunk-C627OKTW.js";
+import {
+  ApiError
+} from "./chunk-VX7SCIF2.js";
+import {
+  defaultCtx
+} from "./chunk-SOXRITAW.js";
+import {
+  CLI_BIN_NAME,
+  CLI_INSTALL_COMMAND,
+  cliNpxCommand
+} from "./chunk-4DRHR7LR.js";
+import "./chunk-K3NQKI34.js";
+
+// src/help.ts
+var HOST_NOTE = `Host: --host URL, else HIVEFLOOR_URL, else the hosted instance. Self-hosting: pass --host or set HIVEFLOOR_URL.`;
+var COMMAND_HELP = {
+  connect: `Usage: ${CLI_BIN_NAME} connect [options]
+
+Connect this computer once: every agent on it (Claude profiles, Codex, ...) shows up.
+
+Options:
+  --host URL      Hivefloor server (default: HIVEFLOOR_URL, else the hosted instance)
+  --name NAME     Display name for this machine (default: the computer's hostname)
+  --no-open       Print the sign-in link instead of opening a browser
+  --no-service    Do not install the background service
+  --yes, -y       Skip confirmation prompts and accept defaults
+  --agent         Connect one agent for the current git repo (MCP and tasks) instead of the machine
+  --tool NAME     Like --agent for one tool: claude, codex, cursor, gemini, grok or other
+  --no-cli        With --agent or --tool: write the tool's config files directly instead of running its own CLI (claude mcp add, ...)
+
+${HOST_NOTE}
+`,
+  disconnect: `Usage: ${CLI_BIN_NAME} disconnect [options]
+
+Remove everything connect added: hooks, MCP entries, service, stored tokens, and the machine on the server.
+
+Options:
+  --host URL      Only remove credentials for this server (a different server leaves this machine in place)
+  --tool NAME     Remove one agent tool only: claude, codex, cursor, gemini or grok
+`,
+  status: `Usage: ${CLI_BIN_NAME} status [options]
+
+This machine and its service; the per-repo agent, its projects and live sessions.
+
+Options:
+  --host URL      Server to query (default: HIVEFLOOR_URL, else the last connected host)
+  --tool NAME     Look at one agent tool's token
+
+${HOST_NOTE}
+`,
+  where: `Usage: ${CLI_BIN_NAME} where [tool] [options]
+
+Which account to run next on. Read only: nothing is switched.
+
+Arguments:
+  tool            claude, codex, ... (a tool or provider name)
+
+Options:
+  --json          Print the raw answer
+  --host URL      Server to query (default: HIVEFLOOR_URL, else the last connected host)
+  --tool NAME     Look at one agent tool's token
+
+${HOST_NOTE}
+`,
+  service: `Usage: ${CLI_BIN_NAME} service run
+
+Run the background service in the foreground. Your OS starts it for you after connect; you rarely run it by hand.
+`,
+  link: `Usage: ${CLI_BIN_NAME} link [options]
+
+Link this repo to another project. With neither --project nor --new, your browser opens to pick one.
+
+Options:
+  --project ID    Link to an existing project
+  --new NAME      Create a project and link to it (not together with --project)
+  --path PREFIX   Repo path inside the project (monorepo subfolder)
+  --host URL      Server (default: HIVEFLOOR_URL, else the stored host)
+  --tool NAME     Which agent tool's token to use
+  --no-open       Print the sign-in link instead of opening a browser
+
+${HOST_NOTE}
+`,
+  token: `Usage: ${CLI_BIN_NAME} token [options]
+
+Print the stored token for shell use, for example: export HIVEFLOOR_TOKEN=$(${CLI_BIN_NAME} token)
+It refuses to print to a terminal unless you pass --reveal.
+
+Options:
+  --reveal        Print to a terminal anyway
+  --host URL      Host to look up the token for (default: HIVEFLOOR_URL, else the last connected host)
+  --tool NAME     Which agent tool's token to print
+`,
+  mcp: `Usage: ${CLI_BIN_NAME} mcp [options]
+
+Stdio MCP server that proxies to Hivefloor, for tools that cannot send HTTP headers. Needs a stored token (run ${cliNpxCommand("connect")} first).
+
+Options:
+  --url URL       MCP endpoint (default: <host>/mcp)
+  --host URL      Host that resolves the stored token
+  --tool NAME     Which agent tool's token to use
+
+${HOST_NOTE}
+`,
+  voice: `Usage: ${CLI_BIN_NAME} voice status
+       ${CLI_BIN_NAME} voice list [--agent-id ID]
+       ${CLI_BIN_NAME} voice say "<text>" --out FILE.wav [--voice ID | --agent-id AGENT_ID] [--speed N]
+
+Speech from TalkBack's Kokoro voice, which runs on this computer (https://github.com/Errr0rr404/talkback).
+
+  status          Is TalkBack's voice running? (reads ~/.talkback/voiced.json and pings it)
+  list            Print the Kokoro voice ids. Does not contact TalkBack.
+  say             Synthesize the text to a 24 kHz mono WAV file. Nothing is played.
+
+Options for list:
+  --agent-id ID   Print the voice and speed hivefloor gives that agent id
+
+Options for say:
+  --out FILE      Where to write the WAV (required)
+  --voice ID      A Kokoro voice id, for example af_heart or bf_emma
+  --agent-id ID   Use the stable voice and speed hivefloor gives that agent id
+  --speed N       0.5 to 2 (default: TalkBack's setting)
+
+If TalkBack is not installed, status and say print the install line and exit 1. list does not contact TalkBack. Text for say is limited to 2000 characters.
+`,
+  hook: `Usage: ${CLI_BIN_NAME} hook <tool> <event> [--profile KEY]
+
+The hook runner that Claude Code, Codex and other tools call. It reads the event JSON on stdin, reports it to Hivefloor, and always exits 0 so a hook never fails the agent. You do not run it by hand; ${cliNpxCommand("connect")} installs the hook entries.
+
+Arguments:
+  tool            claude, codex, ...
+  event           the tool's native event name, for example PreToolUse
+  --profile KEY   Use this machine profile's token and host (set by machine connect)
+`
+};
+function commandHelp(cmd) {
+  return Object.hasOwn(COMMAND_HELP, cmd) ? COMMAND_HELP[cmd] : void 0;
+}
+
+// src/cli.ts
+var HELP = `hivefloor ${VERSION}
+
+Usage: ${CLI_BIN_NAME} <command> [options]
+       ${cliNpxCommand("<command> [options]")}   (no install)
+
+Commands:
+  connect      Connect this computer once: every agent on it shows up (Claude profiles, Codex, ...)
+                 --host URL   --name NAME   --no-open   --no-service   --yes
+                 --agent | --tool claude|codex|cursor|gemini|grok|other   connect one agent for one repo (MCP and tasks) instead
+  disconnect   Remove everything connect added, the machine on the server included (--tool <name> for one agent tool)
+  status       This machine and its service; the per-repo agent, its projects and live sessions
+  where        [tool] Which account to run next on (read only; --json for the raw answer)
+  service      run: the background service (started by your OS; you rarely run it by hand)
+  link         Link this repo to another project (--project ID | --new NAME [--path PREFIX])
+  token        Print the stored token for shell use (--reveal to print to a terminal)
+  voice        status | list [--agent-id ID] | say "<text>" --out file.wav: TalkBack's spoken voice on this computer
+  mcp          Stdio MCP server that proxies to Hivefloor (for tools without HTTP header support)
+  hook         <tool> <event>: the hook runner the tools call (reads JSON on stdin)
+  help         Show this help (hivefloor <command> --help, or help <command>, for one command)
+  --version    Print the version
+
+Install once: ${CLI_INSTALL_COMMAND}
+Host: https://hivefloor.worldofz.info. Self-hosting: pass --host URL or set HIVEFLOOR_URL.
+`;
+async function run(argv, ctx = defaultCtx()) {
+  const [cmd, ...rest] = argv;
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    ctx.out(`${VERSION}
+`);
+    return 0;
+  }
+  if (cmd === "help" && rest[0] !== void 0 && !rest[0].startsWith("-")) {
+    const h = rest[0] === "help" || rest[0] === "version" ? HELP : commandHelp(rest[0]);
+    if (h === void 0) {
+      ctx.err(`hivefloor: unknown command "${rest[0]}". Run "hivefloor help".
+`);
+      return 2;
+    }
+    ctx.out(h);
+    return 0;
+  }
+  if (cmd === void 0 || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    ctx.out(HELP);
+    return 0;
+  }
+  const p = parseArgs(rest);
+  if (p.flags.help) {
+    ctx.out(commandHelp(cmd) ?? HELP);
+    return 0;
+  }
+  try {
+    switch (cmd) {
+      case "connect":
+        return await (await import("./connect-2HLVPEOL.js")).connect(ctx, p);
+      case "disconnect":
+        return await (await import("./disconnect-WQMDCUXT.js")).disconnect(ctx, p);
+      case "status":
+        return await (await import("./status-GOCFNO7K.js")).status(ctx, p);
+      case "where":
+        return await (await import("./where-XFXRTP7E.js")).where(ctx, p);
+      case "service":
+        if (p.positionals[0] !== "run") {
+          ctx.err("hivefloor: usage: hivefloor service run\n");
+          return 2;
+        }
+        return await (await import("./run-ZAZ45MKQ.js")).runService({ ctx });
+      case "link":
+        return await (await import("./link-ORT4LID6.js")).link(ctx, p);
+      case "token":
+        return await (await import("./token-EMM4AJAU.js")).token(ctx, p);
+      case "voice":
+        return await (await import("./voice-F5MIS3IZ.js")).voice(ctx, p);
+      case "mcp":
+        return await (await import("./mcp-2SF6Y73M.js")).runMcpProxy(ctx, p);
+      case "hook": {
+        const { runHook, readStdin } = await import("./hook-AYJNRGIY.js");
+        await runHook(rest, { env: ctx.env, cwd: ctx.cwd, fetch: ctx.fetch, now: ctx.now, readStdin });
+        return 0;
+      }
+      default:
+        ctx.err(`hivefloor: unknown command "${cmd}". Run "hivefloor help".
+`);
+        return 2;
+    }
+  } catch (e) {
+    if (e instanceof ApiError) ctx.err(`hivefloor: ${e.message}
+`);
+    else ctx.err(`hivefloor: ${e.message}
+`);
+    return 1;
+  }
+}
+export {
+  HELP,
+  VERSION,
+  run
+};

package/dist/connect-2HLVPEOL.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  connect,
+  connectAgent,
+  resolveHost
+} from "./chunk-IWIDKNWC.js";
+import "./chunk-3N5JYP5O.js";
+import "./chunk-6XVIEX75.js";
+import "./chunk-RYGL6XU4.js";
+import "./chunk-6MDJB3BV.js";
+import "./chunk-TKMIV7BG.js";
+import "./chunk-C627OKTW.js";
+import "./chunk-IJRHCDIG.js";
+import "./chunk-VX7SCIF2.js";
+import "./chunk-TPMFQUAW.js";
+import "./chunk-SOXRITAW.js";
+import "./chunk-4DRHR7LR.js";
+import "./chunk-K3NQKI34.js";
+export {
+  connect,
+  connectAgent,
+  resolveHost
+};