@hivefloor/cli 0.1.4 → 0.1.8

package/dist/hook-TPSHBCWU.js

@@ -0,0 +1,575 @@
+#!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
+import {
+  HARD_EXIT_MS,
+  PERMISSION_HARD_STOP_MS,
+  PERMISSION_WAIT_MS
+} from "./chunk-4G362W6G.js";
+import {
+  detectRepo
+} from "./chunk-BLLPDPTL.js";
+import {
+  envTokenForHost
+} from "./chunk-NMUH5NXN.js";
+import {
+  defaultHost,
+  loadToken
+} from "./chunk-QLMLB7RB.js";
+import "./chunk-QPAFN47B.js";
+import {
+  agentPidOf,
+  appendToSpool,
+  clientIdleSec,
+  contextEventName,
+  contextOutput,
+  findPane,
+  nudgesOf,
+  readSessions,
+  realProc,
+  releaseSpool,
+  senderName,
+  stashNudges,
+  takeDecision,
+  takeInbox,
+  takeSpool,
+  takeStashed,
+  updateSession,
+  validCwd,
+  validTranscript
+} from "./chunk-5OJUJCE3.js";
+import "./chunk-SBOEAOHD.js";
+import {
+  controlOn,
+  readControl
+} from "./chunk-KQMPCV57.js";
+import {
+  readMachine,
+  serviceAlive
+} from "./chunk-LX5A25O6.js";
+import {
+  runFile
+} from "./chunk-XAXKZ572.js";
+import {
+  configDir,
+  machineSpoolFile
+} from "./chunk-XPGL7VYE.js";
+import {
+  DEFAULT_HOST,
+  assertTokenTransport,
+  hostFromEnv
+} from "./chunk-QGULSOQ2.js";
+import {
+  CONTROL_REPLY_MAX,
+  HOOK_BATCH_MAX,
+  PROFILE_KEY_RE,
+  SESSION_ACCOUNT_RE,
+  machinePromptResponse,
+  redact
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
+
+// src/hook.ts
+import fs from "fs";
+
+// src/hookmap.ts
+var NAMES = {
+  sessionstart: "session_start",
+  sessionend: "session_end",
+  userpromptsubmit: "prompt",
+  beforesubmitprompt: "prompt",
+  stop: "stop",
+  afteragent: "stop",
+  notification: "waiting",
+  subagentstart: "subagent_start",
+  subagentstop: "subagent_stop",
+  pretooluse: "tool_agent_pre",
+  posttooluse: "tool_agent_post"
+};
+var WAITING_TYPES = /* @__PURE__ */ new Set(["permission_prompt"]);
+function endsWithQuestion(text) {
+  const t = str(text);
+  if (!t) return false;
+  const last = t.split(/\r?\n/).map((l) => l.trim()).filter((l) => l !== "" && !/^```/.test(l)).pop() ?? "";
+  return /\?[\s*_)"'`]*$/.test(last);
+}
+var LINE_MAX = 140;
+var str = (v) => typeof v === "string" && v.trim() !== "" ? v : void 0;
+var rec = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+function statusLine(text) {
+  const t = str(text);
+  if (!t) return void 0;
+  const first = t.split(/\r?\n/).map((l) => l.trim()).find((l) => l !== "");
+  if (!first) return void 0;
+  return redact(first).text.slice(0, LINE_MAX).trim() || void 0;
+}
+function oneLine(text) {
+  const t = str(text);
+  return t ? redact(t.replace(/\s+/g, " ").trim()).text.slice(0, LINE_MAX) : void 0;
+}
+function mapHookEvent(tool, native, input) {
+  const event = NAMES[native.toLowerCase()];
+  if (!event) return null;
+  const session_id = str(input.conversation_id) ?? str(input.session_id);
+  if (!session_id) return null;
+  const out = { tool, event, session_id };
+  const model = str(input.model) ?? str(input.subagent_model);
+  if (model) out.model = model;
+  switch (event) {
+    case "waiting": {
+      if (tool !== "claude" || !WAITING_TYPES.has(String(input.notification_type))) return null;
+      break;
+    }
+    case "subagent_start":
+    case "subagent_stop": {
+      const id = str(input.subagent_id) ?? str(input.agent_id);
+      if (!id) return null;
+      out.subagent_id = id;
+      const type = str(input.subagent_type) ?? str(input.agent_type);
+      if (type) out.subagent_type = type;
+      if (event === "subagent_start") {
+        const d = oneLine(input.description) ?? oneLine(input.task);
+        if (d) out.description = d;
+      } else {
+        const s = statusLine(input.last_assistant_message) ?? statusLine(input.summary);
+        if (s) out.status_line = s;
+      }
+      break;
+    }
+    case "tool_agent_pre":
+    case "tool_agent_post": {
+      if (input.tool_name !== "Agent" && input.tool_name !== "Task") return null;
+      const ti = rec(input.tool_input);
+      const type = str(ti.subagent_type);
+      if (type) out.subagent_type = type;
+      const d = oneLine(ti.description);
+      if (d) out.description = d;
+      break;
+    }
+    case "stop": {
+      const s = statusLine(input.last_assistant_message) ?? statusLine(input.prompt_response);
+      if (s) out.status_line = s;
+      if (endsWithQuestion(input.last_assistant_message ?? input.prompt_response)) out.asks = true;
+      break;
+    }
+    default:
+      break;
+  }
+  return out;
+}
+function cwdOf(input) {
+  const roots = Array.isArray(input.workspace_roots) ? input.workspace_roots : [];
+  return str(input.cwd) ?? str(roots[0]);
+}
+
+// src/hook.ts
+import path from "path";
+
+// src/service/control/hookside.ts
+import { randomBytes } from "crypto";
+var EVENTS = {
+  sessionstart: "SessionStart",
+  sessionend: "SessionEnd",
+  userpromptsubmit: "UserPromptSubmit",
+  pretooluse: "PreToolUse",
+  posttooluse: "PostToolUse",
+  stop: "Stop",
+  notification: "Notification",
+  permissionrequest: "PermissionRequest"
+};
+var INBOX_EVENTS = /* @__PURE__ */ new Set(["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse"]);
+var REPLY_WINDOW_MS = 30 * 6e4;
+var POLL_MS = 250;
+var TERMINAL_ACTIVE_SEC = 60;
+var str2 = (v) => typeof v === "string" && v !== "" ? v : void 0;
+var frameMessage = (from, text) => `Message from ${from} through HiveFloor: ${JSON.stringify(text)}`;
+async function controlHookStep(tool, native, input, deps) {
+  const out = { texts: [] };
+  try {
+    const ctl = (deps.readControl ?? readControl)();
+    const on = controlOn(ctl);
+    const sid = str2(input.session_id);
+    const ev = EVENTS[native.toLowerCase()];
+    if (!sid || !ev || ev === "PermissionRequest" || tool !== "claude" && tool !== "codex") return out;
+    const now = deps.now();
+    if (ev === "SessionEnd") {
+      updateSession(sid, now, () => void 0);
+      return out;
+    }
+    const before = readSessions(now)[sid];
+    const proc = deps.proc ?? realProc(deps.run ?? runFile);
+    const agent = !before?.pid || before.ended || ev === "SessionStart" ? await agentPidOf(proc, deps.pid, deps.ppid) : void 0;
+    const cwdRaw = cwdOf(input);
+    const cwd = validCwd(cwdRaw) ? cwdRaw : void 0;
+    const transcript = tool === "claude" && validTranscript(input.transcript_path) ? input.transcript_path : void 0;
+    const idleNote = ev === "Notification" && input.notification_type !== "permission_prompt";
+    let closed;
+    updateSession(sid, now, (e) => {
+      const next = { ...e ?? { tool, event: idleNote ? "Stop" : ev, at: deps.startedAt }, tool };
+      if (next.ended && !agent) {
+        delete next.pid;
+        delete next.start;
+      }
+      delete next.ended;
+      if (cwd) next.cwd = cwd;
+      if (transcript) next.transcript = transcript;
+      if (agent) {
+        next.pid = agent.pid;
+        next.start = agent.start;
+      }
+      if (!idleNote && deps.startedAt >= next.at) {
+        next.event = ev;
+        next.at = deps.startedAt;
+      }
+      if (on && next.prompt_id && ev !== "Notification") {
+        closed = next.prompt_id;
+        delete next.prompt_id;
+        delete next.prompt_at;
+      }
+      return next;
+    });
+    if (!on) return out;
+    if (closed) await deps.post(`/api/v1/machine/prompts/${encodeURIComponent(closed)}/close`, {}, 1500);
+    if (tool !== "claude") return out;
+    if (INBOX_EVENTS.has(ev)) out.texts = takeInbox(sid, now).map((m) => frameMessage(senderName(m.from), m.text));
+    if (ev === "Stop") {
+      const text = str2(input.last_assistant_message);
+      const after = readSessions(now)[sid]?.msg_at;
+      const allowed = ctl.config.replies === "always" || ctl.config.replies === "after_message" && after !== void 0 && now - after <= REPLY_WINDOW_MS;
+      if (text && allowed) out.reply = redact(text).text.slice(0, CONTROL_REPLY_MAX);
+    }
+  } catch {
+  }
+  return out;
+}
+var allow = JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } });
+var deny = (message) => JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "deny", ...message ? { message } : {} } } });
+function promptSummary(toolName, toolInput) {
+  let text = "";
+  try {
+    text = typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput) ?? "";
+  } catch {
+    text = "";
+  }
+  return `${toolName}: ${redact(text).text.slice(0, 300)}`.slice(0, 600);
+}
+async function permissionHook(input, deps) {
+  let timer;
+  const hard = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), PERMISSION_HARD_STOP_MS);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([permissionInner(input, deps), hard]);
+  } catch {
+    return void 0;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function permissionInner(input, deps) {
+  const ctl = (deps.readControl ?? readControl)();
+  const v = ctl.state === "ok" && ctl.config.enabled ? ctl.config.verbs : void 0;
+  if (!v || !v.approve && !v.deny) return void 0;
+  const sid = str2(input.session_id);
+  const toolName = str2(input.tool_name);
+  if (!sid || !toolName) return void 0;
+  const start = deps.now();
+  const run = deps.run ?? runFile;
+  const proc = deps.proc ?? realProc(run);
+  const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const promptId = randomBytes(16).toString("hex");
+  const agent = await agentPidOf(proc, deps.pid, deps.ppid);
+  updateSession(sid, start, (e) => ({
+    ...e ?? { tool: "claude", event: "PermissionRequest", at: deps.startedAt },
+    tool: "claude",
+    ...agent ? { pid: agent.pid, start: agent.start } : {},
+    event: "PermissionRequest",
+    at: Math.max(e?.at ?? 0, deps.startedAt),
+    prompt_id: promptId,
+    prompt_at: start
+  }));
+  const forget = () => updateSession(sid, deps.now(), (e) => {
+    if (!e || e.prompt_id !== promptId) return e;
+    const { prompt_id: _p, prompt_at: _a, ...rest } = e;
+    return rest;
+  });
+  const res = await deps.post("/api/v1/machine/prompts", { session_id: sid, prompt_id: promptId, tool_name: toolName, summary: promptSummary(toolName, input.tool_input) }, 3e3);
+  const hold = res && res.status >= 200 && res.status < 300 ? machinePromptResponse.safeParse(res.json) : void 0;
+  if (!hold?.success || !hold.data.hold) {
+    forget();
+    return void 0;
+  }
+  const pid = agent?.pid ?? readSessions(start)[sid]?.pid;
+  const pane = pid !== void 0 ? await findPane(run, proc, pid) : void 0;
+  const idle = pane ? await clientIdleSec(run, pane, deps.now()) : void 0;
+  if (idle !== void 0 && idle < TERMINAL_ACTIVE_SEC) {
+    await deps.post(`/api/v1/machine/prompts/${promptId}/close`, {}, 1500);
+    forget();
+    return void 0;
+  }
+  while (deps.now() - start < PERMISSION_WAIT_MS) {
+    const d = takeDecision(promptId);
+    if (d) {
+      forget();
+      return d.behavior === "allow" ? allow : deny(d.message);
+    }
+    await sleep(POLL_MS);
+  }
+  const last = takeDecision(promptId);
+  if (last) {
+    forget();
+    return last.behavior === "allow" ? allow : deny(last.message);
+  }
+  await deps.post(`/api/v1/machine/prompts/${promptId}/close`, {}, 1500);
+  forget();
+  return void 0;
+}
+
+// src/hook.ts
+var CONTROL_STEP_MS = 1500;
+var POST_TIMEOUT_MS = 2e3;
+var EXIT_MARGIN_MS = 400;
+var MIN_POST_MS = 250;
+var TOOLS = /* @__PURE__ */ new Set(["claude", "codex", "cursor", "gemini", "grok"]);
+var DEDUPE_WINDOW_MS = 2e3;
+function dedupeFile() {
+  return path.join(configDir(), "dedupe.json");
+}
+function isDuplicate(key, nowMs) {
+  let seen = {};
+  try {
+    seen = JSON.parse(fs.readFileSync(dedupeFile(), "utf8"));
+  } catch {
+  }
+  const fresh = Object.fromEntries(Object.entries(seen).filter(([, t]) => nowMs - t < 1e4));
+  const dup = key in fresh && nowMs - fresh[key] < DEDUPE_WINDOW_MS;
+  if (!dup) {
+    fresh[key] = nowMs;
+    try {
+      fs.mkdirSync(configDir(), { recursive: true, mode: 448 });
+      fs.writeFileSync(dedupeFile(), JSON.stringify(fresh), { mode: 384 });
+    } catch {
+    }
+  }
+  return dup;
+}
+async function post(deps, host, token, events, timeoutMs, route = "/api/v1/hooks", nudges) {
+  try {
+    assertTokenTransport(host);
+  } catch {
+    return "drop";
+  }
+  try {
+    const res = await deps.fetch(`${host}${route}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({ events }),
+      redirect: "error",
+      // a 3xx would send this bearer token to another URL
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const text = await res.text().catch(() => "");
+    if (res.status >= 200 && res.status < 300) {
+      if (nudges && text.includes('"nudges"')) {
+        try {
+          nudges.push(...nudgesOf(JSON.parse(text)));
+        } catch {
+        }
+      }
+      return "ok";
+    }
+    if (res.status === 429 || res.status >= 500) return "retry";
+    return "drop";
+  } catch {
+    return "retry";
+  }
+}
+function controlPost(deps, host, token) {
+  return async (route, body, timeoutMs) => {
+    try {
+      assertTokenTransport(host);
+      const res = await deps.fetch(`${host}${route}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify(body),
+        redirect: "error",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      const text = await res.text().catch(() => "");
+      let json;
+      try {
+        json = text ? JSON.parse(text) : void 0;
+      } catch {
+        json = void 0;
+      }
+      return { status: res.status, json };
+    } catch {
+      return void 0;
+    }
+  };
+}
+function controlDeps(deps, host, token, startedAt) {
+  return { now: deps.now, startedAt, pid: deps.pid ?? process.pid, ppid: deps.ppid ?? process.ppid, post: controlPost(deps, host, token), ...deps.control };
+}
+async function writeOut(deps, text) {
+  if (deps.write) {
+    deps.write(text);
+    return;
+  }
+  await new Promise((resolve) => {
+    const t = setTimeout(resolve, 500);
+    try {
+      process.stdout.write(`${text}
+`, () => {
+        clearTimeout(t);
+        resolve();
+      });
+    } catch {
+      clearTimeout(t);
+      resolve();
+    }
+  });
+}
+async function runHook(args, deps) {
+  try {
+    await runHookInner(args, deps, deps.now());
+  } catch {
+  }
+}
+function machineCoversTool(tool) {
+  const m = readMachine();
+  if (!m || m.revoked) return false;
+  if (tool === "claude") return m.installed.claude_dirs.length > 0;
+  if (tool === "codex") return m.installed.codex_dir !== void 0;
+  return false;
+}
+async function runHookInner(args, deps, startedAt) {
+  const [toolArg, native] = args;
+  if (!toolArg || !native || !TOOLS.has(toolArg)) return;
+  const pi = args.indexOf("--profile");
+  const profile = pi >= 0 ? args[pi + 1] : void 0;
+  const machine = profile !== void 0 ? readMachine() : void 0;
+  if (profile !== void 0 && (!machine || machine.revoked || !PROFILE_KEY_RE.test(profile))) return;
+  if (profile === void 0 && machineCoversTool(toolArg)) return;
+  const host = machine ? machine.host : deps.env.HIVEFLOOR_URL ? hostFromEnv(deps.env) : defaultHost() ?? DEFAULT_HOST;
+  const grokId = deps.env.GROK_SESSION_ID;
+  const tool = grokId ? "grok" : toolArg;
+  const envToken = machine ? void 0 : envTokenForHost(deps.env, host);
+  const stored = !machine && !envToken ? await loadToken(host, tool) : void 0;
+  const token = machine ? machine.token : envToken || stored?.token;
+  if (!token) return;
+  let input = {};
+  try {
+    const raw = await deps.readStdin();
+    const parsed = raw.trim() ? JSON.parse(raw) : {};
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) input = parsed;
+  } catch {
+    return;
+  }
+  if (grokId && !input.session_id && !input.conversation_id) input = { ...input, session_id: grokId };
+  const controlled = machine !== void 0 && profile !== void 0 && !grokId && (toolArg === "claude" || toolArg === "codex");
+  let ctl = { texts: [] };
+  if (controlled) {
+    const cd = controlDeps(deps, host, token, startedAt);
+    if (toolArg === "claude" && native.toLowerCase() === "permissionrequest") {
+      const out = await permissionHook(input, cd);
+      if (out) await writeOut(deps, out);
+      return;
+    }
+    ctl = await Promise.race([controlHookStep(toolArg, native, input, cd), new Promise((r) => setTimeout(() => r({ texts: [] }), CONTROL_STEP_MS).unref())]);
+  }
+  const mapped = mapHookEvent(toolArg === "grok" ? "claude" : toolArg, native, input);
+  if (!mapped) {
+    const name = contextEventName(toolArg, native);
+    if (name && ctl.texts.length > 0) await writeOut(deps, contextOutput(name, ctl.texts));
+    return;
+  }
+  const nowMs = deps.now();
+  const event = { ...mapped, tool, client_at: new Date(nowMs).toISOString() };
+  const contextName = grokId ? null : contextEventName(toolArg, native);
+  if (contextName) event.deliver = true;
+  if (ctl.reply && mapped.event === "stop") event.reply = ctl.reply;
+  const nudges = ctl.texts.map((text) => ({ session_id: event.session_id, text }));
+  const show = () => printNudges(deps, contextName, event.session_id, nudges, nowMs);
+  if (grokId && isDuplicate(`${tool}|${event.session_id}|${event.event}|${event.subagent_id ?? ""}`, nowMs)) return;
+  const reportedCwd = cwdOf(input);
+  if (validCwd(reportedCwd)) event.cwd = reportedCwd;
+  const repo = await detectRepo(reportedCwd ?? deps.cwd);
+  if (repo) event.repo = { remote: repo.remote, ...repo.branch ? { branch: repo.branch } : {}, ...repo.path ? { path: repo.path } : {} };
+  if (machine && profile !== void 0) {
+    const account = deps.env.FLEET_PROFILE?.trim();
+    const mevent = { ...event, profile, ...account && SESSION_ACCOUNT_RE.test(account) ? { account } : {} };
+    if (serviceAlive(deps.now())) {
+      appendToSpool(mevent, machineSpoolFile());
+      if (contextName) nudges.push(...takeStashed(event.session_id, nowMs).map((text) => ({ session_id: event.session_id, text })));
+      show();
+      return;
+    }
+    const claim2 = takeSpool(machineSpoolFile());
+    await sendBatches(deps, host, token, [...claim2?.events ?? [], mevent], startedAt, "/api/v1/machine/hooks", claim2, machineSpoolFile(), nudges);
+    show();
+    return;
+  }
+  const claim = takeSpool();
+  await sendBatches(deps, host, token, [...claim?.events ?? [], event], startedAt, "/api/v1/hooks", claim, void 0, nudges);
+  show();
+}
+function printNudges(deps, contextName, sessionId, nudges, nowMs) {
+  if (nudges.length === 0) return;
+  const mine = contextName ? nudges.filter((n) => n.session_id === sessionId) : [];
+  const others = nudges.filter((n) => !mine.includes(n));
+  if (others.length > 0) stashNudges(others, nowMs);
+  if (!contextName || mine.length === 0) return;
+  const out = contextOutput(contextName, mine.map((n) => n.text));
+  try {
+    (deps.write ?? ((t) => void process.stdout.write(`${t}
+`)))(out);
+  } catch {
+  }
+}
+async function sendBatches(deps, host, token, pending, startedAt, route, claim, spool, nudges) {
+  const batches = [];
+  for (let k = 0; k < pending.length; k += HOOK_BATCH_MAX) batches.push(pending.slice(k, k + HOOK_BATCH_MAX));
+  const unsent = [];
+  let down = false;
+  for (const batch of batches) {
+    const left = HARD_EXIT_MS - EXIT_MARGIN_MS - (deps.now() - startedAt);
+    if (down || left < MIN_POST_MS) {
+      unsent.push(...batch);
+      down = true;
+      continue;
+    }
+    const r = await post(deps, host, token, batch, Math.min(POST_TIMEOUT_MS, left), route, nudges);
+    if (r === "retry") {
+      unsent.push(...batch);
+      down = true;
+    }
+  }
+  releaseSpool(claim, unsent, spool);
+}
+async function readStdin(timeoutMs = 1e3) {
+  if (process.stdin.isTTY) return "";
+  return await new Promise((resolve) => {
+    const chunks = [];
+    const done = () => resolve(Buffer.concat(chunks).toString("utf8"));
+    const timer = setTimeout(done, timeoutMs);
+    process.stdin.on("data", (c) => chunks.push(c));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      done();
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      done();
+    });
+  });
+}
+function runHookCli(args) {
+  return runHook(args, { env: process.env, cwd: process.cwd(), fetch: (...a) => fetch(...a), now: () => Date.now(), readStdin });
+}
+export {
+  readStdin,
+  runHook,
+  runHookCli
+};

