opencode-rag-plugin 1.15.0 → 1.17.0

package/dist/core/setup-runtime.js

@@ -0,0 +1,183 @@
+import path from "node:path";
+import os from "node:os";
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, symlinkSync, } from "node:fs";
+import { execSync } from "node:child_process";
+const PLUGIN_NAME = "opencode-rag-plugin";
+export function getRuntimeDir() {
+    return path.join(os.homedir(), ".opencode");
+}
+export function getNpmGlobalRoot() {
+    return execSync("npm root -g", {
+        encoding: "utf-8",
+        timeout: 10_000,
+    }).trim();
+}
+function createJunction(targetPath, linkPath) {
+    const type = process.platform === "win32" ? "junction" : "dir";
+    symlinkSync(targetPath, linkPath, type);
+}
+function removeIfExists(targetPath) {
+    if (existsSync(targetPath)) {
+        rmSync(targetPath, { recursive: true, force: true });
+    }
+}
+export function getVersionFile(runtimeDir) {
+    return path.join(runtimeDir, ".bundle-version");
+}
+export function readVersionFile(versionFile) {
+    try {
+        return readFileSync(versionFile, "utf-8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Bin name npm generates for this package (without .cmd/.ps1). */
+function getBinName() {
+    const pkgJson = path.join(getNpmGlobalRoot(), PLUGIN_NAME, "package.json");
+    try {
+        const pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+        if (pkg.bin && typeof pkg.bin === "object") {
+            return Object.keys(pkg.bin)[0] ?? PLUGIN_NAME;
+        }
+        if (typeof pkg.bin === "string") {
+            return PLUGIN_NAME;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return PLUGIN_NAME;
+}
+/**
+ * npm-generated .cmd / .ps1 wrappers on Windows invoke `.js` files directly
+ * via file association. If the `.js` association points to a text editor
+ * (e.g. Notepad++) instead of Node.js, the CLI opens the editor instead of
+ * running. This function patches the wrappers to call `node` explicitly.
+ *
+ * Runs only on Windows. Safe to call on every setup — detects already-patched
+ * wrappers by checking for the `node` prefix.
+ */
+export function patchWindowsWrappers(npmGlobalRoot) {
+    if (process.platform !== "win32")
+        return;
+    const binDir = path.resolve(npmGlobalRoot, "..");
+    const binName = getBinName();
+    // ── .cmd wrapper ──────────────────────────────────────────────
+    const cmdFile = path.join(binDir, `${binName}.cmd`);
+    if (existsSync(cmdFile)) {
+        const content = readFileSync(cmdFile, "utf-8");
+        // npm generates: "%dp0%\node_modules\opencode-rag-plugin\dist\cli\index.js"   %*
+        // We want:       node "%dp0%\node_modules\opencode-rag-plugin\dist\cli\index.js"   %*
+        const cmdJsLine = /^(?!node\s)("[^"]+\.js"\s+%\*)$/m;
+        if (cmdJsLine.test(content)) {
+            const patched = content.replace(cmdJsLine, "node $1");
+            writeFileSync(cmdFile, patched, "utf-8");
+        }
+    }
+    // ── PowerShell wrapper ────────────────────────────────────────
+    const ps1File = path.join(binDir, `${binName}.ps1`);
+    if (existsSync(ps1File)) {
+        let content = readFileSync(ps1File, "utf-8");
+        // Skip if already patched
+        if (content.includes('node "$basedir'))
+            return;
+        // npm generates:
+        //   $input | & "$basedir/node_modules/.../index.js"   $args
+        //   & "$basedir/node_modules/.../index.js"   $args
+        // Replace to: & node "$basedir/.../index.js"   $args
+        const ps1DirectLine = /(&\s+)("\$basedir\/[^"]+\.js"\s+\$args)/g;
+        if (ps1DirectLine.test(content)) {
+            content = content.replace(ps1DirectLine, "$1node $2");
+            writeFileSync(ps1File, content, "utf-8");
+        }
+    }
+}
+export async function setupRuntime(options) {
+    const errors = [];
+    const pluginVersion = options?.version || process.env.OPCODE_RAG_VERSION || "0.0.0";
+    const runtimeDir = getRuntimeDir();
+    const versionFile = getVersionFile(runtimeDir);
+    const runtimePluginDir = path.join(runtimeDir, "node_modules", PLUGIN_NAME);
+    const runtimeSdkDir = path.join(runtimeDir, "node_modules", "@opencode-ai");
+    const runtimeSdkPluginDir = path.join(runtimeSdkDir, "plugin");
+    const installedVersion = readVersionFile(versionFile);
+    const runtimeDist = path.join(runtimePluginDir, "dist");
+    const alreadyInstalled = existsSync(runtimeDist);
+    if (alreadyInstalled && installedVersion === pluginVersion && !options?.force) {
+        return { success: true, errors: [] };
+    }
+    let npmGlobalRoot;
+    try {
+        npmGlobalRoot = getNpmGlobalRoot();
+    }
+    catch {
+        errors.push("npm is not available on PATH. Cannot determine global package location.");
+        return { success: false, errors };
+    }
+    const globalPluginDir = path.join(npmGlobalRoot, PLUGIN_NAME);
+    const globalSdkPluginDir = path.join(npmGlobalRoot, "@opencode-ai", "plugin");
+    if (!existsSync(globalPluginDir)) {
+        errors.push(`Plugin not found at: ${globalPluginDir}`);
+        return { success: false, errors };
+    }
+    if (!existsSync(path.join(globalPluginDir, "dist", "cli.js"))) {
+        errors.push(`Global install seems incomplete: dist/ not found in ${globalPluginDir}`);
+        return { success: false, errors };
+    }
+    mkdirSync(runtimeDir, { recursive: true });
+    const runtimePkg = path.join(runtimeDir, "package.json");
+    if (!existsSync(runtimePkg)) {
+        writeFileSync(runtimePkg, JSON.stringify({ private: true, type: "module" }, null, 2) + "\n", "utf-8");
+    }
+    removeIfExists(runtimePluginDir);
+    mkdirSync(path.dirname(runtimePluginDir), { recursive: true });
+    try {
+        createJunction(globalPluginDir, runtimePluginDir);
+    }
+    catch {
+        const { cpSync } = await import("node:fs");
+        cpSync(globalPluginDir, runtimePluginDir, { recursive: true });
+    }
+    if (existsSync(globalSdkPluginDir)) {
+        removeIfExists(runtimeSdkPluginDir);
+        mkdirSync(runtimeSdkDir, { recursive: true });
+        try {
+            createJunction(globalSdkPluginDir, runtimeSdkPluginDir);
+        }
+        catch {
+            const { cpSync } = await import("node:fs");
+            cpSync(globalSdkPluginDir, runtimeSdkPluginDir, { recursive: true });
+        }
+    }
+    else {
+        mkdirSync(runtimeSdkDir, { recursive: true });
+        try {
+            execSync(`npm install @opencode-ai/plugin --no-save`, {
+                cwd: runtimeDir,
+                stdio: "pipe",
+                timeout: 60_000,
+            });
+        }
+        catch (cause) {
+            errors.push(`Failed to install @opencode-ai/plugin SDK: ${cause.message}`);
+            return { success: false, errors };
+        }
+    }
+    writeFileSync(versionFile, pluginVersion, "utf-8");
+    patchWindowsWrappers(npmGlobalRoot);
+    const cliEntry = path.join(runtimePluginDir, "dist", "cli.js");
+    const pluginEntry = path.join(runtimePluginDir, "dist", "plugin-entry.js");
+    const sdkPkg = path.join(runtimeSdkPluginDir, "package.json");
+    const success = existsSync(cliEntry) && existsSync(pluginEntry) && existsSync(sdkPkg);
+    if (!success) {
+        if (!existsSync(cliEntry))
+            errors.push(`CLI entry missing: ${cliEntry}`);
+        if (!existsSync(pluginEntry))
+            errors.push(`Plugin entry missing: ${pluginEntry}`);
+        if (!existsSync(sdkPkg))
+            errors.push(`Plugin SDK missing: ${sdkPkg}`);
+    }
+    return { success, errors };
+}
+//# sourceMappingURL=setup-runtime.js.map

package/dist/core/version-check.d.ts

@@ -0,0 +1,9 @@
+export interface UpdateInfo {
+    currentVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+    releaseUrl: string;
+    publishedAt: string;
+}
+export declare function compareVersions(a: string, b: string): number;
+export declare function checkForUpdate(currentVersion: string): Promise<UpdateInfo>;

package/dist/core/version-check.js

@@ -0,0 +1,49 @@
+export function compareVersions(a, b) {
+    const pa = a.split(".").map((s) => parseInt(s, 10));
+    const pb = b.split(".").map((s) => parseInt(s, 10));
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    return 0;
+}
+export async function checkForUpdate(currentVersion) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const response = await fetch("https://api.github.com/repos/MrDoe/OpenCodeRAG/releases/latest", {
+            headers: {
+                Accept: "application/vnd.github+json",
+                "User-Agent": "opencode-rag-updater",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
+        }
+        const data = (await response.json());
+        const tagName = data.tag_name;
+        if (!tagName) {
+            return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
+        }
+        const latestVersion = tagName.replace(/^v/i, "");
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable: compareVersions(latestVersion, currentVersion) > 0,
+            releaseUrl: data.html_url ?? "",
+            publishedAt: data.published_at ?? "",
+        };
+    }
+    catch {
+        return { currentVersion, latestVersion: currentVersion, updateAvailable: false, releaseUrl: "", publishedAt: "" };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=version-check.js.map

package/dist/describer/anthropic.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Anthropic Messages API description provider for generating natural-language descriptions of code chunks.
  */
-import type { Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
+import type { BatchDescriptionOptions, Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
 import type { DescriptionConfig } from "../core/config.js";
 /**
  * Description provider that uses Anthropic's Messages API to generate natural-language descriptions of code chunks.
@@ -18,7 +18,7 @@ export declare class AnthropicDescriptionProvider implements DescriptionProvider
     /** @inheritdoc */
     generateDescription(chunk: Chunk): Promise<string>;
     /** @inheritdoc */
-    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger): Promise<Map<string, string>>;
+    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
     /**
      * Sends a request to the Anthropic Messages API with retry and exponential backoff.
      * The system prompt is combined with all user messages into a single message payload, and

package/dist/describer/anthropic.js

@@ -25,11 +25,11 @@ export class AnthropicDescriptionProvider {
         return this.chatRequest(messages, this.config.timeoutMs ?? 60000);
     }
     /** @inheritdoc */
-    async generateBatchDescriptions(chunks, logger) {
-        const log = logger ?? { info: (msg) => console.log(msg), warn: (msg) => console.warn(msg), debug: (msg) => console.debug(msg) };
+    async generateBatchDescriptions(chunks, logger, opts) {
+        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => process.stderr.write(`${msg}\n`), debug: (msg) => process.stderr.write(`${msg}\n`) };
         const concurrency = this.config.batchConcurrency ?? 3;
         const total = chunks.length;
-        log.info(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
+        log.debug(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
         const result = new Map();
         const limit = pLimit(concurrency);
         let completed = 0;
@@ -45,11 +45,9 @@ export class AnthropicDescriptionProvider {
                 log.warn(`[describer] Failed to describe chunk ${chunk.id} (${chunk.metadata.filePath}:${chunk.metadata.startLine}): ${err instanceof Error ? err.message : String(err)}`);
             }
             completed++;
-            if (completed % 25 === 0 || completed === total) {
-                log.info(`[describer] Progress: ${completed}/${total}`);
-            }
+            opts?.onProgress?.(chunk, completed, opts.total ?? total);
         })));
-        log.info(`[describer] Descriptions generated: ${result.size}/${total}`);
+        log.debug(`[describer] Descriptions generated: ${result.size}/${total}`);
         return result;
     }
     /**

package/dist/describer/describer.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview OpenAI-compatible LLM description provider for generating natural-language descriptions of code chunks.
  */
-import type { Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
+import type { BatchDescriptionOptions, Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
 import type { DescriptionConfig } from "../core/config.js";
 /**
  * Description provider that works with any OpenAI-compatible chat API (including Ollama).
@@ -18,7 +18,7 @@ export declare class LlmDescriptionProvider implements DescriptionProvider {
     /** @inheritdoc */
     generateDescription(chunk: Chunk): Promise<string>;
     /** @inheritdoc */
-    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger): Promise<Map<string, string>>;
+    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
     /**
      * Sends a chat completion request to the LLM API with retry and exponential backoff.
      * For Ollama, uses the `/api/chat` endpoint with streaming disabled; otherwise uses the standard `/v1/chat/completions` endpoint.

package/dist/describer/describer.js

@@ -2,7 +2,7 @@ import { postJson } from "../embedder/http.js";
 import { buildUserMessage, sleep } from "./shared.js";
 import pLimit from "p-limit";
 /** HTTP status codes that are safe to retry on. */
-const RETRYABLE_STATUSES = new Set([404, 408, 429, 500, 502, 503, 504]);
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
 /**
  * Description provider that works with any OpenAI-compatible chat API (including Ollama).
  *
@@ -26,11 +26,11 @@ export class LlmDescriptionProvider {
         return this.chatRequest(messages, this.config.timeoutMs ?? 60000);
     }
     /** @inheritdoc */
-    async generateBatchDescriptions(chunks, logger) {
-        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => console.warn(msg), debug: (msg) => console.debug(msg) };
+    async generateBatchDescriptions(chunks, logger, opts) {
+        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => process.stderr.write(`${msg}\n`), debug: (msg) => process.stderr.write(`${msg}\n`) };
         const concurrency = this.config.batchConcurrency ?? 3;
         const total = chunks.length;
-        log.info(`Generating descriptions for ${total} chunks via ${this.config.provider}/${this.config.model} (concurrency: ${concurrency})...`);
+        log.debug(`[describer] Generating descriptions for ${total} chunks via ${this.config.provider}/${this.config.model} (concurrency: ${concurrency})`);
         const result = new Map();
         const limit = pLimit(concurrency);
         let completed = 0;
@@ -46,11 +46,9 @@ export class LlmDescriptionProvider {
                 log.warn(`[describer] Failed to describe chunk ${chunk.id} (${chunk.metadata.filePath}:${chunk.metadata.startLine}): ${err instanceof Error ? err.message : String(err)}`);
             }
             completed++;
-            if (completed % 25 === 0 || completed === total) {
-                log.info(`Descriptions: ${completed}/${total}`);
-            }
+            opts?.onProgress?.(chunk, completed, opts.total ?? total);
         })));
-        log.info(`Descriptions: ${result.size}/${total} done.`);
+        log.debug(`[describer] Descriptions generated: ${result.size}/${total}`);
         return result;
     }
     /**

package/dist/describer/gemini.d.ts

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Google Gemini description provider for generating natural-language descriptions of code chunks.
  */
-import type { Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
+import type { BatchDescriptionOptions, Chunk, DescriptionProvider, DescriptionLogger } from "../core/interfaces.js";
 import type { DescriptionConfig } from "../core/config.js";
 /**
  * Description provider that uses Google Gemini's generateContent API to describe code chunks.
@@ -12,6 +12,6 @@ export declare class GeminiDescriptionProvider implements DescriptionProvider {
     private readonly config;
     constructor(config: DescriptionConfig);
     generateDescription(chunk: Chunk): Promise<string>;
-    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger): Promise<Map<string, string>>;
+    generateBatchDescriptions(chunks: Chunk[], logger?: DescriptionLogger, opts?: BatchDescriptionOptions): Promise<Map<string, string>>;
     private chatRequest;
 }

package/dist/describer/gemini.js

@@ -21,11 +21,11 @@ export class GeminiDescriptionProvider {
         ];
         return this.chatRequest(contents, this.config.timeoutMs ?? 60000);
     }
-    async generateBatchDescriptions(chunks, logger) {
-        const log = logger ?? { info: (msg) => console.log(msg), warn: (msg) => console.warn(msg), debug: (msg) => console.debug(msg) };
+    async generateBatchDescriptions(chunks, logger, opts) {
+        const log = logger ?? { info: (msg) => process.stderr.write(`${msg}\n`), warn: (msg) => process.stderr.write(`${msg}\n`), debug: (msg) => process.stderr.write(`${msg}\n`) };
         const concurrency = this.config.batchConcurrency ?? 3;
         const total = chunks.length;
-        log.info(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
+        log.debug(`[describer] Generating descriptions for ${total} chunks (concurrency: ${concurrency})`);
         const result = new Map();
         const limit = pLimit(concurrency);
         let completed = 0;
@@ -41,11 +41,9 @@ export class GeminiDescriptionProvider {
                 log.warn(`[describer] Failed to describe chunk ${chunk.id} (${chunk.metadata.filePath}:${chunk.metadata.startLine}): ${err instanceof Error ? err.message : String(err)}`);
             }
             completed++;
-            if (completed % 25 === 0 || completed === total) {
-                log.info(`[describer] Progress: ${completed}/${total}`);
-            }
+            opts?.onProgress?.(chunk, completed, opts.total ?? total);
         })));
-        log.info(`[describer] Descriptions generated: ${result.size}/${total}`);
+        log.debug(`[describer] Descriptions generated: ${result.size}/${total}`);
         return result;
     }
     async chatRequest(contents, timeoutMs) {

package/dist/embedder/factory.d.ts

@@ -27,6 +27,8 @@ export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
  * @param batchSize - Number of texts per batch (default 10)
  * @param purpose - Optional hint for query vs. document embedding
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
+ * @param onProgress - Optional callback invoked after each batch with the running
+ *   completed count and total; per-text granularity when `concurrency <= 1`.
  * @returns A promise resolving to a flat array of embedding vectors (one per input text)
  */
-export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number): Promise<number[][]>;
+export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void): Promise<number[][]>;

