@hivefloor/cli 0.0.0-stage → 0.1.0

package/dist/chunk-SGDM7MAT.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import {
+  configDir,
+  readText,
+  removeFile,
+  serviceLogFile,
+  spoolFile
+} from "./chunk-WNDUGQDX.js";
+
+// src/spool.ts
+import fs from "fs";
+import path from "path";
+var SPOOL_MAX_BYTES = 1024 * 1024;
+var LOCK_STALE_MS = 1e4;
+var CLAIM_STALE_MS = 6e4;
+var LOCK_WAIT_MS = 250;
+var CAP_SLACK = 64 * 1024;
+var counter = 0;
+var uniq = () => `${Date.now()}-${process.pid}-${counter++}`;
+function parseSpool(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+function capped(events, maxBytes = SPOOL_MAX_BYTES) {
+  const lines = events.map((e) => JSON.stringify(e));
+  let total = lines.reduce((n, l) => n + Buffer.byteLength(l) + 1, 0);
+  let start = 0;
+  while (total > maxBytes && start < lines.length) {
+    total -= Buffer.byteLength(lines[start]) + 1;
+    start += 1;
+  }
+  return { events: events.slice(start), dropped: start };
+}
+function droppedEvents(file = spoolFile()) {
+  try {
+    return Number(fs.readFileSync(`${file}.dropped`, "utf8").trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+function noteDropped(spool, dropped) {
+  if (dropped <= 0) return;
+  try {
+    fs.writeFileSync(`${spool}.dropped`, String(droppedEvents(spool) + dropped), { mode: 384 });
+  } catch {
+  }
+  try {
+    fs.appendFileSync(serviceLogFile(), `${(/* @__PURE__ */ new Date()).toISOString()} spool full: dropped ${dropped} event(s), the cap is ${SPOOL_MAX_BYTES} bytes
+`, { mode: 384 });
+  } catch {
+  }
+}
+function pause(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+var lockPath = (file) => `${file}.lock`;
+function acquireLock(file) {
+  const lp = lockPath(file);
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  for (; ; ) {
+    try {
+      fs.closeSync(fs.openSync(lp, "wx", 384));
+      return true;
+    } catch (e) {
+      if (e.code !== "EEXIST") return false;
+    }
+    try {
+      if (Date.now() - fs.statSync(lp).mtimeMs > LOCK_STALE_MS) {
+        fs.rmSync(lp, { force: true });
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (Date.now() >= deadline) return false;
+    pause(5);
+  }
+}
+function releaseLock(file) {
+  removeFile(lockPath(file));
+}
+var claimPath = (file) => `${file}.claim-${uniq()}`;
+var pendingPath = (file) => `${file}.pending-${uniq()}`;
+function sideFiles(dir, file, kind) {
+  const prefix = `${path.basename(file)}.${kind}-`;
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((n) => n.startsWith(prefix)).sort().map((n) => path.join(dir, n));
+}
+function owner(file) {
+  const m = /\.(?:claim|pending)-(\d+)-(\d+)-\d+$/.exec(path.basename(file));
+  if (!m) return void 0;
+  return { ts: Number(m[1]), pid: Number(m[2]) };
+}
+function alive(pid) {
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function abandoned(file) {
+  const o = owner(file);
+  if (!o) return false;
+  if (!alive(o.pid)) return true;
+  return Date.now() - o.ts > CLAIM_STALE_MS;
+}
+function writeEvents(file, events) {
+  const tmp = `${file}.tmp-${process.pid}-${counter++}`;
+  try {
+    fs.writeFileSync(tmp, events.map((e) => JSON.stringify(e)).join("\n") + (events.length ? "\n" : ""), { mode: 384 });
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    removeFile(tmp);
+    throw e;
+  }
+}
+function writeSpool(file, events, maxBytes = SPOOL_MAX_BYTES) {
+  const { events: kept, dropped } = capped(events, maxBytes);
+  if (dropped > 0) noteDropped(file, dropped);
+  writeEvents(file, kept);
+}
+function recover(file) {
+  const dir = path.dirname(file);
+  const stale = [...sideFiles(dir, file, "claim").filter(abandoned), ...sideFiles(dir, file, "pending")].sort();
+  if (stale.length === 0) return;
+  const events = [];
+  for (const f of stale) events.push(...parseSpool(readText(f) ?? ""));
+  if (events.length > 0) {
+    const existing = parseSpool(readText(file) ?? "");
+    writeSpool(file, [...events, ...existing]);
+  }
+  for (const f of stale) removeFile(f);
+}
+function takeSpool(file = spoolFile()) {
+  fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  if (!acquireLock(file)) return void 0;
+  try {
+    recover(file);
+    const claim = claimPath(file);
+    try {
+      fs.renameSync(file, claim);
+    } catch {
+      return void 0;
+    }
+    let events;
+    try {
+      events = parseSpool(fs.readFileSync(claim, "utf8"));
+    } catch {
+      return void 0;
+    }
+    if (events.length === 0) {
+      removeFile(claim);
+      return void 0;
+    }
+    return { spool: file, file: claim, events };
+  } finally {
+    releaseLock(file);
+  }
+}
+function releaseSpool(claim, keep, spool = spoolFile()) {
+  if (keep.length === 0) {
+    if (claim) removeFile(claim.file);
+    return;
+  }
+  const target = claim?.spool ?? spool;
+  try {
+    returnToSpool(keep, target);
+  } catch {
+    if (claim) {
+      try {
+        writeEvents(claim.file, keep);
+      } catch {
+      }
+      return;
+    }
+    try {
+      writeEvents(pendingPath(target), keep);
+    } catch {
+    }
+    return;
+  }
+  if (claim) removeFile(claim.file);
+}
+function returnToSpool(events, file = spoolFile()) {
+  if (events.length === 0) return;
+  fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  if (!acquireLock(file)) {
+    writeEvents(pendingPath(file), events);
+    return;
+  }
+  try {
+    const existing = parseSpool(readText(file) ?? "");
+    writeSpool(file, [...events, ...existing]);
+  } finally {
+    releaseLock(file);
+  }
+}
+function appendToSpool(event, file = spoolFile()) {
+  fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+  const line = JSON.stringify(event) + "\n";
+  if (!acquireLock(file)) {
+    fs.appendFileSync(file, line, { mode: 384 });
+    return;
+  }
+  try {
+    fs.appendFileSync(file, line, { mode: 384 });
+    let size = 0;
+    try {
+      size = fs.statSync(file).size;
+    } catch {
+      size = 0;
+    }
+    if (size > SPOOL_MAX_BYTES) writeSpool(file, parseSpool(readText(file) ?? ""), SPOOL_MAX_BYTES - CAP_SLACK);
+  } finally {
+    releaseLock(file);
+  }
+}
+
+export {
+  takeSpool,
+  releaseSpool,
+  appendToSpool
+};

package/dist/chunk-TKMIV7BG.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// src/args.ts
+var BOOLEAN = /* @__PURE__ */ new Set(["no-open", "yes", "y", "reveal", "help", "h", "json", "no-cli", "agent", "no-service"]);
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let k = 0; k < argv.length; k++) {
+    const a = argv[k];
+    if (a === "--") {
+      positionals.push(...argv.slice(k + 1));
+      break;
+    }
+    if (a.startsWith("--") && a.length > 2) {
+      const eq = a.indexOf("=");
+      if (eq > 0) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const name = a.slice(2);
+        const next = argv[k + 1];
+        if (BOOLEAN.has(name) || next === void 0 || next.startsWith("--") || next === "-y" || next === "-h") {
+          flags[name] = true;
+        } else {
+          flags[name] = next;
+          k += 1;
+        }
+      }
+    } else if (a === "-y") flags.yes = true;
+    else if (a === "-h") flags.help = true;
+    else positionals.push(a);
+  }
+  return { positionals, flags };
+}
+var flagStr = (p, name) => typeof p.flags[name] === "string" ? p.flags[name] : void 0;
+function checkUnknownFlags(p, allowed) {
+  for (const f of Object.keys(p.flags)) {
+    if (!allowed.has(f)) return f;
+  }
+  return void 0;
+}
+
+export {
+  parseArgs,
+  flagStr,
+  checkUnknownFlags
+};

package/dist/chunk-UPRHMVYJ.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  ApiError,
+  apiRequest,
+  errorOf
+} from "./chunk-PY74LT2W.js";
+import {
+  deviceCodeResponseSchema,
+  deviceTokenErrorSchema,
+  deviceTokenSuccessSchema
+} from "./chunk-RE2EQZWL.js";
+
+// src/device.ts
+var printable = (s) => [...s].filter((c) => c.charCodeAt(0) >= 32 && c.charCodeAt(0) !== 127).join("");
+async function deviceLogin(ctx, opts) {
+  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);
+  const userCode = printable(code.user_code);
+  const url = printable(code.verification_uri_complete);
+  ctx.out(`
+Your code is ${userCode}
+Confirm it at ${url}
+`);
+  if (opts.openBrowser) {
+    try {
+      await ctx.open(url);
+    } catch {
+    }
+  }
+  ctx.out("Waiting for you to confirm in the browser...\n");
+  const deadline = ctx.now() + code.expires_in * 1e3;
+  let interval = code.interval;
+  let failures = 0;
+  for (; ; ) {
+    await ctx.sleep(interval * 1e3);
+    if (ctx.now() >= deadline) throw new ApiError(400, "expired_token", "The code expired before it was confirmed. Run the command again.");
+    let res;
+    try {
+      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}`);
+      continue;
+    }
+    if (res.status === 200) return opts.parse ? opts.parse(res.json) : deviceTokenSuccessSchema.parse(res.json);
+    const err = deviceTokenErrorSchema.safeParse(res.json);
+    if (res.status === 429) {
+      interval += 5;
+      continue;
+    }
+    if (!err.success) {
+      failures += 1;
+      if (failures >= 5 || res.status >= 400 && res.status < 500) throw errorOf(res);
+      continue;
+    }
+    failures = 0;
+    switch (err.data.error) {
+      case "authorization_pending":
+        break;
+      case "slow_down":
+        interval += 5;
+        break;
+      case "access_denied":
+        throw new ApiError(400, "access_denied", "The request was denied in the browser.");
+      case "expired_token":
+        throw new ApiError(400, "expired_token", "The code expired before it was confirmed. Run the command again.");
+    }
+  }
+}
+
+export {
+  deviceLogin
+};

package/dist/chunk-WNDUGQDX.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+// src/fsutil.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var home = () => os.homedir();
+function configDirFor(platform, env, homeDir) {
+  if (platform === "win32") return path.win32.join(env.APPDATA || path.win32.join(homeDir, "AppData", "Roaming"), "hivefloor");
+  return path.join(homeDir, ".config", "hivefloor");
+}
+var configDir = () => configDirFor(process.platform, process.env, home());
+var credentialsFile = () => path.join(configDir(), "credentials.json");
+var spoolFile = () => path.join(configDir(), "spool.jsonl");
+var manifestFile = () => path.join(configDir(), "manifest.json");
+var machineFile = () => path.join(configDir(), "machine.json");
+var machineSpoolFile = () => path.join(configDir(), "machine-spool.jsonl");
+var serviceStateFile = () => path.join(configDir(), "service.json");
+var serviceLogFile = () => path.join(configDir(), "service.log");
+var cliDir = () => path.join(configDir(), "cli");
+var cliEntry = () => path.join(cliDir(), "index.js");
+function readText(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return void 0;
+    throw e;
+  }
+}
+function resolveLink(file) {
+  try {
+    return fs.realpathSync(file);
+  } catch {
+    try {
+      return path.resolve(path.dirname(file), fs.readlinkSync(file));
+    } catch {
+      return file;
+    }
+  }
+}
+function atomicWrite(link, content, mode) {
+  atomicWriteBytes(link, Buffer.from(content, "utf8"), mode);
+}
+function atomicWriteBytes(link, content, mode) {
+  const file = resolveLink(link);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  let m = mode;
+  if (m === void 0) {
+    try {
+      m = fs.statSync(file).mode & 511;
+    } catch {
+      m = 420;
+    }
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, content, { mode: m });
+    fs.chmodSync(tmp, m);
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+    throw e;
+  }
+}
+function atomicWriteUtf16(link, content, mode) {
+  atomicWriteBytes(link, Buffer.concat([Buffer.from([255, 254]), Buffer.from(content, "utf16le")]), mode);
+}
+function backupOnce(file) {
+  const bak = `${file}.hivefloor.bak`;
+  if (fs.existsSync(file) && !fs.existsSync(bak)) fs.copyFileSync(file, bak);
+}
+function dropBackupIfSame(file) {
+  const bak = `${file}.hivefloor.bak`;
+  const a = readText(file);
+  const b = readText(bak);
+  if (b !== void 0 && a === b) fs.unlinkSync(bak);
+}
+function removeFile(file) {
+  try {
+    fs.unlinkSync(file);
+  } catch {
+  }
+}
+var ConfigError = class extends Error {
+};
+function readJsonFile(file) {
+  const text = readText(file);
+  if (text === void 0 || text.trim() === "") {
+    return { data: {}, style: { indent: 2, eol: "\n", finalNewline: true }, existed: text !== void 0 };
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new ConfigError(`${file} is not plain JSON (comments or a syntax error), so it was left untouched`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) throw new ConfigError(`${file} is not a JSON object`);
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const m = /\n([ \t]+)\S/.exec(text);
+  const indent = m ? m[1].startsWith("	") ? "	" : m[1].length : text.trim().includes("\n") ? 2 : 0;
+  return { data, style: { indent, eol, finalNewline: text.endsWith("\n") }, existed: true };
+}
+function serializeJson(data, style) {
+  let s = JSON.stringify(data, null, style.indent);
+  if (style.eol === "\r\n") s = s.replace(/\n/g, "\r\n");
+  return style.finalNewline ? s + style.eol : s;
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+
+export {
+  home,
+  configDir,
+  credentialsFile,
+  spoolFile,
+  manifestFile,
+  machineFile,
+  machineSpoolFile,
+  serviceStateFile,
+  serviceLogFile,
+  cliDir,
+  cliEntry,
+  readText,
+  atomicWrite,
+  atomicWriteUtf16,
+  backupOnce,
+  dropBackupIfSame,
+  removeFile,
+  ConfigError,
+  readJsonFile,
+  serializeJson,
+  isRecord
+};

package/dist/cli-7CIYC6A3.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-TKMIV7BG.js";
+import {
+  VERSION
+} from "./chunk-IEYWMDXA.js";
+import {
+  ApiError
+} from "./chunk-PY74LT2W.js";
+import {
+  CLI_BIN_NAME,
+  CLI_INSTALL_COMMAND,
+  cliNpxCommand,
+  defaultCtx
+} from "./chunk-RE2EQZWL.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
+  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-R3PMIY7G.js")).connect(ctx, p);
+      case "disconnect":
+        return await (await import("./disconnect-NRYU6W5P.js")).disconnect(ctx, p);
+      case "status":
+        return await (await import("./status-HADESN2E.js")).status(ctx, p);
+      case "service":
+        if (p.positionals[0] !== "run") {
+          ctx.err("hivefloor: usage: hivefloor service run\n");
+          return 2;
+        }
+        return await (await import("./run-64ZYCJU2.js")).runService({ ctx });
+      case "link":
+        return await (await import("./link-EPWADGYT.js")).link(ctx, p);
+      case "token":
+        return await (await import("./token-SM5MDJKY.js")).token(ctx, p);
+      case "mcp":
+        return await (await import("./mcp-QX6VMTOD.js")).runMcpProxy(ctx, p);
+      case "hook": {
+        const { runHook, readStdin } = await import("./hook-B2I42GE3.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-R3PMIY7G.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  connect,
+  connectAgent,
+  resolveHost
+} from "./chunk-4OFN5KHY.js";
+import "./chunk-LHF4KCEA.js";
+import "./chunk-3IMV5EHP.js";
+import "./chunk-UPRHMVYJ.js";
+import "./chunk-OQ6QVFSH.js";
+import "./chunk-2IMJECYD.js";
+import "./chunk-TKMIV7BG.js";
+import "./chunk-4A5WOW2D.js";
+import "./chunk-IEYWMDXA.js";
+import "./chunk-PY74LT2W.js";
+import "./chunk-WNDUGQDX.js";
+import "./chunk-RE2EQZWL.js";
+import "./chunk-K3NQKI34.js";
+export {
+  connect,
+  connectAgent,
+  resolveHost
+};