@openhoo/hoopilot 0.7.0 → 0.7.2

package/dist/cli.js

@@ -1,11 +1,21 @@
 #!/usr/bin/env bun
+import {
+  main
+} from "./chunk-TEDEVCKM.js";
 
 // src/cli.ts
 import { spawn } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/auth-store.ts
 import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
+var StoredCopilotAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoredCopilotAuthError";
+  }
+};
 function authStorePath(env = process.env) {
   if (env.HOOPILOT_AUTH_FILE) {
     return env.HOOPILOT_AUTH_FILE;
@@ -14,25 +24,38 @@ function authStorePath(env = process.env) {
   return join(base, "hoopilot", "auth.json");
 }
 function readStoredCopilotAuth(path = authStorePath()) {
+  let text;
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
-    if (!parsed || typeof parsed !== "object") {
-      return void 0;
-    }
-    const token = typeof parsed.token === "string" ? parsed.token.trim() : "";
-    if (!token) {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
       return void 0;
     }
-    return {
-      apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : void 0,
-      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : void 0,
-      githubDomain: typeof parsed.githubDomain === "string" ? parsed.githubDomain : void 0,
-      source: typeof parsed.source === "string" ? parsed.source : void 0,
-      token
-    };
+    throw new StoredCopilotAuthError(`Could not read Hoopilot auth file at ${path}.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
   } catch {
-    return void 0;
+    throw new StoredCopilotAuthError(
+      `Hoopilot auth file at ${path} is not valid JSON. Run \`hoopilot login\` to replace it.`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} must contain a JSON object.`);
   }
+  const record = parsed;
+  const token = typeof record.token === "string" ? record.token.trim() : "";
+  if (!token) {
+    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} does not contain a token.`);
+  }
+  return {
+    apiBaseUrl: typeof record.apiBaseUrl === "string" ? record.apiBaseUrl : void 0,
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : void 0,
+    githubDomain: typeof record.githubDomain === "string" ? record.githubDomain : void 0,
+    source: typeof record.source === "string" ? record.source : void 0,
+    token
+  };
 }
 function writeStoredCopilotAuth(auth, path = authStorePath()) {
   mkdirSync(dirname(path), { recursive: true });
@@ -58,6 +81,18 @@ function writeStoredCopilotAuth(auth, path = authStorePath()) {
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
+function isHttpsOrLoopbackUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return false;
+  }
+  if (url.protocol === "https:") {
+    return true;
+  }
+  return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1" || url.hostname === "[::1]");
+}
 async function truncatedResponseText(response, max = 500) {
   const text = await response.text();
   return text.slice(0, max);
@@ -90,7 +125,15 @@ var CopilotAuth = class {
     if (this.#cachedAccess && this.#cachedAccess.expiresAtMs - REFRESH_SKEW_MS > Date.now()) {
       return this.#cachedAccess;
     }
-    const stored = readStoredCopilotAuth(this.#authStorePath);
+    let stored;
+    try {
+      stored = readStoredCopilotAuth(this.#authStorePath);
+    } catch (error) {
+      if (error instanceof StoredCopilotAuthError) {
+        throw new CopilotAuthError(error.message);
+      }
+      throw error;
+    }
     if (stored) {
       return this.#cacheAccess({
         apiBaseUrl: trimTrailingSlash(stored.apiBaseUrl ?? this.#copilotApiBaseUrl),
@@ -149,7 +192,7 @@ var CopilotClient = class {
    * accepted directly here — no Copilot token exchange is required to read quota.
    */
   async usage(signal) {
-    if (!isHttpsOrLoopback(this.#githubApiBaseUrl)) {
+    if (!isHttpsOrLoopbackUrl(this.#githubApiBaseUrl)) {
       throw new Error(
         `Refusing to send the GitHub OAuth token to a non-HTTPS host: ${this.#githubApiBaseUrl}`
       );
@@ -193,6 +236,11 @@ var CopilotClient = class {
   }
   async fetchCopilot(path, init) {
     const access = await this.#auth.getAccess();
+    if (!isHttpsOrLoopbackUrl(access.apiBaseUrl)) {
+      throw new Error(
+        `Refusing to send the GitHub OAuth token to a non-HTTPS host: ${access.apiBaseUrl}`
+      );
+    }
     const headers = applyCopilotHeaders(new Headers(init.headers), access.token);
     return this.#fetch(`${access.apiBaseUrl}${path}`, {
       ...init,
@@ -248,18 +296,6 @@ function usedFrom(entitlement, remaining) {
   }
   return Math.max(0, entitlement - remaining);
 }
-function isHttpsOrLoopback(rawUrl) {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    return false;
-  }
-  if (url.protocol === "https:") {
-    return true;
-  }
-  return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1");
-}
 function numberOrUndefined(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -560,6 +596,51 @@ function chatCompletionToCompletion(completion) {
     usage: completion.usage
   });
 }
+function completionStreamFromChatStream(chatStream) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let sawDone = false;
+  return new ReadableStream({
+    async start(controller) {
+      const enqueue = (data) => {
+        controller.enqueue(encoder.encode(encodeDataSse(data)));
+      };
+      const reader = chatStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          buffer += decoder.decode(result.value, { stream: true });
+          const lines = buffer.split(/\r?\n/);
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            processCompletionSseLine(line, enqueue, () => {
+              sawDone = true;
+            });
+          }
+        }
+        if (buffer) {
+          processCompletionSseLine(buffer, enqueue, () => {
+            sawDone = true;
+          });
+        }
+        if (!sawDone) {
+          enqueue("[DONE]");
+        }
+        controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  });
+}
 function normalizeModelsResponse(upstream) {
   const record = asRecord(upstream);
   const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
@@ -650,6 +731,66 @@ function firstChoice(completion) {
   const choices = Array.isArray(completion.choices) ? completion.choices : [];
   return asRecord(choices[0]);
 }
+function processCompletionSseLine(line, enqueue, markDone) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) {
+    return;
+  }
+  const data = trimmed.slice("data:".length).trim();
+  if (!data) {
+    return;
+  }
+  if (data === "[DONE]") {
+    markDone();
+    enqueue("[DONE]");
+    return;
+  }
+  const parsed = parseJson(data);
+  if (!parsed) {
+    return;
+  }
+  const choice = firstChoice(parsed);
+  const delta = asRecord(choice.delta);
+  const text = contentToText(delta.content);
+  const finishReason = choice.finish_reason ?? null;
+  const usage = asRecord(parsed.usage);
+  const hasUsage = Object.keys(usage).length > 0;
+  if (!text && finishReason === null && !hasUsage) {
+    return;
+  }
+  enqueue(
+    removeUndefined({
+      choices: text || finishReason !== null ? [
+        {
+          finish_reason: finishReason,
+          index: typeof choice.index === "number" ? choice.index : 0,
+          logprobs: null,
+          text
+        }
+      ] : [],
+      created: typeof parsed.created === "number" ? parsed.created : epochSeconds(),
+      id: contentToText(parsed.id) || `cmpl_${randomId()}`,
+      model: contentToText(parsed.model) || DEFAULT_MODEL,
+      object: "text_completion",
+      usage: hasUsage ? usage : void 0
+    })
+  );
+}
+function encodeDataSse(data) {
+  if (data === "[DONE]") {
+    return "data: [DONE]\n\n";
+  }
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function parseJson(data) {
+  try {
+    return asRecord(JSON.parse(data));
+  } catch {
+    return void 0;
+  }
+}
 function removeUndefined(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
 }
@@ -1029,6 +1170,7 @@ function formatNumber(value) {
 // src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
+var FORBIDDEN_BROWSER_ORIGIN_MESSAGE = "Browser-origin requests require HOOPILOT_API_KEY unless the Origin is loopback.";
 var INVALID_JSON_MESSAGE = "Request body must be valid JSON.";
 var USAGE_CACHE_TTL_MS = 6e4;
 function createHoopilotHandler(options = {}) {
@@ -1059,6 +1201,14 @@ function createHoopilotHandler(options = {}) {
       route,
       startedAt
     });
+    const browserOrigin = forbiddenBrowserOrigin(request, apiKey);
+    if (browserOrigin) {
+      requestLogger.warn(
+        { event: "http.request.forbidden_origin", origin: browserOrigin },
+        "blocked unauthenticated browser-origin request"
+      );
+      return finish(jsonError(403, "forbidden_origin", FORBIDDEN_BROWSER_ORIGIN_MESSAGE));
+    }
     if (request.method === "OPTIONS") {
       return finish(new Response(null, { headers: corsHeaders() }));
     }
@@ -1110,6 +1260,7 @@ function createHoopilotHandler(options = {}) {
           { err: errorDetails(error), event: "http.request.failed" },
           "request body was invalid json"
         );
+        return finish(jsonError(400, "invalid_request_error", message));
       } else {
         requestLogger.error(
           { err: errorDetails(error), event: "http.request.failed" },
@@ -1122,7 +1273,7 @@ function createHoopilotHandler(options = {}) {
 }
 function startHoopilotServer(options = {}) {
   const host = options.host ?? options.env?.HOST ?? DEFAULT_HOST;
-  const port = Number(options.port ?? options.env?.PORT ?? DEFAULT_PORT);
+  const port = normalizeServerPort(options.port ?? options.env?.PORT ?? DEFAULT_PORT);
   const apiKey = options.apiKey ?? options.env?.HOOPILOT_API_KEY;
   const allowUnauthenticated = options.allowUnauthenticated ?? options.env?.HOOPILOT_ALLOW_UNAUTHENTICATED === "1";
   if (!isLoopbackHost(host) && !apiKey && !allowUnauthenticated) {
@@ -1188,8 +1339,19 @@ async function handleCompletions(client, metrics, recordTokens, request, logger)
   }
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(body.model);
-  if (isStreamingResponse(upstream)) {
-    return proxyResponse(observeResponseUsage(upstream, model, recordTokens, request.signal));
+  if (isStreamingResponse(upstream) && upstream.body) {
+    return proxyResponse(
+      observeResponseUsage(
+        new Response(completionStreamFromChatStream(upstream.body), {
+          headers: upstream.headers,
+          status: upstream.status,
+          statusText: upstream.statusText
+        }),
+        model,
+        recordTokens,
+        request.signal
+      )
+    );
   }
   const completion = asRecord(await upstream.json());
   const usage = extractTokenUsage(completion.usage);
@@ -1223,7 +1385,7 @@ async function proxyError(upstream, logger) {
     { event: "copilot.request.failed", upstreamStatus: upstream.status },
     "copilot upstream request failed"
   );
-  return jsonError(upstream.status, "copilot_error", text || upstream.statusText);
+  return upstreamErrorResponse(upstream.status, text || upstream.statusText);
 }
 function proxyResponse(upstream) {
   const headers = new Headers(upstream.headers);
@@ -1276,6 +1438,13 @@ function jsonError(status, code, message) {
     status
   );
 }
+function upstreamErrorResponse(status, text) {
+  const parsedError = asRecord(asRecord(safeParseJson(text)).error);
+  if (Object.keys(parsedError).length > 0) {
+    return jsonResponse({ error: parsedError }, status);
+  }
+  return jsonError(status, "copilot_error", text);
+}
 function websocketUnsupportedResponse() {
   const response = jsonError(
     426,
@@ -1300,6 +1469,17 @@ function isAuthorized(request, apiKey) {
   const bearer = authorization.match(/^Bearer\s+(.+)$/i)?.[1];
   return bearer === apiKey || request.headers.get("x-api-key") === apiKey;
 }
+function forbiddenBrowserOrigin(request, apiKey) {
+  if (apiKey) {
+    return void 0;
+  }
+  const origin = request.headers.get("origin")?.trim();
+  if (origin) {
+    return isLoopbackOrigin(origin) ? void 0 : origin;
+  }
+  const fetchSite = request.headers.get("sec-fetch-site")?.toLowerCase();
+  return fetchSite === "cross-site" ? "cross-site" : void 0;
+}
 function isUpstreamAuthStatus(status) {
   return status === 401 || status === 403;
 }
@@ -1307,7 +1487,21 @@ function upstreamAuthMessage(message) {
   return `GitHub Copilot rejected the credential or account access: ${message}`;
 }
 function isLoopbackHost(host) {
-  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+}
+function isLoopbackOrigin(origin) {
+  try {
+    return isLoopbackHost(new URL(origin).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+function normalizeServerPort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid port: ${value}.`);
+  }
+  return port;
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -1526,7 +1720,8 @@ import {
   mkdirSync as mkdirSync2,
   realpathSync,
   renameSync as renameSync2,
-  rmSync
+  rmSync,
+  writeFileSync as writeFileSync2
 } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -1649,6 +1844,46 @@ function upgradeCommandFor(kind) {
 function shouldCleanupOldBinary(platform, isStandaloneBinary) {
   return platform === "win32" && isStandaloneBinary;
 }
+function codexxShimFiles(platform) {
+  if (platform === "win32") {
+    return [
+      {
+        content: `$ErrorActionPreference = 'Stop'
+$hoopilot = Join-Path $PSScriptRoot 'hoopilot.exe'
+& $hoopilot codexx @args
+exit $LASTEXITCODE
+`,
+        executable: false,
+        name: "codexx.ps1"
+      },
+      {
+        content: `@echo off
+setlocal
+where pwsh >nul 2>nul
+if %ERRORLEVEL% EQU 0 (
+  pwsh -NoProfile -ExecutionPolicy Bypass -File "%~dp0codexx.ps1" %*
+) else (
+  powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0codexx.ps1" %*
+)
+exit /b %ERRORLEVEL%
+`,
+        executable: false,
+        name: "codexx.cmd"
+      }
+    ];
+  }
+  return [
+    {
+      content: `#!/bin/sh
+set -eu
+script_dir=$(CDPATH= cd "$(dirname "$0")" && pwd)
+exec "$script_dir/hoopilot" codexx "$@"
+`,
+      executable: true,
+      name: "codexx"
+    }
+  ];
+}
 function formatUpdateNotice(current, latest, kind) {
   return `
 Update available for hoopilot: ${current} \u2192 ${latest}
@@ -1958,6 +2193,23 @@ function swapBinary(tmpFile, exePath) {
     }
   }
 }
+function refreshCodexxShim(dir, logger) {
+  try {
+    for (const file of codexxShimFiles(process.platform)) {
+      const path = join2(dir, file.name);
+      writeFileSync2(path, file.content, "utf8");
+      if (file.executable) {
+        chmodSync2(path, 493);
+      }
+    }
+  } catch (error) {
+    logger?.warn(
+      { err: errorDetails(error), event: "update.codexx_shim_failed" },
+      "could not refresh codexx shim"
+    );
+    console.warn(`Updated hoopilot, but could not refresh the codexx shim: ${errorMessage2(error)}`);
+  }
+}
 function cleanupOldBinary() {
   if (!shouldCleanupOldBinary(process.platform, IS_STANDALONE_BINARY)) {
     return;
@@ -2016,6 +2268,7 @@ async function runUpdate(currentVersion, logger) {
       chmodSync2(tmpFile, 493);
     }
     swapBinary(tmpFile, exePath);
+    refreshCodexxShim(dirname2(exePath), logger);
   } catch (error) {
     const code = error.code;
     if (code === "EACCES" || code === "EPERM") {
@@ -2039,9 +2292,12 @@ async function runUpdate(currentVersion, logger) {
     console.log("Restart hoopilot to run the new version.");
   }
 }
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/cli.ts
-async function main(argv = Bun.argv.slice(2)) {
+async function main2(argv = Bun.argv.slice(2)) {
   cleanupOldBinary();
   const command = argv[0];
   if (command === "update" || command === "upgrade") {
@@ -2054,6 +2310,10 @@ async function main(argv = Bun.argv.slice(2)) {
     await runUpdate(await getVersion(), logger2);
     return;
   }
+  if (command === "codexx") {
+    await main(argv.slice(1), process.env);
+    return;
+  }
   if (command === "login") {
     const args2 = withRuntimeEnv(parseArgs(argv.slice(1)));
     if (args2.help) {
@@ -2139,7 +2399,7 @@ function parseArgs(argv) {
       args.noUpdateCheck = true;
       continue;
     }
-    const [name, inlineValue] = arg.split("=", 2);
+    const [name, inlineValue] = splitOption(arg);
     const value = inlineValue ?? rest.shift();
     if (!value) {
       throw new Error(`Missing value for ${arg}.`);
@@ -2148,6 +2408,9 @@ function parseArgs(argv) {
       case "--api-key":
         args.apiKey = value;
         break;
+      case "--api-key-file":
+        args.apiKey = readApiKeyFile(value);
+        break;
       case "--auth-file":
         args.authStorePath = value;
         break;
@@ -2166,7 +2429,7 @@ function parseArgs(argv) {
       case "--port":
       case "-p":
         args.port = Number(value);
-        if (!Number.isInteger(args.port) || args.port <= 0) {
+        if (!Number.isInteger(args.port) || args.port <= 0 || args.port > 65535) {
           throw new Error(`Invalid port: ${value}.`);
         }
         break;
@@ -2176,6 +2439,20 @@ function parseArgs(argv) {
   }
   return args;
 }
+function splitOption(arg) {
+  const separator = arg.indexOf("=");
+  if (separator === -1) {
+    return [arg, void 0];
+  }
+  return [arg.slice(0, separator), arg.slice(separator + 1)];
+}
+function readApiKeyFile(path) {
+  const value = readFileSync2(path, "utf8").trim();
+  if (!value) {
+    throw new Error(`API key file is empty: ${path}.`);
+  }
+  return value;
+}
 async function runLogin(options = {}) {
   const logger = options.logger?.child({ component: "auth" }) ?? noopLogger;
   logger.debug({ event: "auth.login.started" }, "starting github copilot browser login");
@@ -2314,6 +2591,9 @@ async function verifyCopilotOAuthToken(token, options = {}) {
   const apiBaseUrl = trimTrailingSlash(
     options.copilotApiBaseUrl ?? options.env?.COPILOT_API_BASE_URL ?? DEFAULT_COPILOT_API_BASE_URL
   );
+  if (!isHttpsOrLoopbackUrl(apiBaseUrl)) {
+    throw new Error(`Refusing to send the GitHub OAuth token to a non-HTTPS host: ${apiBaseUrl}`);
+  }
   const fetcher = options.fetch ?? fetch;
   const response = await fetcher(`${apiBaseUrl}/models`, {
     headers: applyCopilotHeaders(new Headers(), token),
@@ -2378,6 +2658,7 @@ OpenAI-compatible proxy for GitHub Copilot.
 
 Usage:
   hoopilot [serve] [options]
+  hoopilot codexx [codex options] [prompt]
   hoopilot login [options]
   hoopilot models [options]
   hoopilot usage [options]
@@ -2386,6 +2667,7 @@ Usage:
 
 Commands:
   serve                             Start the proxy server (default)
+  codexx                            Run Codex through the local Hoopilot server
   login                             Sign in through GitHub OAuth in a browser and verify Copilot access
   models                            List available GitHub Copilot model IDs
   usage                             Show GitHub Copilot quota and premium-request usage
@@ -2399,6 +2681,7 @@ Options:
   -p, --port <port>                 Port to listen on. Default: 4141
       --host <host>                 Host to listen on. Default: 127.0.0.1
       --api-key <key>               Require clients to send Authorization: Bearer <key> or x-api-key: <key>
+      --api-key-file <path>         Read the local API key from a file instead of argv
       --auth-file <path>            OAuth credential store path
       --copilot-api-base-url <url>  Copilot API base URL override
       --log-level <level>           trace, debug, info, warn, error, fatal, or silent
@@ -2421,13 +2704,13 @@ Environment:
 `;
 }
 if (import.meta.main) {
-  main().catch((error) => {
+  main2().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   });
 }
 export {
-  main,
+  main2 as main,
   parseArgs,
   runModels,
   runUsage,