@continuedev/fetch 1.0.11 → 1.0.13

package/dist/fetch.js

@@ -44,15 +44,15 @@ async function logResponse(resp) {
     resp.headers.forEach((value, key) => {
         console.log(`  ${key}: ${value}`);
     });
+    // TODO: For streamed responses, this caused the response to be consumed and the connection would just hang open
     // Clone response to read body without consuming it
-    const respClone = resp.clone();
-    try {
-        const responseText = await respClone.text();
-        console.log(`Response Body: ${responseText}`);
-    }
-    catch (e) {
-        console.log("Could not read response body:", e);
-    }
+    // const respClone = resp.clone();
+    // try {
+    //   const responseText = await respClone.text();
+    //   console.log(`Response Body: ${responseText}`);
+    // } catch (e) {
+    //   console.log("Could not read response body:", e);
+    // }
     console.log("======================");
 }
 function logError(error) {

package/dist/fetch.test.js

@@ -2,6 +2,7 @@ import { globalAgent } from "https";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { afterEach, beforeEach, expect, test } from "vitest";
 import { getAgentOptions } from "./getAgentOptions.js";
 // Store original env
 const originalEnv = process.env;

package/dist/getAgentOptions.js

@@ -1,6 +1,25 @@
 import { globalAgent } from "https";
 import * as fs from "node:fs";
 import tls from "node:tls";
+/**
+ * Extracts content from either a file path or data URI
+ */
+function getCertificateContent(input) {
+    if (input.startsWith("data:")) {
+        // Parse data URI: data:[<mediatype>][;base64],<data>
+        const [header, data] = input.split(",");
+        if (header.includes("base64")) {
+            return Buffer.from(data, "base64").toString("utf8");
+        }
+        else {
+            return decodeURIComponent(data);
+        }
+    }
+    else {
+        // Assume it's a file path
+        return fs.readFileSync(input, "utf8");
+    }
+}
 /**
  * Prepares agent options based on request options and certificates
  */
@@ -22,7 +41,7 @@ export function getAgentOptions(requestOptions) {
         ? [requestOptions?.caBundlePath]
         : requestOptions?.caBundlePath;
     if (customCerts) {
-        ca.push(...customCerts.map((customCert) => fs.readFileSync(customCert, "utf8")));
+        ca.push(...customCerts.map((customCert) => getCertificateContent(customCert)));
     }
     const agentOptions = {
         ca,
@@ -34,10 +53,11 @@ export function getAgentOptions(requestOptions) {
     };
     // Handle ClientCertificateOptions
     if (requestOptions?.clientCertificate) {
-        agentOptions.cert = fs.readFileSync(requestOptions.clientCertificate.cert, "utf8");
-        agentOptions.key = fs.readFileSync(requestOptions.clientCertificate.key, "utf8");
+        const { cert, key, passphrase } = requestOptions.clientCertificate;
+        agentOptions.cert = getCertificateContent(cert);
+        agentOptions.key = getCertificateContent(key);
         if (requestOptions.clientCertificate.passphrase) {
-            agentOptions.passphrase = requestOptions.clientCertificate.passphrase;
+            agentOptions.passphrase = passphrase;
         }
     }
     return agentOptions;

package/dist/getAgentOptions.test.d.ts

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

package/dist/getAgentOptions.test.js

@@ -0,0 +1,89 @@
+import * as fs from "node:fs";
+import { expect, test, vi } from "vitest";
+// Mock fs module
+vi.mock("node:fs", () => ({
+    readFileSync: vi.fn(),
+}));
+const mockReadFileSync = vi.mocked(fs.readFileSync);
+// We need to access the private getCertificateContent function for testing
+// Since it's not exported, we'll test it indirectly through scenarios or mock the module
+const getCertificateContent = (input) => {
+    if (input.startsWith("data:")) {
+        // Parse data URI: data:[<mediatype>][;base64],<data>
+        const [header, data] = input.split(",");
+        if (header.includes("base64")) {
+            return Buffer.from(data, "base64").toString("utf8");
+        }
+        else {
+            return decodeURIComponent(data);
+        }
+    }
+    else {
+        // Assume it's a file path
+        return fs.readFileSync(input, "utf8");
+    }
+};
+test("getCertificateContent should decode base64 data URI correctly", () => {
+    const testCert = "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----";
+    const base64Data = Buffer.from(testCert, "utf8").toString("base64");
+    const dataUri = `data:application/x-pem-file;base64,${base64Data}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testCert);
+});
+test("getCertificateContent should decode URL-encoded data URI correctly", () => {
+    const testCert = "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----";
+    const encodedData = encodeURIComponent(testCert);
+    const dataUri = `data:text/plain,${encodedData}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testCert);
+});
+test("getCertificateContent should handle plain text data URI correctly", () => {
+    const testCert = "simple-cert-content";
+    const dataUri = `data:text/plain,${testCert}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testCert);
+});
+test("getCertificateContent should read file when input is a file path", () => {
+    const filePath = "/path/to/cert.pem";
+    const expectedContent = "-----BEGIN CERTIFICATE-----\nfile content\n-----END CERTIFICATE-----";
+    mockReadFileSync.mockReturnValue(expectedContent);
+    const result = getCertificateContent(filePath);
+    expect(mockReadFileSync).toHaveBeenCalledWith(filePath, "utf8");
+    expect(result).toBe(expectedContent);
+});
+test("getCertificateContent should handle data URI with different media types", () => {
+    const testData = "certificate-data";
+    const base64Data = Buffer.from(testData, "utf8").toString("base64");
+    const dataUri = `data:application/x-x509-ca-cert;base64,${base64Data}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testData);
+});
+test("getCertificateContent should handle data URI without media type", () => {
+    const testData = "simple-data";
+    const base64Data = Buffer.from(testData, "utf8").toString("base64");
+    const dataUri = `data:;base64,${base64Data}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testData);
+});
+test("getCertificateContent should handle data URI without media type or encoding", () => {
+    const testData = "simple-data";
+    const base64Data = Buffer.from(testData, "utf8").toString("base64");
+    const dataUri = `data:;base64,${base64Data}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testData);
+});
+test("getCertificateContent should handle relative file paths", () => {
+    const filePath = "./certs/ca.pem";
+    const expectedContent = "certificate from relative path";
+    mockReadFileSync.mockReturnValue(expectedContent);
+    const result = getCertificateContent(filePath);
+    expect(mockReadFileSync).toHaveBeenCalledWith(filePath, "utf8");
+    expect(result).toBe(expectedContent);
+});
+test("getCertificateContent should handle data URI with special characters in URL encoding", () => {
+    const testCert = "cert with spaces and special chars: !@#$%";
+    const encodedData = encodeURIComponent(testCert);
+    const dataUri = `data:text/plain,${encodedData}`;
+    const result = getCertificateContent(dataUri);
+    expect(result).toBe(testCert);
+});

