@continuedev/fetch 1.0.6 → 1.0.10

package/dist/fetch.js

@@ -1,54 +1,27 @@
-import { globalAgent } from "https";
-import * as fs from "node:fs";
-import tls from "node:tls";
 import * as followRedirects from "follow-redirects";
 import { HttpProxyAgent } from "http-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
-import fetch from "node-fetch";
+import fetch, { Response } from "node-fetch";
+import { getAgentOptions } from "./getAgentOptions.js";
+import { getProxyFromEnv, shouldBypassProxy } from "./util.js";
 const { http, https } = followRedirects.default;
 export async function fetchwithRequestOptions(url_, init, requestOptions) {
     const url = typeof url_ === "string" ? new URL(url_) : url_;
     if (url.host === "localhost") {
         url.host = "127.0.0.1";
     }
-    const TIMEOUT = 7200; // 7200 seconds = 2 hours
-    let globalCerts = [];
-    if (process.env.IS_BINARY) {
-        if (Array.isArray(globalAgent.options.ca)) {
-            globalCerts = [...globalAgent.options.ca.map((cert) => cert.toString())];
-        }
-        else if (typeof globalAgent.options.ca !== "undefined") {
-            globalCerts.push(globalAgent.options.ca.toString());
-        }
-    }
-    const ca = Array.from(new Set([...tls.rootCertificates, ...globalCerts]));
-    const customCerts = typeof requestOptions?.caBundlePath === "string"
-        ? [requestOptions?.caBundlePath]
-        : requestOptions?.caBundlePath;
-    if (customCerts) {
-        ca.push(...customCerts.map((customCert) => fs.readFileSync(customCert, "utf8")));
-    }
-    const timeout = (requestOptions?.timeout ?? TIMEOUT) * 1000; // measured in ms
-    const agentOptions = {
-        ca,
-        rejectUnauthorized: requestOptions?.verifySsl,
-        timeout,
-        sessionTimeout: timeout,
-        keepAlive: true,
-        keepAliveMsecs: timeout,
-    };
-    // Handle ClientCertificateOptions
-    if (requestOptions?.clientCertificate) {
-        agentOptions.cert = fs.readFileSync(requestOptions.clientCertificate.cert, "utf8");
-        agentOptions.key = fs.readFileSync(requestOptions.clientCertificate.key, "utf8");
-        if (requestOptions.clientCertificate.passphrase) {
-            agentOptions.passphrase = requestOptions.clientCertificate.passphrase;
-        }
+    const agentOptions = getAgentOptions(requestOptions);
+    // Get proxy from options or environment variables
+    let proxy = requestOptions?.proxy;
+    if (!proxy) {
+        proxy = getProxyFromEnv(url.protocol);
     }
-    const proxy = requestOptions?.proxy;
+    // Check if should bypass proxy based on requestOptions or NO_PROXY env var
+    const shouldBypass = requestOptions?.noProxy?.includes(url.hostname) ||
+        shouldBypassProxy(url.hostname);
     // Create agent
     const protocol = url.protocol === "https:" ? https : http;
-    const agent = proxy && !requestOptions?.noProxy?.includes(url.hostname)
+    const agent = proxy && !shouldBypass
         ? protocol === https
             ? new HttpsProxyAgent(proxy, agentOptions)
             : new HttpProxyAgent(proxy, agentOptions)
@@ -80,17 +53,29 @@ export async function fetchwithRequestOptions(url_, init, requestOptions) {
         console.log("Unable to parse HTTP request body: ", e);
     }
     // fetch the request with the provided options
-    const resp = await fetch(url, {
-        ...init,
-        body: updatedBody ?? init?.body,
-        headers: headers,
-        agent: agent,
-    });
-    if (!resp.ok) {
-        const requestId = resp.headers.get("x-request-id");
-        if (requestId) {
-            console.log(`Request ID: ${requestId}, Status: ${resp.status}`);
+    try {
+        const resp = await fetch(url, {
+            ...init,
+            body: updatedBody ?? init?.body,
+            headers: headers,
+            agent: agent,
+        });
+        if (!resp.ok) {
+            const requestId = resp.headers.get("x-request-id");
+            if (requestId) {
+                console.log(`Request ID: ${requestId}, Status: ${resp.status}`);
+            }
+        }
+        return resp;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            // Return a Response object that streamResponse etc can handle
+            return new Response(null, {
+                status: 499, // Client Closed Request
+                statusText: "Client Closed Request",
+            });
         }
+        throw error;
     }
-    return resp;
 }

package/dist/fetch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetch.test.js

@@ -0,0 +1,130 @@
+import { globalAgent } from "https";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentOptions } from "./getAgentOptions.js";
+// Store original env
+const originalEnv = process.env;
+const originalGlobalAgentOptions = { ...globalAgent.options };
+// Temporary directory for test certificate files
+let tempDir;
+beforeEach(() => {
+    // Create a temporary directory for test files
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "fetch-test-"));
+    process.env = { ...originalEnv };
+    // Reset globalAgent for each test
+    globalAgent.options = { ...originalGlobalAgentOptions };
+});
+afterEach(() => {
+    process.env = originalEnv;
+    globalAgent.options = originalGlobalAgentOptions;
+    // Clean up temporary directory
+    try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch (error) {
+        console.error(`Failed to remove temp directory: ${error}`);
+    }
+});
+// Helper function to create test certificate files
+function createTestCertFile(filename, content) {
+    const filePath = path.join(tempDir, filename);
+    fs.writeFileSync(filePath, content, "utf8");
+    return filePath;
+}
+test("getAgentOptions returns basic configuration with default values", () => {
+    const options = getAgentOptions();
+    // Check default timeout (7200 seconds = 2 hours = 7,200,000 ms)
+    expect(options.timeout).toBe(7200000);
+    expect(options.sessionTimeout).toBe(7200000);
+    expect(options.keepAliveMsecs).toBe(7200000);
+    expect(options.keepAlive).toBe(true);
+    // Verify certificates array exists and contains items
+    expect(options.ca).toBeInstanceOf(Array);
+    expect(options.ca.length).toBeGreaterThan(0);
+    // Verify at least one of the real TLS root certificates is included
+    // This assumes there's at least one certificate with "CERTIFICATE" in it
+    expect(options.ca.some((cert) => cert.includes("CERTIFICATE"))).toBe(true);
+});
+test("getAgentOptions respects custom timeout", () => {
+    const customTimeout = 300; // 5 minutes
+    const options = getAgentOptions({ timeout: customTimeout });
+    // Check timeout values (300 seconds = 300,000 ms)
+    expect(options.timeout).toBe(300000);
+    expect(options.sessionTimeout).toBe(300000);
+    expect(options.keepAliveMsecs).toBe(300000);
+});
+test("getAgentOptions uses verifySsl setting", () => {
+    // With verifySsl true
+    let options = getAgentOptions({ verifySsl: true });
+    expect(options.rejectUnauthorized).toBe(true);
+    // With verifySsl false
+    options = getAgentOptions({ verifySsl: false });
+    expect(options.rejectUnauthorized).toBe(false);
+});
+test("getAgentOptions incorporates custom CA bundle paths", () => {
+    // Create a test CA bundle file
+    const caBundleContent = "-----BEGIN CERTIFICATE-----\nMIIDtTCCAp2gAwIBAgIJAMcuSp7chAYdMA==\n-----END CERTIFICATE-----";
+    const caBundlePath = createTestCertFile("ca-bundle.pem", caBundleContent);
+    // Single string path
+    let options = getAgentOptions({ caBundlePath });
+    // Verify that our test certificate is included in the CA list
+    expect(options.ca).toContain(caBundleContent);
+    // Create multiple test CA bundle files
+    const caContent1 = "-----BEGIN CERTIFICATE-----\nABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n-----END CERTIFICATE-----";
+    const caContent2 = "-----BEGIN CERTIFICATE-----\n0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\n-----END CERTIFICATE-----";
+    const caPath1 = createTestCertFile("ca1.pem", caContent1);
+    const caPath2 = createTestCertFile("ca2.pem", caContent2);
+    // Array of paths
+    options = getAgentOptions({
+        caBundlePath: [caPath1, caPath2],
+    });
+    // Verify that both test certificates are included in the CA list
+    expect(options.ca).toContain(caContent1);
+    expect(options.ca).toContain(caContent2);
+});
+test("getAgentOptions includes global certs when running as binary", () => {
+    // Set up test certs in globalAgent
+    globalAgent.options.ca = ["global-cert-1", "global-cert-2"];
+    // Set IS_BINARY environment variable
+    process.env.IS_BINARY = "true";
+    const options = getAgentOptions();
+    // Test for global certs
+    expect(options.ca).toContain("global-cert-1");
+    expect(options.ca).toContain("global-cert-2");
+});
+test("getAgentOptions handles client certificate configuration", () => {
+    // Create test certificate files
+    const clientCertContent = "-----BEGIN CERTIFICATE-----\nCLIENTCERT\n-----END CERTIFICATE-----";
+    const clientKeyContent = "-----BEGIN PRIVATE KEY-----\nCLIENTKEY\n-----END PRIVATE KEY-----";
+    const certPath = createTestCertFile("client.cert", clientCertContent);
+    const keyPath = createTestCertFile("client.key", clientKeyContent);
+    const clientCertOptions = {
+        clientCertificate: {
+            cert: certPath,
+            key: keyPath,
+            passphrase: "secret-passphrase",
+        },
+    };
+    const options = getAgentOptions(clientCertOptions);
+    expect(options.cert).toBe(clientCertContent);
+    expect(options.key).toBe(clientKeyContent);
+    expect(options.passphrase).toBe("secret-passphrase");
+});
+test("getAgentOptions handles client certificate without passphrase", () => {
+    // Create test certificate files
+    const clientCertContent = "-----BEGIN CERTIFICATE-----\nCLIENTCERT2\n-----END CERTIFICATE-----";
+    const clientKeyContent = "-----BEGIN PRIVATE KEY-----\nCLIENTKEY2\n-----END PRIVATE KEY-----";
+    const certPath = createTestCertFile("client2.cert", clientCertContent);
+    const keyPath = createTestCertFile("client2.key", clientKeyContent);
+    const clientCertOptions = {
+        clientCertificate: {
+            cert: certPath,
+            key: keyPath,
+        },
+    };
+    const options = getAgentOptions(clientCertOptions);
+    expect(options.cert).toBe(clientCertContent);
+    expect(options.key).toBe(clientKeyContent);
+    expect(options.passphrase).toBeUndefined();
+});