package/dist/embedder/factory.js

@@ -46,9 +46,11 @@ export function createEmbedder(config) {
  * @param batchSize - Number of texts per batch (default 10)
  * @param purpose - Optional hint for query vs. document embedding
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
+ * @param onProgress - Optional callback invoked after each batch with the running
+ *   completed count and total; per-text granularity when `concurrency <= 1`.
  * @returns A promise resolving to a flat array of embedding vectors (one per input text)
  */
-export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1) {
+export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress) {
     if (texts.length === 0)
         return [];
     const batches = [];
@@ -60,12 +62,16 @@ export async function embedBatch(embedder, texts, batchSize = 10, purpose, concu
         for (const batch of batches) {
             const embeddings = await embedder.embed(batch.texts, purpose);
             results.push(...embeddings);
+            onProgress?.(results.length, texts.length);
         }
         return results;
     }
     const limit = pLimit(concurrency);
+    let completedCount = 0;
     const batchResults = await Promise.all(batches.map((batch) => limit(async () => {
         const embeddings = await embedder.embed(batch.texts, purpose);
+        completedCount += embeddings.length;
+        onProgress?.(completedCount, texts.length);
         return { index: batch.index, embeddings };
     })));
     batchResults.sort((a, b) => a.index - b.index);

package/dist/embedder/health.js

@@ -328,6 +328,10 @@ export async function pullOllamaModels(models, onProgress) {
                 }
             }
             finally {
+                try {
+                    await reader.cancel();
+                }
+                catch { }
                 reader.releaseLock();
             }
         }