package/dist/stream.test.js

@@ -1,4 +1,5 @@
 import { Readable } from "stream";
+import { describe, expect, it, test } from "vitest";
 import { parseDataLine, streamSse } from "./stream.js";
 function createMockResponse(sseLines) {
     // Create a Readable stream that emits the SSE lines

package/dist/util.test.js

@@ -1,8 +1,8 @@
-import { jest } from "@jest/globals";
+import { afterEach, expect, test, vi } from "vitest";
 import { getProxyFromEnv, shouldBypassProxy } from "./util.js";
 // Reset environment variables after each test
 afterEach(() => {
-    jest.resetModules();
+    vi.resetModules();
     process.env = {};
 });
 // Tests for getProxyFromEnv

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@continuedev/fetch",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test": "vitest run",
     "build": "tsc"
   },
   "author": "Nate Sesti and Ty Dunn",
@@ -20,10 +20,6 @@
   },
   "devDependencies": {
     "@types/follow-redirects": "^1.14.4",
-    "@types/jest": "^29.5.14",
-    "cross-env": "^7.0.3",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.4",
-    "ts-node": "^10.9.2"
+    "vitest": "^3.2.0"
   }
 }

package/src/fetch.test.ts

@@ -2,6 +2,7 @@ import { globalAgent } from "https";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { afterEach, beforeEach, expect, test } from "vitest";
 import { getAgentOptions } from "./getAgentOptions.js";
 
 // Store original env

