@speedkit/cli 4.23.3 → 4.24.1

package/dist/services/onboarding/virtual-orestes-app/crawler.d.ts

@@ -1,13 +1,11 @@
 import { SpeedKitServerConfig } from "../onboarding-model.js";
 import { CliService } from "../../cli/index.js";
-import { Agent } from "undici";
 export declare class Crawler {
     private cli;
-    private agentConfig;
     private speedKitServerConfig?;
     /** Warnings already shown, so a per-fetch condition is reported once per session. */
     private readonly warned;
-    constructor(cli: CliService, agentConfig: Agent, speedKitServerConfig?: SpeedKitServerConfig);
+    constructor(cli: CliService, speedKitServerConfig?: SpeedKitServerConfig);
     private warnOnce;
     fetchRemote(originUrl: string, variation: string): Promise<{
         response: Response;

package/dist/services/onboarding/virtual-orestes-app/crawler.js

@@ -1,15 +1,14 @@
 import { safe } from "../../../helpers/safe.js";
 import { resolveRequest, UndefinedVariationError, } from "../../origin-request/index.js";
+import { originFetch } from "../../../helpers/origin-proxy.js";
 import { randomUUID } from "node:crypto";
 export class Crawler {
     cli;
-    agentConfig;
     speedKitServerConfig;
     /** Warnings already shown, so a per-fetch condition is reported once per session. */
     warned = new Set();
-    constructor(cli, agentConfig, speedKitServerConfig) {
+    constructor(cli, speedKitServerConfig) {
         this.cli = cli;
-        this.agentConfig = agentConfig;
         this.speedKitServerConfig = speedKitServerConfig;
     }
     warnOnce(key, message) {
@@ -22,13 +21,9 @@ export class Crawler {
         // origin URL with the variation's query params applied — returned so callers compare it
         // (not the bare originUrl) against response.url for redirect detection
         const { url, init } = this.prepareOriginRequest(originUrl, variation);
-        const requestInit = {
-            ...init,
-            agent: this.agentConfig,
-        };
         const uuid = randomUUID();
         this.cli.startAction(`DOCUMENTHANDLER:FETCH:${uuid}`, `[documentHandler:fetch]: ${url}`);
-        const fetchResponse = await safe(fetch(url, requestInit));
+        const fetchResponse = await safe(originFetch(url, init));
         if (fetchResponse.success === true) {
             this.cli.successAction(`DOCUMENTHANDLER:FETCH:${uuid}`);
             return { response: fetchResponse.data, url };
@@ -79,8 +74,9 @@ export class Crawler {
         return { url: resolved.url, init };
     }
     prepareAuthRequest(originUrl) {
-        if (!this.speedKitServerConfig ||
-            this.speedKitServerConfig.speedKit?.authentications?.length < 1) {
+        // A missing `authentications` has to leave through the same door as an empty one. Comparing
+        // `undefined < 1` yields false, so the previous guard fell through and iterated undefined.
+        if (!this.speedKitServerConfig?.speedKit?.authentications?.length) {
             return;
         }
         const origin = new URL(originUrl).origin;

package/dist/services/onboarding/virtual-orestes-app/crawler.spec.d.ts

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

package/dist/services/onboarding/virtual-orestes-app/crawler.spec.js

@@ -0,0 +1,49 @@
+import { expect } from "chai";
+import { describe, beforeEach, afterEach, it } from "mocha";
+import http from "node:http";
+import { Crawler } from "./crawler.js";
+/** Records the lines the crawler reports, so a spec can assert on them. */
+function stubCli() {
+    const warnings = [];
+    const errors = [];
+    const actions = [];
+    return {
+        warnings,
+        errors,
+        actions,
+        cli: {
+            startAction: (name) => actions.push(name),
+            successAction: (name) => actions.push(`${name}:ok`),
+            failAction: (name) => actions.push(`${name}:fail`),
+            writeWarning: (message) => warnings.push(message),
+            writeError: (message) => errors.push(message),
+        },
+    };
+}
+describe("Crawler.fetchRemote", () => {
+    let server;
+    let url;
+    beforeEach(async () => {
+        server = http.createServer((_request, response) => response.end("origin"));
+        await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+        url = `http://127.0.0.1:${server.address().port}/`;
+    });
+    afterEach(() => server.close());
+    it("fetches an origin whose runtime config carries no authentications", async () => {
+        const { cli } = stubCli();
+        // The config API omits the key for an app without origin auth. Comparing `undefined < 1`
+        // yielded false, so the crawler used to iterate undefined and throw on every fetch.
+        const serverConfig = {
+            speedKit: { variations: { "*": { headers: {} } } },
+        };
+        const result = await new Crawler(cli, serverConfig).fetchRemote(url, "DEFAULT");
+        expect(result).to.not.equal(undefined);
+        expect(await result.response.text()).to.equal("origin");
+    });
+    it("fetches an origin when no runtime config loaded at all", async () => {
+        const { cli, warnings } = stubCli();
+        const result = await new Crawler(cli, undefined).fetchRemote(url, "DEFAULT");
+        expect(await result.response.text()).to.equal("origin");
+        expect(warnings.join(" ")).to.contain("no variations available");
+    });
+});

package/dist/services/origin-request/origin-request-service-factory.js

@@ -1,6 +1,7 @@
 import { CliServiceFactory } from "../cli/index.js";
 import { ConfigApiContext, ConfigApiServiceFactory, } from "../config-api/index.js";
 import { IntegrationApiContext, IntegrationApiFactory, } from "../integration-api/index.js";
+import { applyOriginProxy } from "../../helpers/origin-proxy.js";
 import { OriginRequestService } from "./origin-request-service.js";
 export class OriginRequestServiceFactory {
     context;
@@ -19,7 +20,10 @@ export class OriginRequestServiceFactory {
     async build() {
         const files = await this.getIntegrationFiles();
         const customer = files.getCustomerConfig().config;
-        this.service = new OriginRequestService(this.context, new CliServiceFactory().getService(), this.getConfigApi(customer.app));
+        const cli = new CliServiceFactory().getService();
+        // `--json` owns stdout, so the proxy line stays out of a machine-readable run.
+        applyOriginProxy(customer.chromeFlags, this.context.json ? undefined : cli);
+        this.service = new OriginRequestService(this.context, cli, this.getConfigApi(customer.app));
     }
     async getIntegrationFiles() {
         const integrationApiContext = new IntegrationApiContext(this.context.customerPath, this.context.configName, []);

package/dist/services/origin-request/origin-request-service.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { safe } from "../../helpers/safe.js";
+import { originFetch } from "../../helpers/origin-proxy.js";
 import { DEFAULT_TYPE, resolveRequest, toCurl, UndefinedVariationError, } from "./asset-variations.js";
 /**
  * Fetches a page from origin with exactly the headers Speed Kit's server would send for a cache
@@ -43,7 +44,7 @@ export class OriginRequestService {
             }
             throw error;
         }
-        const response = await fetch(resolved.url, {
+        const response = await originFetch(resolved.url, {
             headers: resolved.headers,
             redirect: "manual",
         });

package/oclif.manifest.json

@@ -1220,5 +1220,5 @@
       ]
     }
   },
-  "version": "4.23.3"
+  "version": "4.24.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@speedkit/cli",
   "description": "Speed Kit CLI",
-  "version": "4.23.3",
+  "version": "4.24.1",
   "author": {
     "name": "Baqend.com",
     "email": "info@baqend.com"
@@ -124,6 +124,7 @@
     "strip-comments": "^2.0.1",
     "tsx": "^4.21.0",
     "tty-table": "^5.0.0",
+    "undici": "^8.1.0",
     "uuid": "^13.0.0"
   },
   "devDependencies": {