hive-intelligence 1.1.4 → 1.4.0

package/build/chunk-3OZFBWFK.js

@@ -0,0 +1,180 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  createToolNotFoundResult,
+  executeEndpoint,
+  getAllWrappedEndpoints,
+  getSharedClients,
+  getSupabaseAdmin,
+  resolveEndpoint,
+  secureLogger
+} from "./chunk-UFTNBCSA.js";
+
+// src/services/wallet-service.ts
+async function consumeCredits(args) {
+  const { userId, cost, idempotencyKey, requestId, keyId } = args;
+  const { data, error } = await getSupabaseAdmin().rpc("consume_credits", {
+    p_user_id: userId,
+    p_cost: cost,
+    p_idempotency_key: idempotencyKey,
+    p_request_id: requestId ?? null,
+    p_key_id: keyId ?? null
+  });
+  if (error) {
+    secureLogger.error("consume_credits RPC failed", error, { userId });
+    throw new Error(`consume_credits failed: ${error.message}`);
+  }
+  const row = Array.isArray(data) ? data[0] : data;
+  if (!row) {
+    throw new Error("consume_credits returned no row");
+  }
+  return {
+    code: row.code,
+    balance: row.balance ?? null,
+    monthlyGrant: row.monthly_grant ?? 0,
+    cycleEnd: row.cycle_end ?? null
+  };
+}
+async function ensureWallet(userId, planId) {
+  const { error } = await getSupabaseAdmin().rpc("ensure_wallet", {
+    p_user_id: userId,
+    p_plan_id: planId
+  });
+  if (error) {
+    secureLogger.error("ensure_wallet RPC failed", error, { userId });
+    throw new Error(`ensure_wallet failed: ${error.message}`);
+  }
+}
+async function getWalletStatus(userId) {
+  const { data, error } = await getSupabaseAdmin().rpc("read_wallet", {
+    p_user_id: userId
+  });
+  const row = Array.isArray(data) ? data[0] : data;
+  if (error || !row) {
+    secureLogger.warn("getWalletStatus returned no row", {
+      userId,
+      hasError: !!error,
+      errorCode: error?.code,
+      errorMessage: error?.message
+    });
+    return null;
+  }
+  return {
+    planId: row.plan_id,
+    balance: row.balance ?? null,
+    monthlyGrant: row.monthly_grant,
+    cycleStart: row.cycle_start,
+    cycleEnd: row.cycle_end,
+    updatedAt: row.updated_at
+  };
+}
+async function applyPlanChange(args) {
+  const { data, error } = await getSupabaseAdmin().rpc("apply_plan_change", {
+    p_event_id: args.eventId,
+    p_event_type: args.eventType,
+    p_user_id: args.userId,
+    p_new_plan_id: args.newPlanId ?? null,
+    p_grant_credits: args.grantCredits ?? false,
+    p_cycle_start: args.cycleStart ?? null,
+    p_cycle_end: args.cycleEnd ?? null,
+    p_billing_status: args.billingStatus ?? null,
+    p_customer_id: args.customerId ?? null,
+    p_subscription_id: args.subscriptionId ?? null,
+    p_subscription_status: args.subscriptionStatus ?? null,
+    p_price_id: args.priceId ?? null,
+    p_ledger_reason: args.ledgerReason ?? "plan_change",
+    p_term_end: args.termEnd ?? null
+  });
+  if (error) {
+    secureLogger.error("apply_plan_change RPC failed", error, {
+      userId: args.userId,
+      eventType: args.eventType
+    });
+    throw new Error(`apply_plan_change failed: ${error.message}`);
+  }
+  const row = Array.isArray(data) ? data[0] : data;
+  if (!row) {
+    throw new Error("apply_plan_change returned no row");
+  }
+  return {
+    outcome: String(row.outcome ?? "applied"),
+    replayed: Boolean(row.replayed),
+    planId: row.plan_id ?? null,
+    balance: row.balance ?? null,
+    billingStatus: row.billing_status ?? null
+  };
+}
+
+// src/services/tool-execution.ts
+async function executeToolByName(toolName, args, options) {
+  const allEndpoints = getAllWrappedEndpoints();
+  const lookup = resolveEndpoint(allEndpoints, toolName);
+  if (!lookup.ok) {
+    const result2 = createToolNotFoundResult(toolName);
+    secureLogger.toolCall(toolName, false, result2.durationMs, {
+      transport: "rest",
+      runtimeStatus: "failing",
+      errorClass: "not_found",
+      receiptId: result2.hive.receipt_id,
+      receiptVersion: result2.hive.receipt_version,
+      requestId: options?.requestId,
+      serverVersion: result2.hive.server_version,
+      buildSha: result2.hive.build_sha,
+      inputDigest: result2.hive.input_digest,
+      resultDigest: result2.hive.result_digest
+    });
+    return {
+      ok: false,
+      error: result2.error,
+      durationMs: result2.durationMs,
+      meta: result2.hive
+    };
+  }
+  const result = await executeEndpoint(lookup.endpoint, args, {
+    transport: "rest",
+    requestId: options?.requestId,
+    clients: getSharedClients(),
+    beforeExecution: options?.beforeExecution
+  });
+  if (result.validationErrors) {
+    return {
+      ok: false,
+      error: result.error,
+      validationErrors: result.validationErrors,
+      durationMs: result.durationMs,
+      meta: result.hive
+    };
+  }
+  if (result.ok) {
+    return {
+      ok: true,
+      data: result.data,
+      durationMs: result.durationMs,
+      meta: result.hive
+    };
+  }
+  if (result.error?.code === "PROVIDER_UNAVAILABLE") {
+    return {
+      ok: false,
+      error: result.error,
+      durationMs: result.durationMs,
+      meta: result.hive
+    };
+  }
+  if (result.error?.code === "INTERNAL_ERROR") {
+    secureLogger.error(`[tool-execution] ${toolName} threw`, result.error, {});
+  }
+  return {
+    ok: false,
+    error: result.error,
+    durationMs: result.durationMs,
+    meta: result.hive
+  };
+}
+
+export {
+  consumeCredits,
+  ensureWallet,
+  getWalletStatus,
+  applyPlanChange,
+  executeToolByName
+};