package/dist/index.js

@@ -1,22 +1,25 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
-  HARD_EXIT_MS
-} from "./chunk-JCLWCMEM.js";
-import "./chunk-K3NQKI34.js";
+  hardExitFor
+} from "./chunk-4G362W6G.js";
+import "./chunk-2ERPDCOT.js";
 
 // src/index.ts
 var argv = process.argv.slice(2);
 if (argv[0] === "hook") {
   process.on("uncaughtException", () => process.exit(0));
   process.on("unhandledRejection", () => process.exit(0));
-  setTimeout(() => process.exit(0), HARD_EXIT_MS).unref();
+  setTimeout(() => process.exit(0), hardExitFor(argv[2])).unref();
   try {
-    const { runHookCli } = await import("./hook-KR2HGVAR.js");
+    const { runHookCli } = await import("./hook-TPSHBCWU.js");
     await runHookCli(argv.slice(1));
   } catch {
   }
   process.exit(0);
 } else {
-  const { run } = await import("./cli-P3DYE5IR.js");
+  const { run } = await import("./cli-BFOJWJNG.js");
   process.exitCode = await run(argv);
+  if (argv[0] === "service") process.exit(process.exitCode);
 }

package/dist/{link-HXBMMSG3.js → link-EAS5F5PC.js}

