@speedkit/cli 4.20.1 → 4.20.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [4.20.3](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.20.2...v4.20.3) (2026-08-07)
+
+
+### Bug Fixes
+
+* **onboarding:** make headless launch match headed ([aa9af3e](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/aa9af3ea69602c82ef30ffa547b33a32092258e5))
+
+## [4.20.2](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.20.1...v4.20.2) (2026-08-07)
+
+
+### Bug Fixes
+
+* **onboarding:** partial variations local mode ([bf809b1](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/bf809b10b3f6ef8918675971ee950735c3250213))
+
 ## [4.20.1](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.20.0...v4.20.1) (2026-08-07)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.20.1 linux-x64 node-v22.23.2
+@speedkit/cli/4.20.3 linux-x64 node-v22.23.2
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND

package/dist/services/onboarding/browser/executable/headed-user-agent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The user agent headed Chrome sends for this build. Headless would otherwise say
+ * `HeadlessChrome/<version>`, which some origins treat as a crawler.
+ *
+ * @param browserVersionString `chrome --version` output, e.g. `Google Chrome for Testing 146.0.7680.165`
+ */
+export declare function buildHeadedUserAgent(browserVersionString: string, platform?: string): string | undefined;

package/dist/services/onboarding/browser/executable/headed-user-agent.js

@@ -0,0 +1,29 @@
+/**
+ * Chrome's reduced User-Agent, as documented at https://www.chromium.org/updates/ua-reduction/:
+ *
+ *   Mozilla/5.0 (<unifiedPlatform>) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/<major>.0.0.0 Safari/537.36
+ *
+ * Only the major version moves — everything after it is frozen at 0.0.0, and the platform tokens are
+ * literal values that "will not update even if a user is on an updated operating system or device".
+ * So taking the major version from the installed binary keeps this current on its own.
+ */
+const UNIFIED_PLATFORMS = {
+    darwin: "Macintosh; Intel Mac OS X 10_15_7",
+    win32: "Windows NT 10.0; Win64; x64",
+};
+// Chrome reports X11 for every other *nix build it ships.
+const DEFAULT_UNIFIED_PLATFORM = "X11; Linux x86_64";
+/**
+ * The user agent headed Chrome sends for this build. Headless would otherwise say
+ * `HeadlessChrome/<version>`, which some origins treat as a crawler.
+ *
+ * @param browserVersionString `chrome --version` output, e.g. `Google Chrome for Testing 146.0.7680.165`
+ */
+export function buildHeadedUserAgent(browserVersionString, platform = process.platform) {
+    const majorVersion = browserVersionString.match(/(\d+)\.\d+\.\d+\.\d+/)?.[1];
+    if (!majorVersion) {
+        return undefined;
+    }
+    const unifiedPlatform = UNIFIED_PLATFORMS[platform] ?? DEFAULT_UNIFIED_PLATFORM;
+    return `Mozilla/5.0 (${unifiedPlatform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${majorVersion}.0.0.0 Safari/537.36`;
+}

package/dist/services/onboarding/browser/executable/headed-user-agent.spec.d.ts

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

package/dist/services/onboarding/browser/executable/headed-user-agent.spec.js

@@ -0,0 +1,30 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { buildHeadedUserAgent } from "./headed-user-agent.js";
+const CHROME_VERSION = "Google Chrome for Testing 146.0.7680.165";
+describe("buildHeadedUserAgent", () => {
+    it("builds the reduced user agent for Linux", () => {
+        expect(buildHeadedUserAgent(CHROME_VERSION, "linux")).to.equal("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36");
+    });
+    it("builds the reduced user agent for macOS", () => {
+        expect(buildHeadedUserAgent(CHROME_VERSION, "darwin")).to.equal("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36");
+    });
+    it("builds the reduced user agent for Windows", () => {
+        expect(buildHeadedUserAgent(CHROME_VERSION, "win32")).to.equal("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36");
+    });
+    it("falls back to the X11 platform token on other unix builds", () => {
+        expect(buildHeadedUserAgent(CHROME_VERSION, "freebsd")).to.include("(X11; Linux x86_64)");
+    });
+    it("freezes everything after the major version", () => {
+        expect(buildHeadedUserAgent("Google Chrome 131.0.6778.86", "linux")).to.include("Chrome/131.0.0.0 ");
+    });
+    it("reads the version from the Windows ProductName + FileVersion shape", () => {
+        expect(buildHeadedUserAgent("Google Chrome 146.0.7680.165", "win32")).to.include("Chrome/146.0.0.0 ");
+    });
+    it("never advertises the headless token", () => {
+        expect(buildHeadedUserAgent(CHROME_VERSION, "linux")).to.not.include("HeadlessChrome");
+    });
+    it("returns undefined when the version string has no version in it", () => {
+        expect(buildHeadedUserAgent("unknown", "linux")).to.equal(undefined);
+    });
+});

