@speedkit/cli 4.20.2 → 4.20.3

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [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)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.20.2 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/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];

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/oclif.manifest.json

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

package/package.json

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