@@ -1,38 +1,56 @@
 #!/usr/bin/env node
+import { createRequire as __hfCreateRequire } from 'node:module';
+const require = __hfCreateRequire(import.meta.url);
 import {
   deviceLogin
-} from "./chunk-R5KDI4WI.js";
+} from "./chunk-FPJNGKT5.js";
 import {
   detectRepo
-} from "./chunk-2BSA7LFD.js";
+} from "./chunk-BLLPDPTL.js";
 import {
   resolveSession
-} from "./chunk-7KF7IQJN.js";
+} from "./chunk-NMUH5NXN.js";
 import {
-  isTool
-} from "./chunk-2IMJECYD.js";
+  saveToken
+} from "./chunk-QLMLB7RB.js";
 import {
+  checkUnknownFlags,
   flagStr
-} from "./chunk-TKMIV7BG.js";
-import {
-  saveToken
-} from "./chunk-PDXYOREI.js";
+} from "./chunk-QPAFN47B.js";
 import {
   VERSION
-} from "./chunk-DNG5CRT3.js";
+} from "./chunk-K2IRTZH5.js";
 import {
   apiRequest,
   errorOf
-} from "./chunk-PY74LT2W.js";
-import "./chunk-VNCQFFQO.js";
+} from "./chunk-NRJONTFT.js";
+import "./chunk-XAXKZ572.js";
+import {
+  isTool
+} from "./chunk-XPGL7VYE.js";
 import {
-  cliNpxCommand,
   machineName
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
+} from "./chunk-QGULSOQ2.js";
+import {
+  cliNpxCommand
+} from "./chunk-HWBUESB4.js";
+import "./chunk-2ERPDCOT.js";
 
 // src/link.ts
