hive-intelligence 1.1.4 → 1.4.0

package/build/init-all-RG542NWG.js

@@ -0,0 +1,427 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  detectClients,
+  installSkillsForClients
+} from "./chunk-AEU43ACS.js";
+import {
+  getClaudeDesktopInstructions,
+  getCodexInstructions,
+  getGrokInstructions,
+  getVscodeInstructions,
+  printChatGptDesktopInstructions,
+  writeClaudeCodeUserConfig,
+  writeClaudeDesktopConfig,
+  writeCodexConfig,
+  writeCursorConfig,
+  writeGeminiCliConfig,
+  writeVscodeConfig,
+  writeWindsurfConfig
+} from "./chunk-QDZ7MAVN.js";
+import {
+  browserLogin
+} from "./chunk-AQQAPAER.js";
+import {
+  saveProfile
+} from "./chunk-TVQJY47C.js";
+import {
+  detectInstallMode
+} from "./chunk-GHCYCBA3.js";
+import "./chunk-M6REON2I.js";
+import "./chunk-L326MQZP.js";
+import "./chunk-ZXKFJQDE.js";
+import {
+  bold,
+  dim,
+  green,
+  red,
+  yellow
+} from "./chunk-725R3KLJ.js";
+import {
+  resolveApiKey,
+  resolveApiUrl
+} from "./chunk-6PC3HUAK.js";
+import "./chunk-ILVPOLA7.js";
+
+// src/cli/init-all.ts
+import { fileURLToPath } from "url";
+var RESTART_HINTS = {
+  "claude-code": "Restart Claude Code (or run /mcp in an open session) to pick up the new server.",
+  "claude-desktop": "Quit and reopen Claude Desktop to pick up the new server.",
+  cursor: 'Reload the Cursor window (Cmd/Ctrl+Shift+P \u2192 "Reload Window") to pick up the new server.',
+  vscode: 'Reload the VS Code window (Cmd/Ctrl+Shift+P \u2192 "Reload Window") to pick up the new server.',
+  windsurf: "Restart Windsurf to pick up the new server.",
+  codex: "Start a new Codex CLI session to pick up the new server.",
+  "gemini-cli": "Start a new Gemini CLI session to pick up the new server."
+};
+function w(line) {
+  process.stderr.write(line + "\n");
+}
+function step(label) {
+  w(`
+${bold(label)}`);
+}
+function ok(line) {
+  w(`  ${green("\u2713")} ${line}`);
+}
+function bad(line) {
+  w(`  ${red("\u2717")} ${line}`);
+}
+function warn(line) {
+  w(`  ${yellow("!")} ${line}`);
+}
+function info(line) {
+  w(`  ${dim(line)}`);
+}
+function hiveCommandPrefix() {
+  let execPath = "";
+  try {
+    execPath = fileURLToPath(import.meta.url);
+  } catch {
+    execPath = process.argv[1] ?? "";
+  }
+  return detectInstallMode(execPath) === "npx" ? "npx -y -p hive-intelligence@latest " : "";
+}
+function writeForClient(client, apiUrlOverride) {
+  const base = {
+    client: client.id,
+    name: client.name
+  };
+  if (!client.programmable) {
+    if (client.id === "claude-desktop") {
+      const inst = getClaudeDesktopInstructions(apiUrlOverride);
+      return { ...base, ok: false, manual: true, steps: inst.steps };
+    }
+    if (client.id === "chatgpt-desktop") {
+      const inst = printChatGptDesktopInstructions(apiUrlOverride);
+      return { ...base, ok: false, manual: true, steps: inst.steps };
+    }
+    if (client.id === "grok") {
+      const inst = getGrokInstructions(apiUrlOverride);
+      return { ...base, ok: false, manual: true, steps: inst.steps };
+    }
+    return {
+      ...base,
+      ok: false,
+      manual: true,
+      error: client.hint || "Manual setup required"
+    };
+  }
+  try {
+    let result;
+    switch (client.id) {
+      case "claude-code":
+        result = writeClaudeCodeUserConfig(apiUrlOverride);
+        break;
+      case "claude-desktop":
+        result = writeClaudeDesktopConfig();
+        break;
+      case "codex": {
+        const codex = writeCodexConfig(apiUrlOverride);
+        if (!codex.written || !codex.authenticated) {
+          return {
+            ...base,
+            ok: false,
+            path: codex.path,
+            manual: true,
+            steps: getCodexInstructions(apiUrlOverride).steps,
+            error: codex.error || "Codex OAuth setup did not complete"
+          };
+        }
+        result = codex;
+        break;
+      }
+      case "cursor":
+        result = writeCursorConfig(apiUrlOverride);
+        break;
+      case "vscode":
+        result = writeVscodeConfig(apiUrlOverride);
+        if (!result.written) {
+          return {
+            ...base,
+            ok: false,
+            manual: true,
+            steps: getVscodeInstructions(apiUrlOverride).steps,
+            error: "VS Code CLI install did not complete"
+          };
+        }
+        break;
+      case "windsurf":
+        result = writeWindsurfConfig(apiUrlOverride);
+        break;
+      case "gemini-cli":
+        result = writeGeminiCliConfig(apiUrlOverride);
+        break;
+      case "chatgpt-desktop":
+        return {
+          ...base,
+          ok: false,
+          manual: true,
+          steps: printChatGptDesktopInstructions(apiUrlOverride).steps
+        };
+      case "grok":
+        return {
+          ...base,
+          ok: false,
+          manual: true,
+          steps: getGrokInstructions(apiUrlOverride).steps
+        };
+    }
+    return {
+      ...base,
+      ok: result.written,
+      path: result.path,
+      restartHint: result.written ? RESTART_HINTS[client.id] : void 0,
+      error: result.written ? void 0 : "Client configuration was not written"
+    };
+  } catch (err) {
+    return {
+      ...base,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function verifyConnection(apiUrlOverride) {
+  const apiUrl = (apiUrlOverride || resolveApiUrl()).replace(/\/+$/, "");
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15e3);
+    const res = await fetch(`${apiUrl}/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        // Streamable HTTP POSTs must accept both content types.
+        Accept: "application/json, text/event-stream"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "hive-init-verify",
+        method: "tools/call",
+        params: { name: "get_token_price", arguments: { token: "bitcoin" } }
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (res.status === 401) {
+      return {
+        ok: true,
+        detail: "Hosted MCP reachable \u2014 server answered with an auth challenge; finish sign-in inside each client."
+      };
+    }
+    if (!res.ok) {
+      return {
+        ok: false,
+        detail: `Hosted MCP endpoint returned HTTP ${res.status}`
+      };
+    }
+    const contentType = res.headers?.get?.("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      return { ok: true, detail: "Hosted MCP reachable (streaming reply)" };
+    }
+    const body = await res.json();
+    if (body?.jsonrpc !== "2.0") {
+      return {
+        ok: false,
+        detail: "Endpoint did not answer with an MCP JSON-RPC envelope"
+      };
+    }
+    if (body.error) {
+      const code = body.error.data?.code || "classified error";
+      return {
+        ok: true,
+        detail: `Hosted MCP reachable \u2014 server answered with a classified response (${code})`
+      };
+    }
+    return {
+      ok: true,
+      detail: "Hosted MCP reachable \u2014 anonymous hero call answered"
+    };
+  } catch {
+    return {
+      ok: false,
+      detail: "Network failure reaching the hosted MCP endpoint"
+    };
+  }
+}
+async function runInitAll(opts = {}) {
+  const summary = {
+    authenticated: false,
+    apiKeyPresent: Boolean(resolveApiKey()),
+    apiUrl: opts.apiUrl || resolveApiUrl(),
+    clients: [],
+    skills: [],
+    verified: null,
+    complete: false,
+    dryRun: Boolean(opts.dryRun)
+  };
+  if (!opts.json) {
+    w(bold("\nHive Intelligence \u2014 Init"));
+    if (summary.dryRun) info("(dry-run \u2014 nothing will be written)");
+  }
+  if (opts.browser) {
+    step("Authenticating via browser");
+    if (summary.dryRun) {
+      info("Would open browser sign-in at /auth/cli");
+      summary.authenticated = false;
+    } else {
+      try {
+        const result = await browserLogin({
+          baseUrl: process.env.HIVE_AUTH_BASE_URL || "https://hiveintelligence.xyz",
+          timeout: 3e5
+        });
+        saveProfile("default", result.key, summary.apiUrl);
+        summary.authenticated = true;
+        summary.apiKeyPresent = true;
+        ok(`Signed in as ${result.email || "(email unavailable)"}`);
+      } catch (err) {
+        bad(`Browser auth failed: ${err instanceof Error ? err.message : err}`);
+        if (!summary.apiKeyPresent) {
+          info("Client configs remain secret-free and will use native OAuth.");
+          warn(
+            "Run `hive auth login --manual` only if you also need the CLI API path."
+          );
+        }
+      }
+    }
+  } else if (!summary.apiKeyPresent) {
+    step("Authentication mode");
+    ok("Client configs will use native OAuth; no API key is required.");
+    info(
+      "For direct CLI or headless API calls, run `hive auth login` separately."
+    );
+  } else {
+    step("Authentication");
+    ok("Existing API key resolved (env or saved profile)");
+    summary.authenticated = true;
+  }
+  step("Detecting MCP-capable clients");
+  const detected = detectClients();
+  for (const c of detected) {
+    if (c.detected) {
+      ok(`${c.name} ${dim("(" + c.configPath + ")")}`);
+    } else if (c.id === "chatgpt-desktop" || c.id === "grok") {
+      continue;
+    } else if (!opts.all) {
+      continue;
+    } else {
+      info(`${c.name} \u2014 not detected (${c.hint || "skipped"})`);
+    }
+  }
+  const browserOnly = Boolean(opts.browser && !opts.all);
+  const targets = browserOnly ? [] : detected.filter((c) => c.detected);
+  step("Writing client configs");
+  for (const client of targets) {
+    if (summary.dryRun && client.programmable) {
+      info(`Would write ${client.configPath}`);
+      summary.clients.push({
+        client: client.id,
+        name: client.name,
+        ok: true,
+        path: client.configPath
+      });
+      continue;
+    }
+    const result = writeForClient(client, opts.apiUrl);
+    summary.clients.push(result);
+    if (result.ok && result.path) {
+      ok(`${result.name} ${dim("\u2192 " + result.path)}`);
+      if (result.restartHint) info(result.restartHint);
+    } else if (result.manual && result.steps) {
+      warn(`${result.name} \u2014 manual setup required:`);
+      for (const stepText of result.steps) info(`  \u2022 ${stepText}`);
+    } else {
+      bad(`${result.name} \u2014 ${result.error || "unknown error"}`);
+    }
+  }
+  for (const manualId of ["chatgpt-desktop", "grok"]) {
+    const client = detected.find((candidate) => candidate.id === manualId);
+    if (browserOnly || !client || summary.clients.some((entry) => entry.client === manualId)) {
+      continue;
+    }
+    const steps = manualId === "chatgpt-desktop" ? printChatGptDesktopInstructions(opts.apiUrl).steps : getGrokInstructions(opts.apiUrl).steps;
+    summary.clients.push({
+      client: manualId,
+      name: client.name,
+      ok: false,
+      manual: true,
+      steps
+    });
+    info(
+      `${client.name} \u2014 manual setup (${manualId === "grok" ? "grok.com/connectors" : "Settings \u2192 Apps"})`
+    );
+  }
+  if (!opts.skipSkills && !browserOnly) {
+    step("Installing skill packs");
+    if (summary.dryRun) {
+      info("Would copy agent-skills/packs/ into per-client skills dirs");
+    } else {
+      const skillTargets = targets.map((c) => c.id);
+      const skillResults = installSkillsForClients(skillTargets);
+      summary.skills = skillResults;
+      for (const r of skillResults) {
+        if (r.installed.length > 0) {
+          ok(
+            `${r.client}: ${r.installed.length} pack${r.installed.length === 1 ? "" : "s"} ${dim("\u2192 " + r.destination)}`
+          );
+        } else if (r.reason) {
+          info(`${r.client}: ${r.reason}`);
+        }
+      }
+    }
+  }
+  if (!opts.skipVerify && !summary.dryRun) {
+    step("Verifying hosted MCP endpoint (anonymous hero call)");
+    const verified = await verifyConnection(opts.apiUrl);
+    summary.verified = verified.ok;
+    if (verified.ok) {
+      ok(verified.detail);
+    } else {
+      warn(
+        `Could not verify (${verified.detail}) \u2014 run \`hive doctor\` for details (this can be a transient network issue)`
+      );
+    }
+  }
+  const programmableTargets = targets.filter((client) => client.programmable);
+  const programmableIds = new Set(
+    programmableTargets.map((client) => client.id)
+  );
+  const programmableResults = summary.clients.filter(
+    (client) => programmableIds.has(client.client)
+  );
+  const clientsComplete = browserOnly || targets.length > 0 && programmableResults.length === programmableTargets.length && programmableResults.every((client) => client.ok);
+  const skillsComplete = opts.skipSkills === true || browserOnly || summary.skills.every(
+    (result) => result.destination === null || result.installed.length > 0 && result.skipped.length === 0
+  );
+  const browserComplete = !opts.browser || summary.authenticated;
+  const verificationComplete = opts.skipVerify === true || summary.verified === true;
+  summary.complete = summary.dryRun || clientsComplete && skillsComplete && browserComplete && verificationComplete;
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+  } else {
+    w("");
+    if (!summary.complete) {
+      bad(
+        "Setup is incomplete; fix the failed steps above and re-run this command."
+      );
+    }
+    w(bold("Next steps"));
+    const hx = hiveCommandPrefix();
+    if (summary.apiKeyPresent) {
+      w(
+        dim("  Try a CLI query: ") + `${hx}hive market price --ids bitcoin --vs usd`
+      );
+    } else {
+      w(
+        dim("  In your AI client: ") + 'Ask "Use Hive to check USDT token risk."'
+      );
+      w(dim("  Optional CLI auth: ") + `${hx}hive auth login`);
+    }
+    w(dim("  Open dashboard: ") + `${hx}hive open dashboard`);
+    w(dim("  Health check:   ") + `${hx}hive doctor`);
+    w("");
+  }
+  return summary.complete ? 0 : 1;
+}
+export {
+  runInitAll
+};