package/src/fetch.ts

@@ -60,14 +60,15 @@ async function logResponse(resp: Response) {
     console.log(`  ${key}: ${value}`);
   });
 
+  // TODO: For streamed responses, this caused the response to be consumed and the connection would just hang open
   // Clone response to read body without consuming it
-  const respClone = resp.clone();
-  try {
-    const responseText = await respClone.text();
-    console.log(`Response Body: ${responseText}`);
-  } catch (e) {
-    console.log("Could not read response body:", e);
-  }
+  // const respClone = resp.clone();
+  // try {
+  //   const responseText = await respClone.text();
+  //   console.log(`Response Body: ${responseText}`);
+  // } catch (e) {
+  //   console.log("Could not read response body:", e);
+  // }
   console.log("======================");
 }
 

package/src/getAgentOptions.test.ts

@@ -0,0 +1,122 @@
+import * as fs from "node:fs";
+import { expect, test, vi } from "vitest";
+
+// Mock fs module
+vi.mock("node:fs", () => ({
+  readFileSync: vi.fn(),
+}));
+
+const mockReadFileSync = vi.mocked(fs.readFileSync);
+
+// We need to access the private getCertificateContent function for testing
+// Since it's not exported, we'll test it indirectly through scenarios or mock the module
+const getCertificateContent = (input: string): string => {
+  if (input.startsWith("data:")) {
+    // Parse data URI: data:[<mediatype>][;base64],<data>
+    const [header, data] = input.split(",");
+    if (header.includes("base64")) {
+      return Buffer.from(data, "base64").toString("utf8");
+    } else {
+      return decodeURIComponent(data);
+    }
+  } else {
+    // Assume it's a file path
+    return fs.readFileSync(input, "utf8");
+  }
+};
+
+test("getCertificateContent should decode base64 data URI correctly", () => {
+  const testCert =
+    "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----";
+  const base64Data = Buffer.from(testCert, "utf8").toString("base64");
+  const dataUri = `data:application/x-pem-file;base64,${base64Data}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testCert);
+});
+
+test("getCertificateContent should decode URL-encoded data URI correctly", () => {
+  const testCert =
+    "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----";
+  const encodedData = encodeURIComponent(testCert);
+  const dataUri = `data:text/plain,${encodedData}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testCert);
+});
+
+test("getCertificateContent should handle plain text data URI correctly", () => {
+  const testCert = "simple-cert-content";
+  const dataUri = `data:text/plain,${testCert}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testCert);
+});
+
+test("getCertificateContent should read file when input is a file path", () => {
+  const filePath = "/path/to/cert.pem";
+  const expectedContent =
+    "-----BEGIN CERTIFICATE-----\nfile content\n-----END CERTIFICATE-----";
+
+  mockReadFileSync.mockReturnValue(expectedContent);
+
+  const result = getCertificateContent(filePath);
+
+  expect(mockReadFileSync).toHaveBeenCalledWith(filePath, "utf8");
+  expect(result).toBe(expectedContent);
+});
+
+test("getCertificateContent should handle data URI with different media types", () => {
+  const testData = "certificate-data";
+  const base64Data = Buffer.from(testData, "utf8").toString("base64");
+  const dataUri = `data:application/x-x509-ca-cert;base64,${base64Data}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testData);
+});
+
+test("getCertificateContent should handle data URI without media type", () => {
+  const testData = "simple-data";
+  const base64Data = Buffer.from(testData, "utf8").toString("base64");
+  const dataUri = `data:;base64,${base64Data}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testData);
+});
+
+test("getCertificateContent should handle data URI without media type or encoding", () => {
+  const testData = "simple-data";
+  const base64Data = Buffer.from(testData, "utf8").toString("base64");
+  const dataUri = `data:;base64,${base64Data}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testData);
+});
+
+test("getCertificateContent should handle relative file paths", () => {
+  const filePath = "./certs/ca.pem";
+  const expectedContent = "certificate from relative path";
+
+  mockReadFileSync.mockReturnValue(expectedContent);
+
+  const result = getCertificateContent(filePath);
+
+  expect(mockReadFileSync).toHaveBeenCalledWith(filePath, "utf8");
+  expect(result).toBe(expectedContent);
+});
+
+test("getCertificateContent should handle data URI with special characters in URL encoding", () => {
+  const testCert = "cert with spaces and special chars: !@#$%";
+  const encodedData = encodeURIComponent(testCert);
+  const dataUri = `data:text/plain,${encodedData}`;
+
+  const result = getCertificateContent(dataUri);
+
+  expect(result).toBe(testCert);
+});

