@hivefloor/cli 0.1.4 → 0.1.8

package/dist/{status-KBBSAADD.js → status-QXOOJGGN.js}

@@ -1,41 +1,55 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   detectRepo
-} from "./chunk-2BSA7LFD.js";
+} from "./chunk-BLLPDPTL.js";
 import {
   resolveSession
-} from "./chunk-7KF7IQJN.js";
-import "./chunk-2IMJECYD.js";
-import "./chunk-TKMIV7BG.js";
+} from "./chunk-NMUH5NXN.js";
 import {
   SCHTASKS_TASK,
+  hostKey,
   readCredentials,
   windowsServiceStatus
-} from "./chunk-PDXYOREI.js";
+} from "./chunk-QLMLB7RB.js";
+import {
+  checkUnknownFlags
+} from "./chunk-QPAFN47B.js";
 import {
   profileKeys
-} from "./chunk-UJ4BQFWV.js";
+} from "./chunk-L6EFW2SJ.js";
 import {
   SERVICE_ALIVE_MS,
   readMachine,
   readServiceState
-} from "./chunk-T7TG6WA4.js";
+} from "./chunk-LX5A25O6.js";
 import {
   apiRequest,
   errorOf
-} from "./chunk-PY74LT2W.js";
-import "./chunk-VNCQFFQO.js";
+} from "./chunk-NRJONTFT.js";
+import "./chunk-XAXKZ572.js";
+import "./chunk-XPGL7VYE.js";
 import {
-  cliNpxCommand,
   machineName,
   runCmd
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-QGULSOQ2.js";
+import {
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
 
 // src/status.ts
 var str = (v) => typeof v === "string" ? v : void 0;
 var rec = (v) => typeof v === "object" && v !== null ? v : {};
+var STATUS_FLAGS = /* @__PURE__ */ new Set(["host", "tool", "help", "h"]);
 async function status(ctx, p) {
+  const unknown = checkUnknownFlags(p, STATUS_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
   const machine = readMachine();
   if (machine) await machineStatus(ctx, machine);
   const s = await resolveSession(ctx, p);
@@ -50,7 +64,8 @@ async function status(ctx, p) {
   ctx.out(`Host: ${s.host}
 Machine: ${machineName()}
 `);
-  const connected = Object.keys(readCredentials().hosts[s.host]?.tools ?? {});
+  const creds = readCredentials();
+  const connected = Object.keys(creds.hosts[hostKey(creds, s.host) ?? ""]?.tools ?? {});
   if (connected.length > 0) ctx.out(`Connected tools: ${connected.join(", ")}
 `);
   if (repo) ctx.out(`Repo here: ${repo.remote}${repo.branch ? ` (${repo.branch})` : ""}
@@ -59,7 +74,7 @@ Machine: ${machineName()}
   try {
     res = await apiRequest(ctx, s.host, "/api/v1/agent/whoami", { token: s.token, headers: repo ? { "x-hf-repo": repo.remote } : {}, timeoutMs: 8e3 });
   } catch (e) {
-    ctx.err(`hivefloor: could not reach ${s.host}: ${e.message}
+    ctx.err(`hivefloor: ${e.message}
 `);
     return 1;
   }

package/dist/token-BFWWQIDA.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  resolveSession
+} from "./chunk-NMUH5NXN.js";
+import "./chunk-QLMLB7RB.js";
+import {
+  checkUnknownFlags
+} from "./chunk-QPAFN47B.js";
+import "./chunk-XAXKZ572.js";
+import "./chunk-XPGL7VYE.js";
+import "./chunk-QGULSOQ2.js";
+import {
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
+
+// src/token.ts
+var TOKEN_FLAGS = /* @__PURE__ */ new Set(["reveal", "host", "tool", "help", "h"]);
+async function token(ctx, p) {
+  const unknown = checkUnknownFlags(p, TOKEN_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
+  const s = await resolveSession(ctx, p);
+  if (!s) {
+    ctx.err(`hivefloor: no token stored. Run: ${cliNpxCommand("connect")}
+`);
+    return 1;
+  }
+  if (ctx.stdoutIsTTY && !p.flags.reveal) {
+    ctx.err("hivefloor: refusing to print the token to a terminal. Use it in a pipe or $(...), or pass --reveal.\n");
+    return 1;
+  }
+  ctx.out(`${s.token}
+`);
+  return 0;
+}
+export {
+  token
+};

package/dist/voice-QXHFXRWG.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-QPAFN47B.js";
+import {
+  KOKORO_VOICES,
+  KOKORO_VOICE_ID,
+  voiceFor
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.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-CMUORQIO.js}

@@ -1,24 +1,36 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   resolveSession
-} from "./chunk-7KF7IQJN.js";
-import "./chunk-2IMJECYD.js";
-import "./chunk-TKMIV7BG.js";
-import "./chunk-PDXYOREI.js";
+} from "./chunk-NMUH5NXN.js";
+import "./chunk-QLMLB7RB.js";
+import {
+  checkUnknownFlags
+} from "./chunk-QPAFN47B.js";
 import {
   apiRequest,
   errorOf
-} from "./chunk-PY74LT2W.js";
-import "./chunk-VNCQFFQO.js";
+} from "./chunk-NRJONTFT.js";
+import "./chunk-XAXKZ572.js";
+import "./chunk-XPGL7VYE.js";
+import "./chunk-QGULSOQ2.js";
 import {
   cliNpxCommand,
   routeProviderFromParam,
   usageRouteSchema
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.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",
-  "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": "Errr0rr404",
+    "name": "Zan",
     "url": "https://github.com/Errr0rr404"
   },
   "keywords": [
@@ -18,14 +18,13 @@
   ],
   "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-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
-};