@hivefloor/cli 0.1.4 → 0.1.8

package/dist/hook-KR2HGVAR.js

@@ -1,301 +0,0 @@
-#!/usr/bin/env node
-import {
-  HARD_EXIT_MS
-} from "./chunk-JCLWCMEM.js";
-import {
-  detectRepo
-} from "./chunk-2BSA7LFD.js";
-import {
-  defaultHost,
-  loadToken
-} from "./chunk-PDXYOREI.js";
-import {
-  appendToSpool,
-  contextEventName,
-  contextOutput,
-  nudgesOf,
-  releaseSpool,
-  stashNudges,
-  takeSpool,
-  takeStashed
-} from "./chunk-O2TC3WSS.js";
-import {
-  readMachine,
-  serviceAlive
-} from "./chunk-T7TG6WA4.js";
-import {
-  configDir,
-  machineSpoolFile
-} from "./chunk-VNCQFFQO.js";
-import {
-  DEFAULT_HOST,
-  HOOK_BATCH_MAX,
-  PROFILE_KEY_RE,
-  SESSION_ACCOUNT_RE,
-  hostFromEnv,
-  redact
-} from "./chunk-ZC2DAKB5.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", nudges) {
-  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)
-    });
-    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";
-  }
-}
-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() };
-  const contextName = grokId ? null : contextEventName(toolArg, native);
-  if (contextName) event.deliver = true;
-  const nudges = [];
-  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 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 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/mcp-N2TMD4GR.js

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-import {
-  detectRepo
-} from "./chunk-2BSA7LFD.js";
-import {
-  resolveSession
-} from "./chunk-7KF7IQJN.js";
-import {
-  toolFromEnv
-} from "./chunk-2IMJECYD.js";
-import {
-  flagStr
-} from "./chunk-TKMIV7BG.js";
-import {
-  loadToken
-} from "./chunk-PDXYOREI.js";
-import "./chunk-VNCQFFQO.js";
-import {
-  cliNpxCommand,
-  isSecureUrl,
-  normalizeHost
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
-
-// src/mcp.ts
-import os from "os";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-async function contextHeaders(ctx, token, toolName) {
-  const h = { Authorization: `Bearer ${token}`, "X-HF-Tool": ctx.env.HIVEFLOOR_TOOL || toolFromEnv(ctx.env) || toolName, "X-HF-Machine": os.hostname().split(".")[0] ?? "machine" };
-  const session = ctx.env.HIVEFLOOR_SESSION || ctx.env.CLAUDE_SESSION_ID || ctx.env.GROK_SESSION_ID || ctx.env.CODEX_SESSION_ID;
-  if (session) h["X-HF-Session"] = session;
-  const model = ctx.env.HIVEFLOOR_MODEL || ctx.env.ANTHROPIC_MODEL;
-  if (model) h["X-HF-Model"] = model;
-  const repo = await detectRepo(ctx.cwd);
-  if (repo) {
-    h["X-HF-Repo"] = repo.remote;
-    if (repo.branch) h["X-HF-Branch"] = repo.branch;
-    if (repo.path) h["X-HF-Path"] = repo.path;
-  }
-  return h;
-}
-var isRequest = (m) => "method" in m && "id" in m;
-function mcpTargetUrl(flagUrl, host) {
-  if (!flagUrl) return new URL(`${host}/mcp`);
-  let u;
-  try {
-    u = new URL(flagUrl);
-  } catch {
-    throw new Error("--url is not a URL");
-  }
-  if (!isSecureUrl(u)) throw new Error(`--url must be https (http is only allowed on localhost): ${u.origin}`);
-  return u;
-}
-async function runMcpProxy(ctx, p, io = { stdin: process.stdin, stdout: process.stdout }) {
-  const s = await resolveSession(ctx, p);
-  if (!s) {
-    ctx.err(`hivefloor: not connected. Run: ${cliNpxCommand("connect")}
-`);
-    return 1;
-  }
-  let url;
-  try {
-    url = mcpTargetUrl(flagStr(p, "url"), s.host);
-  } catch (e) {
-    ctx.err(`hivefloor mcp: ${e.message}
-`);
-    return 1;
-  }
-  let token = s.token;
-  let tool = s.tool;
-  if (url.origin !== new URL(s.host).origin) {
-    const other = await loadToken(normalizeHost(url.origin));
-    if (!other) {
-      ctx.err(`hivefloor mcp: refusing to send the token of ${s.host} to ${url.origin}; connect to that host first
-`);
-      return 1;
-    }
-    token = other.token;
-    tool = other.tool;
-  }
-  const headers = await contextHeaders(ctx, token, tool);
-  const upstream = new StreamableHTTPClientTransport(url, { requestInit: { headers } });
-  const downstream = new StdioServerTransport(io.stdin, io.stdout);
-  return await new Promise((resolve) => {
-    let closing = false;
-    const finish = (code) => {
-      if (closing) return;
-      closing = true;
-      void Promise.allSettled([upstream.close(), downstream.close()]).then(() => resolve(code));
-    };
-    downstream.onmessage = (msg) => {
-      upstream.send(msg).catch((e) => {
-        if (isRequest(msg)) void downstream.send({ jsonrpc: "2.0", id: msg.id, error: { code: -32e3, message: `Hivefloor is not reachable: ${e.message}` } });
-      });
-    };
-    upstream.onmessage = (msg) => {
-      const result = msg.result;
-      if (result && typeof result.protocolVersion === "string") upstream.setProtocolVersion?.(result.protocolVersion);
-      void downstream.send(msg);
-    };
-    upstream.onerror = (e) => ctx.err(`hivefloor mcp: ${e.message}
-`);
-    downstream.onerror = (e) => ctx.err(`hivefloor mcp: ${e.message}
-`);
-    downstream.onclose = () => finish(0);
-    io.stdin.once("end", () => finish(0));
-    io.stdin.once("close", () => finish(0));
-    upstream.onclose = () => finish(0);
-    upstream.start().then(() => downstream.start()).catch((e) => {
-      ctx.err(`hivefloor mcp: ${e.message}
-`);
-      finish(1);
-    });
-  });
-}
-export {
-  contextHeaders,
-  mcpTargetUrl,
-  runMcpProxy
-};

package/dist/token-JDRLEV5D.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import {
-  resolveSession
-} from "./chunk-7KF7IQJN.js";
-import "./chunk-2IMJECYD.js";
-import "./chunk-TKMIV7BG.js";
-import "./chunk-PDXYOREI.js";
-import "./chunk-VNCQFFQO.js";
-import {
-  cliNpxCommand
-} from "./chunk-ZC2DAKB5.js";
-import "./chunk-K3NQKI34.js";
-
-// src/token.ts
-async function token(ctx, p) {
-  const s = await resolveSession(ctx, p);
-  if (!s) {
-    ctx.err(`hivefloor: no token stored. Run: ${cliNpxCommand("connect")}
-`);
-    return 1;
-  }
-  if (ctx.stdoutIsTTY && !p.flags.reveal) {
-    ctx.err("hivefloor: refusing to print the token to a terminal. Use it in a pipe or $(...), or pass --reveal.\n");
-    return 1;
-  }
-  ctx.out(`${s.token}
-`);
-  return 0;
-}
-export {
-  token
-};