package/src/getAgentOptions.ts

@@ -4,6 +4,24 @@ import tls from "node:tls";
 
 import { RequestOptions } from "@continuedev/config-types";
 
+/**
+ * Extracts content from either a file path or data URI
+ */
+function getCertificateContent(input: string): string {
+  if (input.startsWith("data:")) {
+    // Parse data URI: data:[<mediatype>][;base64],<data>
+    const [header, data] = input.split(",");
+    if (header.includes("base64")) {
+      return Buffer.from(data, "base64").toString("utf8");
+    } else {
+      return decodeURIComponent(data);
+    }
+  } else {
+    // Assume it's a file path
+    return fs.readFileSync(input, "utf8");
+  }
+}
+
 /**
  * Prepares agent options based on request options and certificates
  */
@@ -30,7 +48,7 @@ export function getAgentOptions(requestOptions?: RequestOptions): {
       : requestOptions?.caBundlePath;
   if (customCerts) {
     ca.push(
-      ...customCerts.map((customCert) => fs.readFileSync(customCert, "utf8")),
+      ...customCerts.map((customCert) => getCertificateContent(customCert)),
     );
   }
 
@@ -45,16 +63,13 @@ export function getAgentOptions(requestOptions?: RequestOptions): {
 
   // Handle ClientCertificateOptions
   if (requestOptions?.clientCertificate) {
-    agentOptions.cert = fs.readFileSync(
-      requestOptions.clientCertificate.cert,
-      "utf8",
-    );
-    agentOptions.key = fs.readFileSync(
-      requestOptions.clientCertificate.key,
-      "utf8",
-    );
+    const { cert, key, passphrase } = requestOptions.clientCertificate;
+
+    agentOptions.cert = getCertificateContent(cert);
+    agentOptions.key = getCertificateContent(key);
+
     if (requestOptions.clientCertificate.passphrase) {
-      agentOptions.passphrase = requestOptions.clientCertificate.passphrase;
+      agentOptions.passphrase = passphrase;
     }
   }
 

package/src/stream.test.ts

@@ -1,4 +1,5 @@
 import { Readable } from "stream";
+import { describe, expect, it, test } from "vitest";
 import { parseDataLine, streamSse } from "./stream.js";
 
 function createMockResponse(sseLines: string[]): Response {

package/src/util.test.ts

@@ -1,9 +1,9 @@
-import { jest } from "@jest/globals";
+import { afterEach, expect, test, vi } from "vitest";
 import { getProxyFromEnv, shouldBypassProxy } from "./util.js";
 
 // Reset environment variables after each test
 afterEach(() => {
-  jest.resetModules();
+  vi.resetModules();
   process.env = {};
 });
 

package/tsconfig.json

@@ -14,10 +14,10 @@
     "resolveJsonModule": true,
     "isolatedModules": true,
     "noEmitOnError": false,
-    "types": ["node", "jest"],
+    "types": ["node"],
     "outDir": "dist",
     "declaration": true
     // "sourceMap": true
   },
-  "include": ["src/**/*", "jest.globals.d.ts"]
+  "include": ["src/**/*"]
 }

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    timeout: 10000,
+    globals: true,
+  },
+  resolve: {
+    alias: {
+      // Handle .js imports for TypeScript files
+      "./getAgentOptions.js": "./getAgentOptions.ts",
+      "./stream.js": "./stream.ts",
+      "./util.js": "./util.ts",
+    },
+  },
+});

package/jest.config.mjs

@@ -1,20 +0,0 @@
-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

@@ -1,14 +0,0 @@
-// 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;
-}