package/dist/getAgentOptions.d.ts

@@ -0,0 +1,7 @@
+import { RequestOptions } from "@continuedev/config-types";
+/**
+ * Prepares agent options based on request options and certificates
+ */
+export declare function getAgentOptions(requestOptions?: RequestOptions): {
+    [key: string]: any;
+};

package/dist/getAgentOptions.js

@@ -0,0 +1,44 @@
+import { globalAgent } from "https";
+import * as fs from "node:fs";
+import tls from "node:tls";
+/**
+ * Prepares agent options based on request options and certificates
+ */
+export function getAgentOptions(requestOptions) {
+    const TIMEOUT = 7200; // 7200 seconds = 2 hours
+    const timeout = (requestOptions?.timeout ?? TIMEOUT) * 1000; // measured in ms
+    // Get root certificates
+    let globalCerts = [];
+    if (process.env.IS_BINARY) {
+        if (Array.isArray(globalAgent.options.ca)) {
+            globalCerts = [...globalAgent.options.ca.map((cert) => cert.toString())];
+        }
+        else if (typeof globalAgent.options.ca !== "undefined") {
+            globalCerts.push(globalAgent.options.ca.toString());
+        }
+    }
+    const ca = Array.from(new Set([...tls.rootCertificates, ...globalCerts]));
+    const customCerts = typeof requestOptions?.caBundlePath === "string"
+        ? [requestOptions?.caBundlePath]
+        : requestOptions?.caBundlePath;
+    if (customCerts) {
+        ca.push(...customCerts.map((customCert) => fs.readFileSync(customCert, "utf8")));
+    }
+    const agentOptions = {
+        ca,
+        rejectUnauthorized: requestOptions?.verifySsl,
+        timeout,
+        sessionTimeout: timeout,
+        keepAlive: true,
+        keepAliveMsecs: timeout,
+    };
+    // Handle ClientCertificateOptions
+    if (requestOptions?.clientCertificate) {
+        agentOptions.cert = fs.readFileSync(requestOptions.clientCertificate.cert, "utf8");
+        agentOptions.key = fs.readFileSync(requestOptions.clientCertificate.key, "utf8");
+        if (requestOptions.clientCertificate.passphrase) {
+            agentOptions.passphrase = requestOptions.clientCertificate.passphrase;
+        }
+    }
+    return agentOptions;
+}