package/build/mcpServer-D7OXUDU5.js

@@ -0,0 +1,34 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  HiveMCPServer,
+  ROOT_VISIBLE_TOOL_NAMES,
+  ROOT_VISIBLE_TOOL_ORDER,
+  buildServerInstructions,
+  createHiveMcpServer,
+  getSharedClients,
+  getToolsForScope,
+  memoizedJsonSchemaToZodInputSchema,
+  memoizedJsonSchemaToZodOutputSchema
+} from "./chunk-UFTNBCSA.js";
+import "./chunk-L326MQZP.js";
+import "./chunk-EPF36Q3Z.js";
+import {
+  PUBLIC_MCP_REGISTRY_ID,
+  SERVER_NAME,
+  SERVER_VERSION
+} from "./chunk-ZXKFJQDE.js";
+import "./chunk-ILVPOLA7.js";
+export {
+  HiveMCPServer,
+  PUBLIC_MCP_REGISTRY_ID,
+  ROOT_VISIBLE_TOOL_NAMES,
+  ROOT_VISIBLE_TOOL_ORDER,
+  SERVER_NAME,
+  SERVER_VERSION,
+  buildServerInstructions,
+  createHiveMcpServer,
+  getSharedClients,
+  getToolsForScope,
+  memoizedJsonSchemaToZodInputSchema,
+  memoizedJsonSchemaToZodOutputSchema
+};