hive-intelligence 1.1.2 → 1.1.4

package/build/chunk-FRXMGRZQ.js

@@ -0,0 +1,102 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  REGISTRY_PACKAGE,
+  SERVER_VERSION
+} from "./chunk-ZCU7XQKF.js";
+import {
+  ensureConfigDir,
+  getConfigDir,
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-POT2MBEK.js";
+
+// src/cli/update-check.ts
+import { join } from "path";
+var CACHE_TTL_MS = 864e5;
+function getCachePath() {
+  return join(getConfigDir(), "cache", "update-check.json");
+}
+async function checkForUpdates() {
+  if (shouldSkipUpdateCheck(process.argv, process.env)) {
+    return;
+  }
+  const cached = readUpdateCache();
+  if (cached?.checkedAt) {
+    const age = Date.now() - new Date(cached.checkedAt).getTime();
+    if (age < CACHE_TTL_MS) {
+      if (cached.latestVersion && isNewerVersion(cached.latestVersion, SERVER_VERSION)) {
+        showUpdateMessage(cached.latestVersion);
+      }
+      return;
+    }
+  }
+  const latest = await fetchLatestVersion();
+  if (latest === null) return;
+  ensureConfigDir();
+  writeJsonFile(getCachePath(), {
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion: latest
+  });
+  if (isNewerVersion(latest, SERVER_VERSION)) showUpdateMessage(latest);
+}
+async function fetchLatestVersion(timeoutMs = 3e3) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(
+      `https://registry.npmjs.org/${REGISTRY_PACKAGE}/latest`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function readUpdateCache() {
+  return readJsonFile(getCachePath());
+}
+function getPendingUpdateVersion() {
+  const cached = readUpdateCache();
+  if (cached?.latestVersion && isNewerVersion(cached.latestVersion, SERVER_VERSION)) {
+    return cached.latestVersion;
+  }
+  return null;
+}
+function shouldSkipUpdateCheck(argv = process.argv, env = process.env) {
+  if (env.CI || env.HIVE_NO_UPDATE_CHECK) return true;
+  if (env.NODE_ENV === "test" || env.VITEST || env.VITEST_WORKER_ID) {
+    return true;
+  }
+  return argv.some((arg) => ["--help", "-h", "--version", "-V"].includes(arg));
+}
+function isNewerVersion(candidate, current) {
+  const parse = (version) => version.replace(/^[^\d]*/, "").split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+  const a = parse(candidate);
+  const b = parse(current);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] > b[i]) return true;
+    if (a[i] < b[i]) return false;
+  }
+  return false;
+}
+function showUpdateMessage(newVersion) {
+  process.stderr.write(
+    `
+Update available: ${SERVER_VERSION} \u2192 ${newVersion}
+  npm: npm update -g hive-intelligence
+  npx: npx -y -p hive-intelligence@latest hive
+
+`
+  );
+}
+
+export {
+  checkForUpdates,
+  fetchLatestVersion,
+  getPendingUpdateVersion,
+  shouldSkipUpdateCheck,
+  isNewerVersion
+};

package/build/chunk-GZPDEXO4.js

@@ -0,0 +1,126 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// src/cli/browser-auth.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { execFile } from "child_process";
+import { platform } from "os";
+function openBrowser(url) {
+  const plat = platform();
+  let cmd;
+  let args;
+  if (plat === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (plat === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  execFile(cmd, args, (err) => {
+    if (err) process.stderr.write(`
+Open this URL manually:
+  ${url}
+
+`);
+  });
+}
+async function browserLogin(opts) {
+  const baseUrl = opts.baseUrl || "https://hiveintelligence.xyz";
+  const timeout = opts.timeout || 3e5;
+  const state = randomBytes(16).toString("hex");
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const server = createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://localhost`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      if (settled) {
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+      const key = url.searchParams.get("key");
+      const email = url.searchParams.get("email");
+      const returnedState = url.searchParams.get("state");
+      if (returnedState !== state) {
+        res.writeHead(403);
+        res.end("State mismatch \u2014 possible CSRF attack. Please try again.");
+        return;
+      }
+      if (!key) {
+        res.writeHead(400);
+        res.end("Missing API key in callback");
+        return;
+      }
+      settled = true;
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`<!DOCTYPE html>
+<html>
+<head><title>Hive CLI \u2014 Authenticated</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
+  .card { text-align: center; padding: 2rem; }
+  h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+  p { color: #888; }
+</style>
+</head>
+<body>
+  <div class="card">
+    <h1>Authenticated</h1>
+    <p>You can close this tab and return to the terminal.</p>
+  </div>
+</body>
+</html>`);
+      clearTimeout(timer);
+      server.close();
+      resolve({ key, email: email || "", state: returnedState });
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+      const port = addr.port;
+      const loginUrl = new URL("/auth/cli", baseUrl);
+      loginUrl.searchParams.set("callback_port", String(port));
+      loginUrl.searchParams.set("state", state);
+      process.stderr.write(`
+Opening browser to sign in...
+`);
+      process.stderr.write(
+        `If the browser doesn't open, visit:
+  ${loginUrl.toString()}
+
+`
+      );
+      openBrowser(loginUrl.toString());
+    });
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      server.close();
+      reject(
+        new Error(
+          "Login timed out after 5 minutes. Run: hive auth login --manual"
+        )
+      );
+    }, timeout);
+    server.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+export {
+  browserLogin
+};

package/build/chunk-IZPAMRHP.js

@@ -0,0 +1,43 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  executeRemoteTool
+} from "./chunk-7JWXBKEJ.js";
+import {
+  trackCommand
+} from "./chunk-YZ2PXBJK.js";
+import {
+  debug,
+  shouldOutputJson,
+  writeOutput
+} from "./chunk-NP6NSOG2.js";
+
+// src/cli/execute.ts
+import ora from "ora";
+async function executeTool(toolName, args, timeoutMs = 3e4) {
+  debug(`Executing ${toolName} remotely`);
+  const showSpinner = !shouldOutputJson() && !!process.stderr.isTTY;
+  const spinner = showSpinner ? ora({ text: `Calling ${toolName}...`, stream: process.stderr }).start() : null;
+  const startMs = Date.now();
+  let response;
+  try {
+    response = await executeRemoteTool(toolName, args, timeoutMs);
+    spinner?.succeed(`${toolName} (${Date.now() - startMs}ms)`);
+  } catch (err) {
+    spinner?.fail(`${toolName} failed (${Date.now() - startMs}ms)`);
+    throw err;
+  }
+  trackCommand(
+    toolName,
+    Date.now() - startMs,
+    response.ok ? void 0 : response.error?.code
+  );
+  await writeOutput(response);
+  if (!response.ok) {
+    const exitCode = response.error?.code === "TOOL_NOT_FOUND" ? 3 : response.error?.code === "PROVIDER_UNAVAILABLE" ? 5 : response.error?.code === "RATE_LIMITED" ? 6 : response.error?.code === "TIMEOUT" ? 124 : 4;
+    process.exit(exitCode);
+  }
+}
+
+export {
+  executeTool
+};