@hivefloor/cli 0.0.0-stage → 0.1.1

package/dist/chunk-U7PMOZGI.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import {
+  claudeConfigDirs,
+  claudeLabel,
+  codexConfigDir,
+  codexLabel,
+  profileKeys
+} from "./chunk-NCRQGIJY.js";
+
+// src/osinfo.ts
+import os from "os";
+var cliVersionOs = () => `${os.platform()} ${os.release()}`.slice(0, 100);
+
+// src/service/discovery.ts
+import fs from "fs";
+import path from "path";
+var BY_EXE = { claude: "claude", codex: "codex", "cursor-agent": "cursor", gemini: "gemini", grok: "grok" };
+var BY_DIR = { "claude-code": "claude", codex: "codex", "cursor-agent": "cursor", "gemini-cli": "gemini", "grok-cli": "grok" };
+var RUNNERS = /* @__PURE__ */ new Set(["node", "bun", "deno", "npx"]);
+var HELPER_ARGS = /* @__PURE__ */ new Set(["mcp", "update", "doctor", "--version"]);
+var exeName = (tok) => (tok.replace(/^"|"$/g, "").split(/[\\/]/).pop() ?? "").replace(/\.(?:js|mjs|cjs|exe|cmd)$/, "");
+var dirTool = (script) => {
+  for (const part of script.split(/[\\/]/).reverse()) {
+    const tool = BY_DIR[part];
+    if (tool) return tool;
+  }
+  return void 0;
+};
+function splitCommandLine(line) {
+  const toks = [];
+  let cur = "";
+  let quoted = false;
+  let started = false;
+  for (const c of line) {
+    if (c === '"') {
+      quoted = !quoted;
+      started = true;
+    } else if (!quoted && /\s/.test(c)) {
+      if (started) toks.push(cur);
+      cur = "";
+      started = false;
+    } else {
+      cur += c;
+      started = true;
+    }
+  }
+  if (started) toks.push(cur);
+  return toks;
+}
+function fromTokens(pid, toks) {
+  const first = exeName(toks[0] ?? "");
+  let rest = toks.slice(1);
+  let tool;
+  if (RUNNERS.has(first) && toks[1] && !toks[1].startsWith("-")) {
+    tool = BY_EXE[exeName(toks[1])] ?? dirTool(toks[1]);
+    rest = toks.slice(2);
+  } else {
+    tool = BY_EXE[first];
+  }
+  if (!tool || pid === process.pid) return void 0;
+  if (HELPER_ARGS.has(rest[0] ?? "")) return void 0;
+  const mi = rest.findIndex((t) => t === "--model" || t === "-m");
+  const eq = rest.find((t) => t.startsWith("--model="));
+  const model = eq ? eq.slice(8) : mi >= 0 ? rest[mi + 1] : void 0;
+  return { pid, tool, ...model && /^[\w.:\-/[\]]{1,100}$/.test(model) ? { model } : {} };
+}
+function parsePs(text, uid) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s+\S+\s+(.+)$/.exec(line);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    if (uid !== void 0 && Number(m[2]) !== uid) continue;
+    const p = fromTokens(pid, m[3].trim().split(/\s+/));
+    if (p) out.push(p);
+  }
+  return out;
+}
+function parseWindowsProcesses(text) {
+  const raw = text.replace(/^\uFEFF/, "").trim();
+  if (raw === "" || raw === "null") return [];
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const item of Array.isArray(data) ? data : [data]) {
+    if (typeof item !== "object" || item === null) continue;
+    const p = item;
+    const pid = typeof p.ProcessId === "number" ? p.ProcessId : typeof p.ProcessId === "string" ? Number(p.ProcessId) : NaN;
+    if (!Number.isInteger(pid) || pid <= 0 || typeof p.CommandLine !== "string" || p.CommandLine.trim() === "") continue;
+    const found = fromTokens(pid, splitCommandLine(p.CommandLine));
+    if (found) out.push(found);
+  }
+  return out;
+}
+function makeEnvReader(platform, run) {
+  if (platform === "win32") return async () => void 0;
+  return async (pid, name) => {
+    try {
+      if (platform === "linux") {
+        const raw = fs.readFileSync(`/proc/${pid}/environ`, "utf8");
+        for (const kv of raw.split("\0")) if (kv.startsWith(`${name}=`)) return kv.slice(name.length + 1) || void 0;
+        return void 0;
+      }
+      if (platform === "darwin") {
+        const r = await run("ps", ["-E", "-ww", "-p", String(pid), "-o", "command="], { timeoutMs: 5e3 });
+        const m = new RegExp(`(?:^|\\s)${name}=(\\S+)`).exec(r.stdout);
+        return m?.[1];
+      }
+    } catch {
+    }
+    return void 0;
+  };
+}
+var WINDOWS_PROCESS_QUERY = [
+  "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
+  "$me = [Security.Principal.WindowsIdentity]::GetCurrent().Name",
+  "$names = @('claude.exe', 'claude', 'codex.exe', 'codex', 'cursor-agent.exe', 'cursor-agent', 'gemini.exe', 'gemini', 'grok.exe', 'grok', 'node.exe', 'node', 'bun.exe', 'bun', 'deno.exe', 'deno', 'npx.cmd', 'npx')",
+  '$rows = @(Get-CimInstance Win32_Process | Where-Object { $names -contains $_.Name.ToLowerInvariant() } | ForEach-Object { $p = $_; $o = Invoke-CimMethod -InputObject $p -MethodName GetOwner; if ($o.ReturnValue -eq 0) { $owner = if ($o.Domain) { "$($o.Domain)\\$($o.User)" } else { $o.User }; if ($owner -ieq $me) { [pscustomobject]@{ ProcessId = $p.ProcessId; CommandLine = $p.CommandLine } } } })',
+  "ConvertTo-Json -InputObject $rows -Compress"
+].join("; ");
+async function scanProcesses(d) {
+  if (d.platform === "win32") {
+    const r2 = await d.run("powershell", ["-NoProfile", "-NonInteractive", "-Command", WINDOWS_PROCESS_QUERY], { timeoutMs: 1e4 });
+    if (r2.code !== 0) return { procs: [] };
+    return { procs: parseWindowsProcesses(r2.stdout) };
+  }
+  const r = await d.run("ps", ["-axo", "pid=,uid=,etime=,command="], { timeoutMs: 1e4 });
+  if (r.code !== 0) return { procs: [] };
+  const readEnv = d.readEnv ?? makeEnvReader(d.platform, d.run);
+  const procs = [];
+  const uid = d.uid ?? (typeof process.getuid === "function" ? process.getuid() : void 0);
+  for (const p of parsePs(r.stdout, uid)) {
+    const dir = p.tool === "claude" ? await readEnv(p.pid, "CLAUDE_CONFIG_DIR") : p.tool === "codex" ? await readEnv(p.pid, "CODEX_HOME") : void 0;
+    procs.push({ ...p, ...dir ? { dir } : {} });
+  }
+  return { procs };
+}
+var claudeDirsOfScan = (s) => s.procs.filter((p) => p.tool === "claude" && p.dir).map((p) => p.dir);
+function buildProfiles(scan, env, homeDir) {
+  const claudeDirs = claudeConfigDirs(claudeDirsOfScan(scan), homeDir);
+  const ckeys = profileKeys("claude", claudeDirs);
+  const out = [];
+  const defaultDir = claudeDirs[0];
+  for (const dir of claudeDirs) {
+    const key = ckeys.get(dir);
+    const here = scan.procs.filter((p) => p.tool === "claude" && (p.dir ? path.resolve(p.dir) : defaultDir) === dir);
+    if (here.length === 0 && !fs.existsSync(dir)) continue;
+    const model = latestModel(here);
+    out.push({ tool: "claude", key, label: claudeLabel(dir, key), ...model ? { model } : {}, running: here.length });
+  }
+  const cdir = codexConfigDir(env);
+  const codexProcs = scan.procs.filter((p) => p.tool === "codex");
+  const codexKeys = profileKeys("codex", [cdir, ...codexProcs.flatMap((p) => p.dir ? [path.resolve(p.dir)] : [])]);
+  const seenCodex = /* @__PURE__ */ new Set();
+  for (const [dir, key] of codexKeys) {
+    if (seenCodex.has(dir)) continue;
+    seenCodex.add(dir);
+    const here = codexProcs.filter((p) => p.dir ? path.resolve(p.dir) === dir : dir === cdir);
+    if (here.length === 0 && !fs.existsSync(dir)) continue;
+    const model = latestModel(here);
+    out.push({ tool: "codex", key, label: codexLabel(dir), ...model ? { model } : {}, running: here.length });
+  }
+  for (const tool of ["cursor", "gemini", "grok"]) {
+    const here = scan.procs.filter((p) => p.tool === tool);
+    if (here.length === 0) continue;
+    const model = latestModel(here);
+    out.push({ tool, key: "default", label: { cursor: "Cursor", gemini: "Gemini CLI", grok: "Grok CLI" }[tool], ...model ? { model } : {}, running: here.length });
+  }
+  return out;
+}
+var latestModel = (ps) => ps.map((p) => p.model).filter((m) => Boolean(m)).pop();
+
+export {
+  cliVersionOs,
+  scanProcesses,
+  claudeDirsOfScan,
+  buildProfiles
+};

