@openhoo/hoopilot 0.8.3 → 0.9.0

package/README.md

@@ -50,6 +50,27 @@ curl -fsSL https://raw.githubusercontent.com/openhoo/hoopilot/main/scripts/insta
 
 The standalone installer also installs a `codexx` wrapper next to `hoopilot`. Re-run the installer if `hoopilot` works but your shell does not recognize `codexx`; the installer stops the installed `hoopilot.exe` if needed and replaces the existing files in place.
 
+### Docker
+
+Run Hoopilot as a long-lived service from the published multi-arch image on the GitHub Container Registry (`linux/amd64` and `linux/arm64`):
+
+```sh
+# 1. Sign in once; the OAuth credential is written to the persisted /data volume.
+docker run --rm -it -v hoopilot-data:/data ghcr.io/openhoo/hoopilot login
+
+# 2. Run the proxy. An API key is required because the container binds 0.0.0.0.
+docker run -d --name hoopilot --restart unless-stopped \
+  -p 4141:4141 -e HOOPILOT_API_KEY=local-key \
+  -v hoopilot-data:/data ghcr.io/openhoo/hoopilot
+```
+
+Tags follow the release version (e.g. `ghcr.io/openhoo/hoopilot:0.8`, `:0.8.3`) plus `:latest`. The image listens on `0.0.0.0:4141`, runs as a non-root user, and stores its OAuth credential at `/data/auth.json` (override with `HOOPILOT_AUTH_FILE`). A `docker-compose.yml` is provided in the repository:
+
+```sh
+docker compose run --rm hoopilot login   # one-time GitHub OAuth
+HOOPILOT_API_KEY=local-key docker compose up -d
+```
+
 ## Update
 
 Standalone binaries update themselves in place from the latest GitHub release:

package/dist/cli.js

@@ -690,6 +690,25 @@ function completionStreamFromChatStream(chatStream) {
     }
   });
 }