package/dist/stream.d.ts

@@ -1,4 +1,5 @@
 export declare function toAsyncIterable(nodeReadable: NodeJS.ReadableStream): AsyncGenerator<Uint8Array>;
 export declare function streamResponse(response: Response): AsyncGenerator<string>;
+export declare function parseDataLine(line: string): any;
 export declare function streamSse(response: Response): AsyncGenerator<any>;
 export declare function streamJSON(response: Response): AsyncGenerator<any>;

package/dist/stream.js

@@ -1,10 +1,13 @@
 export async function* toAsyncIterable(nodeReadable) {
     for await (const chunk of nodeReadable) {
-        // @ts-expect-error
+        // @ts-ignore
         yield chunk;
     }
 }
 export async function* streamResponse(response) {
+    if (response.status === 499) {
+        return; // In case of client-side cancellation, just return
+    }
     if (response.status !== 200) {
         throw new Error(await response.text());
     }
@@ -13,24 +16,33 @@ export async function* streamResponse(response) {
     }
     // Get the major version of Node.js
     const nodeMajorVersion = parseInt(process.versions.node.split(".")[0], 10);
-    if (nodeMajorVersion >= 20) {
-        // Use the new API for Node 20 and above
-        const stream = ReadableStream.from(response.body);
-        for await (const chunk of stream.pipeThrough(new TextDecoderStream("utf-8"))) {
-            yield chunk;
+    try {
+        if (nodeMajorVersion >= 20) {
+            // Use the new API for Node 20 and above
+            const stream = ReadableStream.from(response.body);
+            for await (const chunk of stream.pipeThrough(new TextDecoderStream("utf-8"))) {
+                yield chunk;
+            }
+        }
+        else {
+            // Fallback for Node versions below 20
+            // Streaming with this method doesn't work as version 20+ does
+            const decoder = new TextDecoder("utf-8");
+            const nodeStream = response.body;
+            for await (const chunk of toAsyncIterable(nodeStream)) {
+                yield decoder.decode(chunk, { stream: true });
+            }
         }
     }
-    else {
-        // Fallback for Node versions below 20
-        // Streaming with this method doesn't work as version 20+ does
-        const decoder = new TextDecoder("utf-8");
-        const nodeStream = response.body;
-        for await (const chunk of toAsyncIterable(nodeStream)) {
-            yield decoder.decode(chunk, { stream: true });
+    catch (e) {
+        if (e instanceof Error && e.name.startsWith("AbortError")) {
+            return; // In case of client-side cancellation, just return
         }
+        throw e;
     }
 }
-function parseDataLine(line) {
+// Export for testing purposes
+export function parseDataLine(line) {
     const json = line.startsWith("data: ")
         ? line.slice("data: ".length)
         : line.slice("data:".length);
@@ -42,11 +54,17 @@ function parseDataLine(line) {
         return data;
     }
     catch (e) {
+        // If the error was thrown by our error check, rethrow it
+        if (e instanceof Error &&
+            e.message.startsWith("Error streaming response:")) {
+            throw e;
+        }
+        // Otherwise it's a JSON parsing error
         throw new Error(`Malformed JSON sent from server: ${json}`);
     }
 }
 function parseSseLine(line) {
-    if (line.startsWith("data: [DONE]")) {
+    if (line.startsWith("data:[DONE]") || line.startsWith("data: [DONE]")) {
         return { done: true, data: undefined };
     }
     if (line.startsWith("data:")) {

package/dist/stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/stream.test.js

@@ -0,0 +1,88 @@
+import { Readable } from "stream";
+import { parseDataLine, streamSse } from "./stream.js";
+function createMockResponse(sseLines) {
+    // Create a Readable stream that emits the SSE lines
+    const stream = new Readable({
+        read() {
+            for (const line of sseLines) {
+                this.push(line + "\n\n");
+            }
+            this.push(null); // End of stream
+        },
+    });
+    // Minimal Response mock
+    return {
+        status: 200,
+        body: stream,
+        text: async () => "",
+    };
+}
+describe("streamSse", () => {
+    it("yields parsed SSE data objects that ends with `data:[DONE]`", async () => {
+        const sseLines = [
+            'data: {"foo": "bar"}',
+            'data: {"baz": 42}',
+            "data:[DONE]",
+        ];
+        const response = createMockResponse(sseLines);
+        const results = [];
+        for await (const data of streamSse(response)) {
+            results.push(data);
+        }
+        expect(results).toEqual([{ foo: "bar" }, { baz: 42 }]);
+    });
+    it("yields parsed SSE data objects that ends with `data: [DONE]` (with a space before [DONE]", async () => {
+        const sseLines = [
+            'data: {"foo": "bar"}',
+            'data: {"baz": 42}',
+            "data: [DONE]",
+        ];
+        const response = createMockResponse(sseLines);
+        const results = [];
+        for await (const data of streamSse(response)) {
+            results.push(data);
+        }
+        expect(results).toEqual([{ foo: "bar" }, { baz: 42 }]);
+    });
+    it("throws on malformed JSON", async () => {
+        const sseLines = ['data: {"foo": "bar"', "data:[DONE]"];
+        const response = createMockResponse(sseLines);
+        const iterator = streamSse(response)[Symbol.asyncIterator]();
+        await expect(iterator.next()).rejects.toThrow(/Malformed JSON/);
+    });
+});
+describe("parseDataLine", () => {
+    test("parseDataLine should parse valid JSON data with 'data: ' prefix", () => {
+        const line = 'data: {"message":"hello","status":"ok"}';
+        const result = parseDataLine(line);
+        expect(result).toEqual({ message: "hello", status: "ok" });
+    });
+    test("parseDataLine should parse valid JSON data with 'data:' prefix (no space)", () => {
+        const line = 'data:{"message":"hello","status":"ok"}';
+        const result = parseDataLine(line);
+        expect(result).toEqual({ message: "hello", status: "ok" });
+    });
+    test("parseDataLine should throw error for malformed JSON", () => {
+        const line = "data: {invalid json}";
+        expect(() => parseDataLine(line)).toThrow("Malformed JSON sent from server");
+    });
+    test("parseDataLine should throw error when data contains error field", () => {
+        const line = 'data: {"error":"something went wrong"}';
+        expect(() => parseDataLine(line)).toThrow("Error streaming response: something went wrong");
+    });
+    test("parseDataLine should handle empty objects", () => {
+        const line = "data: {}";
+        const result = parseDataLine(line);
+        expect(result).toEqual({});
+    });
+    test("parseDataLine should handle arrays", () => {
+        const line = "data: [1,2,3]";
+        const result = parseDataLine(line);
+        expect(result).toEqual([1, 2, 3]);
+    });
+    test("parseDataLine should handle nested objects", () => {
+        const line = 'data: {"user":{"name":"John","age":30}}';
+        const result = parseDataLine(line);
+        expect(result).toEqual({ user: { name: "John", age: 30 } });
+    });
+});

package/dist/util.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gets the proxy settings from environment variables
+ * @param protocol The URL protocol (http: or https:)
+ * @returns The proxy URL if available, otherwise undefined
+ */
+export declare function getProxyFromEnv(protocol: string): string | undefined;
+/**
+ * Checks if a hostname should bypass proxy based on NO_PROXY environment variable
+ * @param hostname The hostname to check
+ * @returns True if the hostname should bypass proxy
+ */
+export declare function shouldBypassProxy(hostname: string): boolean;

package/dist/util.js

@@ -0,0 +1,39 @@
+/**
+ * Gets the proxy settings from environment variables
+ * @param protocol The URL protocol (http: or https:)
+ * @returns The proxy URL if available, otherwise undefined
+ */
+export function getProxyFromEnv(protocol) {
+    if (protocol === "https:") {
+        return (process.env.HTTPS_PROXY ||
+            process.env.https_proxy ||
+            process.env.HTTP_PROXY ||
+            process.env.http_proxy);
+    }
+    else {
+        return process.env.HTTP_PROXY || process.env.http_proxy;
+    }
+}
+/**
+ * Checks if a hostname should bypass proxy based on NO_PROXY environment variable
+ * @param hostname The hostname to check
+ * @returns True if the hostname should bypass proxy
+ */
+export function shouldBypassProxy(hostname) {
+    const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+    if (!noProxy)
+        return false;
+    const noProxyItems = noProxy.split(",").map((item) => item.trim());
+    return noProxyItems.some((item) => {
+        // Exact match
+        if (item === hostname)
+            return true;
+        // Wildcard domain match (*.example.com)
+        if (item.startsWith("*.") && hostname.endsWith(item.substring(1)))
+            return true;
+        // Domain suffix match (.example.com)
+        if (item.startsWith(".") && hostname.endsWith(item.slice(1)))
+            return true;
+        return false;
+    });
+}

package/dist/util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util.test.js

@@ -0,0 +1,85 @@
+import { jest } from "@jest/globals";
+import { getProxyFromEnv, shouldBypassProxy } from "./util.js";
+// Reset environment variables after each test
+afterEach(() => {
+    jest.resetModules();
+    process.env = {};
+});
+// Tests for getProxyFromEnv
+test("getProxyFromEnv returns undefined when no proxy is set", () => {
+    expect(getProxyFromEnv("http:")).toBeUndefined();
+    expect(getProxyFromEnv("https:")).toBeUndefined();
+});
+test("getProxyFromEnv returns HTTP_PROXY for http protocol", () => {
+    process.env.HTTP_PROXY = "http://proxy.example.com";
+    expect(getProxyFromEnv("http:")).toBe("http://proxy.example.com");
+});
+test("getProxyFromEnv returns lowercase http_proxy for http protocol", () => {
+    process.env.http_proxy = "http://proxy.example.com";
+    expect(getProxyFromEnv("http:")).toBe("http://proxy.example.com");
+});
+test("getProxyFromEnv prefers HTTP_PROXY over http_proxy for http protocol", () => {
+    process.env.HTTP_PROXY = "http://upper.example.com";
+    process.env.http_proxy = "http://lower.example.com";
+    expect(getProxyFromEnv("http:")).toBe("http://upper.example.com");
+});
+test("getProxyFromEnv returns HTTPS_PROXY for https protocol", () => {
+    process.env.HTTPS_PROXY = "https://secure.example.com";
+    expect(getProxyFromEnv("https:")).toBe("https://secure.example.com");
+});
+test("getProxyFromEnv returns lowercase https_proxy for https protocol", () => {
+    process.env.https_proxy = "https://secure.example.com";
+    expect(getProxyFromEnv("https:")).toBe("https://secure.example.com");
+});
+test("getProxyFromEnv falls back to HTTP_PROXY for https protocol when HTTPS_PROXY is not set", () => {
+    process.env.HTTP_PROXY = "http://fallback.example.com";
+    expect(getProxyFromEnv("https:")).toBe("http://fallback.example.com");
+});
+test("getProxyFromEnv prefers HTTPS_PROXY over other env vars for https protocol", () => {
+    process.env.HTTPS_PROXY = "https://preferred.example.com";
+    process.env.https_proxy = "https://notused1.example.com";
+    process.env.HTTP_PROXY = "http://notused2.example.com";
+    process.env.http_proxy = "http://notused3.example.com";
+    expect(getProxyFromEnv("https:")).toBe("https://preferred.example.com");
+});
+// Tests for shouldBypassProxy
+test("shouldBypassProxy returns false when NO_PROXY is not set", () => {
+    expect(shouldBypassProxy("example.com")).toBe(false);
+});
+test("shouldBypassProxy returns true for exact hostname match", () => {
+    process.env.NO_PROXY = "example.com,another.com";
+    expect(shouldBypassProxy("example.com")).toBe(true);
+});
+test("shouldBypassProxy returns false when hostname doesn't match any NO_PROXY entry", () => {
+    process.env.NO_PROXY = "example.com,another.com";
+    expect(shouldBypassProxy("different.com")).toBe(false);
+});
+test("shouldBypassProxy handles lowercase no_proxy", () => {
+    process.env.no_proxy = "example.com";
+    expect(shouldBypassProxy("example.com")).toBe(true);
+});
+test("shouldBypassProxy works with wildcard domains", () => {
+    process.env.NO_PROXY = "*.example.com";
+    expect(shouldBypassProxy("sub.example.com")).toBe(true);
+    expect(shouldBypassProxy("example.com")).toBe(false);
+    expect(shouldBypassProxy("different.com")).toBe(false);
+});
+test("shouldBypassProxy works with domain suffix", () => {
+    process.env.NO_PROXY = ".example.com";
+    expect(shouldBypassProxy("sub.example.com")).toBe(true);
+    expect(shouldBypassProxy("example.com")).toBe(true);
+    expect(shouldBypassProxy("different.com")).toBe(false);
+});
+test("shouldBypassProxy handles multiple entries with different patterns", () => {
+    process.env.NO_PROXY = "internal.local,*.example.com,.test.com";
+    expect(shouldBypassProxy("internal.local")).toBe(true);
+    expect(shouldBypassProxy("sub.example.com")).toBe(true);
+    expect(shouldBypassProxy("sub.test.com")).toBe(true);
+    expect(shouldBypassProxy("test.com")).toBe(true);
+    expect(shouldBypassProxy("example.org")).toBe(false);
+});
+test("shouldBypassProxy ignores whitespace in NO_PROXY", () => {
+    process.env.NO_PROXY = " example.com , *.test.org ";
+    expect(shouldBypassProxy("example.com")).toBe(true);
+    expect(shouldBypassProxy("subdomain.test.org")).toBe(true);
+});

package/jest.config.mjs

@@ -0,0 +1,20 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
+export default {
+  transform: {
+    "\\.[jt]sx?$": ["ts-jest", { useESM: true }],
+  },
+
+  moduleNameMapper: {
+    "(.+)\\.js": "$1",
+  },
+  extensionsToTreatAsEsm: [".ts"],
+  preset: "ts-jest/presets/default-esm",
+  testTimeout: 10000,
+  testEnvironment: "node",
+  globals: {
+    __dirname: path.dirname(fileURLToPath(import.meta.url)),
+    __filename: path.resolve(fileURLToPath(import.meta.url)),
+  },
+};

package/jest.globals.d.ts

@@ -0,0 +1,14 @@
+// This file declares the Jest globals for TypeScript
+import '@jest/globals';
+
+declare global {
+  const describe: typeof import('@jest/globals').describe;
+  const expect: typeof import('@jest/globals').expect;
+  const it: typeof import('@jest/globals').it;
+  const test: typeof import('@jest/globals').test;
+  const beforeAll: typeof import('@jest/globals').beforeAll;
+  const afterAll: typeof import('@jest/globals').afterAll;
+  const beforeEach: typeof import('@jest/globals').beforeEach;
+  const afterEach: typeof import('@jest/globals').afterEach;
+  const jest: typeof import('@jest/globals').jest;
+}