@hivefloor/cli 0.0.0-stage → 0.1.1

package/dist/machine-connect-I3OZCTUZ.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import {
+  resolveHost
+} from "./chunk-76HDATOB.js";
+import {
+  installCliCopy,
+  installMachineHooks
+} from "./chunk-WHHV2NZA.js";
+import "./chunk-YCZ7XJJF.js";
+import {
+  claudeDirsOfScan,
+  cliVersionOs,
+  scanProcesses
+} from "./chunk-U7PMOZGI.js";
+import {
+  codexConfigDir
+} from "./chunk-NCRQGIJY.js";
+import {
+  readMachine,
+  secureWindowsMachine,
+  writeMachine
+} from "./chunk-3IMV5EHP.js";
+import {
+  deviceLogin
+} from "./chunk-WO7NALQO.js";
+import "./chunk-CWEEIRW2.js";
+import {
+  findBin
+} from "./chunk-2IMJECYD.js";
+import {
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  installService,
+  windowsUser
+} from "./chunk-Q2TS3GT3.js";
+import {
+  VERSION
+} from "./chunk-WLHRUZTR.js";
+import "./chunk-PY74LT2W.js";
+import {
+  cliEntry
+} from "./chunk-WNDUGQDX.js";
+import {
+  cliNpxCommand,
+  machineName,
+  machineTokenSuccessSchema,
+  normalizeHost,
+  runCmd
+} from "./chunk-ZYRPQPGL.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
+};

package/dist/mcp-47WTNQNN.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import {
+  resolveSession
+} from "./chunk-MMWX62ZU.js";
+import {
+  detectRepo
+} from "./chunk-CWEEIRW2.js";
+import {
+  toolFromEnv
+} from "./chunk-2IMJECYD.js";
+import {
+  flagStr
+} from "./chunk-TKMIV7BG.js";
+import {
+  loadToken
+} from "./chunk-Q2TS3GT3.js";
+import "./chunk-WNDUGQDX.js";
+import {
+  cliNpxCommand,
+  isSecureUrl,
+  normalizeHost
+} from "./chunk-ZYRPQPGL.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
+};