package/build/{chunk-POT2MBEK.js → chunk-6PC3HUAK.js}

@@ -1,7 +1,13 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
 // src/cli/config-dir.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
 import { join } from "path";
 import { homedir } from "os";
 var DEFAULT_CONFIG = {
@@ -24,9 +30,9 @@ function getConfigDir() {
 }
 function ensureConfigDir() {
   const dir = getConfigDir();
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
   const cacheDir = join(dir, "cache");
-  if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true });
+  if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true, mode: 448 });
 }
 function readJsonFile(filePath) {
   try {
@@ -41,6 +47,7 @@ function writeJsonFile(filePath, data) {
     encoding: "utf-8",
     mode: 384
   });
+  chmodSync(filePath, 384);
 }
 function getConfig() {
   const filePath = join(getConfigDir(), "config.json");

package/build/{chunk-NP6NSOG2.js → chunk-725R3KLJ.js}

@@ -149,7 +149,8 @@ function errorEnvelope(err, meta) {
     error: {
       code: err.code,
       message: err.message,
-      ...err.suggestion && { suggestion: err.suggestion }
+      ...err.suggestion && { suggestion: err.suggestion },
+      ...err.docUrl && { doc_url: err.docUrl }
     },
     meta
   };
@@ -201,12 +202,34 @@ async function writeOutput(envelope) {
     const provider = envelope.meta.provider ? dim(` (${envelope.meta.provider})`) : "";
     const timing = envelope.meta.duration_ms != null ? dim(` ${envelope.meta.duration_ms}ms`) : "";
     process.stderr.write(`${status}${provider}${timing}
-
 `);
+    const receipt = [
+      envelope.meta.provider ? `provider=${envelope.meta.provider}` : void 0,
+      envelope.meta.source ? `source=${envelope.meta.source}` : void 0,
+      envelope.meta.origin_source ? `origin=${envelope.meta.origin_source}` : void 0,
+      envelope.meta.runtime_status ? `runtime=${envelope.meta.runtime_status}` : void 0,
+      envelope.meta.fetched_at ? `fetched=${envelope.meta.fetched_at}` : void 0,
+      envelope.meta.observed_at ? `observed=${envelope.meta.observed_at}` : void 0,
+      envelope.meta.cache_age_ms != null ? `cache_age_ms=${envelope.meta.cache_age_ms}` : void 0,
+      envelope.meta.cache_status ? `cache=${envelope.meta.cache_status}` : void 0,
+      envelope.meta.receipt_id ? `receipt=${envelope.meta.receipt_id}` : void 0
+    ].filter((value) => Boolean(value));
+    if (receipt.length > 0) {
+      process.stderr.write(dim(`Evidence: ${receipt.join(" \xB7 ")}
+`));
+    }
+    if (envelope.meta.truncated) {
+      process.stderr.write(yellow("Evidence warning: response was truncated.\n"));
+    }
+    for (const warning of envelope.meta.warnings ?? []) {
+      process.stderr.write(yellow(`Evidence warning: ${warning}
+`));
+    }
+    process.stderr.write("\n");
   }
   if (envelope.ok && envelope.data != null) {
     if (Array.isArray(envelope.data) && envelope.data.length > 0 && typeof envelope.data[0] === "object" && envelope.data[0] !== null) {
-      const { formatTable } = await import("./format-5X2HIVDT.js");
+      const { formatTable } = await import("./format-H7FOQSYY.js");
       process.stdout.write(
         formatTable(envelope.data) + "\n"
       );

package/build/chunk-7DYHWY4Y.js

@@ -0,0 +1,125 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  executeRemoteTool
+} from "./chunk-P7NLFSZQ.js";
+import {
+  trackCommand
+} from "./chunk-RU6QOFHH.js";
+import {
+  debug,
+  dim,
+  shouldOutputJson,
+  writeOutput
+} from "./chunk-725R3KLJ.js";
+import {
+  resolveApiKey
+} from "./chunk-6PC3HUAK.js";
+
+// src/cli/execute.ts
+import ora from "ora";
+
+// src/cli/keyless-heroes.ts
+var CHAIN_ID_TO_NAME = {
+  "1": "ethereum",
+  "10": "optimism",
+  "56": "bsc",
+  "137": "polygon",
+  "8453": "base",
+  "42161": "arbitrum",
+  "43114": "avalanche"
+};
+var ALCHEMY_NETWORK_TO_CHAIN = {
+  "eth-mainnet": "ethereum",
+  "opt-mainnet": "optimism",
+  "bnb-mainnet": "bsc",
+  "polygon-mainnet": "polygon",
+  "base-mainnet": "base",
+  "arb-mainnet": "arbitrum",
+  "avax-mainnet": "avalanche"
+};
+function firstListEntry(value) {
+  if (typeof value !== "string") return null;
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length === 1 ? parts[0] : null;
+}
+function remapForKeylessHero(toolName, args) {
+  if (toolName === "get_price") {
+    const token = firstListEntry(args.ids);
+    if (!token) return null;
+    const vsCurrency = firstListEntry(args.vs_currencies) ?? "usd";
+    return {
+      tool: "get_token_price",
+      args: { token, vs_currency: vsCurrency },
+      note: "no API key \u2014 routed through the keyless get_token_price hero"
+    };
+  }
+  if (toolName === "get_token_security") {
+    const address = firstListEntry(args.contract_addresses);
+    if (!address) return null;
+    const chainId = typeof args.chain_id === "string" || typeof args.chain_id === "number" ? String(args.chain_id) : null;
+    const chain = chainId ? CHAIN_ID_TO_NAME[chainId] ?? chainId : void 0;
+    return {
+      tool: "check_token_safety",
+      args: chain ? { address, chain } : { address },
+      note: "no API key \u2014 routed through the keyless check_token_safety hero"
+    };
+  }
+  if (toolName === "alchemy_get_tokens_by_wallet") {
+    const address = typeof args.address === "string" && args.address.trim() ? args.address.trim() : null;
+    if (!address) return null;
+    const network = typeof args.network === "string" ? args.network.trim() : null;
+    const chain = network ? ALCHEMY_NETWORK_TO_CHAIN[network] : void 0;
+    return {
+      tool: "get_wallet_portfolio",
+      args: chain ? { address, chain } : { address },
+      note: "no API key \u2014 routed through the keyless get_wallet_portfolio hero"
+    };
+  }
+  return null;
+}
+
+// src/cli/execute.ts
+async function executeTool(toolName, args, timeoutMs = 3e4) {
+  if (!resolveApiKey()) {
+    const remap = remapForKeylessHero(toolName, args);
+    if (remap) {
+      debug(remap.note);
+      toolName = remap.tool;
+      args = remap.args;
+    }
+  }
+  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);
+  const quotaRemaining = response.meta?.quota_remaining;
+  if (typeof quotaRemaining === "number" && !resolveApiKey() && !shouldOutputJson()) {
+    process.stderr.write(
+      dim(
+        `${quotaRemaining} free call${quotaRemaining === 1 ? "" : "s"} left today \u2014 run \`hive auth login\` for a full key.`
+      ) + "\n"
+    );
+  }
+  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
+};

package/build/{chunk-ZXB53E7H.js → chunk-AEU43ACS.js}

@@ -1,12 +1,13 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
   getClaudeDesktopConfigPath,
+  getCodexConfigPath,
   getCursorConfigPath,
   getVscodeConfigPath
-} from "./chunk-4F5CI6LX.js";
+} from "./chunk-QDZ7MAVN.js";
 import {
   HIVE_AGENT_SKILLS
-} from "./chunk-VBOKVQ74.js";
+} from "./chunk-L326MQZP.js";
 
 // src/cli/detect-clients.ts
 import { existsSync } from "fs";