+function completionSseTextFromChatSseText(text) {
+  const chunks = [];
+  let sawTerminalEvent = false;
+  const enqueue = (data) => {
+    chunks.push(encodeDataSse(data));
+  };
+  const markTerminal = () => {
+    sawTerminalEvent = true;
+  };
+  for (const block of text.split(/\r?\n\r?\n/)) {
+    if (block.trim()) {
+      processCompletionSseBlock(block, enqueue, markTerminal);
+    }
+  }
+  if (!sawTerminalEvent) {
+    enqueue("[DONE]");
+  }
+  return chunks.join("");
+}
 function normalizeModelsResponse(upstream) {
   const record = asRecord(upstream);
   const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
@@ -950,16 +969,7 @@ function responsesStreamToAnthropicStream(stream, options) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   let buffer = "";
-  const state = {
-    blocks: /* @__PURE__ */ new Map(),
-    completed: false,
-    messageId: options.messageId ?? `msg_${randomId2()}`,
-    model: options.model,
-    nextBlockIndex: 0,
-    sawToolUse: false,
-    started: false,
-    usage: anthropicUsage(void 0)
-  };
+  const state = createAnthropicStreamState(options);
   return new ReadableStream({
     async start(controller) {
       const enqueue = (event, data) => {
@@ -995,6 +1005,20 @@ function responsesStreamToAnthropicStream(stream, options) {
     }
   });
 }
+function responsesSseTextToAnthropicSseText(text, options) {
+  const chunks = [];
+  const state = createAnthropicStreamState(options);
+  const enqueue = (event, data) => {
+    chunks.push(encodeSse(event, data));
+  };
+  for (const block of text.split(/\r?\n\r?\n/)) {
+    if (block.trim()) {
+      processResponsesSseBlock(block, state, enqueue);
+    }
+  }
+  finishAnthropicStream(state, enqueue);
+  return chunks.join("");
+}
 function estimateAnthropicMessageTokens(request) {
   const chars = estimatedTextSize(request.system) + estimatedTextSize(request.messages) + estimatedTextSize(request.tools) + estimatedTextSize(request.tool_choice) + estimatedTextSize(request.thinking);
   const messageCount = Array.isArray(request.messages) ? request.messages.length : 1;
@@ -1005,6 +1029,18 @@ function estimateAnthropicMessageTokens(request) {
     total_tokens: inputTokens
   };
 }
+function createAnthropicStreamState(options) {
+  return {
+    blocks: /* @__PURE__ */ new Map(),
+    completed: false,
+    messageId: options.messageId ?? `msg_${randomId2()}`,
+    model: options.model,
+    nextBlockIndex: 0,
+    sawToolUse: false,
+    started: false,
+    usage: anthropicUsage(void 0)
+  };
+}
 function anthropicMessagesToResponsesInput(messages) {
   if (!Array.isArray(messages)) {
     throw new AnthropicCompatibilityError("Anthropic Messages requests require messages[].");
@@ -1845,6 +1881,20 @@ function observeResponseUsage(response, fallbackModel, onUsage, signal) {
     statusText: response.statusText
   });
 }
+function recordResponseTextUsage(text, isSse, fallbackModel, onUsage) {
+  const accumulator = createUsageAccumulator(fallbackModel, onUsage);
+  if (isSse) {
+    for (const line of text.split(/\r?\n/)) {
+      considerSseLine(line, accumulator.consider);
+    }
+  } else {
+    const parsed = safeParse(text);
+    if (parsed !== void 0) {
+      accumulator.consider(parsed);
+    }
+  }
+  accumulator.finish();
+}
 async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
   const reader = stream.getReader();
   const onAbort = () => {
@@ -1858,22 +1908,10 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   }
   const decoder = new TextDecoder();
-  let model = fallbackModel;
-  let usage;
+  const accumulator = createUsageAccumulator(fallbackModel, onUsage);
   let buffer = "";
   let bufferedBytes = 0;
   let overflowed = false;
-  const consider = (payload) => {
-    const record = asRecord(payload);
-    const found = extractTokenUsage(record.usage) ?? extractTokenUsage(asRecord(record.response).usage);
-    if (found) {
-      usage = found;
-    }
-    const candidateModel = modelText(record.model) || modelText(asRecord(record.response).model);
-    if (candidateModel) {
-      model = candidateModel;
-    }
-  };
   try {
     while (true) {
       const result = await reader.read();
@@ -1886,7 +1924,7 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
         const lines = buffer.split(/\r?\n/);
         buffer = lines.pop() ?? "";
         for (const line of lines) {
-          considerSseLine(line, consider);
+          considerSseLine(line, accumulator.consider);
         }
         if (buffer.length > USAGE_BUFFER_LIMIT_BYTES) {
           buffer = "";
@@ -1904,21 +1942,41 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
     const finalBuffer = buffer + decoder.decode();
     if (isSse) {
       if (finalBuffer) {
-        considerSseLine(finalBuffer, consider);
+        considerSseLine(finalBuffer, accumulator.consider);
       }
     } else if (!overflowed && finalBuffer) {
       const parsed = safeParse(finalBuffer);
       if (parsed !== void 0) {
-        consider(parsed);
+        accumulator.consider(parsed);
       }
     }
   } finally {
     signal?.removeEventListener("abort", onAbort);
     reader.releaseLock();
   }
-  if (usage) {
-    onUsage(model, usage);
-  }
+  accumulator.finish();
+}
+function createUsageAccumulator(fallbackModel, onUsage) {
+  let model = fallbackModel;
+  let usage;
+  return {
+    consider(payload) {
+      const record = asRecord(payload);
+      const found = extractTokenUsage(record.usage) ?? extractTokenUsage(asRecord(record.response).usage);
+      if (found) {
+        usage = found;
+      }
+      const candidateModel = modelText(record.model) || modelText(asRecord(record.response).model);
+      if (candidateModel) {
+        model = candidateModel;
+      }
+    },
+    finish() {
+      if (usage) {
+        onUsage(model, usage);
+      }
+    }
+  };
 }
 function considerSseLine(line, consider) {
   const trimmed = line.trim();
@@ -1965,6 +2023,30 @@ function formatNumber(value) {
   return Number.isInteger(value) ? value.toString() : String(value);
 }
 
+// src/version.ts
+var BAKED_VERSION = typeof HOOPILOT_VERSION !== "undefined" ? HOOPILOT_VERSION : void 0;
+var BAKED_TARGET = typeof HOOPILOT_TARGET !== "undefined" ? HOOPILOT_TARGET : void 0;
+var IS_STANDALONE_BINARY = BAKED_VERSION !== void 0;
+var cachedVersion;
+async function getVersion() {
+  if (cachedVersion !== void 0) {
+    return cachedVersion;
+  }
+  let resolved;
+  if (BAKED_VERSION) {
+    resolved = BAKED_VERSION;
+  } else {
+    try {
+      const manifest = await Bun.file(new URL("../package.json", import.meta.url)).json();
+      resolved = typeof manifest.version === "string" ? manifest.version : "0.0.0";
+    } catch {
+      resolved = "0.0.0";
+    }
+  }
+  cachedVersion = resolved;
+  return resolved;
+}
+
 // src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
@@ -1988,6 +2070,8 @@ function createHoopilotHandler(options = {}) {
   const metrics = options.metrics ?? new MetricsRegistry();
   const readUsage = createUsageReader(client, metrics);
   const recordTokens = (model, usage) => metrics.recordTokens(model, usage);
+  const streamingProxyMode = resolveStreamingProxyMode(options);
+  const bufferProxyBodies = shouldBufferProxyBodies(streamingProxyMode);
   return async (request) => {
     const startedAt = performance.now();
     const url = new URL(request.url);
@@ -2007,7 +2091,9 @@ function createHoopilotHandler(options = {}) {
       metrics,
       requestId,
       route,
-      startedAt
+      startedAt,
+      closeConnection: bufferProxyBodies,
+      trackStreamingBody: !bufferProxyBodies
     });
     const browserOrigin = forbiddenBrowserOrigin(request, apiKey);
     if (browserOrigin) {
@@ -2042,7 +2128,14 @@ function createHoopilotHandler(options = {}) {
       }
       if (request.method === "POST" && apiPath === "/v1/messages") {
         return finish(
-          await handleAnthropicMessages(client, metrics, recordTokens, request, requestLogger)
+          await handleAnthropicMessages(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
         );
       }
       if (request.method === "POST" && apiPath === "/v1/messages/count_tokens") {
@@ -2050,16 +2143,39 @@ function createHoopilotHandler(options = {}) {
       }
       if (request.method === "POST" && apiPath === "/v1/chat/completions") {
         return finish(
-          await handleChatCompletions(client, metrics, recordTokens, request, requestLogger)
+          await handleChatCompletions(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
         );
       }
       if (request.method === "POST" && apiPath === "/v1/completions") {
         return finish(
-          await handleCompletions(client, metrics, recordTokens, request, requestLogger)
+          await handleCompletions(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
         );
       }
       if (request.method === "POST" && apiPath === "/v1/responses") {
-        return finish(await handleResponses(client, metrics, recordTokens, request, requestLogger));
+        return finish(
+          await handleResponses(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
+        );
       }
       return finish(jsonError(404, "not_found", `No route for ${request.method} ${url.pathname}.`));
     } catch (error) {
@@ -2124,7 +2240,7 @@ function startHoopilotServer(options = {}) {
     url: `http://${urlHost(host)}:${server.port}`
   };
 }
-async function handleAnthropicMessages(client, metrics, recordTokens, request, logger) {
+async function handleAnthropicMessages(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const anthropicRequest = await readJson(request);
   const responsesRequest = anthropicMessagesToResponsesRequest(anthropicRequest);
   const upstream = await client.responses(JSON.stringify(responsesRequest), request.signal);
@@ -2135,6 +2251,13 @@ async function handleAnthropicMessages(client, metrics, recordTokens, request, l
   logUpstreamSuccess(logger, "/responses", upstream.status);
   const model = normalizeRequestedModel(responsesRequest.model);
   if (isStreamingResponse(upstream) && upstream.body) {
+    if (bufferProxyBodies) {
+      const text = await upstream.text();
+      recordResponseTextUsage(text, true, model, recordTokens);
+      return proxyResponse(
+        responseFromText(upstream, responsesSseTextToAnthropicSseText(text, { model }))
+      );
+    }
     const observed = observeResponseUsage(upstream, model, recordTokens, request.signal);
     if (!observed.body) {
       return proxyResponse(observed);
@@ -2178,7 +2301,7 @@ async function handleModels(client, metrics, signal, logger) {
   logUpstreamSuccess(logger, "/models", upstream.status);
   return jsonResponse(normalizeModelsResponse(await upstream.json()));
 }
-async function handleChatCompletions(client, metrics, recordTokens, request, logger) {
+async function handleChatCompletions(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const chatRequest = normalizeChatCompletionRequest(await readJson(request));
   const upstream = await client.chatCompletions(chatRequest, request.signal);
   metrics.recordUpstream("/chat/completions", upstream.ok);
@@ -2187,9 +2310,17 @@ async function handleChatCompletions(client, metrics, recordTokens, request, log
   }
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(chatRequest.model);
-  return proxyResponse(observeResponseUsage(upstream, model, recordTokens, request.signal));
+  return proxyResponse(
+    await responseWithObservedUsage(
+      upstream,
+      model,
+      recordTokens,
+      request.signal,
+      bufferProxyBodies
+    )
+  );
 }
-async function handleCompletions(client, metrics, recordTokens, request, logger) {
+async function handleCompletions(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const body = await readJson(request);
   const upstream = await client.chatCompletions(
     completionsRequestToChatCompletion(body),
@@ -2202,6 +2333,12 @@ async function handleCompletions(client, metrics, recordTokens, request, logger)
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(body.model);
   if (isStreamingResponse(upstream) && upstream.body) {
+    if (bufferProxyBodies) {
+      const upstreamText = await upstream.text();
+      recordResponseTextUsage(upstreamText, true, model, recordTokens);
+      const text = completionSseTextFromChatSseText(upstreamText);
+      return proxyResponse(responseFromText(upstream, text));
+    }
     return proxyResponse(
       observeResponseUsage(
         new Response(completionStreamFromChatStream(upstream.body), {
@@ -2223,7 +2360,7 @@ async function handleCompletions(client, metrics, recordTokens, request, logger)
   }
   return jsonResponse(chatCompletionToCompletion(completion));
 }
-async function handleResponses(client, metrics, recordTokens, request, logger) {
+async function handleResponses(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const body = await readJsonText(request);
   const upstream = await client.responses(body, request.signal);
   metrics.recordUpstream("/responses", upstream.ok);
@@ -2232,7 +2369,31 @@ async function handleResponses(client, metrics, recordTokens, request, logger) {
   }
   logUpstreamSuccess(logger, "/responses", upstream.status);
   const model = normalizeRequestedModel(asRecord(safeParseJson(body)).model);
-  return proxyResponse(observeResponseUsage(upstream, model, recordTokens, request.signal));
+  return proxyResponse(
+    await responseWithObservedUsage(
+      upstream,
+      model,
+      recordTokens,
+      request.signal,
+      bufferProxyBodies
+    )
+  );
+}
+async function responseWithObservedUsage(response, fallbackModel, recordTokens, signal, bufferBody) {
+  const isSse = isStreamingResponse(response);
+  if (bufferBody && response.body) {
+    const text = await response.text();
+    recordResponseTextUsage(text, isSse, fallbackModel, recordTokens);
+    return responseFromText(response, text);
+  }
+  return observeResponseUsage(response, fallbackModel, recordTokens, signal);
+}
+function responseFromText(source, text) {
+  return new Response(text, {
+    headers: source.headers,
+    status: source.status,
+    statusText: source.statusText
+  });
 }
 async function proxyError(upstream, logger) {
   const text = await upstream.text();
@@ -2424,8 +2585,24 @@ function serverLogger(options) {
   }
   return noopLogger;
 }
+function resolveStreamingProxyMode(options) {
+  const value = options.streamingProxyMode ?? envValue(options.env?.HOOPILOT_STREAM_MODE) ?? envValue(options.env?.HOOPILOT_STREAMING_PROXY_MODE) ?? "auto";
+  if (value === "auto" || value === "buffer" || value === "live") {
+    return value;
+  }
+  throw new Error(`Invalid stream mode: ${value}. Expected auto, live, or buffer.`);
+}
+function shouldBufferProxyBodies(mode) {
+  if (mode === "buffer") {
+    return true;
+  }
+  if (mode === "live") {
+    return false;
+  }
+  return process.platform === "win32" && IS_STANDALONE_BINARY;
+}
 function finishResponse(response, options) {
-  const withRequestId = responseWithRequestId(response, options.requestId);
+  const withRequestId = responseWithRequestId(response, options.requestId, options.closeConnection);
   const stream = isStreamingResponse(withRequestId);
   const status = withRequestId.status;
   const complete = () => {
@@ -2433,7 +2610,7 @@ function finishResponse(response, options) {
     options.metrics.observe({ durationMs, method: options.method, route: options.route, status });
     logRequestCompleted(options.logger, status, stream, durationMs);
   };
-  if (stream && withRequestId.body) {
+  if (stream && withRequestId.body && options.trackStreamingBody) {
     return new Response(trackStreamCompletion(withRequestId.body, complete), {
       headers: withRequestId.headers,
       status,
@@ -2443,9 +2620,12 @@ function finishResponse(response, options) {
   complete();
   return withRequestId;
 }
-function responseWithRequestId(response, requestId) {
+function responseWithRequestId(response, requestId, closeConnection) {
   const headers = new Headers(response.headers);
   headers.set("x-request-id", requestId);
+  if (closeConnection) {
+    headers.set("connection", "close");
+  }
   return new Response(response.body, {
     headers,
     status: response.status,
@@ -2864,30 +3044,6 @@ function latestReleaseApiUrl() {
   return `https://api.github.com/repos/${REPO}/releases/latest`;
 }
 
-// src/version.ts
-var BAKED_VERSION = typeof HOOPILOT_VERSION !== "undefined" ? HOOPILOT_VERSION : void 0;
-var BAKED_TARGET = typeof HOOPILOT_TARGET !== "undefined" ? HOOPILOT_TARGET : void 0;
-var IS_STANDALONE_BINARY = BAKED_VERSION !== void 0;
-var cachedVersion;
-async function getVersion() {
-  if (cachedVersion !== void 0) {
-    return cachedVersion;
-  }
-  let resolved;
-  if (BAKED_VERSION) {
-    resolved = BAKED_VERSION;
-  } else {
-    try {
-      const manifest = await Bun.file(new URL("../package.json", import.meta.url)).json();
-      resolved = typeof manifest.version === "string" ? manifest.version : "0.0.0";
-    } catch {
-      resolved = "0.0.0";
-    }
-  }
-  cachedVersion = resolved;
-  return resolved;
-}
-
 // src/update.ts
 var REQUEST_TIMEOUT_MS2 = 8e3;
 var SHA256SUMS = "SHA256SUMS";
@@ -3340,6 +3496,9 @@ function parseArgs(argv) {
       case "--log-level":
         args.logLevel = parseLogLevel(optionValue(name, inlineValue, rest));
         break;
+      case "--stream-mode":
+        args.streamingProxyMode = parseStreamMode(optionValue(name, inlineValue, rest));
+        break;
       case "--host":
         args.host = optionValue(name, inlineValue, rest);
         break;
@@ -3358,6 +3517,12 @@ function parseArgs(argv) {
   }
   return args;
 }
+function parseStreamMode(value) {
+  if (value === "auto" || value === "buffer" || value === "live") {
+    return value;
+  }
+  throw new Error(`Invalid stream mode: ${value}. Expected auto, live, or buffer.`);
+}
 function optionValue(name, inlineValue, rest) {
   const value = inlineValue ?? rest.shift();
   if (!value) {
@@ -3615,6 +3780,7 @@ Options:
       --copilot-api-base-url <url>  Copilot API base URL override
       --log-level <level>           trace, debug, info, warn, error, fatal, or silent
       --log-format <format>         json or pretty. Default: pretty
+      --stream-mode <mode>          auto, live, or buffer. Auto buffers Windows standalone streams.
       --no-update-check             Do not check GitHub for a newer release
       --allow-unauthenticated       Allow non-loopback bind without --api-key
   -h, --help                        Show help
@@ -3627,6 +3793,7 @@ Environment:
   HOOPILOT_GITHUB_DOMAIN
   HOOPILOT_LOG_FORMAT               json or pretty. Default: pretty
   HOOPILOT_LOG_LEVEL                trace, debug, info, warn, error, fatal, or silent
+  HOOPILOT_STREAM_MODE              auto, live, or buffer
   COPILOT_API_BASE_URL
   HOOPILOT_GITHUB_API_BASE_URL      GitHub REST base for the usage/quota lookup. Default: https://api.github.com
   HOOPILOT_ALLOW_UNSAFE_UPSTREAM    Set to 1 to allow nonstandard HTTPS token hosts