hive-intelligence 1.1.4 → 1.3.0

package/build/chunk-QDZ7MAVN.js

@@ -0,0 +1,447 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  resolveApiUrl
+} from "./chunk-6PC3HUAK.js";
+
+// src/cli/config.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir, platform } from "os";
+import { dirname, join } from "path";
+import { spawnSync } from "child_process";
+var DEFAULT_URL = "https://mcp.hiveintelligence.xyz";
+var SERVER_NAME = "hive";
+function getServerUrl(override) {
+  return (override || resolveApiUrl() || DEFAULT_URL).replace(/\/+$/, "");
+}
+function configClaudeDesktop() {
+  const instructions = getClaudeDesktopInstructions();
+  console.log("\nConnect Hive in Claude Desktop:\n");
+  for (const [index, step] of instructions.steps.entries()) {
+    console.log(`${index + 1}. ${step}`);
+  }
+  console.log(
+    "\nClaude Desktop's claude_desktop_config.json is for local stdio servers; Hive's hosted URL must be added through the Connectors UI."
+  );
+}
+function getClaudeDesktopInstructions(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  return {
+    manual: true,
+    steps: [
+      "Open Settings > Connectors.",
+      'Choose "Add custom connector".',
+      `Enter ${url}/mcp.`,
+      "Sign in to Hive and approve the requested scopes."
+    ]
+  };
+}
+function configCursor() {
+  const url = getServerUrl();
+  const config = {
+    mcpServers: {
+      [SERVER_NAME]: {
+        url: `${url}/mcp`
+      }
+    }
+  };
+  console.log("\nAdd to .cursor/mcp.json:\n");
+  console.log(JSON.stringify(config, null, 2));
+}
+function configVscode() {
+  const instructions = getVscodeInstructions();
+  console.log("\nInstall Hive in your VS Code user profile:\n");
+  for (const [index, instruction] of instructions.steps.entries()) {
+    console.log(`${index + 1}. ${instruction}`);
+  }
+}
+function configClaudeCode() {
+  const url = getServerUrl();
+  console.log("\nRun this command:\n");
+  console.log(
+    `claude mcp add --transport http --scope user ${SERVER_NAME} ${url}/mcp`
+  );
+  console.log("\nClaude opens Hive browser authorization on first connect.");
+}
+function configCodex() {
+  const instructions = getCodexInstructions();
+  console.log("\nConnect Hive in Codex with native OAuth:\n");
+  for (const [index, step] of instructions.steps.entries()) {
+    console.log(`${index + 1}. ${step}`);
+  }
+}
+function configGrok() {
+  const instructions = getGrokInstructions();
+  console.log("\nConnect Hive in Grok:\n");
+  for (const [index, step] of instructions.steps.entries()) {
+    console.log(`${index + 1}. ${step}`);
+  }
+}
+function configHttpUrl(url) {
+  console.log(`
+Remote MCP server URL: ${url}/mcp`);
+  console.log("\nFor Claude Code:");
+  console.log(
+    `  claude mcp add --transport http --scope user ${SERVER_NAME} ${url}/mcp`
+  );
+  console.log("\nFor OAuth-capable MCP clients:");
+  console.log(
+    JSON.stringify(
+      {
+        [SERVER_NAME]: {
+          url: `${url}/mcp`
+        }
+      },
+      null,
+      2
+    )
+  );
+  console.log(
+    "\nHeadless fallback: send Authorization: Bearer $HIVE_API_KEY from secret storage."
+  );
+}
+function readJsonSafe(filePath) {
+  if (!existsSync(filePath)) return {};
+  const raw = readFileSync(filePath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Config file at ${filePath} contains invalid JSON. Fix it manually before running setup.`
+    );
+  }
+}
+function writeJsonSafe(filePath, data) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+  chmodSync(filePath, 384);
+}
+function getClaudeDesktopConfigPath() {
+  return platform() === "darwin" ? join(
+    homedir(),
+    "Library",
+    "Application Support",
+    "Claude",
+    "claude_desktop_config.json"
+  ) : platform() === "win32" ? join(
+    homedir(),
+    "AppData",
+    "Roaming",
+    "Claude",
+    "claude_desktop_config.json"
+  ) : join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+function getCursorConfigPath() {
+  return join(homedir(), ".cursor", "mcp.json");
+}
+function getVscodeConfigPath() {
+  return 'VS Code user profile ("MCP: Open User Configuration")';
+}
+function getWindsurfMcpConfigPath() {
+  return join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+}
+function getGeminiCliSettingsPath() {
+  return join(homedir(), ".gemini", "settings.json");
+}
+function getClaudeCodeUserConfigPath() {
+  return join(homedir(), ".claude.json");
+}
+function getCodexConfigPath() {
+  return join(homedir(), ".codex", "config.toml");
+}
+function writeClaudeDesktopConfig() {
+  return { path: getClaudeDesktopConfigPath(), written: false };
+}
+function writeCursorConfig(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  const p = getCursorConfigPath();
+  const existing = readJsonSafe(p);
+  const mcpServers = existing.mcpServers || {};
+  mcpServers[SERVER_NAME] = {
+    url: `${url}/mcp`
+  };
+  existing.mcpServers = mcpServers;
+  writeJsonSafe(p, existing);
+  return { path: p, written: true };
+}
+function vscodeServerDefinition(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  return { name: SERVER_NAME, type: "http", url: `${url}/mcp` };
+}
+function getVscodeInstallDeeplink(baseUrl) {
+  return `vscode:mcp/install?${encodeURIComponent(
+    JSON.stringify(vscodeServerDefinition(baseUrl))
+  )}`;
+}
+function getVscodeInstructions(baseUrl) {
+  const definition = JSON.stringify(vscodeServerDefinition(baseUrl));
+  return {
+    manual: true,
+    steps: [
+      `Open the one-click install link: ${getVscodeInstallDeeplink(baseUrl)}`,
+      `Or run: code --add-mcp '${definition}'`,
+      'If neither opens, run "MCP: Add Server" and choose Global in the VS Code Command Palette.',
+      "Review the server, start it, and complete Hive browser authorization."
+    ]
+  };
+}
+function writeVscodeConfig(baseUrl, runner = (command, args) => spawnSync(command, args, {
+  encoding: "utf8",
+  timeout: 1e4,
+  stdio: ["ignore", "pipe", "pipe"]
+})) {
+  const definition = JSON.stringify(vscodeServerDefinition(baseUrl));
+  const command = `code --add-mcp '${definition}'`;
+  const result = runner("code", ["--add-mcp", definition]);
+  const stderr = result.stderr?.toString().trim();
+  return {
+    path: getVscodeConfigPath(),
+    written: result.status === 0,
+    command,
+    deeplink: getVscodeInstallDeeplink(baseUrl),
+    ...result.status === 0 ? {} : {
+      error: stderr || result.error?.message || "VS Code CLI is unavailable or rejected the MCP definition."
+    }
+  };
+}
+function writeClaudeCodeConfig(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  return {
+    command: `claude mcp add --transport http --scope user ${SERVER_NAME} ${url}/mcp`
+  };
+}
+function codexCommands(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  return {
+    add: `codex mcp add ${SERVER_NAME} --url ${url}/mcp`,
+    login: `codex mcp login ${SERVER_NAME}`
+  };
+}
+function runCodexClientCommand(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: 3e5,
+    // stdout stays live for browser-login instructions. stderr is captured so
+    // an existing entry and unsupported CLI version are handled idempotently.
+    stdio: ["inherit", "inherit", "pipe"]
+  });
+  if (result.stderr) process.stderr.write(result.stderr);
+  return result;
+}
+function getCodexInstructions(baseUrl) {
+  const commands = codexCommands(baseUrl);
+  return {
+    manual: true,
+    steps: [
+      "If `codex mcp add --help` does not list `--url`, run `codex update`; if that command is unavailable, update Codex through its original installer or package manager. Confirm `--url` appears before continuing.",
+      `Run: ${commands.add}`,
+      `Run: ${commands.login}`,
+      "Complete Hive browser authorization and approve the requested scopes."
+    ]
+  };
+}
+function writeCodexConfig(baseUrl, runner = runCodexClientCommand) {
+  const url = getServerUrl(baseUrl);
+  const commands = codexCommands(baseUrl);
+  const addResult = runner("codex", [
+    "mcp",
+    "add",
+    SERVER_NAME,
+    "--url",
+    `${url}/mcp`
+  ]);
+  const addStderr = addResult.stderr?.toString().trim();
+  const written = addResult.status === 0 || Boolean(addStderr?.match(/already exists/i));
+  if (!written) {
+    const upgradeRequired = Boolean(
+      addStderr?.match(/unexpected argument.*--url|unrecognized.*--url/i)
+    );
+    return {
+      path: getCodexConfigPath(),
+      written: false,
+      authenticated: false,
+      commands,
+      error: (upgradeRequired ? "This Codex version cannot add remote HTTP MCP servers. Run `codex update`, or update Codex through its original installer or package manager if self-update is unavailable. Confirm `codex mcp add --help` lists `--url`, then retry." : addStderr) || addResult.error?.message || "Codex CLI is unavailable or rejected the MCP server."
+    };
+  }
+  const loginResult = runner("codex", ["mcp", "login", SERVER_NAME]);
+  const loginStderr = loginResult.stderr?.toString().trim();
+  const loginUpgradeRequired = Boolean(
+    loginStderr?.match(/unrecognized subcommand.*login|unexpected argument.*login/i)
+  );
+  return {
+    path: getCodexConfigPath(),
+    written: true,
+    authenticated: loginResult.status === 0,
+    commands,
+    ...loginResult.status === 0 ? {} : {
+      error: (loginUpgradeRequired ? "Hive was added, but this Codex version cannot run MCP OAuth login. Run `codex update`, or update Codex through its original installer or package manager if self-update is unavailable, then run `codex mcp login hive`." : loginStderr) || loginResult.error?.message || "Codex installed Hive but native OAuth login did not complete."
+    }
+  };
+}
+function writeClaudeCodeUserConfig(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  const p = getClaudeCodeUserConfigPath();
+  const existing = readJsonSafe(p);
+  const mcpServers = existing.mcpServers || {};
+  mcpServers[SERVER_NAME] = {
+    type: "http",
+    url: `${url}/mcp`
+  };
+  existing.mcpServers = mcpServers;
+  writeJsonSafe(p, existing);
+  return { path: p, written: true };
+}
+function writeWindsurfConfig(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  const p = getWindsurfMcpConfigPath();
+  const existing = readJsonSafe(p);
+  const mcpServers = existing.mcpServers || {};
+  mcpServers[SERVER_NAME] = {
+    serverUrl: `${url}/mcp`
+  };
+  existing.mcpServers = mcpServers;
+  writeJsonSafe(p, existing);
+  return { path: p, written: true };
+}
+function writeGeminiCliConfig(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  const p = getGeminiCliSettingsPath();
+  const existing = readJsonSafe(p);
+  const mcpServers = existing.mcpServers || {};
+  mcpServers[SERVER_NAME] = {
+    httpUrl: `${url}/mcp`
+  };
+  existing.mcpServers = mcpServers;
+  writeJsonSafe(p, existing);
+  return { path: p, written: true };
+}
+function printChatGptDesktopInstructions(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  return {
+    manual: true,
+    steps: [
+      "In ChatGPT, open Settings > Apps and enable Developer mode if your workspace requires it.",
+      "Choose Create app, enter the Hive MCP endpoint, then scan tools.",
+      `MCP endpoint: ${url}/mcp`,
+      "Complete the Hive OAuth sign-in and approve the requested MCP scopes.",
+      "For headless OpenAI API agents, use the Responses API remote MCP tool with HIVE_API_KEY kept server-side."
+    ]
+  };
+}
+function getGrokInstructions(baseUrl) {
+  const url = getServerUrl(baseUrl);
+  return {
+    manual: true,
+    steps: [
+      "Open https://grok.com/connectors.",
+      "Add a custom MCP connector named Hive.",
+      `Use the MCP endpoint ${url}/mcp.`,
+      "Complete Hive OAuth and approve the requested scopes."
+    ]
+  };
+}
+function removeServerEntry(filePath, serversKey) {
+  if (!existsSync(filePath)) return { removed: false, path: filePath };
+  const existing = readJsonSafe(filePath);
+  const servers = existing[serversKey] || {};
+  if (!(SERVER_NAME in servers)) return { removed: false, path: filePath };
+  delete servers[SERVER_NAME];
+  if (Object.keys(servers).length === 0) {
+    delete existing[serversKey];
+  } else {
+    existing[serversKey] = servers;
+  }
+  writeJsonSafe(filePath, existing);
+  return { removed: true, path: filePath };
+}
+function removeClaudeDesktopConfig() {
+  return {
+    ...removeServerEntry(getClaudeDesktopConfigPath(), "mcpServers"),
+    manual: true,
+    instructions: "Claude Settings \u2192 Connectors \u2192 Hive \u2192 Disconnect/Remove"
+  };
+}
+function removeCursorConfig() {
+  return removeServerEntry(getCursorConfigPath(), "mcpServers");
+}
+function removeVscodeConfig() {
+  return {
+    removed: false,
+    path: 'VS Code Command Palette \u2192 "MCP: List Servers" \u2192 Hive \u2192 Uninstall',
+    manual: true,
+    instructions: 'VS Code Command Palette \u2192 "MCP: List Servers" \u2192 Hive \u2192 Uninstall'
+  };
+}
+function removeClaudeCodeUserConfig() {
+  return removeServerEntry(getClaudeCodeUserConfigPath(), "mcpServers");
+}
+function removeCodexConfig(runner = (command, args) => spawnSync(command, args, {
+  encoding: "utf8",
+  timeout: 1e4,
+  stdio: ["ignore", "pipe", "pipe"]
+})) {
+  const path = getCodexConfigPath();
+  if (!existsSync(dirname(path))) return { removed: false, path };
+  const result = runner("codex", ["mcp", "remove", SERVER_NAME]);
+  if (result.status === 0) return { removed: true, path };
+  return {
+    removed: false,
+    path,
+    manual: true,
+    instructions: `Run: codex mcp remove ${SERVER_NAME}`
+  };
+}
+function removeWindsurfConfig() {
+  return removeServerEntry(getWindsurfMcpConfigPath(), "mcpServers");
+}
+function removeGeminiCliConfig() {
+  return removeServerEntry(getGeminiCliSettingsPath(), "mcpServers");
+}
+
+export {
+  configClaudeDesktop,
+  getClaudeDesktopInstructions,
+  configCursor,
+  configVscode,
+  configClaudeCode,
+  configCodex,
+  configGrok,
+  configHttpUrl,
+  getClaudeDesktopConfigPath,
+  getCursorConfigPath,
+  getVscodeConfigPath,
+  getWindsurfMcpConfigPath,
+  getGeminiCliSettingsPath,
+  getClaudeCodeUserConfigPath,
+  getCodexConfigPath,
+  writeClaudeDesktopConfig,
+  writeCursorConfig,
+  getVscodeInstallDeeplink,
+  getVscodeInstructions,
+  writeVscodeConfig,
+  writeClaudeCodeConfig,
+  getCodexInstructions,
+  writeCodexConfig,
+  writeClaudeCodeUserConfig,
+  writeWindsurfConfig,
+  writeGeminiCliConfig,
+  printChatGptDesktopInstructions,
+  getGrokInstructions,
+  removeClaudeDesktopConfig,
+  removeCursorConfig,
+  removeVscodeConfig,
+  removeClaudeCodeUserConfig,
+  removeCodexConfig,
+  removeWindsurfConfig,
+  removeGeminiCliConfig
+};

package/build/{chunk-ZTJVOWDQ.js → chunk-R6YZTFQL.js}

@@ -18,11 +18,13 @@ var ERROR_CODE_TO_EXIT = {
   TOOL_NOT_FOUND: ExitCode.TOOL_NOT_FOUND,
   API_ERROR: ExitCode.API_ERROR,
   PROVIDER_UNAVAILABLE: ExitCode.AUTH_FAILURE,
+  AUTH_REQUIRED: ExitCode.AUTH_FAILURE,
   RATE_LIMITED: ExitCode.RATE_LIMITED,
   TIMEOUT: ExitCode.TIMEOUT,
   VALIDATION_ERROR: ExitCode.INVALID_ARGS
 };
 var ERROR_DOC_URLS = {
+  AUTH_REQUIRED: "https://www.hiveintelligence.xyz/errors#auth-required",
   RATE_LIMITED: "https://www.hiveintelligence.xyz/errors#rate-limited",
   TIMEOUT: "https://www.hiveintelligence.xyz/errors#timeout",
   PROVIDER_UNAVAILABLE: "https://www.hiveintelligence.xyz/errors#provider-unavailable",

package/build/{chunk-YZ2PXBJK.js → chunk-RU6QOFHH.js}

@@ -1,12 +1,15 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  CLI_TELEMETRY_CONSENT_COPY
+} from "./chunk-EPF36Q3Z.js";
 import {
   SERVER_VERSION
-} from "./chunk-ZCU7XQKF.js";
+} from "./chunk-ZXKFJQDE.js";
 import {
   ensureConfigDir,
   getConfig,
   saveConfig
-} from "./chunk-POT2MBEK.js";
+} from "./chunk-6PC3HUAK.js";
 
 // src/cli/telemetry.ts
 import { platform, release } from "os";
@@ -19,13 +22,7 @@ function enableTelemetry() {
   const config = getConfig();
   config.telemetry = true;
   saveConfig(config);
-  process.stderr.write(
-    "Telemetry enabled. Thank you for helping improve Hive CLI.\n"
-  );
-  process.stderr.write(
-    "Only command names, duration, and error codes are collected.\n"
-  );
-  process.stderr.write("API keys, arguments, and data are never tracked.\n\n");
+  process.stderr.write(CLI_TELEMETRY_CONSENT_COPY);
 }
 function disableTelemetry() {
   ensureConfigDir();

package/build/{chunk-5XXI25JE.js → chunk-RUHO24SX.js}

@@ -5,7 +5,7 @@ import {
   getCredentials,
   saveConfig,
   saveCredentials
-} from "./chunk-POT2MBEK.js";
+} from "./chunk-6PC3HUAK.js";
 
 // src/cli/auth.ts
 import { createInterface } from "readline";
@@ -204,7 +204,7 @@ Profile "${profileName}" saved. Key: ${maskKey(apiKey)}
 Hive CLI \u2014 Login (profile: ${profileName})
 `);
   try {
-    const { browserLogin } = await import("./browser-auth-VPF5LZMZ.js");
+    const { browserLogin } = await import("./browser-auth-OJSUNFBI.js");
     const apiUrl = process.env.HIVE_API_URL || "https://mcp.hiveintelligence.xyz";
     const websiteUrl = process.env.HIVE_WEBSITE_URL || "https://hiveintelligence.xyz";
     const result = await browserLogin({ baseUrl: websiteUrl });
@@ -294,7 +294,7 @@ async function runSwitch(name) {
   }
 }
 async function runSignup(opts) {
-  const { authSignup } = await import("./api-client-EPF6FD7A.js");
+  const { authSignup } = await import("./api-client-FTVDFW5V.js");
   const profileName = opts.profile ?? "default";
   process.stderr.write(`
 Hive CLI \u2014 Signup (profile: ${profileName})
@@ -352,7 +352,7 @@ Account created but no API key was generated.
   }
 }
 async function runKeysList() {
-  const { listKeysApi } = await import("./api-client-EPF6FD7A.js");
+  const { listKeysApi } = await import("./api-client-FTVDFW5V.js");
   const creds = getCredentials();
   const config = getConfig();
   const jwt = creds.profiles[config.activeProfile]?.jwt;
@@ -391,7 +391,7 @@ async function runKeysList() {
   process.stderr.write("\n");
 }
 async function runKeysCreate(opts) {
-  const { createKey } = await import("./api-client-EPF6FD7A.js");
+  const { createKey } = await import("./api-client-FTVDFW5V.js");
   const creds = getCredentials();
   const config = getConfig();
   const jwt = creds.profiles[config.activeProfile]?.jwt;
@@ -424,7 +424,7 @@ API Key: ${data.key}
   );
 }
 async function runKeysRevoke(keyId) {
-  const { revokeKeyApi } = await import("./api-client-EPF6FD7A.js");
+  const { revokeKeyApi } = await import("./api-client-FTVDFW5V.js");
   const creds = getCredentials();
   const config = getConfig();
   const jwt = creds.profiles[config.activeProfile]?.jwt;
@@ -445,11 +445,18 @@ async function runKeysRevoke(keyId) {
   }
 }
 async function runUsage() {
-  const { getUsage } = await import("./api-client-EPF6FD7A.js");
+  const { getUsage } = await import("./api-client-FTVDFW5V.js");
   const result = await getUsage();
   if (!result.ok) {
-    process.stderr.write("Failed to fetch usage. Check your API key.\n");
-    process.exit(1);
+    const { outputError } = await import("./output-ITGLBKIG.js");
+    const { CliError, classifyError } = await import("./errors-HGHUF575.js");
+    const code = result.error?.code;
+    const err = code === "AUTH_REQUIRED" || code === "INVALID_TOKEN" ? new CliError(
+      "AUTH_REQUIRED",
+      code === "INVALID_TOKEN" ? "API key was rejected \u2014 usage requires a valid account key." : "No API key found \u2014 usage requires an account key.",
+      "Run: hive auth login (or set HIVE_API_KEY)"
+    ) : classifyError(result.error?.message ?? "Failed to fetch usage");
+    await outputError(err, {});
   }
   const data = result.data;
   const plan = data.plan;

package/build/{chunk-FH3YGSY5.js → chunk-TNQ7GJ6Q.js}

@@ -291,65 +291,6 @@ var NAMESPACE = [
       }
     ]
   },
-  {
-    name: "social",
-    description: "Social media analytics \u2014 sentiment, influencers, trending topics",
-    commands: [
-      {
-        name: "trending",
-        description: "Trending topics",
-        tool: "get_trending_topics"
-      },
-      {
-        name: "metrics",
-        description: "Topic engagement metrics",
-        tool: "get_topic_metrics",
-        args: {
-          topic: {
-            flag: "--topic <name>",
-            description: "Topic or coin name",
-            required: true
-          }
-        }
-      },
-      {
-        name: "creators",
-        description: "Top content creators",
-        tool: "get_topic_creators",
-        args: {
-          topic: {
-            flag: "--topic <name>",
-            description: "Topic or coin name",
-            required: true
-          }
-        }
-      },
-      {
-        name: "posts",
-        description: "Social media posts",
-        tool: "get_topic_posts",
-        args: {
-          topic: {
-            flag: "--topic <name>",
-            description: "Topic or coin name",
-            required: true
-          }
-        }
-      },
-      {
-        name: "news",
-        description: "Topic news articles",
-        tool: "get_topic_news",
-        args: {
-          topic: {
-            flag: "--topic <name>",
-            description: "Topic or coin name",
-            required: true
-          }
-        }
-      }
-    ]
-  },
   {
     name: "exchange",
     description: "Centralized exchange data \u2014 tickers, orderbooks, trades, funding",