@@ -24,6 +25,9 @@ function getGeminiCliConfigPath() {
 function detectClaudeCode() {
   return existsSync(getClaudeCodeConfigPath()) || existsSync(join(homedir(), ".claude"));
 }
+function detectCodex() {
+  return existsSync(join(homedir(), ".codex"));
+}
 function detectClaudeDesktop() {
   const configPath = getClaudeDesktopConfigPath();
   if (existsSync(configPath)) return true;
@@ -61,6 +65,7 @@ function detectGeminiCli() {
 function detectClients() {
   const claudeCode = detectClaudeCode();
   const claudeDesktop = detectClaudeDesktop();
+  const codex = detectCodex();
   const cursor = detectCursor();
   const vscode = detectVscode();
   const windsurf = detectWindsurf();
@@ -79,8 +84,16 @@ function detectClients() {
       name: "Claude Desktop",
       configPath: getClaudeDesktopConfigPath(),
       detected: claudeDesktop,
+      programmable: false,
+      hint: claudeDesktop ? "Add the hosted endpoint in Settings > Connectors; the local config file is stdio-only" : "Claude Desktop application directory not found"
+    },
+    {
+      id: "codex",
+      name: "OpenAI Codex",
+      configPath: getCodexConfigPath(),
+      detected: codex,
       programmable: true,
-      hint: claudeDesktop ? void 0 : "Claude Desktop application directory not found"
+      hint: codex ? "Hive will use the official Codex MCP CLI and native OAuth login" : "~/.codex not found"
     },
     {
       id: "cursor",
@@ -96,7 +109,7 @@ function detectClients() {
       configPath: getVscodeConfigPath(),
       detected: vscode,
       programmable: true,
-      hint: vscode ? void 0 : "VS Code user data dir not found"
+      hint: vscode ? "Hive will use the official code --add-mcp user-profile installer" : "VS Code user data dir not found"
     },
     {
       id: "windsurf",
@@ -121,7 +134,15 @@ function detectClients() {
       detected: false,
       // No reliable filesystem signal — always print instructions
       programmable: false,
-      hint: "Direct ChatGPT app connectors are auth-dependent; use OpenAI Responses API or an OAuth-compatible proxy."
+      hint: "Create the Hive app manually in ChatGPT Settings > Apps, then complete OAuth."
+    },
+    {
+      id: "grok",
+      name: "Grok",
+      configPath: "https://grok.com/connectors",
+      detected: false,
+      programmable: false,
+      hint: "Add Hive manually at grok.com/connectors, then complete OAuth."
     }
   ];
 }
@@ -143,17 +164,20 @@ function getClientSkillsDir(client) {
   switch (client) {
     case "claude-code":
       return join2(homedir2(), ".claude", "skills");
+    case "codex":
+      return join2(homedir2(), ".codex", "skills");
     case "cursor":
       return join2(homedir2(), ".cursor", "skills");
     case "vscode":
-      return null;
+      return join2(homedir2(), ".copilot", "skills");
     case "windsurf":
       return null;
     case "gemini-cli":
-      return null;
+      return join2(homedir2(), ".gemini", "skills");
     case "claude-desktop":
       return join2(homedir2(), ".claude", "skills");
     case "chatgpt-desktop":
+    case "grok":
       return null;
   }
 }

package/build/chunk-AQQAPAER.js

@@ -0,0 +1,197 @@
+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";
+var CLI_EXCHANGE_PATH = "/auth/cli/exchange";
+var CLI_LOGIN_PATH = "/auth/cli";
+var CLI_CALLBACK_PATH = "/callback";
+function parseCliCallback(rawUrl, expectedState) {
+  const url = new URL(rawUrl, "http://localhost");
+  if (url.pathname !== CLI_CALLBACK_PATH) return { kind: "ignore" };
+  const returnedState = url.searchParams.get("state");
+  if (returnedState !== expectedState) return { kind: "state-mismatch" };
+  if (url.searchParams.get("key")) return { kind: "legacy-key" };
+  const code = url.searchParams.get("code");
+  if (!code) return { kind: "missing-code" };
+  return { kind: "code", code, state: returnedState };
+}
+function buildCliLoginUrl(baseUrl, port, state) {
+  const loginUrl = new URL(CLI_LOGIN_PATH, baseUrl);
+  loginUrl.searchParams.set("callback_port", String(port));
+  loginUrl.searchParams.set("state", state);
+  return loginUrl;
+}
+async function exchangeCliCode(args) {
+  const exchangeUrl = new URL(CLI_EXCHANGE_PATH, args.baseUrl);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const response = await fetch(exchangeUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code: args.code, state: args.state }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`CLI auth exchange failed with HTTP ${response.status}`);
+    }
+    const payload = await response.json();
+    const key = typeof payload.key === "string" ? payload.key : typeof payload.api_key?.key === "string" ? payload.api_key.key : "";
+    if (!key) throw new Error("CLI auth exchange returned no API key.");
+    return {
+      key,
+      email: typeof payload.email === "string" ? payload.email : ""
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+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(async (req, res) => {
+      const outcome = parseCliCallback(req.url || "/", state);
+      if (outcome.kind === "ignore") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      if (settled) {
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+      if (outcome.kind === "state-mismatch") {
+        res.writeHead(403);
+        res.end("State mismatch \u2014 possible CSRF attack. Please try again.");
+        return;
+      }
+      if (outcome.kind === "legacy-key") {
+        res.writeHead(400);
+        res.end(
+          "Insecure legacy callback rejected. Please update Hive auth and try again."
+        );
+        return;
+      }
+      if (outcome.kind === "missing-code") {
+        res.writeHead(400);
+        res.end("Missing one-time code in callback");
+        return;
+      }
+      settled = true;
+      let exchanged;
+      try {
+        exchanged = await exchangeCliCode({
+          baseUrl,
+          code: outcome.code,
+          state: outcome.state
+        });
+      } catch (error) {
+        clearTimeout(timer);
+        server.close();
+        res.writeHead(502);
+        res.end("Could not complete CLI auth exchange. Return to the terminal.");
+        reject(error);
+        return;
+      }
+      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: exchanged.key,
+        email: exchanged.email,
+        state: outcome.state
+      });
+    });
+    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 = buildCliLoginUrl(baseUrl, port, 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 {
+  CLI_EXCHANGE_PATH,
+  CLI_LOGIN_PATH,
+  CLI_CALLBACK_PATH,
+  parseCliCallback,
+  buildCliLoginUrl,
+  exchangeCliCode,
+  browserLogin
+};