@hivefloor/cli 0.1.4 → 0.1.5

package/dist/voice-F5MIS3IZ.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  KOKORO_VOICES,
+  KOKORO_VOICE_ID,
+  voiceFor
+} from "./chunk-4DRHR7LR.js";
+import "./chunk-K3NQKI34.js";
+
+// src/voice/index.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/voice/talkback.ts
+import net from "net";
+import os from "os";
+import path from "path";
+import fs from "fs";
+var TALKBACK_INSTALL_LINE = "claude plugin marketplace add Errr0rr404/talkback && claude plugin install talkback@talkback";
+var SYNTH_MAX_CHARS = 2e3;
+var MAX_WAV_BYTES = 64 * 1024 * 1024;
+var VoiceError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "VoiceError";
+  }
+  code;
+};
+var talkbackDir = (o = {}) => (o.env ?? process.env).TALKBACK_HOME || path.join(o.homeDir ?? os.homedir(), ".talkback");
+function readEndpoint(o = {}) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path.join(talkbackDir(o), "voiced.json"), "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const j = JSON.parse(raw);
+    if (typeof j.port === "number" && Number.isInteger(j.port) && j.port > 0 && j.port < 65536 && typeof j.token === "string" && j.token) return { port: j.port, token: j.token };
+  } catch {
+  }
+  return void 0;
+}
+function need(o) {
+  const ep = readEndpoint(o);
+  if (!ep) throw new VoiceError("not_installed", `TalkBack's voice is not set up here. Install it with:
+  ${TALKBACK_INSTALL_LINE}
+then run /talkback on in Claude Code (the first session sets the voice up).`);
+  return ep;
+}
+function exchange(ep, req, o, parse) {
+  const timeoutMs = o.timeoutMs ?? 12e4;
+  return new Promise((resolve, reject) => {
+    const sock = net.connect({ host: "127.0.0.1", port: ep.port });
+    const chunks = [];
+    let size = 0;
+    let settled = false;
+    const finish = (err, buf) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      sock.destroy();
+      if (err) reject(err);
+      else resolve(buf ?? Buffer.alloc(0));
+    };
+    const timer = setTimeout(() => finish(new VoiceError("timeout", `TalkBack's voice did not answer within ${Math.round(timeoutMs / 1e3)} s.`)), timeoutMs);
+    sock.on("connect", () => sock.write(`${JSON.stringify({ ...req, token: ep.token })}
+`));
+    sock.on("data", (d) => {
+      chunks.push(d);
+      size += d.length;
+      if (size > MAX_WAV_BYTES + 256) return finish(new VoiceError("protocol", "The voice daemon sent more data than a reply can hold."));
+      const buf = Buffer.concat(chunks);
+      let state;
+      try {
+        state = parse(buf);
+      } catch (e) {
+        return finish(e instanceof VoiceError ? e : new VoiceError("protocol", "Unreadable reply from the voice daemon."));
+      }
+      if (state === "done") finish(void 0, buf);
+    });
+    sock.on("end", () => {
+      const buf = Buffer.concat(chunks);
+      if (buf.length === 0) return finish(new VoiceError("no_reply", 'The voice daemon closed the connection without an answer (an old TalkBack that lacks "synth", or it was restarted). Update TalkBack and try again.'));
+      let state = "more";
+      try {
+        state = parse(buf);
+      } catch (e) {
+        return finish(e instanceof VoiceError ? e : new VoiceError("protocol", "Unreadable reply from the voice daemon."));
+      }
+      if (state === "done") finish(void 0, buf);
+      else finish(new VoiceError("protocol", "The voice daemon closed the connection before the reply was complete."));
+    });
+    sock.on("error", (e) => finish(new VoiceError("unreachable", `TalkBack's voice is not reachable on 127.0.0.1:${ep.port} (${e.code ?? "error"}). Start a Claude Code session with TalkBack on, or run /talkback status.`)));
+  });
+}
+async function ping(o = {}) {
+  const ep = need(o);
+  const buf = await exchange(ep, { cmd: "ping" }, { timeoutMs: 5e3, ...o }, (b) => b.includes(10) ? "done" : "more");
+  const line = buf.subarray(0, buf.indexOf(10)).toString("utf8").trim();
+  const m = /^pong (\S+) (\S+) (\S+)$/.exec(line);
+  if (!m) throw new VoiceError("protocol", "The daemon at the TalkBack port did not answer like TalkBack.");
+  return { engine: m[1], version: m[2], player: m[3] };
+}
+async function synthToWav(text, voice2, speed, o = {}) {
+  if (!text.trim()) throw new VoiceError("empty", "Nothing to say: the text is empty.");
+  if (text.length > SYNTH_MAX_CHARS) throw new VoiceError("too_long", `The text is ${text.length} characters; the voice takes at most ${SYNTH_MAX_CHARS}.`);
+  const ep = need(o);
+  const req = { cmd: "synth", text };
+  if (voice2 !== void 0) req.voice = voice2;
+  if (speed !== void 0) req.speed = speed;
+  let header;
+  const buf = await exchange(ep, req, o, (b) => {
+    if (!header) {
+      const nl = b.indexOf(10);
+      if (nl < 0) return b.length > 512 ? fail("protocol", "Unreadable reply from the voice daemon.") : "more";
+      const line = b.subarray(0, nl).toString("utf8").trim();
+      const ok = /^ok (\d+) (\d+) wav$/.exec(line);
+      if (!ok) {
+        const err = /^err (\S+)(?: (.{0,200}))?$/.exec(line);
+        if (err?.[1] === "empty") throw new VoiceError("empty", "Nothing to say: the text is empty.");
+        if (err?.[1] === "too_long") throw new VoiceError("too_long", `The voice refused the text as too long (over ${SYNTH_MAX_CHARS} characters).`);
+        if (err?.[1] === "engine") throw new VoiceError("engine", `The voice engine failed${err[2] ? `: ${err[2]}` : "."}`);
+        return fail("protocol", "The daemon at the TalkBack port did not answer like TalkBack.");
+      }
+      const n = Number(ok[1]);
+      if (!Number.isSafeInteger(n) || n < 44 || n > MAX_WAV_BYTES) return fail("protocol", "The voice daemon announced an audio size that is not a WAV reply.");
+      if (ok[2] !== "24000") return fail("protocol", `The voice daemon sent ${ok[2]} Hz audio; 24000 Hz was expected.`);
+      header = { end: nl + 1, n };
+    }
+    return b.length >= header.end + header.n ? "done" : "more";
+  });
+  if (!header) throw new VoiceError("protocol", "Unreadable reply from the voice daemon.");
+  const wav = buf.subarray(header.end, header.end + header.n);
+  if (wav.length !== header.n || wav.toString("latin1", 0, 4) !== "RIFF" || wav.toString("latin1", 8, 12) !== "WAVE") throw new VoiceError("protocol", "The voice daemon sent audio that is not a WAV file.");
+  return Buffer.from(wav);
+}
+function fail(code, message) {
+  throw new VoiceError(code, message);
+}
+
+// src/voice/index.ts
+var SAY_FLAGS = /* @__PURE__ */ new Set(["out", "voice", "speed", "agent-id", "help", "h"]);
+var LIST_FLAGS = /* @__PURE__ */ new Set(["agent-id", "help", "h"]);
+var USAGE = 'usage: hivefloor voice status | hivefloor voice list [--agent-id ID] | hivefloor voice say "<text>" --out file.wav [--voice ID | --agent-id AGENT_ID] [--speed N]\n';
+async function voice(ctx, p) {
+  const sub = p.positionals[0];
+  const opts = { env: ctx.env };
+  if (sub === "list") {
+    const unknown = checkUnknownFlags(p, LIST_FLAGS);
+    if (unknown || p.positionals.length > 1 || p.flags["agent-id"] === true) {
+      ctx.err(unknown ? `hivefloor: unknown flag "--${unknown}". Run "hivefloor voice --help".
+` : USAGE);
+      return 2;
+    }
+    const agent = flagStr(p, "agent-id");
+    if (agent !== void 0) {
+      const v = voiceFor(agent);
+      ctx.out(`agent ${agent}: ${v.voice} at ${v.speed}x
+`);
+      return 0;
+    }
+    const american = KOKORO_VOICES.filter((id) => id.startsWith("a"));
+    const british = KOKORO_VOICES.filter((id) => id.startsWith("b"));
+    ctx.out(`American English
+${american.join("\n")}
+British English
+${british.join("\n")}
+`);
+    return 0;
+  }
+  if (sub === "status") {
+    const unknown = checkUnknownFlags(p, /* @__PURE__ */ new Set(["help", "h"]));
+    if (unknown || p.positionals.length > 1) {
+      ctx.err(unknown ? `hivefloor: unknown flag "--${unknown}". Run "hivefloor voice --help".
+` : USAGE);
+      return 2;
+    }
+    try {
+      const r = await ping(opts);
+      ctx.out(`TalkBack voice: running (engine ${r.engine}, version ${r.version}, player ${r.player})
+`);
+      return 0;
+    } catch (e) {
+      return fail2(ctx, e);
+    }
+  }
+  if (sub === "say") {
+    const unknown = checkUnknownFlags(p, SAY_FLAGS);
+    if (unknown) {
+      ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor voice --help".
+`);
+      return 2;
+    }
+    const text = p.positionals.slice(1).join(" ");
+    const out = flagStr(p, "out");
+    if (!text.trim() || !out) {
+      ctx.err(USAGE);
+      return 2;
+    }
+    let voiceId = flagStr(p, "voice");
+    let speed;
+    if (p.flags.voice === true || p.flags.speed === true || p.flags["agent-id"] === true) {
+      ctx.err("hivefloor: --voice, --speed and --agent-id each need a value.\n");
+      return 2;
+    }
+    const agent = flagStr(p, "agent-id");
+    if (agent !== void 0) {
+      const v = voiceFor(agent);
+      voiceId ??= v.voice;
+      speed = v.speed;
+    }
+    if (voiceId !== void 0 && !KOKORO_VOICE_ID.test(voiceId)) {
+      ctx.err(`hivefloor: "${voiceId}" is not a voice id (for example af_heart or bf_emma).
+`);
+      return 2;
+    }
+    const sp = flagStr(p, "speed");
+    if (sp !== void 0) {
+      speed = Number(sp);
+      if (!Number.isFinite(speed) || speed < 0.5 || speed > 2) {
+        ctx.err("hivefloor: --speed must be a number from 0.5 to 2.\n");
+        return 2;
+      }
+    }
+    try {
+      const wav = await synthToWav(text, voiceId, speed, opts);
+      const file = path2.resolve(ctx.cwd, out);
+      fs2.writeFileSync(file, wav);
+      ctx.out(`Wrote ${file} (${wav.length} bytes, 24 kHz mono WAV)
+`);
+      return 0;
+    } catch (e) {
+      return fail2(ctx, e);
+    }
+  }
+  ctx.err(USAGE);
+  return 2;
+}
+function fail2(ctx, e) {
+  if (e instanceof VoiceError) {
+    ctx.err(`hivefloor: ${e.message}
+`);
+    return e.code === "empty" || e.code === "too_long" ? 2 : 1;
+  }
+  ctx.err(`hivefloor: ${e.message}
+`);
+  return 1;
+}
+export {
+  SYNTH_MAX_CHARS,
+  TALKBACK_INSTALL_LINE,
+  VoiceError,
+  ping,
+  readEndpoint,
+  synthToWav,
+  voice
+};

package/dist/{where-KR7VWSEC.js → where-XFXRTP7E.js}

@@ -1,24 +1,33 @@
 #!/usr/bin/env node
 import {
   resolveSession
-} from "./chunk-7KF7IQJN.js";
-import "./chunk-2IMJECYD.js";
-import "./chunk-TKMIV7BG.js";
-import "./chunk-PDXYOREI.js";
+} from "./chunk-H6NYMF2D.js";
+import "./chunk-6MDJB3BV.js";
+import {
+  checkUnknownFlags
+} from "./chunk-TKMIV7BG.js";
 import {
   apiRequest,
   errorOf
-} from "./chunk-PY74LT2W.js";
-import "./chunk-VNCQFFQO.js";
+} from "./chunk-VX7SCIF2.js";
+import "./chunk-TPMFQUAW.js";
+import "./chunk-SOXRITAW.js";
 import {
   cliNpxCommand,
   routeProviderFromParam,
   usageRouteSchema
-} from "./chunk-ZC2DAKB5.js";
+} from "./chunk-4DRHR7LR.js";
 import "./chunk-K3NQKI34.js";
 
 // src/where.ts
+var WHERE_FLAGS = /* @__PURE__ */ new Set(["json", "host", "tool", "help", "h"]);
 async function where(ctx, p) {
+  const unknown = checkUnknownFlags(p, WHERE_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
   const arg = p.positionals[0];
   if (arg !== void 0 && routeProviderFromParam(arg) === null) {
     ctx.err(`hivefloor: "${arg}" is not a tool or provider. Try: ${cliNpxCommand("where claude")}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@hivefloor/cli",
-  "version": "0.1.4",
+  "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.",
   "author": {
-    "name": "Errr0rr404",
+    "name": "Zan",
     "url": "https://github.com/Errr0rr404"
   },
   "keywords": [

package/dist/chunk-2IMJECYD.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-
-// src/tools.ts
-import fs from "fs";
-import path 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"],
-  cursor: ["cursor-agent", "agent"],
-  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(path.delimiter)) {
-    if (!dir) continue;
-    for (const ext of exts) {
-      const p = path.join(dir, name + ext);
-      try {
-        if (fs.statSync(p).isFile()) {
-          fs.accessSync(p, fs.constants.X_OK);
-          return p;
-        }
-      } catch {
-      }
-    }
-  }
-  return void 0;
-}
-function detectTools(env) {
-  const found = [];
-  for (const tool of REAL_TOOLS) {
-    for (const name of BINARIES[tool]) {
-      const bin = findBin(name, env);
-      if (bin) {
-        found.push({ tool, bin });
-        break;
-      }
-    }
-  }
-  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 {
-  REAL_TOOLS,
-  TOOL_LABEL,
-  isTool,
-  findBin,
-  detectTools,
-  toolFromEnv
-};

package/dist/chunk-7KF7IQJN.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import {
-  isTool
-} from "./chunk-2IMJECYD.js";
-import {
-  flagStr
-} from "./chunk-TKMIV7BG.js";
-import {
-  defaultHost,
-  loadToken
-} from "./chunk-PDXYOREI.js";
-import {
-  hostFromEnv,
-  normalizeHost
-} from "./chunk-ZC2DAKB5.js";
-
-// src/session.ts
-async function resolveSession(ctx, p) {
-  const flagHost = flagStr(p, "host");
-  const host = flagHost ? normalizeHost(flagHost) : ctx.env.HIVEFLOOR_URL ? hostFromEnv(ctx.env) : defaultHost() ?? hostFromEnv(ctx.env);
-  const toolFlag = flagStr(p, "tool");
-  const t = await loadToken(host, toolFlag && isTool(toolFlag) ? toolFlag : void 0);
-  if (t) return { host, token: t.token, tool: t.tool };
-  if (ctx.env.HIVEFLOOR_TOKEN) return { host, token: ctx.env.HIVEFLOOR_TOKEN, tool: toolFlag ?? "other" };
-  return void 0;
-}
-
-export {
-  resolveSession
-};

package/dist/chunk-GT3HFFT4.js

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-import {
-  CLAUDE_EVENTS,
-  CODEX_EVENTS,
-  addCreated,
-  addHooks,
-  editJson,
-  enableFeatureHooks,
-  forgetCreated,
-  removeHooks,
-  restoreFeatureHooks,
-  wasCreated
-} from "./chunk-QHYZBHXO.js";
-import {
-  claudeConfigDirs,
-  codexConfigDir,
-  profileKeys
-} from "./chunk-UJ4BQFWV.js";
-import {
-  atomicWrite,
-  backupOnce,
-  cliDir,
-  cliEntry,
-  dropBackupIfSame,
-  isDir,
-  readText,
-  removeFile
-} from "./chunk-VNCQFFQO.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")}"`;
-function codexMachineSpecs(node, profile) {
-  return CODEX_EVENTS.map((event) => ({ event, entry: { type: "command", command: `${q(node)} ${q(cliEntry())} hook codex ${event} --profile ${profile}` } }));
-}
-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 {
-      editJson(path.join(dir, "hooks.json"), (d) => (addHooks(d, "nested", codexMachineSpecs(node, key), "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")}`);
-    } 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 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 {
-    }
-    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-PY74LT2W.js

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-
-// 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 = {}) {
-  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";
-  const 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,
-    signal: AbortSignal.timeout(opts.timeoutMs ?? 15e3)
-  });
-  const text = await res.text();
-  let json = null;
-  try {
-    json = text ? JSON.parse(text) : null;
-  } catch {
-    json = null;
-  }
-  return { status: res.status, json };
-}
-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/cli-P3DYE5IR.js

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-import {
-  parseArgs
-} from "./chunk-TKMIV7BG.js";
-import {
-  VERSION
-} from "./chunk-DNG5CRT3.js";
-import {
-  ApiError
-} from "./chunk-PY74LT2W.js";
-import {
-  CLI_BIN_NAME,
-  CLI_INSTALL_COMMAND,
-  cliNpxCommand,
-  defaultCtx
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
-
-// 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)
-  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
-  --version    Print the version
-
-Install once: ${CLI_INSTALL_COMMAND}
-Host: https://hivefloor.worldofz.info, 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 === void 0 || cmd === "help" || cmd === "--help" || cmd === "-h") {
-    ctx.out(HELP);
-    return 0;
-  }
-  const p = parseArgs(rest);
-  if (p.flags.help) {
-    ctx.out(HELP);
-    return 0;
-  }
-  try {
-    switch (cmd) {
-      case "connect":
-        return await (await import("./connect-ACNM5DQG.js")).connect(ctx, p);
-      case "disconnect":
-        return await (await import("./disconnect-MKRHK4CX.js")).disconnect(ctx, p);
-      case "status":
-        return await (await import("./status-KBBSAADD.js")).status(ctx, p);
-      case "where":
-        return await (await import("./where-KR7VWSEC.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-336BSU72.js")).runService({ ctx });
-      case "link":
-        return await (await import("./link-HXBMMSG3.js")).link(ctx, p);
-      case "token":
-        return await (await import("./token-JDRLEV5D.js")).token(ctx, p);
-      case "mcp":
-        return await (await import("./mcp-N2TMD4GR.js")).runMcpProxy(ctx, p);
-      case "hook": {
-        const { runHook, readStdin } = await import("./hook-KR2HGVAR.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
-};