@hivefloor/cli 0.0.0-stage → 0.1.0

package/dist/disconnect-NRYU6W5P.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import {
+  removeCliCopy,
+  removeMachineHooks
+} from "./chunk-DIW4VIU7.js";
+import {
+  claudeJson,
+  geminiSettings,
+  readManifest,
+  removeClaude,
+  removeCodex,
+  removeCursor,
+  removeGemini,
+  removeGrok,
+  removeRcLine,
+  updateManifest
+} from "./chunk-LHF4KCEA.js";
+import "./chunk-M3PLXINO.js";
+import {
+  readMachine,
+  removeMachineFile
+} from "./chunk-3IMV5EHP.js";
+import {
+  REAL_TOOLS,
+  TOOL_LABEL,
+  isTool
+} from "./chunk-2IMJECYD.js";
+import {
+  checkUnknownFlags,
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  deleteCredentials,
+  readCredentials,
+  uninstallService
+} from "./chunk-4A5WOW2D.js";
+import {
+  apiRequest
+} from "./chunk-PY74LT2W.js";
+import {
+  ConfigError,
+  machineSpoolFile,
+  manifestFile,
+  removeFile,
+  serviceLogFile,
+  serviceStateFile
+} from "./chunk-WNDUGQDX.js";
+import {
+  normalizeHost,
+  runCmd
+} from "./chunk-RE2EQZWL.js";
+import "./chunk-K3NQKI34.js";
+
+// src/disconnect.ts
+import fs from "fs";
+var DISCONNECT_FLAGS = /* @__PURE__ */ new Set(["tool", "host", "help", "h"]);
+async function disconnect(ctx, p) {
+  const unknown = checkUnknownFlags(p, DISCONNECT_FLAGS);
+  if (unknown) {
+    ctx.err(`hivefloor: unknown flag "--${unknown}". Run "hivefloor help".
+`);
+    return 2;
+  }
+  const toolFlag = flagStr(p, "tool");
+  if (toolFlag !== void 0 && (!isTool(toolFlag) || toolFlag === "other")) {
+    ctx.err(`hivefloor: unknown tool "${toolFlag}". Use one of: ${REAL_TOOLS.join(", ")}.
+`);
+    return 2;
+  }
+  const hostFlag = flagStr(p, "host");
+  const host = hostFlag ? normalizeHost(hostFlag) : void 0;
+  const tools = toolFlag ? [toolFlag] : REAL_TOOLS;
+  const manifest = readManifest();
+  const lines = [];
+  const warnings = [];
+  const machine = readMachine();
+  if (machine && !toolFlag) {
+    if (!machine.revoked) {
+      try {
+        const r = await apiRequest(ctx, machine.host, "/api/v1/machine/disconnect", { method: "POST", token: machine.token, body: {}, timeoutMs: 8e3 });
+        if (r.status >= 200 && r.status < 300) lines.push(`Machine ${machine.machine.name} removed on ${machine.host}`);
+        else if (r.status !== 401) warnings.push(`the server answered ${r.status}; remove the machine on its Machines page`);
+      } catch {
+        warnings.push(`could not reach ${machine.host}; remove the machine on its Machines page`);
+      }
+    }
+    if (machine.installed.service) {
+      await uninstallService(machine.installed.service, ctx.run ?? runCmd, typeof process.getuid === "function" ? process.getuid() : void 0);
+      lines.push(`Service removed (${machine.installed.service.file})`);
+    }
+    lines.push(...removeMachineHooks(machine.installed));
+    for (const f of [machineSpoolFile(), serviceStateFile(), serviceLogFile()]) removeFile(f);
+    removeCliCopy();
+    removeMachineFile();
+    lines.push("Machine token and state removed");
+  }
+  const keepHooks = machine !== void 0 && !machine.revoked && toolFlag !== void 0;
+  for (const tool of tools) {
+    const entry = manifest.tools[tool];
+    const viaCli = entry?.mcp === "cli";
+    const legacyBak = tool === "claude" ? fs.existsSync(claudeJson() + ".hivefloor.bak") : tool === "gemini" ? fs.existsSync(geminiSettings() + ".hivefloor.bak") : false;
+    const viaFile = entry ? entry.mcp === "file" : legacyBak;
+    let r;
+    try {
+      r = tool === "claude" ? await removeClaude(ctx, viaCli, keepHooks, viaFile) : tool === "codex" ? await removeCodex(ctx, viaCli, keepHooks) : tool === "cursor" ? await removeCursor() : tool === "gemini" ? await removeGemini(ctx, viaCli, viaFile) : await removeGrok(ctx, viaCli);
+    } catch (e) {
+      if (!(e instanceof ConfigError)) throw e;
+      warnings.push(e.message);
+      continue;
+    }
+    lines.push(...r.lines);
+    warnings.push(...r.warnings);
+    if (viaCli && r.lines.length === 0) warnings.push(`${TOOL_LABEL[tool]}: could not run its CLI to remove the "hivefloor" MCP server; remove it by hand`);
+  }
+  const n = await deleteCredentials(host, toolFlag);
+  if (n > 0) lines.push(`Removed ${n} stored token${n === 1 ? "" : "s"}`);
+  const left = Object.keys(readCredentials().hosts).length > 0;
+  if (!toolFlag || !left) {
+    const files = readManifest().rc;
+    for (const f of files) if (removeRcLine(f)) lines.push(`Shell: removed the token export from ${f}`);
+    updateManifest((m2) => m2.rc = []);
+  }
+  updateManifest((m2) => {
+    for (const t of tools) delete m2.tools[t];
+  });
+  const m = readManifest();
+  if (Object.keys(m.tools).length === 0 && m.rc.length === 0) removeFile(manifestFile());
+  if (lines.length === 0) ctx.out("Nothing to remove: no Hivefloor entries found.\n");
+  else {
+    ctx.out("Disconnected:\n");
+    for (const l of lines) ctx.out(`  ${l}
+`);
+  }
+  for (const w of warnings) ctx.out(`  note: ${w}
+`);
+  return 0;
+}
+export {
+  disconnect
+};

