@hivefloor/cli 0.1.4 → 0.1.8

package/dist/{chunk-2BSA7LFD.js → chunk-BLLPDPTL.js}

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
-  formatRemote,
-  normalizeRemote,
   runCmd
-} from "./chunk-ZC2DAKB5.js";
+} from "./chunk-QGULSOQ2.js";
+import {
+  formatRemote,
+  normalizeRemote
+} from "./chunk-HWBUESB4.js";
 
 // src/git.ts
 function remoteOf(url) {

package/dist/{chunk-R5KDI4WI.js → chunk-FPJNGKT5.js}

@@ -1,18 +1,24 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   ApiError,
   apiRequest,
   errorOf
-} from "./chunk-PY74LT2W.js";
+} from "./chunk-NRJONTFT.js";
+import {
+  assertTokenTransport
+} from "./chunk-QGULSOQ2.js";
 import {
   deviceCodeResponseSchema,
   deviceTokenErrorSchema,
   deviceTokenSuccessSchema
-} from "./chunk-ZC2DAKB5.js";
+} from "./chunk-HWBUESB4.js";
 
 // src/device.ts
 var printable = (s) => [...s].filter((c) => c.charCodeAt(0) >= 32 && c.charCodeAt(0) !== 127).join("");
 async function deviceLogin(ctx, opts) {
+  assertTokenTransport(opts.host);
   const started = await apiRequest(ctx, opts.host, "/api/v1/device/code", { method: "POST", body: opts.request });
   if (started.status !== 200) throw errorOf(started);
   const code = deviceCodeResponseSchema.parse(started.json);
@@ -40,7 +46,7 @@ Confirm it at ${url}
       res = await apiRequest(ctx, opts.host, "/api/v1/device/token", { method: "POST", body: { device_code: code.device_code } });
     } catch (e) {
       failures += 1;
-      if (failures >= 5) throw new ApiError(0, "network", `Could not reach ${opts.host}: ${e.message}`);
+      if (failures >= 5) throw e;
       continue;
     }
     if (res.status === 200) return opts.parse ? opts.parse(res.json) : deviceTokenSuccessSchema.parse(res.json);