+var LINK_FLAGS = /* @__PURE__ */ new Set(["project", "new", "path", "tool", "host", "no-open", "help", "h"]);
 async function link(ctx, p) {
+  const unknown = checkUnknownFlags(p, LINK_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
+  const project = flagStr(p, "project");
+  const newName = flagStr(p, "new");
+  if (project && newName) {
+    ctx.err("hivefloor: pass --project or --new, not both.\n");
+    return 2;
+  }
   const repo = await detectRepo(ctx.cwd);
   if (!repo) {
     ctx.err("hivefloor: this directory has no git remote to link.\n");
@@ -44,8 +62,6 @@ async function link(ctx, p) {
 `);
     return 1;
   }
-  const project = flagStr(p, "project");
-  const newName = flagStr(p, "new");
   const prefix = flagStr(p, "path") ?? repo.path;
   if (project || newName) {
     const body = { remote: repo.remote, ...prefix ? { path_prefix: prefix } : {}, ...project ? { project_id: project } : { new_project_name: newName } };
@@ -64,7 +80,7 @@ async function link(ctx, p) {
   const tool = toolFlag && isTool(toolFlag) ? toolFlag : isTool(s.tool) ? s.tool : "other";
   const request = {
     client: { tool, machine: machineName(), os: process.platform, cli_version: VERSION },
-    repo: { remote: repo.remote, ...repo.branch ? { branch: repo.branch } : {}, ...repo.path ? { path: repo.path } : {} }
+    repo: { remote: repo.remote, ...repo.branch ? { branch: repo.branch } : {}, ...prefix ? { path: prefix } : {} }
   };
   const result = await deviceLogin(ctx, { host: s.host, request, openBrowser: !p.flags["no-open"] });
   await saveToken(s.host, tool, result.token, { agent: result.agent, project: result.project });