package/dist/services/onboarding/dashboard/diff-against-current-page.js

@@ -13,8 +13,8 @@ export class DiffAgainstCurrentPage {
     async postDiff(currentHtml, currentUrl, variant = "default", transform = false) {
         this.cli.writeWarning(`received diff for url: ${currentUrl}`);
         this.cli.startAction(`DIFF:FETCH:FILE:${currentUrl}`, `fetch remote`);
-        const originResponse = await this.crawler.fetchRemote(currentUrl, variant);
-        let originHtml = await originResponse?.text();
+        const fetchResult = await this.crawler.fetchRemote(currentUrl, variant);
+        let originHtml = await fetchResult?.response?.text();
         if (!originHtml) {
             this.cli.failAction(`DIFF:FETCH:FILE:${currentUrl}`);
             throw new Error("Could not fetch remote page");

package/dist/services/onboarding/onboarding-model.d.ts

@@ -5,6 +5,8 @@ import { AbortResponse } from "./browser/abort-response.js";
 import { task } from "./todo-collector.js";
 import { VanillaPuppeteer } from "puppeteer-extra";
 import { Command } from "@oclif/core/command";
+declare const HEADLESS_DEFAULT_ARGS_TO_DROP: string[];
+export { HEADLESS_DEFAULT_ARGS_TO_DROP };
 export declare const BROWSER_EVENTS: {
     DISCONNECTED: string;
     FETCH_AUTH_REQUIRED: string;
@@ -43,6 +45,12 @@ export declare class BrowserContext {
     readonly browserArgs: string[];
     readonly chromePath: string;
     constructor(domain: string, browserVersionString?: string, chromeFlags?: string[], userConfig?: UserCliConfig, userAgent?: string, debuggingPort?: boolean, headless?: boolean, debugPort?: number);
+    /**
+     * Applied as a launch flag rather than over CDP on purpose: a per-page
+     * `Network.setUserAgentOverride` never reaches the Service Worker, so Speed Kit's dynamic-block
+     * refetch would still leak the headless token and re-poison the merged body.
+     */
+    private getHeadlessParityArgs;
     private isChromeBrowser;
     private getBrowserExtensionPath;
     getPuppeteerLaunchOptions(): Parameters<VanillaPuppeteer["launch"]>[0];
@@ -83,7 +91,7 @@ export type SpeedKitServerConfigVariation = Record<string, {
         accept?: string;
         "user-agent"?: string;
     };
-    queryParams?: [];
+    queryParams?: string[];
     regex?: null | string;
     urlPrefix?: string;
 }>;

package/dist/services/onboarding/onboarding-model.js

@@ -1,6 +1,7 @@
 import { Flags } from "@oclif/core";
 import { CLI_CONFIG_IS_TEST, CLI_CONFIG_NAME, CLIParameters, CLIParametersChar, } from "../../models/cli-parameters.js";
 import { BrowserConfig } from "./browser/config/browser-config.js";
+import { buildHeadedUserAgent } from "./browser/executable/headed-user-agent.js";
 import { resolve } from "node:path";
 const DEFAULT_BROWSER_ARGS = [
     "--enable-features=Translate,NetworkService",
@@ -12,6 +13,25 @@ const DEFAULT_BROWSER_ARGS = [
     // triggered by the flag above. Value is arbitrary and only used as an identifier.
     "--test-type=speed-kit-cli",
 ];
+// Headless Chrome differs from headed in ways customer bot detection and responsive layout both
+// key on, so a page can render differently — or not at all — depending on the mode. Each entry
+// below erases one measured difference; see HEADLESS_DEFAULT_ARGS_TO_DROP for the counterpart.
+const HEADLESS_PARITY_ARGS = [
+    // Headless exposes no pointing device, so `hover: none` / `any-pointer: coarse` send sites down
+    // their touch code path.
+    "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4",
+    // Headless otherwise pins the screen to 800x600, i.e. a tablet breakpoint. --screen-info is what
+    // overrides it; Chrome's own --ozone-override-screen-size is not reachable via ignoreDefaultArgs.
+    "--window-size=1920,1200",
+    "--screen-info={1920x1200}",
+];
+// Puppeteer-injected headless defaults with no headed equivalent. ignoreDefaultArgs only filters what
+// Puppeteer itself adds, so a spec asserts every entry is still in its defaultArgs.
+const HEADLESS_DEFAULT_ARGS_TO_DROP = [
+    // Scrollbar width 0 instead of 15 narrows the layout viewport and skews layout-shift work.
+    "--hide-scrollbars",
+];
+export { HEADLESS_DEFAULT_ARGS_TO_DROP };
 export const BROWSER_EVENTS = {
     DISCONNECTED: "disconnected",
     FETCH_AUTH_REQUIRED: "Fetch.authRequired",
@@ -61,7 +81,8 @@ export class BrowserContext {
         this.domain = domain;
         this.chromeFlags = chromeFlags || [];
         this.chromePath = resolve(userConfig.chromePath);
-        const browserArguments = DEFAULT_BROWSER_ARGS;
+        // Copy: pushing onto the shared module-level array leaked args into every later instance.
+        const browserArguments = [...DEFAULT_BROWSER_ARGS];
         if (userConfig?.chromeUserProfilePath) {
             browserArguments.push(`--user-data-dir=${userConfig?.chromeUserProfilePath}`);
         }
@@ -70,12 +91,32 @@ export class BrowserContext {
             const temporaryProfileDirectory = browserConfig.loadProfileTempDir();
             browserArguments.push(`--user-data-dir=${temporaryProfileDirectory}`);
         }
+        if (this.headless) {
+            this.userAgent =
+                this.userAgent ?? buildHeadedUserAgent(browserVersionString);
+        }
         this.browserArgs = [
             ...browserArguments,
             `--unsafely-treat-insecure-origin-as-secure=${domain}`,
+            ...this.getHeadlessParityArgs(),
+            // Last, so a customer's chromeFlags override our defaults — Chrome takes the last occurrence.
             ...this.chromeFlags,
         ];
     }
+    /**
+     * Applied as a launch flag rather than over CDP on purpose: a per-page
+     * `Network.setUserAgentOverride` never reaches the Service Worker, so Speed Kit's dynamic-block
+     * refetch would still leak the headless token and re-poison the merged body.
+     */
+    getHeadlessParityArgs() {
+        if (!this.headless) {
+            return [];
+        }
+        return [
+            ...HEADLESS_PARITY_ARGS,
+            ...(this.userAgent ? [`--user-agent=${this.userAgent}`] : []),
+        ];
+    }
     isChromeBrowser() {
         return !!/chrome/i.test(this.browserVersionString);
     }
@@ -95,7 +136,10 @@ export class BrowserContext {
             args: this.browserArgs,
             // Strip Puppeteer's default `--enable-automation` so Chrome doesn't show
             // the "Chrome is being controlled by automated test software" infobar.
-            ignoreDefaultArgs: ["--enable-automation"],
+            ignoreDefaultArgs: [
+                "--enable-automation",
+                ...(this.headless ? HEADLESS_DEFAULT_ARGS_TO_DROP : []),
+            ],
         };
         if (this.userConfig?.chromeExtensionPaths) {
             if (this.isChromeBrowser()) {

package/dist/services/onboarding/onboarding-model.spec.js

@@ -1,12 +1,20 @@
 import { expect } from "chai";
 import { describe, it } from "mocha";
-import { BrowserContext } from "./onboarding-model.js";
+import { BrowserContext, HEADLESS_DEFAULT_ARGS_TO_DROP, } from "./onboarding-model.js";
+import { buildHeadedUserAgent } from "./browser/executable/headed-user-agent.js";
 // Providing chromeUserProfilePath keeps BrowserContext off the filesystem
 // (it skips the temp-profile branch in the constructor).
 const userConfig = {
     chromePath: "/usr/bin/google-chrome",
     chromeUserProfilePath: "/tmp/sk-test-profile",
 };
+function newContext(headless, { chromeFlags = [], userAgent, browserVersionString = "Google Chrome for Testing 146.0.7680.165", } = {}) {
+    return new BrowserContext("example.com", browserVersionString, chromeFlags, userConfig, userAgent, false, headless, undefined);
+}
+function launchArgs(headless, overrides = {}) {
+    return newContext(headless, overrides).getPuppeteerLaunchOptions()
+        .args;
+}
 function remoteDebuggingArg(debuggingPort, headless, debugPort) {
     const context = new BrowserContext("example.com", "Chrome/120", [], userConfig, undefined, debuggingPort, headless, debugPort);
     const args = context.getPuppeteerLaunchOptions().args;
@@ -26,3 +34,65 @@ describe("BrowserContext.getPuppeteerLaunchOptions remote debugging port", () =>
         expect(remoteDebuggingArg(false, false, 9223)).to.equal(undefined);
     });
 });
+describe("BrowserContext headless/headed parity", () => {
+    const userAgentOf = (args) => args.find((arg) => arg.startsWith("--user-agent="));
+    it("derives the headed user agent from the installed Chrome version", () => {
+        expect(userAgentOf(launchArgs(true))).to.equal(`--user-agent=${buildHeadedUserAgent("Google Chrome for Testing 146.0.7680.165")}`);
+    });
+    it("never contains the HeadlessChrome token", () => {
+        expect(launchArgs(true).join(" ")).to.not.include("HeadlessChrome");
+    });
+    it("leaves the user agent to Chrome in headed mode", () => {
+        expect(userAgentOf(launchArgs(false))).to.equal(undefined);
+    });
+    it("prefers an explicitly provided user agent", () => {
+        expect(userAgentOf(launchArgs(true, { userAgent: "custom-agent" }))).to.equal("--user-agent=custom-agent");
+    });
+    it("omits the flag when the Chrome version cannot be read", () => {
+        expect(userAgentOf(launchArgs(true, { browserVersionString: "unknown" }))).to.equal(undefined);
+    });
+    it("restores hover and fine-pointer support", () => {
+        expect(launchArgs(true)).to.include("--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4");
+    });
+    it("overrides the 800x600 headless screen", () => {
+        expect(launchArgs(true)).to.include.members([
+            "--window-size=1920,1200",
+            "--screen-info={1920x1200}",
+        ]);
+    });
+    it("applies no parity args in headed mode", () => {
+        const headedArgs = launchArgs(false);
+        expect(headedArgs).to.not.include("--window-size=1920,1200");
+        expect(headedArgs.some((arg) => arg.startsWith("--blink-settings="))).to.equal(false);
+    });
+    it("lets customer chromeFlags win over the parity defaults", () => {
+        const args = launchArgs(true, {
+            chromeFlags: ["--window-size=390,844", "--user-agent=mobile-agent"],
+        });
+        // Chrome takes the last occurrence of a switch, so the customer values must come last.
+        expect(args.lastIndexOf("--window-size=390,844")).to.be.greaterThan(args.lastIndexOf("--window-size=1920,1200"));
+        expect(args.lastIndexOf("--user-agent=mobile-agent")).to.be.greaterThan(args.findIndex((arg) => arg.startsWith("--user-agent=Mozilla/5.0")));
+    });
+    it("drops the Puppeteer headless defaults that have no headed equivalent", () => {
+        expect(newContext(true).getPuppeteerLaunchOptions().ignoreDefaultArgs).to.include.members(["--enable-automation", "--hide-scrollbars"]);
+    });
+    // ignoreDefaultArgs filters Puppeteer's own args by exact string. Anything Chrome adds itself is
+    // unreachable that way, and a Puppeteer bump that renames or drops an arg would silently turn an
+    // entry into a no-op — which is how --ozone-override-screen-size got in here in the first place.
+    it("only ignores args Puppeteer actually adds", async () => {
+        const { defaultArgs } = await import("puppeteer");
+        const puppeteerHeadlessArgs = defaultArgs({ headless: true });
+        expect(puppeteerHeadlessArgs).to.include.members([
+            ...HEADLESS_DEFAULT_ARGS_TO_DROP,
+            "--enable-automation",
+        ]);
+    });
+    it("keeps only --enable-automation ignored in headed mode", () => {
+        expect(newContext(false).getPuppeteerLaunchOptions().ignoreDefaultArgs).to.deep.equal(["--enable-automation"]);
+    });
+    it("does not leak args between instances", () => {
+        const first = launchArgs(true).length;
+        launchArgs(true);
+        expect(launchArgs(true).length).to.equal(first);
+    });
+});

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

@@ -6,7 +6,10 @@ export declare class Crawler {
     private agentConfig;
     private speedKitServerConfig?;
     constructor(cli: CliService, agentConfig: Agent, speedKitServerConfig?: SpeedKitServerConfig);
-    fetchRemote(originUrl: string, variation: string): Promise<Response>;
+    fetchRemote(originUrl: string, variation: string): Promise<{
+        response: Response;
+        url: string;
+    } | undefined>;
     private setDefaultUserAgent;
     /**
      * Mirrors how the Baqend asset server applies the `variations` block from
@@ -28,8 +31,17 @@ export declare class Crawler {
      *      cookie like `fmarktcookie=${storeId}` becomes
      *      `fmarktcookie=2879130`.
      *   3. Origin-level basic auth fallback (only if no variation matched).
+     *
+     * Returns the (query-param-augmented) origin URL alongside the request init,
+     * so query-param variations like `Sortierung=${sort}` reach the origin.
      */
     private prepareOriginRequest;
+    /**
+     * Applies a matched variation: merges its headers into `init` and appends its
+     * `queryParams` onto `url`, substituting regex named groups (`${name}`) — so
+     * `Sortierung=${sort}` with `{ sort: "3" }` becomes `Sortierung=3`.
+     */
+    private applyVariation;
     /**
      * Replaces `${name}` placeholders in each header value with the matching
      * named capture group from a regex match. Used by `prepareOriginRequest`

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

@@ -16,18 +16,21 @@ export class Crawler {
         const headers = {
             "User-Agent": userAgent,
         };
+        // 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, {
+            headers,
+        });
         const requestInit = {
-            ...this.prepareOriginRequest(originUrl, variation, {
-                headers,
-            }),
+            ...init,
             agent: this.agentConfig,
         };
         const uuid = randomUUID();
-        this.cli.startAction(`DOCUMENTHANDLER:FETCH:${uuid}`, `[documentHandler:fetch]: ${originUrl}`);
-        const fetchResponse = await safe(fetch(originUrl, requestInit));
+        this.cli.startAction(`DOCUMENTHANDLER:FETCH:${uuid}`, `[documentHandler:fetch]: ${url}`);
+        const fetchResponse = await safe(fetch(url, requestInit));
         if (fetchResponse.success === true) {
             this.cli.successAction(`DOCUMENTHANDLER:FETCH:${uuid}`);
-            return fetchResponse.data;
+            return { response: fetchResponse.data, url };
         }
         this.cli.failAction(`DOCUMENTHANDLER:FETCH:${uuid}`, `error while fetching Asset: ${originUrl}`);
         this.cli.writeError(fetchResponse.error);
@@ -62,32 +65,35 @@ export class Crawler {
      *      cookie like `fmarktcookie=${storeId}` becomes
      *      `fmarktcookie=2879130`.
      *   3. Origin-level basic auth fallback (only if no variation matched).
+     *
+     * Returns the (query-param-augmented) origin URL alongside the request init,
+     * so query-param variations like `Sortierung=${sort}` reach the origin.
      */
     prepareOriginRequest(originUrl, variationParameter, init) {
+        const url = new URL(originUrl);
         if (!this.speedKitServerConfig) {
-            return init;
+            return { url: url.toString(), init };
         }
         const variations = this.speedKitServerConfig.speedKit.variations;
-        // Wildcard variation headers apply to every request, regardless of which
+        // Wildcard variation applies to every request, regardless of which
         // specific variation (if any) is requested.
         if (variations?.["*"]) {
-            const config = variations["*"];
-            init.headers = { ...init.headers, ...config.headers };
+            this.applyVariation(url, init, variations["*"], undefined);
         }
         if (!variationParameter) {
-            return init;
+            return { url: url.toString(), init };
         }
         // First-match-wins over the variations in declaration order. Each entry
         // can match by exact key or by its Java-style `regex` field; whichever
-        // entry matches first applies its headers and short-circuits the rest.
+        // entry matches first applies its headers + query params and short-circuits.
         for (const variationKey in variations) {
             if (variationKey === "*") {
                 continue;
             }
             const variationConfig = variations[variationKey];
             if (variationParameter === variationKey) {
-                init.headers = { ...init.headers, ...variationConfig.headers };
-                return init;
+                this.applyVariation(url, init, variationConfig, undefined);
+                return { url: url.toString(), init };
             }
             if (!variationConfig.regex) {
                 continue;
@@ -102,18 +108,35 @@ export class Crawler {
             if (!match) {
                 continue;
             }
-            init.headers = {
-                ...init.headers,
-                ...this.substituteNamedGroups(variationConfig.headers, match.groups),
-            };
-            return init;
+            this.applyVariation(url, init, variationConfig, match.groups);
+            return { url: url.toString(), init };
         }
         // No variation matched: fall back to origin basic auth if configured.
         const authentication = this.prepareAuthRequest(originUrl);
         if (authentication) {
             init.headers["Authorization"] = authentication;
         }
-        return init;
+        return { url: url.toString(), init };
+    }
+    /**
+     * Applies a matched variation: merges its headers into `init` and appends its
+     * `queryParams` onto `url`, substituting regex named groups (`${name}`) — so
+     * `Sortierung=${sort}` with `{ sort: "3" }` becomes `Sortierung=3`.
+     */
+    applyVariation(url, init, variationConfig, groups) {
+        init.headers = {
+            ...init.headers,
+            ...this.substituteNamedGroups(variationConfig.headers, groups),
+        };
+        for (const queryParam of variationConfig.queryParams ?? []) {
+            const substituted = groups
+                ? queryParam.replace(/\$\{(\w+)}/g, (match, name) => groups[name] ?? match)
+                : queryParam;
+            const eq = substituted.indexOf("=");
+            const key = eq === -1 ? substituted : substituted.slice(0, eq);
+            const value = eq === -1 ? "" : substituted.slice(eq + 1);
+            url.searchParams.set(key, value);
+        }
     }
     /**
      * Replaces `${name}` placeholders in each header value with the matching

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

@@ -113,7 +113,10 @@ export class VirtualOrestesApp {
         const variation = UrlObject.searchParams.has("bqvariation")
             ? UrlObject.searchParams.get("bqvariation").trim()
             : "default";
-        const response = await this.crawler.fetchRemote(originUrl, variation);
+        const fetchResult = await this.crawler.fetchRemote(originUrl, variation);
+        const response = fetchResult?.response;
+        // URL we actually fetched (origin + variation query params); used for the redirect check below
+        const fetchedUrl = fetchResult?.url;
         // todo check if we can handle more then htmlResponses
         // only handle html responses
         if (!response?.headers?.get("content-type")?.includes("html")) {
@@ -123,8 +126,8 @@ export class VirtualOrestesApp {
             ?.get("Cache-Control")
             ?.includes("no-store");
         const customHeaders = this.prepareCustomHeaders(originUrl, hasNoStoreFlag);
-        // CDN Redirect
-        if (originUrl !== response.url) {
+        // CDN Redirect — compare the fetched URL, not bare originUrl (variation params aren't a redirect)
+        if (fetchedUrl !== response.url) {
             return this.handleCdnRedirect(customHeaders, response, requestUrl);
         }
         if (response.status > 300 && response.status < 400) {

package/oclif.manifest.json

@@ -1001,5 +1001,5 @@
       ]
     }
   },
-  "version": "4.20.1"
+  "version": "4.20.3"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@speedkit/cli",
   "description": "Speed Kit CLI",
-  "version": "4.20.1",
+  "version": "4.20.3",
   "author": {
     "name": "Baqend.com",
     "email": "info@baqend.com"