package/dist/hook-B2I42GE3.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import {
+  HARD_EXIT_MS
+} from "./chunk-JCLWCMEM.js";
+import {
+  appendToSpool,
+  releaseSpool,
+  takeSpool
+} from "./chunk-SGDM7MAT.js";
+import {
+  readMachine,
+  serviceAlive
+} from "./chunk-3IMV5EHP.js";
+import {
+  detectRepo
+} from "./chunk-OQ6QVFSH.js";
+import {
+  defaultHost,
+  loadToken
+} from "./chunk-4A5WOW2D.js";
+import {
+  configDir,
+  machineSpoolFile
+} from "./chunk-WNDUGQDX.js";
+import {
+  DEFAULT_HOST,
+  HOOK_BATCH_MAX,
+  PROFILE_KEY_RE,
+  hostFromEnv,
+  redact
+} from "./chunk-RE2EQZWL.js";
+import "./chunk-K3NQKI34.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", "idle_prompt"]);
+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;
+      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";
+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") {
+  try {
+    const res = await deps.fetch(`${host}${route}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({ events }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    await res.arrayBuffer().catch(() => void 0);
+    if (res.status >= 200 && res.status < 300) return "ok";
+    if (res.status === 429 || res.status >= 500) return "retry";
+    return "drop";
+  } catch {
+    return "retry";
+  }
+}
+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 = deps.env.HIVEFLOOR_TOKEN;
+  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 mapped = mapHookEvent(toolArg === "grok" ? "claude" : toolArg, native, input);
+  if (!mapped) return;
+  const nowMs = deps.now();
+  const event = { ...mapped, tool, client_at: new Date(nowMs).toISOString() };
+  if (grokId && isDuplicate(`${tool}|${event.session_id}|${event.event}|${event.subagent_id ?? ""}`, nowMs)) return;
+  const repo = await detectRepo(cwdOf(input) ?? 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 mevent = { ...event, profile };
+    if (serviceAlive(deps.now())) {
+      appendToSpool(mevent, machineSpoolFile());
+      return;
+    }
+    const claim2 = takeSpool(machineSpoolFile());
+    await sendBatches(deps, host, token, [...claim2?.events ?? [], mevent], startedAt, "/api/v1/machine/hooks", claim2, machineSpoolFile());
+    return;
+  }
+  const claim = takeSpool();
+  await sendBatches(deps, host, token, [...claim?.events ?? [], event], startedAt, "/api/v1/hooks", claim);
+}
+async function sendBatches(deps, host, token, pending, startedAt, route, claim, spool) {
+  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);
+    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

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  HARD_EXIT_MS
+} from "./chunk-JCLWCMEM.js";
+import "./chunk-K3NQKI34.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();
+  try {
+    const { runHookCli } = await import("./hook-B2I42GE3.js");
+    await runHookCli(argv.slice(1));
+  } catch {
+  }
+  process.exit(0);
+} else {
+  const { run } = await import("./cli-7CIYC6A3.js");
+  process.exitCode = await run(argv);
+}

package/dist/link-EPWADGYT.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import {
+  deviceLogin
+} from "./chunk-UPRHMVYJ.js";
+import {
+  resolveSession
+} from "./chunk-BAB4DPCN.js";
+import {
+  detectRepo
+} from "./chunk-OQ6QVFSH.js";
+import {
+  isTool
+} from "./chunk-2IMJECYD.js";
+import {
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  saveToken
+} from "./chunk-4A5WOW2D.js";
+import {
+  VERSION
+} from "./chunk-IEYWMDXA.js";
+import {
+  apiRequest,
+  errorOf
+} from "./chunk-PY74LT2W.js";
+import "./chunk-WNDUGQDX.js";
+import {
+  cliNpxCommand,
+  machineName
+} from "./chunk-RE2EQZWL.js";
+import "./chunk-K3NQKI34.js";
+
+// src/link.ts
+async function link(ctx, p) {
+  const repo = await detectRepo(ctx.cwd);
+  if (!repo) {
+    ctx.err("hivefloor: this directory has no git remote to link.\n");
+    return 1;
+  }
+  const s = await resolveSession(ctx, p);
+  if (!s) {
+    ctx.err(`hivefloor: not connected. Run: ${cliNpxCommand("connect")}
+`);
+    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 } };
+    const res = await apiRequest(ctx, s.host, "/api/v1/agent/link-repo", { token: s.token, body, headers: { "x-hf-repo": repo.remote } });
+    if (res.status >= 300) {
+      ctx.err(`hivefloor: ${errorOf(res).message}
+`);
+      return 1;
+    }
+    const status = res.json?.status;
+    ctx.out(`Linked ${repo.remote}${typeof status === "string" ? ` (${status})` : ""}.
+`);
+    return 0;
+  }
+  const toolFlag = flagStr(p, "tool");
+  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 } : {} }
+  };
+  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 });
+  ctx.out(`
+Linked ${repo.remote} to project ${result.project.name} (${result.project.key}) for ${result.agent.name}.
+`);
+  return 0;
+}
+export {
+  link
+};

package/dist/machine-connect-RWNZ77NO.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import {
+  resolveHost
+} from "./chunk-4OFN5KHY.js";
+import {
+  installCliCopy,
+  installMachineHooks
+} from "./chunk-DIW4VIU7.js";
+import "./chunk-LHF4KCEA.js";
+import {
+  claudeDirsOfScan,
+  cliVersionOs,
+  scanProcesses
+} from "./chunk-6UZBZ7LR.js";
+import {
+  codexConfigDir
+} from "./chunk-M3PLXINO.js";
+import {
+  readMachine,
+  secureWindowsMachine,
+  writeMachine
+} from "./chunk-3IMV5EHP.js";
+import {
+  deviceLogin
+} from "./chunk-UPRHMVYJ.js";
+import "./chunk-OQ6QVFSH.js";
+import {
+  findBin
+} from "./chunk-2IMJECYD.js";
+import {
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  installService,
+  windowsUser
+} from "./chunk-4A5WOW2D.js";
+import {
+  VERSION
+} from "./chunk-IEYWMDXA.js";
+import "./chunk-PY74LT2W.js";
+import {
+  cliEntry
+} from "./chunk-WNDUGQDX.js";
+import {
+  cliNpxCommand,
+  machineName,
+  machineTokenSuccessSchema,
+  normalizeHost,
+  runCmd
+} from "./chunk-RE2EQZWL.js";
+import "./chunk-K3NQKI34.js";
+
+// src/machine-connect.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function bundleDir(ctx) {
+  const fromEnv = ctx.env.HIVEFLOOR_CLI_SRC;
+  if (fromEnv) return fromEnv;
+  const entry = process.argv[1] ? fs.realpathSync(process.argv[1]) : fileURLToPath(import.meta.url);
+  return path.dirname(entry);
+}
+async function connectMachine(ctx, p) {
+  const host = resolveHost(p, ctx);
+  const name = (flagStr(p, "name") ?? machineName()).slice(0, 100);
+  const platform = ctx.platform ?? process.platform;
+  const run = ctx.run ?? runCmd;
+  const existing = readMachine();
+  if (existing && !existing.revoked && normalizeHost(existing.host) === host && !p.flags.yes && ctx.stdoutIsTTY) {
+    const a = (await ctx.ask(`This computer is already connected as "${existing.machine.name}". Connect it again (the old token stops working)? [y/N] `)).trim();
+    if (!/^y(es)?$/i.test(a)) return 0;
+  }
+  ctx.out(`Connecting this computer (${name}) to ${host}
+`);
+  const request = { client: { kind: "machine", tool: "other", machine: name, os: cliVersionOs(), cli_version: VERSION } };
+  const canOpen = !p.flags["no-open"] && (platform !== "linux" || Boolean(ctx.env.DISPLAY || ctx.env.WAYLAND_DISPLAY));
+  const result = await deviceLogin(ctx, { host, request, openBrowser: canOpen, parse: (j) => machineTokenSuccessSchema.parse(j) });
+  const lines = [];
+  const warnings = [];
+  const state = {
+    version: 1,
+    host,
+    machine: result.machine,
+    token: result.token,
+    connected_at: new Date(ctx.now()).toISOString(),
+    installed: { claude_dirs: [] }
+  };
+  writeMachine(state);
+  if (platform === "win32") await secureWindowsMachine(run, windowsUser(ctx.env));
+  const node = process.execPath;
+  try {
+    installCliCopy(bundleDir(ctx));
+  } catch (e) {
+    warnings.push(`${e.message}: hooks and the service were not installed. Run connect again from the published package.`);
+    writeMachine(state);
+    return finish(ctx, result.machine.name, result.projects.length, lines, warnings, 0, platform);
+  }
+  let processDirs = [];
+  try {
+    processDirs = claudeDirsOfScan(await scanProcesses({ platform, run, env: ctx.env }));
+  } catch {
+  }
+  const hooks = installMachineHooks(node, { processDirs, codex: Boolean(findBin("codex", ctx.env)) || fs.existsSync(codexConfigDir(ctx.env)), env: ctx.env });
+  lines.push(...hooks.lines);
+  warnings.push(...hooks.warnings);
+  state.installed.claude_dirs = hooks.claude_dirs;
+  if (hooks.codex_dir) {
+    state.installed.codex_dir = hooks.codex_dir;
+    warnings.push("Codex asks you to trust new hooks: run codex, open /hooks and approve the Hivefloor hooks once.");
+  }
+  writeMachine(state);
+  if (p.flags["no-service"]) {
+    lines.push(`Service: skipped (--no-service). Start it by hand with: ${cliNpxCommand("service run")}`);
+  } else {
+    const svc = await installService(platform, run, { node, script: cliEntry() }, typeof process.getuid === "function" ? process.getuid() : void 0, ctx.env);
+    lines.push(...svc.lines);
+    warnings.push(...svc.warnings);
+    if (svc.installed) state.installed.service = svc.installed;
+    writeMachine(state);
+  }
+  return finish(ctx, result.machine.name, result.projects.length, lines, warnings, 0, platform);
+}
+function finish(ctx, name, projects, lines, warnings, code, platform) {
+  ctx.out(`
+Connected as ${name}. It can reach ${projects} project${projects === 1 ? "" : "s"}.
+`);
+  ctx.out(platform === "win32" ? "Machine token stored in %APPDATA%\\hivefloor\\machine.json (user-only ACL).\n" : "Machine token stored in ~/.config/hivefloor/machine.json (mode 0600).\n");
+  for (const l of lines) ctx.out(`  ${l}
+`);
+  for (const w of warnings) ctx.out(`  note: ${w}
+`);
+  ctx.out("Your running agents appear on the Floor within a minute. See this machine at /machines.\n");
+  ctx.out(`Check it with: ${cliNpxCommand("status")}    Undo everything with: ${cliNpxCommand("disconnect")}
+`);
+  return code;
+}
+export {
+  connectMachine
+};