package/dist/chunk-HW3KRNCO.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  applyControlHooks
+} from "./chunk-5XXYQQG6.js";
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-QPAFN47B.js";
+import {
+  VERBS,
+  activeVerbs,
+  allOff,
+  orchestratorFullOn,
+  orchestratorOn,
+  readControl,
+  writeControl
+} from "./chunk-KQMPCV57.js";
+import {
+  readMachine,
+  serviceAlive
+} from "./chunk-LX5A25O6.js";
+import {
+  cliEntry,
+  controlFile,
+  controlLogFile,
+  sessionsFile
+} from "./chunk-XPGL7VYE.js";
+
+// src/control.ts
+import fs from "fs";
+var CONTROL_FLAGS = /* @__PURE__ */ new Set(["verbs", "from", "replies", "orchestrator", "help", "h"]);
+var DEFAULT_VERBS = ["message", "stop"];
+var REPLIES = ["off", "after_message", "always"];
+var VERB_RISK = {
+  message: "message: a person can type a message to a live Claude Code session, as if you had typed it (it is cleaned of control characters first).",
+  approve: "approve: a person can approve the permission prompt a session is waiting on, once, by its id.",
+  deny: "deny: a person can deny the permission prompt a session is waiting on.",
+  stop: "stop: a person can interrupt a session (Escape) or end it (SIGTERM to that one process).",
+  peek: "peek: the owner of an agent or a project admin can read the last lines (at most 60) of a session: its tmux pane, or the end of its transcript when it has none. Secrets are redacted on this machine first.",
+  resume: "resume: the owner of an agent can reopen one of its ended Claude Code or Codex sessions on this machine (`claude --resume <id>` or `codex resume <id>` in a new detached tmux session, in the folder this machine recorded for it)."
+};
+function riskLines(v) {
+  const on = VERBS.filter((k) => v[k]);
+  if (on.length === 0) return [];
+  const out = ["If the HiveFloor server were compromised, it could send these (and nothing else: no shell, no program, no file beyond what a verb below names):", ...on.map((k) => `  - ${VERB_RISK[k]}`)];
+  if (v.message && v.approve) out.push("With message and approve both on, a compromised server could prompt your agent and approve its next prompt. That is the cost of turning both on.");
+  out.push("Commands only reach sessions this machine has seen, only from the people `--from` allows, and every one is logged in " + controlLogFile() + " (never the message text).");
+  return out;
+}
+function parseVerbs(text) {
+  if (text.trim() === "none") return [];
+  const out = [];
+  for (const part of text.split(",").map((s) => s.trim()).filter(Boolean)) {
+    if (!VERBS.includes(part)) return `unknown verb "${part}". Use: ${VERBS.join(", ")}.`;
+    if (!out.includes(part)) out.push(part);
+  }
+  return out.length > 0 ? out : "no verbs given.";
+}
+function describe(ctx, r) {
+  const v = activeVerbs(r);
+  const on = VERBS.filter((k) => v[k]);
+  const c = r.config;
+  ctx.out(`Session control: ${on.length > 0 ? "ON" : "OFF"}
+`);
+  ctx.out(`File: ${controlFile()} (${r.state === "ok" ? "valid" : r.state === "missing" ? "not there: everything is off" : "NOT TRUSTED: everything is off"})
+`);
+  if (r.state === "invalid") ctx.out(`Why: ${r.reason}
+`);
+  if (r.state === "ok" && !c.enabled && VERBS.some((k) => c.verbs[k])) ctx.out('The file has verbs set but "enabled" is false: everything is off.\n');
+  ctx.out(`Verbs: ${VERBS.map((k) => `${k} ${v[k] ? "on" : "off"}`).join(", ")}
+`);
+  ctx.out(`Orchestrator: ${orchestratorOn(r) ? "on" : "off"}
+`);
+  if (orchestratorOn(r)) {
+    ctx.out("With the orchestrator on, the HiveFloor server can start one Claude Code session in its own folder (~/.config/hivefloor/orchestrator/work) and type to it. That session may read files in that folder; every other tool call is asked on the HiveFloor orchestrator page first (no answer in 10 minutes is a deny).\n");
+  }
+  describeFull(ctx, r);
+  if (on.length > 0) {
+    ctx.out(`From: ${c.from === "admins" ? "the machine owner and the project owners and admins" : "the machine owner only"}
+`);
+    ctx.out(`Replies: ${c.replies}
+`);
+    if (c.adapters.length > 0) ctx.out(`Local adapters: ${c.adapters.map((a) => a.name).join(", ")}
+`);
+    for (const l of riskLines(v)) ctx.out(`${l}
+`);
+  }
+  const m = readMachine();
+  if (!m || m.revoked) ctx.out('This machine is not connected: run "hivefloor connect" first, or nothing can reach it.\n');
+  else if (!serviceAlive(ctx.now())) ctx.out("The background service is not running: commands are only taken while it runs.\n");
+  ctx.out(`Session map: ${sessionsFile()}
+`);
+}
+var FULL_POWER_MEANS = "With full power on, a start from your HiveFloor account can run the orchestrator as a normal Claude Code session of yours on this computer: your settings, MCP servers, skills and environment, in any folder, resuming any of your sessions by id, and (when the start asks for it) with permission prompts bypassed. That is remote code as you. A session with prompts bypassed asks nothing: text that reaches it from fleet reports (the bridge), from scheduled check-ins and from the output of its tools can make it run commands, and those commands run as you. If the HiveFloor server or your HiveFloor account were compromised, so would this computer be.";
+function describeFull(ctx, r) {
+  ctx.out(`Orchestrator full power: ${orchestratorFullOn(r) ? "ON" : "off"}
+`);
+  if (!orchestratorFullOn(r)) return;
+  ctx.out(`${FULL_POWER_MEANS} Turn it off with "hivefloor orch enable --no-full".
+`);
+}
+function hooksFor(ctx, v) {
+  const m = readMachine();
+  if (!m || m.revoked) {
+    ctx.err('hivefloor: this machine is not connected, so no hooks were changed. Run "hivefloor connect", then "hivefloor control on" again.\n');
+    return;
+  }
+  if (!fs.existsSync(cliEntry())) {
+    ctx.err('hivefloor: the CLI copy the hooks run is missing. Run "hivefloor connect" again, then "hivefloor control on".\n');
+    return;
+  }
+  const r = applyControlHooks(process.execPath, m.installed.claude_dirs, v);
+  for (const l of r.lines) ctx.out(`${l}
+`);
+  for (const w of r.warnings) ctx.err(`hivefloor: ${w}
+`);
+}
+async function control(ctx, p) {
+  const unknown = checkUnknownFlags(p, CONTROL_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help control".
+`);
+    return 2;
+  }
+  const sub = p.positionals[0];
+  if (p.positionals.length > 1 || sub !== "on" && sub !== "off" && sub !== "status") {
+    ctx.err("hivefloor: usage: hivefloor control on [--verbs message,approve,deny,stop,resume|none] [--from owner|admins] [--replies off|after_message|always] [--orchestrator on|off] | off | status\n");
+    return 2;
+  }
+  if (sub === "status") {
+    describe(ctx, readControl());
+    return 0;
+  }
+  const cur = readControl();
+  if (cur.state === "invalid") {
+    ctx.err(`hivefloor: ${cur.reason}. Fix that and run this again; the file is not overwritten.
+`);
+    return 1;
+  }
+  if (sub === "off") {
+    if (cur.state === "ok") writeControl({ ...cur.config, enabled: false, verbs: allOff().verbs, orchestrator_full: false });
+    hooksFor(ctx, allOff().verbs);
+    ctx.out("Session control is off. Takes effect at once; the service reports it at its next heartbeat.\n");
+    return 0;
+  }
+  const base = cur.state === "ok" ? cur.config : allOff();
+  let verbs;
+  const vflag = flagStr(p, "verbs");
+  if (p.flags.verbs === true) {
+    ctx.err("hivefloor: --verbs needs a list, for example --verbs message,stop\n");
+    return 2;
+  }
+  if (vflag !== void 0) {
+    const parsed = parseVerbs(vflag);
+    if (typeof parsed === "string") {
+      ctx.err(`hivefloor: ${parsed}
+`);
+      return 2;
+    }
+    verbs = parsed;
+  } else {
+    const kept = base.enabled ? VERBS.filter((k) => base.verbs[k]) : [];
+    verbs = kept.length > 0 ? kept : DEFAULT_VERBS;
+  }
+  const from = flagStr(p, "from") ?? base.from;
+  if (from !== "owner" && from !== "admins") {
+    ctx.err("hivefloor: --from must be owner or admins\n");
+    return 2;
+  }
+  const replies = flagStr(p, "replies") ?? base.replies;
+  if (!REPLIES.includes(replies)) {
+    ctx.err(`hivefloor: --replies must be one of ${REPLIES.join(", ")}
+`);
+    return 2;
+  }
+  const oflag = flagStr(p, "orchestrator");
+  if (p.flags.orchestrator === true || oflag !== void 0 && oflag !== "on" && oflag !== "off") {
+    ctx.err("hivefloor: --orchestrator must be on or off\n");
+    return 2;
+  }
+  const orchestrator = oflag === void 0 ? base.enabled && base.orchestrator : oflag === "on";
+  if (verbs.length === 0 && !orchestrator) {
+    ctx.err('hivefloor: --verbs none turns nothing on; add --orchestrator on, or use "hivefloor control off".\n');
+    return 2;
+  }
+  const orchestrator_full = orchestrator && base.enabled && base.orchestrator && base.orchestrator_full;
+  const next = { ...base, version: 1, enabled: true, orchestrator, orchestrator_full, verbs: { ...allOff().verbs, ...Object.fromEntries(verbs.map((k) => [k, true])) }, from, replies };
+  writeControl(next);
+  hooksFor(ctx, next.verbs);
+  ctx.out(verbs.length > 0 ? "Session control is on.\n" : "Session control verbs are off; the orchestrator is on.\n");
+  describe(ctx, readControl());
+  return 0;
+}
+
+export {
+  FULL_POWER_MEANS,
+  describeFull,
+  control
+};