package/dist/chunk-WHHV2NZA.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  addCreated,
+  addHooks,
+  editJson,
+  enableFeatureHooks,
+  forgetCreated,
+  removeHooks,
+  restoreFeatureHooks,
+  wasCreated
+} from "./chunk-YCZ7XJJF.js";
+import {
+  claudeConfigDirs,
+  codexConfigDir,
+  profileKeys
+} from "./chunk-NCRQGIJY.js";
+import {
+  atomicWrite,
+  backupOnce,
+  cliDir,
+  cliEntry,
+  dropBackupIfSame,
+  readText,
+  removeFile
+} from "./chunk-WNDUGQDX.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}` } }));
+}
+var isDir = (p) => {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+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-WLHRUZTR.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+// package.json
+var package_default = {
+  name: "@hivefloor/cli",
+  version: "0.1.1",
+  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",
+    url: "https://github.com/Errr0rr404"
+  },
+  keywords: [
+    "hivefloor",
+    "ai-agents",
+    "coding-agents",
+    "claude-code",
+    "codex",
+    "mcp",
+    "hooks",
+    "cli"
+  ],
+  homepage: "https://hivefloor.worldofz.info",
+  bugs: {
+    url: "https://github.com/Errr0rr404/hivefloor/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Errr0rr404/hivefloor.git",
+    directory: "packages/cli"
+  },
+  license: "MIT",
+  type: "module",
+  bin: {
+    hivefloor: "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc -p tsconfig.json",
+    "pack-test": "bash scripts/pack-test.sh",
+    prepack: "npm run build && node scripts/pack-manifest.mjs strip",
+    postpack: "node scripts/pack-manifest.mjs restore"
+  },
+  devDependencies: {
+    "@hivefloor/shared": "workspace:*",
+    "@types/node": "^22.20.5",
+    tsup: "^8.5.1",
+    typescript: "~5.9.3"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.32.2"
+  },
+  optionalDependencies: {
+    "@napi-rs/keyring": "^2.1.2"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+export {
+  VERSION
+};

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/chunk-WO7NALQO.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  ApiError,
+  apiRequest,
+  errorOf
+} from "./chunk-PY74LT2W.js";
+import {
+  deviceCodeResponseSchema,
+  deviceTokenErrorSchema,
+  deviceTokenSuccessSchema
+} from "./chunk-ZYRPQPGL.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
+};