@hivefloor/cli 0.0.0-stage → 0.1.0

package/dist/chunk-4OFN5KHY.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import {
+  RC_LINE,
+  addRcLine,
+  hasRcLine,
+  installClaude,
+  installCodex,
+  installCursor,
+  installGemini,
+  installGrok,
+  rcFileFor,
+  updateManifest
+} from "./chunk-LHF4KCEA.js";
+import {
+  readMachine
+} from "./chunk-3IMV5EHP.js";
+import {
+  deviceLogin
+} from "./chunk-UPRHMVYJ.js";
+import {
+  detectRepo
+} from "./chunk-OQ6QVFSH.js";
+import {
+  REAL_TOOLS,
+  TOOL_LABEL,
+  detectTools,
+  findBin,
+  isTool,
+  toolFromEnv
+} from "./chunk-2IMJECYD.js";
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  saveToken
+} from "./chunk-4A5WOW2D.js";
+import {
+  VERSION
+} from "./chunk-IEYWMDXA.js";
+import {
+  ApiError
+} from "./chunk-PY74LT2W.js";
+import {
+  ConfigError
+} from "./chunk-WNDUGQDX.js";
+import {
+  CLI_BIN_NAME,
+  CLI_INSTALL_COMMAND,
+  cliNpxCommand,
+  hostFromEnv,
+  machineName,
+  normalizeHost
+} from "./chunk-RE2EQZWL.js";
+
+// src/connect.ts
+var INSTALLERS = {
+  claude: installClaude,
+  codex: installCodex,
+  cursor: installCursor,
+  gemini: installGemini,
+  grok: installGrok
+};
+function resolveHost(p, ctx) {
+  const h = flagStr(p, "host");
+  return h ? normalizeHost(h) : hostFromEnv(ctx.env);
+}
+async function chooseTool(ctx, p) {
+  const detected = detectTools(ctx.env).map((d) => d.tool);
+  const flag = flagStr(p, "tool");
+  if (flag !== void 0) {
+    if (!isTool(flag)) throw new ApiError(0, "invalid", `Unknown tool "${flag}". Use one of: ${[...REAL_TOOLS, "other"].join(", ")}.`);
+    return { tool: flag, others: detected.filter((t) => t !== flag) };
+  }
+  const hint = toolFromEnv(ctx.env);
+  let tool = hint ?? detected[0] ?? "other";
+  if (!hint && detected.length > 1 && ctx.stdoutIsTTY && !p.flags.yes) {
+    const answer = (await ctx.ask(`Which tool should this agent be? (${detected.join(", ")}) [${tool}]: `)).trim().toLowerCase();
+    if (isTool(answer)) tool = answer;
+  }
+  return { tool, others: detected.filter((t) => t !== tool) };
+}
+async function connectAgent(ctx, p) {
+  const host = resolveHost(p, ctx);
+  const { tool, others } = await chooseTool(ctx, p);
+  const repo = await detectRepo(ctx.cwd);
+  ctx.out(`Connecting ${TOOL_LABEL[tool]} on ${machineName()} to ${host}
+`);
+  if (repo) ctx.out(`Repo: ${repo.remote}${repo.branch ? ` (${repo.branch})` : ""}${repo.path ? ` in ${repo.path}` : ""}
+`);
+  else ctx.out("No git remote here: the agent will use your default project.\n");
+  const request = {
+    client: { tool, machine: machineName(), os: process.platform, cli_version: VERSION },
+    ...repo ? { repo: { remote: repo.remote, ...repo.branch ? { branch: repo.branch } : {}, ...repo.path ? { path: repo.path } : {} } } : {}
+  };
+  const canOpen = !p.flags["no-open"] && (process.platform !== "linux" || Boolean(ctx.env.DISPLAY || ctx.env.WAYLAND_DISPLAY));
+  const result = await deviceLogin(ctx, { host, request, openBrowser: canOpen });
+  const storage = await saveToken(host, tool, result.token, { agent: result.agent, project: result.project });
+  const rc = rcFileFor(ctx.env);
+  let rcInstalled = rc !== void 0 && hasRcLine(rc);
+  let rcAdded;
+  if (rc && !rcInstalled && tool !== "other") {
+    let yes = Boolean(p.flags.yes);
+    if (!yes && ctx.stdoutIsTTY) yes = /^y(es)?$/i.test((await ctx.ask(`Add this line to ${rc} so your tools can read the token?
+  ${RC_LINE}
+Add it? [y/N] `)).trim());
+    if (yes) {
+      addRcLine(rc);
+      rcInstalled = true;
+      rcAdded = rc;
+      updateManifest((m) => {
+        if (!m.rc.includes(rc)) m.rc.push(rc);
+      });
+    }
+  }
+  const machine = readMachine();
+  const ownsHooks = machine !== void 0 && !machine.revoked;
+  const lines = [];
+  const warnings = [];
+  const mcpUrl = `${host}/mcp`;
+  if (tool === "other") {
+    lines.push(`MCP server: ${mcpUrl} (streamable HTTP), header "Authorization: Bearer <token>" (run: ${cliNpxCommand("token --reveal")})`);
+    lines.push("The agent shows up the first time it calls a tool.");
+  } else {
+    try {
+      const r = await INSTALLERS[tool]({
+        ctx,
+        mcpUrl,
+        token: result.token,
+        useEnvToken: rcInstalled,
+        noCli: Boolean(p.flags["no-cli"]),
+        skipHooks: ownsHooks,
+        onMcpRegistered: (mcp) => {
+          updateManifest((m) => {
+            m.tools[tool] = { mcp, host };
+          });
+        }
+      });
+      lines.push(...r.report.lines);
+      warnings.push(...r.report.warnings);
+      updateManifest((m) => {
+        m.tools[tool] = { mcp: r.mcp, host };
+      });
+    } catch (e) {
+      if (!(e instanceof ConfigError)) throw e;
+      warnings.push(e.message);
+    }
+  }
+  if (rcAdded) lines.push(`Shell: added the token export to ${rcAdded}`);
+  if (!findBin(CLI_BIN_NAME, ctx.env) && tool !== "other") warnings.push(`"${CLI_BIN_NAME}" is not on your PATH, so the hooks cannot run it. Install it once: ${CLI_INSTALL_COMMAND}`);
+  ctx.out(`
+Connected as ${result.agent.name} to project ${result.project.name} (${result.project.key}).
+`);
+  ctx.out(`Token stored in ${storage === "keychain" ? "the OS keychain" : "~/.config/hivefloor/credentials.json (mode 0600)"}.
+`);
+  for (const l of lines) ctx.out(`  ${l}
+`);
+  for (const w of warnings) ctx.out(`  note: ${w}
+`);
+  if (others.length > 0) ctx.out(`Also installed: ${others.join(", ")}. Connect each with: ${cliNpxCommand("connect --tool <name>")}
+`);
+  ctx.out(`Undo everything with: ${cliNpxCommand("disconnect")}
+`);
+  return 0;
+}
+var CONNECT_FLAGS = /* @__PURE__ */ new Set(["host", "name", "no-open", "no-service", "yes", "y", "agent", "tool", "no-cli", "help", "h"]);
+async function connect(ctx, p) {
+  const unknown = checkUnknownFlags(p, CONNECT_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
+  if (p.flags.agent || p.flags.tool !== void 0) return connectAgent(ctx, p);
+  return (await import("./machine-connect-RWNZ77NO.js")).connectMachine(ctx, p);
+}
+
+export {
+  resolveHost,
+  connectAgent,
+  connect
+};

package/dist/chunk-6UZBZ7LR.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+import {
+  claudeConfigDirs,
+  claudeLabel,
+  codexConfigDir,
+  codexLabel,
+  profileKeys
+} from "./chunk-M3PLXINO.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-BAB4DPCN.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  isTool
+} from "./chunk-2IMJECYD.js";
+import {
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  defaultHost,
+  loadToken
+} from "./chunk-4A5WOW2D.js";
+import {
+  hostFromEnv,
+  normalizeHost
+} from "./chunk-RE2EQZWL.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-DIW4VIU7.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  addCreated,
+  addHooks,
+  editJson,
+  enableFeatureHooks,
+  forgetCreated,
+  removeHooks,
+  restoreFeatureHooks,
+  wasCreated
+} from "./chunk-LHF4KCEA.js";
+import {
+  claudeConfigDirs,
+  codexConfigDir,
+  profileKeys
+} from "./chunk-M3PLXINO.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-IEYWMDXA.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+// package.json
+var package_default = {
+  name: "@hivefloor/cli",
+  version: "0.1.0",
+  description: "Connect your coding agents (Claude Code, Codex, Cursor, Gemini, Grok) to Hivefloor: live presence, task coordination and usage on one floor.",
+  keywords: [
+    "hivefloor",
+    "ai-agents",
+    "coding-agents",
+    "claude-code",
+    "codex",
+    "mcp",
+    "hooks",
+    "cli"
+  ],
+  homepage: "https://hivefloor.worldofz.info",
+  bugs: {
+    url: "https://github.com/Validate-QA/hivefloor/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Validate-QA/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-JCLWCMEM.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// src/hookclock.ts
+var HARD_EXIT_MS = 4e3;
+
+export {
+  HARD_EXIT_MS
+};

package/dist/chunk-K3NQKI34.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};