package/dist/embedder/http.d.ts

@@ -58,4 +58,4 @@ export declare function directRequest(url: URL, body: unknown, headers: Record<s
  * @param proxy - Optional proxy configuration
  * @returns A promise resolving to an HttpResponseLike
  */
-export declare function postJson(urlString: string, body: unknown, headers: Record<string, string>, timeoutMs: number, proxy?: ProxyConfig): Promise<HttpResponseLike>;
+export declare function postJson(urlString: string, body: unknown, headers: Record<string, string>, timeoutMs: number, proxy?: ProxyConfig, signal?: AbortSignal): Promise<HttpResponseLike>;

package/dist/embedder/http.js

@@ -6,6 +6,10 @@ import tls from "node:tls";
 const MAX_POOL_SIZE = 4;
 const IDLE_TIMEOUT_MS = 30000;
 const connectionPool = new Map();
+// Serialize proxied fetch requests that mutate process.env,
+// preventing races when concurrent requests interleave
+// set/restore of HTTP_PROXY/HTTPS_PROXY.
+let proxyRequestQueue = Promise.resolve(undefined);
 function poolKey(host, port, isHttps) {
     return `${isHttps ? "tls" : "tcp"}:${host}:${port}`;
 }
@@ -43,7 +47,13 @@ function releaseConnection(socket, host, port, isHttps) {
             pool.splice(idx, 1);
         socket.destroy();
     }, IDLE_TIMEOUT_MS);
