@hivefloor/cli 0.0.0-stage → 0.1.0

package/dist/mcp-QX6VMTOD.js

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