-    socket.removeAllListeners();
+    // Avoid removeAllListeners — that would strip the error handler
+    // and cause an unhandled crash on ECONNRESET/TLS alert.
+    socket.removeAllListeners("data");
+    socket.removeAllListeners("end");
+    socket.removeAllListeners("drain");
+    socket.removeAllListeners("error");
+    socket.on("error", () => socket.destroy());
     pool.push({ socket, idleTimer });
 }
 /** Destroy all pooled TCP/TLS sockets and clear the connection pool. */
@@ -307,9 +317,9 @@ async function sendRawHttpRequest(url, body, headers, timeoutMs, redirectCount)
                 return;
             }
             if (isChunked) {
-                if (bodyBuffer.length >= 5) {
-                    const tail = bodyBuffer.slice(-7).toString("ascii");
-                    if (tail === "\r\n0\r\n\r\n" || bodyBuffer.toString("ascii") === "0\r\n\r\n") {
+                if (bodyBuffer.length >= 7) {
+                    const ascii = bodyBuffer.toString("ascii");
+                    if (/0(?:;[^\n]*)?\r\n(?:[^\n]+:[^\n]*\r\n)*\r\n$/.test(ascii)) {
                         settle(() => {
                             releaseOrDestroy();
                             resolve(assembled);
@@ -371,7 +381,15 @@ async function sendRawHttpRequest(url, body, headers, timeoutMs, redirectCount)
                 },
             };
         }
-        return sendRawHttpRequest(new URL(location, url), body, headers, timeoutMs, redirectCount + 1);
+        const redirectUrl = new URL(location, url);
+        const sameOrigin = url.protocol === redirectUrl.protocol &&
+            url.hostname === redirectUrl.hostname &&
+            (url.port || (url.protocol === "https:" ? "443" : "80")) ===
+                (redirectUrl.port || (redirectUrl.protocol === "https:" ? "443" : "80"));
+        const safeHeaders = sameOrigin
+            ? headers
+            : Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== "authorization"));
+        return sendRawHttpRequest(redirectUrl, body, safeHeaders, timeoutMs, redirectCount + 1);
     }
     const text = response.body.toString("utf8");
     return {
@@ -399,52 +417,65 @@ async function sendRawHttpRequest(url, body, headers, timeoutMs, redirectCount)
  * @param proxy - Optional proxy configuration
  * @returns A promise resolving to an HttpResponseLike
  */
-export async function postJson(urlString, body, headers, timeoutMs, proxy) {
+export async function postJson(urlString, body, headers, timeoutMs, proxy, signal) {
     const url = new URL(urlString);
     const bypassProxy = isLocalhost(url.hostname) || matchesNoProxy(url.hostname, proxy?.noProxy);
     if (bypassProxy || !proxy?.url) {
         return directRequest(url, body, headers, timeoutMs);
     }
-    return postJsonViaFetch(urlString, body, headers, timeoutMs, proxy);
+    return postJsonViaFetch(urlString, body, headers, timeoutMs, proxy, signal);
 }
 /** Send JSON via the global `fetch` API with proxy environment variable overrides. */
-async function postJsonViaFetch(urlString, body, headers, timeoutMs, proxy) {
+async function postJsonViaFetch(urlString, body, headers, timeoutMs, proxy, signal) {
     const authHeader = buildProxyAuthHeader(proxy);
     const envOverride = applyProxyEnv(proxy);
-    const savedHttpProxy = process.env.HTTP_PROXY;
-    const savedHttpsProxy = process.env.HTTPS_PROXY;
-    try {
-        if (envOverride) {
-            process.env.HTTP_PROXY = envOverride.httpProxy;
-            process.env.HTTPS_PROXY = envOverride.httpsProxy;
-        }
-        const requestHeaders = {
-            "Content-Type": "application/json",
-            ...headers,
-        };
-        if (authHeader) {
-            requestHeaders["Proxy-Authorization"] = authHeader;
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const response = await fetch(urlString, {
-                method: "POST",
-                headers: requestHeaders,
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            return response;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    finally {
-        if (envOverride) {
-            process.env.HTTP_PROXY = savedHttpProxy;
-            process.env.HTTPS_PROXY = savedHttpsProxy;
-        }
-    }
+    // Serialize fetch requests that mutate process.env to prevent
+    // concurrent requests from interleaving set/restore of proxy vars.
+    const [savedHttpProxy, savedHttpsProxy] = [process.env.HTTP_PROXY, process.env.HTTPS_PROXY];
+    return new Promise((resolve, reject) => {
+        proxyRequestQueue = proxyRequestQueue.then(async () => {
+            try {
+                if (envOverride) {
+                    process.env.HTTP_PROXY = envOverride.httpProxy;
+                    process.env.HTTPS_PROXY = envOverride.httpsProxy;
+                }
+                const requestHeaders = {
+                    "Content-Type": "application/json",
+                    ...headers,
+                };
+                if (authHeader) {
+                    requestHeaders["Proxy-Authorization"] = authHeader;
+                }
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), timeoutMs);
+                const onAbort = () => { controller.abort(); clearTimeout(timeout); };
+                signal?.addEventListener("abort", onAbort, { once: true });
+                try {
+                    const response = await fetch(urlString, {
+                        method: "POST",
+                        headers: requestHeaders,
+                        body: JSON.stringify(body),
+                        signal: controller.signal,
+                    });
+                    resolve(response);
+                }
+                finally {
+                    clearTimeout(timeout);
+                    signal?.removeEventListener("abort", onAbort);
+                    if (envOverride) {
+                        process.env.HTTP_PROXY = savedHttpProxy;
+                        process.env.HTTPS_PROXY = savedHttpsProxy;
+                    }
+                }
+            }
+            catch (err) {
+                if (envOverride) {
+                    process.env.HTTP_PROXY = savedHttpProxy;
+                    process.env.HTTPS_PROXY = savedHttpsProxy;
+                }
+                reject(err);
+            }
+        });
+    });
 }
 //# sourceMappingURL=http.js.map

package/dist/eval/compare-merge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Compare two branch benchmark JSON outputs and produce a side-by-side
+ * analysis report (console table + markdown file).
+ *
+ * Usage: node --import tsx src/eval/compare-merge.ts
+ *   --main .opencode/rag_db/eval-results/main.json
+ *   --branch .opencode/rag_db/eval-results/t1-cosine-l2.json
+ *   --output .opencode/rag_db/eval-results/branch-compare-report.md
+ */
+export {};