@speedkit/cli 3.41.0 → 3.43.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [3.43.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v3.42.0...v3.43.0) (2026-04-23)
+
+
+### Features
+
+* **deploy-checks:** polyfill setTimeout and addEventListener in sandboxed config evaluation ([4dac3f0](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/4dac3f04fab2d2f60077a5a301aefef016d57b0f))
+* **onboarding:** hide Chrome automation signals to avoid WAF blocks ([6065442](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/60654424e7a980fd4f8858bdb656ab482b0b9ef1))
+* **onboarding:** serve empty service worker for ?empty=1 requests ([403ad50](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/403ad50bfe953868e63b9a2cd101503fdd1b0c56))
+
+# [3.42.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v3.41.0...v3.42.0) (2026-04-23)
+
+
+### Features
+
+* **customer-config:** add auto feature detection ([81125e8](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/81125e81fe54c8dca01bf7e03c63449d18caab11))
+* **customer-config:** add extended auto detection for shop system + existence of install.js ([c321ba9](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/c321ba98f0a6f89ff90eda9bcab694f64ead5069))
+* **customer-config:** add fetching for most important page types ([948381d](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/948381da8b25aa1f9ead8d7661216bac8ca9ad88))
+* **customer-config:** improve prompts ([cc229d5](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/cc229d56bed19d5b2127cb766837fd660e156a9b))
+* make deployChecks compatible to speed-kit-plugins ([0756959](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/07569595412e533824fda03b2980b7b844415f9f))
+* **wizard:** templates ([a198dde](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/a198dde127b1eee36321007159b92feecc4b64bf))
+
 # [3.41.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v3.40.0...v3.41.0) (2026-04-02)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/3.41.0 linux-x64 node-v20.20.2
+@speedkit/cli/3.43.0 linux-x64 node-v20.20.2
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND

package/dist/helpers/evaluate-speed-kit-config.d.ts

@@ -0,0 +1,15 @@
+import { InstallResourceFile } from "../services/integration-api";
+export declare function evaluateLocalAndRemoteSpeedKit(app: string, origin: string, speedKitConfigFile: InstallResourceFile, activeSpeedKitConfig: string): Promise<{
+    localSpeedKit: {
+        split: any;
+        splitTestId: any;
+        detectDevice: () => void;
+        customVariation: any[];
+    };
+    remoteSpeedKit: {
+        split: any;
+        splitTestId: any;
+        detectDevice: () => void;
+        customVariation: any[];
+    };
+}>;

package/dist/helpers/evaluate-speed-kit-config.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateLocalAndRemoteSpeedKit = evaluateLocalAndRemoteSpeedKit;
+const tslib_1 = require("tslib");
+const evaluate_sk_config_error_1 = require("../services/deploy/error/evaluate-sk-config-error");
+const vm = tslib_1.__importStar(require("node:vm"));
+const bundler_1 = require("../services/bundler");
+async function evaluateLocalAndRemoteSpeedKit(app, origin, speedKitConfigFile, activeSpeedKitConfig) {
+    const localBrowserContext = buildBrowserMock(origin, app);
+    const localFileContent = safeFileContentWrapper(await bundle(speedKitConfigFile.getContent(), app));
+    vm.runInNewContext(localFileContent, localBrowserContext, {
+        filename: speedKitConfigFile.path,
+        displayErrors: false,
+        breakOnSigint: true,
+    });
+    const remoteBrowserContext = buildBrowserMock(origin, app);
+    const remoteFileContent = safeFileContentWrapper(await bundle(activeSpeedKitConfig, app));
+    vm.runInNewContext(remoteFileContent, remoteBrowserContext, {
+        displayErrors: false,
+        breakOnSigint: true,
+    });
+    if (localBrowserContext.vmError !== null) {
+        throw new evaluate_sk_config_error_1.EvaluateSkConfigError(`[config_Speedkit.js] ${localBrowserContext.vmError?.message}`);
+    }
+    if (remoteBrowserContext.vmError !== null) {
+        throw new evaluate_sk_config_error_1.EvaluateSkConfigError(`[remote_config] ${JSON.stringify(remoteBrowserContext.vmError?.message)}`);
+    }
+    const localSpeedKit = localBrowserContext.window.speedKit;
+    const remoteSpeedKit = remoteBrowserContext.window.speedKit;
+    return { localSpeedKit, remoteSpeedKit };
+}
+function buildBrowserMock(origin, app) {
+    const originUrl = new URL(origin);
+    const window = {
+        location: originUrl,
+        APP: app,
+        speedKit: {
+            split: undefined,
+            splitTestId: undefined,
+            detectDevice: () => { },
+            customVariation: [],
+        },
+        SpeedKit: {},
+        serviceWorkerUrl: "",
+        screen: { width: 0, height: 0 },
+        devicePixelRatio: 1,
+        setTimeout: () => { },
+        clearTimeout: () => { },
+        addEventListener: () => { },
+        removeEventListener: () => { },
+        navigator: {
+            userAgent: "",
+            connection: {},
+            cookieEnabled: false,
+            languages: [],
+            online: true,
+        },
+        top: {},
+    };
+    window.top = window;
+    const document = {
+        cookie: "",
+        querySelector: () => { },
+        querySelectorAll: () => { },
+        createElement: () => { },
+        addEventListener: () => { },
+        removeEventListener: () => { },
+        head: {},
+        body: {},
+    };
+    document.head = document;
+    document.body = document;
+    return {
+        vmError: null,
+        ...window,
+        window,
+        document,
+        navigator: { userAgent: "" },
+        localStorage: {
+            getItem: () => { },
+            setItem: () => { },
+        },
+        JSON: JSON,
+        decodeURIComponent: decodeURIComponent,
+        URL: URL,
+    };
+}
+function safeFileContentWrapper(fileContent) {
+    return `
+      try{
+        ${fileContent}
+      } catch (error){
+        vmError = error
+      }
+    `;
+}
+async function bundle(content, app) {
+    const bundler = new bundler_1.BundleService();
+    return bundler.bundle({
+        basePaths: {
+            "speed-kit-config": "https://www.baqend.com/speed-kit-config/latest/",
+        },
+        entryPoints: { "config.js": content },
+        logLevel: "error",
+        minify: false,
+        define: {
+            APP: JSON.stringify(app),
+        },
+    });
+}

package/dist/helpers/site-analyzer.d.ts

@@ -0,0 +1,12 @@
+export type DetectedShopSystem = "shopify" | "shopware" | "salesforce" | "oxid" | "plentymarkets" | "magento" | "woocommerce" | "bigcommerce" | "prestashop" | "jtl" | "commercetools" | "spryker" | "shoptet" | "ecforce" | "futureshop" | null;
+export interface SiteAnalysisResult {
+    useGATracking: boolean;
+    withGoogleOptimize: boolean;
+    activateCfRocketLoaderPlugin: boolean;
+    includeServiceWorker: boolean;
+    removeLazyLoading: boolean;
+    hasSoftNavigations: boolean;
+    shopSystem: DetectedShopSystem;
+    hasInstallJs: boolean;
+}
+export declare function analyzeSite(host: string, log?: (message: string) => void): Promise<SiteAnalysisResult | null>;

package/dist/helpers/site-analyzer.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSite = analyzeSite;
+const tslib_1 = require("tslib");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const safe_js_1 = require("./safe.js");
+const EMPTY_FLAGS = {
+    useGATracking: false,
+    withGoogleOptimize: false,
+    activateCfRocketLoaderPlugin: false,
+    includeServiceWorker: false,
+    removeLazyLoading: false,
+    hasSoftNavigations: false,
+};
+function detectFeatures(html, headers) {
+    return {
+        useGATracking: /dataLayer|gtm\.js|googletagmanager\.com|gtag\/js/.test(html),
+        withGoogleOptimize: /googleoptimize\.com|optimize\.google\.com/.test(html),
+        activateCfRocketLoaderPlugin: /data-cfasync|rocket-loader/.test(html) || "cf-ray" in headers,
+        includeServiceWorker: /navigator\.serviceWorker\.register|serviceWorker\.register/.test(html),
+        removeLazyLoading: /loading=["']lazy["']|data-src=|class=["'][^"']*lazyload|lazysizes/.test(html),
+        hasSoftNavigations: /__NEXT_DATA__|__NUXT__|vue-router|react-router|history\.pushState/.test(html),
+    };
+}
+function mergeFeatures(results) {
+    const keys = Object.keys(EMPTY_FLAGS);
+    const merged = { ...EMPTY_FLAGS };
+    for (const key of keys) {
+        merged[key] = results.some((r) => r[key]);
+    }
+    return merged;
+}
+function detectShopSystem(html) {
+    if (/Shopify\.theme|myshopify\.com|cdn\.shopify\.com/.test(html))
+        return "shopify";
+    if (/shopware|sw-buy-box|sw-product/.test(html))
+        return "shopware";
+    if (/demandware|dw\.ac|sfcc|SalesforceCommerceCloud/.test(html))
+        return "salesforce";
+    if (/oxid-esales|oxid\.php/.test(html))
+        return "oxid";
+    if (/plentymarkets|plenty-/.test(html))
+        return "plentymarkets";
+    if (/Magento|mage-error|magento\.com|\/static\/version/.test(html))
+        return "magento";
+    if (/woocommerce|wc-block|wp-content.*woo/.test(html))
+        return "woocommerce";
+    if (/BigCommerce|bigcommerce\.com|stencil-/.test(html))
+        return "bigcommerce";
+    if (/PrestaShop|prestashop|modules\/ps_/.test(html))
+        return "prestashop";
+    if (/jtl-shop|JTL-Shop|jtl-/.test(html))
+        return "jtl";
+    if (/commercetools/.test(html))
+        return "commercetools";
+    if (/spryker|Spryker/.test(html))
+        return "spryker";
+    if (/shoptet/.test(html))
+        return "shoptet";
+    if (/ecforce/.test(html))
+        return "ecforce";
+    if (/futureshop/.test(html))
+        return "futureshop";
+    return null;
+}
+function detectInstallJs(html) {
+    return /app\.baqend\.com\/v1\/speedkit\/install\.js/.test(html);
+}
+// Heuristics to find PLP/PDP links from page HTML
+const PLP_PATTERN = /\/collections\/[^\s"#'?]+|\/category\/[^\s"#'?]+|\/kategorie\/[^\s"#'?]+|\/c\/[^\s"#'?]+/i;
+const PDP_PATTERN = /\/products\/[^\s"#'?]+|\/product\/[^\s"#'?]+|\/produkt\/[^\s"#'?]+|\/p\/[^\s"#'?]+|\/dp\/[^\s"#'?]+/i;
+function findUrl(html, host, pattern) {
+    const match = html.match(pattern);
+    if (!match)
+        return null;
+    const path = match[0];
+    // Skip paths that look like assets
+    if (/\.\w{2,4}$/.test(path))
+        return null;
+    return `https://${host}${path}`;
+}
+async function fetchPage(url, signal) {
+    const result = await (0, safe_js_1.safe)((0, node_fetch_1.default)(url, { signal: signal }));
+    if (!result.success)
+        return null;
+    const response = result.data;
+    if (response.status !== 200)
+        return null;
+    const html = await response.text();
+    const headers = Object.fromEntries([...response.headers.entries()].map(([k, v]) => [k.toLowerCase(), v]));
+    return { html, headers };
+}
+async function fetchAndAnalyze(host, log) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    try {
+        const featureResults = [];
+        // 1. Fetch homepage (required)
+        log(`Fetching homepage: https://${host}`);
+        const homePage = await fetchPage(`https://${host}`, controller.signal);
+        if (!homePage)
+            return null;
+        featureResults.push(detectFeatures(homePage.html, homePage.headers));
+        // 2. Detect shop system from homepage
+        const shopSystem = detectShopSystem(homePage.html);
+        // 3. Check install.js presence in homepage HTML
+        const hasInstallJs = detectInstallJs(homePage.html);
+        // 4. Find PLP + PDP links from homepage
+        const plpUrl = findUrl(homePage.html, host, PLP_PATTERN);
+        let pdpUrl = findUrl(homePage.html, host, PDP_PATTERN);
+        // 5. Fetch PLP (best-effort)
+        let plpPage = null;
+        if (plpUrl) {
+            log(`Fetching PLP: ${plpUrl}`);
+            plpPage = await fetchPage(plpUrl, controller.signal);
+            if (plpPage) {
+                featureResults.push(detectFeatures(plpPage.html, plpPage.headers));
+                // 6. If homepage didn't have a PDP link, try extracting one from PLP
+                if (!pdpUrl) {
+                    pdpUrl = findUrl(plpPage.html, host, PDP_PATTERN);
+                }
+            }
+        }
+        // 7. Fetch PDP (best-effort)
+        if (pdpUrl) {
+            log(`Fetching PDP: ${pdpUrl}`);
+            const pdpPage = await fetchPage(pdpUrl, controller.signal);
+            if (pdpPage) {
+                featureResults.push(detectFeatures(pdpPage.html, pdpPage.headers));
+            }
+        }
+        return {
+            ...mergeFeatures(featureResults),
+            shopSystem,
+            hasInstallJs,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function analyzeSite(host, log = console.log) {
+    const result = await (0, safe_js_1.safe)(fetchAndAnalyze(host, log));
+    return result.success ? result.data : null;
+}

package/dist/services/cli/cli-service-model.d.ts

@@ -24,7 +24,13 @@ export interface CliServiceInterface {
         defaultAnswer?: any;
         validator?: any;
     }): Promise<string>;
-    select(message: string, choices: any): Promise<string>;
+    select(message: string, choices: any, defaultValue?: string): Promise<string>;
+    multiSelect<T>(message: string, choices: {
+        name: string;
+        value: T;
+        checked?: boolean;
+        description?: string;
+    }[]): Promise<T[]>;
     spacer(): void;
     startAction(message: string): void;
     startProgress(total: number, start?: number, payload?: object, config?: Options): void;

package/dist/services/cli/cli-service.d.ts

@@ -19,7 +19,13 @@ export declare class CliService implements CliServiceInterface {
         defaultAnswer?: any;
         validator?: any;
     }): Promise<string>;
-    select(message: string, choices: any): Promise<string>;
+    select(message: string, choices: any, defaultValue?: string): Promise<string>;
+    multiSelect<T>(message: string, choices: {
+        name: string;
+        value: T;
+        checked?: boolean;
+        description?: string;
+    }[]): Promise<T[]>;
     spacer(): void;
     startAction(message: string): void;
     startProgress(total: number, start?: number, payload?: object, config?: Options): void;

package/dist/services/cli/cli-service.js

@@ -89,8 +89,18 @@ class CliService {
             },
         });
     }
-    async select(message, choices) {
+    async select(message, choices, defaultValue) {
         return (0, prompts_1.select)({
+            choices,
+            default: defaultValue,
+            message: this.getFormattedMessage(message),
+        });
+    }
+    async multiSelect(message, choices) {
+        if (this.quiet) {
+            return choices.filter((c) => c.checked).map((c) => c.value);
+        }
+        return (0, prompts_1.checkbox)({
             choices,
             message: this.getFormattedMessage(message),
         });

package/dist/services/customer-config/customer-config-service-model.d.ts

@@ -4,12 +4,22 @@ export declare enum DirectoryOverwriteOption {
     OVERWRITE_COMPLETELY = "Empty and create new"
 }
 export declare enum ShopSystem {
-    OTHER = "None of the below-mentioned",
+    OTHER = "- unknown -",
     SHOPIFY = "Shopify",
     SHOPWARE = "Shopware",
     SALESFORCE = "Salesforce Commerce Cloud",
     OXID = "OXID eShop",
-    PLENTYMARKETS = "Plentymarkets"
+    PLENTYMARKETS = "Plentymarkets",
+    MAGENTO = "Magento",
+    WOOCOMMERCE = "WooCommerce",
+    PRESTASHOP = "PrestaShop",
+    JTL = "JTL-Shop",
+    COMMERCETOOLS = "commercetools",
+    SPRYKER = "Spryker",
+    SHOPTET = "Shoptet",
+    BIGCOMMERCE = "BigCommerce",
+    ECFORCE = "ecforce",
+    FUTURESHOP = "futureshop"
 }
 export declare enum EnvironmentType {
     PRODUCTION = "production",
@@ -40,9 +50,11 @@ export interface CustomerConfigSettings {
     convertSoftToHardNavigations?: boolean;
     isPOV?: boolean;
     useDisabledSitesApproach?: boolean;
+    shopSystemName?: string;
     isShopify?: boolean;
     isShopware?: boolean;
     isSalesforce?: boolean;
     isOxid?: boolean;
     isPlentymarkets?: boolean;
+    addDowntimeDetection?: boolean;
 }

package/dist/services/customer-config/customer-config-service-model.js

@@ -9,12 +9,25 @@ var DirectoryOverwriteOption;
 })(DirectoryOverwriteOption || (exports.DirectoryOverwriteOption = DirectoryOverwriteOption = {}));
 var ShopSystem;
 (function (ShopSystem) {
-    ShopSystem["OTHER"] = "None of the below-mentioned";
+    ShopSystem["OTHER"] = "- unknown -";
+    // DACH / Europe
     ShopSystem["SHOPIFY"] = "Shopify";
     ShopSystem["SHOPWARE"] = "Shopware";
     ShopSystem["SALESFORCE"] = "Salesforce Commerce Cloud";
     ShopSystem["OXID"] = "OXID eShop";
     ShopSystem["PLENTYMARKETS"] = "Plentymarkets";
+    ShopSystem["MAGENTO"] = "Magento";
+    ShopSystem["WOOCOMMERCE"] = "WooCommerce";
+    ShopSystem["PRESTASHOP"] = "PrestaShop";
+    ShopSystem["JTL"] = "JTL-Shop";
+    ShopSystem["COMMERCETOOLS"] = "commercetools";
+    ShopSystem["SPRYKER"] = "Spryker";
+    ShopSystem["SHOPTET"] = "Shoptet";
+    // US
+    ShopSystem["BIGCOMMERCE"] = "BigCommerce";
+    // Japan
+    ShopSystem["ECFORCE"] = "ecforce";
+    ShopSystem["FUTURESHOP"] = "futureshop";
 })(ShopSystem || (exports.ShopSystem = ShopSystem = {}));
 var EnvironmentType;
 (function (EnvironmentType) {

package/dist/services/customer-config/customer-config-service.js

@@ -6,6 +6,7 @@ const fs = tslib_1.__importStar(require("node:fs"));
 const path = tslib_1.__importStar(require("node:path"));
 const Handlebars = tslib_1.__importStar(require("handlebars"));
 const cli_1 = require("../cli");
+const site_analyzer_js_1 = require("../../helpers/site-analyzer.js");
 const customer_config_service_model_1 = require("./customer-config-service-model");
 class CustomerConfigService {
     context;
@@ -118,10 +119,11 @@ class CustomerConfigService {
         this.cli.spacer();
     }
     async getEnvironmentConfig(environmentType, defaultHost) {
-        const host = await this.cli.prompt(`[${environmentType.toUpperCase()}] Enter ${environmentType.toUpperCase()} host (without https://):`, {
+        const label = environmentType.charAt(0).toUpperCase() + environmentType.slice(1);
+        const host = await this.cli.prompt(`[${label}] Enter ${label.toLowerCase()} host (without https://):`, {
             defaultAnswer: defaultHost,
         });
-        const forceInstall = !(await this.cli.confirm(`[${environmentType.toUpperCase()}] Is the install.js already present on ${environmentType.toUpperCase()}?`, false));
+        const forceInstall = !(await this.cli.confirm(`[${label}] Is the install.js already present?`, false));
         return {
             host,
             forceInstall,
@@ -136,15 +138,70 @@ class CustomerConfigService {
         return true;
     }
     async getConfigSettings() {
-        let { production, staging, includeServiceWorker, activateImageOptimisation, removeLazyLoading, addSSR, addSSRInnerShadowDomSupport, addDeviceDetection, useGATracking, useScrapingBee, withGoogleOptimize, activateCfRocketLoaderPlugin, hasSoftNavigations, convertSoftToHardNavigations, useDisabledSitesApproach, isShopify, isShopware, isSalesforce, isOxid, isPlentymarkets, isPOV, } = {};
-        this.appName = await this.cli.prompt(`[App Name] Enter desired SK app name:`, {
+        let { production, staging, includeServiceWorker, isShopify, isShopware, isSalesforce, isOxid, isPlentymarkets, } = {};
+        this.appName = await this.cli.prompt(`[App] Enter desired Speed Kit app name:`, {
             validator: (input) => /^[\da-z]+(?:-[\da-z]+)*$/.test(input) ? "" : "No valid kebab-case",
             defaultAnswer: this.appName,
         });
-        const selectedShopSystem = await this.cli.select("[Shop System] Which shop system is in use?", Object.values(customer_config_service_model_1.ShopSystem).map((option) => ({
-            name: option,
-            value: option,
-        })));
+        this.cli.spacer();
+        // 1. Production host (needed for site analysis)
+        const productionHost = await this.cli.prompt(`[Production] Enter production host (without https://):`, { defaultAnswer: `www.${this.appName}.de` });
+        this.cli.spacer();
+        // 2. Site analysis (informs shop system, install.js, and feature defaults)
+        let siteAnalysis = null;
+        const shouldAnalyze = await this.cli.confirm("[Analysis] Analyze production site to auto-detect settings?", true);
+        if (shouldAnalyze) {
+            this.cli.startAction(`Analyzing https://${productionHost}`);
+            siteAnalysis = await (0, site_analyzer_js_1.analyzeSite)(productionHost, (message) => this.cli.comment(message));
+            if (siteAnalysis) {
+                this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
+            }
+            else {
+                this.cli.endAction(cli_1.CliActionStatus.SKIPPED);
+                this.cli.comment("Could not analyze site — using defaults.");
+            }
+        }
+        this.cli.spacer();
+        // 3. Shop system
+        const detectedShopMap = {
+            shopify: customer_config_service_model_1.ShopSystem.SHOPIFY,
+            shopware: customer_config_service_model_1.ShopSystem.SHOPWARE,
+            salesforce: customer_config_service_model_1.ShopSystem.SALESFORCE,
+            oxid: customer_config_service_model_1.ShopSystem.OXID,
+            plentymarkets: customer_config_service_model_1.ShopSystem.PLENTYMARKETS,
+            magento: customer_config_service_model_1.ShopSystem.MAGENTO,
+            woocommerce: customer_config_service_model_1.ShopSystem.WOOCOMMERCE,
+            bigcommerce: customer_config_service_model_1.ShopSystem.BIGCOMMERCE,
+            prestashop: customer_config_service_model_1.ShopSystem.PRESTASHOP,
+            jtl: customer_config_service_model_1.ShopSystem.JTL,
+            commercetools: customer_config_service_model_1.ShopSystem.COMMERCETOOLS,
+            spryker: customer_config_service_model_1.ShopSystem.SPRYKER,
+            shoptet: customer_config_service_model_1.ShopSystem.SHOPTET,
+            ecforce: customer_config_service_model_1.ShopSystem.ECFORCE,
+            futureshop: customer_config_service_model_1.ShopSystem.FUTURESHOP,
+        };
+        const detectedShop = siteAnalysis?.shopSystem
+            ? detectedShopMap[siteAnalysis.shopSystem]
+            : undefined;
+        let selectedShopSystem;
+        if (detectedShop) {
+            selectedShopSystem = detectedShop;
+            this.cli.comment(`[Shop System] Detected: ${detectedShop}`);
+        }
+        else {
+            if (siteAnalysis) {
+                this.cli.comment("[Shop System] Could not detect shop system from site.");
+            }
+            selectedShopSystem = await this.cli.select("[Shop System] Which shop system is in use?", [
+                customer_config_service_model_1.ShopSystem.SHOPIFY,
+                customer_config_service_model_1.ShopSystem.SHOPWARE,
+                customer_config_service_model_1.ShopSystem.SALESFORCE,
+                customer_config_service_model_1.ShopSystem.OXID,
+                customer_config_service_model_1.ShopSystem.PLENTYMARKETS,
+                customer_config_service_model_1.ShopSystem.OTHER,
+            ].map((option) => ({ name: option, value: option })));
+        }
+        this.cli.spacer();
         switch (selectedShopSystem) {
             case customer_config_service_model_1.ShopSystem.SHOPIFY: {
                 isShopify = true;
@@ -164,42 +221,155 @@ class CustomerConfigService {
             }
             case customer_config_service_model_1.ShopSystem.PLENTYMARKETS: {
                 isPlentymarkets = true;
+                break;
             }
         }
-        production = await this.getEnvironmentConfig(customer_config_service_model_1.EnvironmentType.PRODUCTION, `www.${this.appName}.de`);
+        // 4. Production install.js
+        const installJsDetected = siteAnalysis?.hasInstallJs ?? false;
+        const forceInstall = !(await this.cli.confirm(`[Production] Is the install.js already present?${installJsDetected ? " (detected)" : ""}`, installJsDetected));
+        this.cli.spacer();
+        production = { host: productionHost, forceInstall };
+        // 5. Staging
         if (!isShopify) {
-            const withStaging = await this.cli.confirm(`[${customer_config_service_model_1.EnvironmentType.STAGING.toUpperCase()}] Should a ${customer_config_service_model_1.EnvironmentType.STAGING.toUpperCase()} config also be added?`, false);
+            const withStaging = await this.cli.confirm("[Staging] Should a staging config also be added?", false);
             if (withStaging) {
-                staging = await this.getEnvironmentConfig(customer_config_service_model_1.EnvironmentType.STAGING, production.host.replace("www", "staging"));
+                staging = await this.getEnvironmentConfig(customer_config_service_model_1.EnvironmentType.STAGING, productionHost.replace("www", "staging"));
             }
+            this.cli.spacer();
         }
-        if (await this.cli.confirm("[Service Worker] Is there a Service Worker which needs to be included?", false)) {
-            includeServiceWorker = await this.cli.prompt("[Service Worker] Enter path of Service Worker to be included:", { defaultAnswer: "/sw.js" });
+        const resolve = (feature, fallback) => {
+            if (!siteAnalysis)
+                return { label: "", checked: fallback };
+            if (siteAnalysis[feature])
+                return { label: " (detected)", checked: true };
+            return { label: " (not detected)", checked: fallback };
+        };
+        const lazyLoading = resolve("removeLazyLoading", true);
+        const softNav = resolve("hasSoftNavigations", false);
+        const serviceWorker = resolve("includeServiceWorker", false);
+        const gaTracking = resolve("useGATracking", true);
+        const googleOptimize = resolve("withGoogleOptimize", false);
+        const cfRocketLoader = resolve("activateCfRocketLoaderPlugin", false);
+        // Detectable features — sorted detected-first when analysis is available
+        const detectableChoices = [
+            {
+                name: `Lazy-Loading Removal / Preloading${lazyLoading.label}`,
+                value: "removeLazyLoading",
+                checked: lazyLoading.checked,
+                description: "Remove lazy-loading attributes and preload critical resources",
+            },
+            {
+                name: `Soft Navigation Tracking${softNav.label}`,
+                value: "hasSoftNavigations",
+                checked: softNav.checked,
+                description: "Track SPA route changes (Next.js, Nuxt, Vue/React Router)",
+            },
+            {
+                name: `Include existing Service Worker${serviceWorker.label}`,
+                value: "includeServiceWorker",
+                checked: serviceWorker.checked,
+                description: "Merge customer's existing Service Worker with Speed Kit's",
+            },
+            ...(isShopify
+                ? []
+                : [
+                    {
+                        name: `GA DataLayer Tracking${gaTracking.label}`,
+                        value: "useGATracking",
+                        checked: gaTracking.checked,
+                        description: "Forward dataLayer events through Speed Kit",
+                    },
+                ]),
+            {
+                name: `Google Optimize Support${googleOptimize.label}`,
+                value: "withGoogleOptimize",
+                checked: googleOptimize.checked,
+                description: "Ensure compatibility with Google Optimize experiments",
+            },
+            {
+                name: `Cloudflare Rocket Loader Plugin${cfRocketLoader.label}`,
+                value: "activateCfRocketLoaderPlugin",
+                checked: cfRocketLoader.checked,
+                description: "Handle Cloudflare Rocket Loader script deferral",
+            },
+        ];
+        if (siteAnalysis) {
+            const detectionRank = (name) => {
+                if (name.includes("(detected)"))
+                    return 0;
+                if (name.includes("(not detected)"))
+                    return 1;
+                return 2;
+            };
+            detectableChoices.sort((a, b) => detectionRank(a.name) - detectionRank(b.name));
         }
-        useDisabledSitesApproach = await this.cli.confirm("[Disabled Sites] Use disabled sites approach as the given URL structure makes it hard to identify specific page types?", false);
-        activateImageOptimisation = await this.cli.confirm("[IO] Should image optimisation be activated?", false);
-        removeLazyLoading = await this.cli.confirm("[Lazy Loading] Does the shop require us to resolve lazy-loaded content?");
-        if (await this.cli.confirm("[Lambda SSR] Add server-side-rendering? This requires a set-up Lambda function to work.", false)) {
-            addSSR = true;
-            if (await this.cli.confirm("[Lambda SSR] Does the customer utilize Shadow DOMs? If so additional handling for this will be added.", false)) {
-                addSSRInnerShadowDomSupport = true;
-            }
+        // Static features — not auto-detectable
+        const staticChoices = [
+            {
+                name: "Disabled Sites approach",
+                value: "useDisabledSitesApproach",
+                description: "Use when URL structure makes page type identification hard",
+            },
+            {
+                name: "Image Optimisation",
+                value: "activateImageOptimisation",
+                description: "Optimize images via Speed Kit (skip if site already uses an image CDN with WebP)",
+            },
+            { name: "Server-Side Rendering (SSR)", value: "addSSR" },
+            {
+                name: "Device Detection",
+                value: "addDeviceDetection",
+                description: "Auto-enabled with SSR",
+            },
+            {
+                name: "Enhanced PoV Tracking",
+                value: "isPOV",
+                description: "Extended analytics for Proof of Value engagements",
+            },
+            {
+                name: "ScrapingBee",
+                value: "useScrapingBee",
+                description: "Use for geo-location-based responses",
+            },
+            { name: "Downtime Detection", value: "addDowntimeDetection" },
+        ];
+        const featureChoices = [
+            ...detectableChoices,
+            ...staticChoices,
+        ];
+        const selectedFeatures = await this.cli.multiSelect("[Features] Select features to enable:", featureChoices);
+        this.cli.spacer();
+        const has = (feature) => selectedFeatures.includes(feature);
+        const useDisabledSitesApproach = has("useDisabledSitesApproach");
+        const activateImageOptimisation = has("activateImageOptimisation");
+        const removeLazyLoading = has("removeLazyLoading");
+        const addSSR = has("addSSR");
+        // SSR always implies device detection
+        const addDeviceDetection = addSSR || has("addDeviceDetection");
+        const hasSoftNavigations = has("hasSoftNavigations");
+        const useGATracking = has("useGATracking");
+        const isPOV = has("isPOV");
+        const withGoogleOptimize = has("withGoogleOptimize");
+        const activateCfRocketLoaderPlugin = has("activateCfRocketLoaderPlugin");
+        const useScrapingBee = has("useScrapingBee");
+        const addDowntimeDetection = has("addDowntimeDetection");
+        // Follow-up questions for features that need additional input
+        if (has("includeServiceWorker")) {
+            includeServiceWorker = await this.cli.prompt("[Service Worker] Enter path of Service Worker to be included:", { defaultAnswer: "/sw.js" });
+            this.cli.spacer();
         }
-        // ask for variation handling only if adding Lambda SSR is not needed, as it will come with device detection anyway
-        addDeviceDetection = addSSR
-            ? true
-            : await this.cli.confirm("[Device Detection] Do mobile and desktop versions of the website differ in their HTML structure, which would require us to add variations?", false);
-        useScrapingBee = await this.cli.confirm("[ScrapingBee] Do customer responses differ geo-location-based which would require ScrapingBee API to fetch documents?", false);
-        if (!isShopify) {
-            useGATracking = await this.cli.confirm("[Tracking] Add tracking based on Google Analytics' DataLayer?");
+        let addSSRInnerShadowDomSupport;
+        if (addSSR) {
+            addSSRInnerShadowDomSupport = await this.cli.confirm("[SSR] Activate handling for customer-utilized Shadow DOMs?", false);
+            this.cli.spacer();
         }
-        hasSoftNavigations = await this.cli.confirm("[Tracking] Add tracking for Soft Navigations?", false);
+        let convertSoftToHardNavigations;
         if (hasSoftNavigations) {
-            convertSoftToHardNavigations = await this.cli.confirm("[Soft2Hard Navigations] Should soft navigations be converted to hard navigations?", false);
+            convertSoftToHardNavigations = await this.cli.confirm("[Soft Navigations] Convert soft navigations to hard navigations?", true);
+            this.cli.spacer();
         }
-        isPOV = await this.cli.confirm("[Tracking] Is a POV (proof of value) anticipated, so that additional tracking is needed?", false);
-        withGoogleOptimize = await this.cli.confirm("[Services] Is Google Optimize used?", false);
-        activateCfRocketLoaderPlugin = await this.cli.confirm("[Services] Is Cloudflare's Rocket Loader used, for which we need to activate our rocket loader plugin?", false);
+        // Resolve shop system display name for template
+        const shopSystemName = selectedShopSystem === customer_config_service_model_1.ShopSystem.OTHER ? undefined : selectedShopSystem;
         return {
             appName: this.appName,
             production,
@@ -217,12 +387,14 @@ class CustomerConfigService {
             hasSoftNavigations,
             convertSoftToHardNavigations,
             useDisabledSitesApproach,
+            shopSystemName,
             isShopify,
             isShopware,
             isSalesforce,
             isOxid,
             isPlentymarkets,
             isPOV,
+            addDowntimeDetection,
         };
     }
     async logWarnings(configSettings) {
@@ -238,8 +410,7 @@ class CustomerConfigService {
     async generateConfig() {
         this.cli.write("\nLet's generate a config...\n");
         const configSettings = await this.getConfigSettings();
-        const addDowntimeDetection = await this.cli.confirm("[Downtime Detection] Add Downtime Detection?", false);
-        if (addDowntimeDetection) {
+        if (configSettings.addDowntimeDetection) {
             this.templates.push("downtimeDetection.js.hbs");
         }
         await this.compileHandlebarsFiles(configSettings);

package/dist/services/customer-config/templates/config_SpeedKit.js.hbs

@@ -336,13 +336,12 @@ import { ShopifyPlugin } from "speed-kit-config/ShopifyPlugin";
     stripQueryParams: [{
       params: [
         // Default:
+        /.*clid$/, // generic Click ID
         "AdSet", // Meta Ads (Facebook)
-        "_autaclid", // Adition Click ID
         "_ga", // Google Analytics User ID (Universal Analytics)
         "_gl", // Google Analytics User ID (GA 4+)
         "_klaviyopid", // Klaviyo
         "_kx", // Klaviyo
-        "_pmclid",
         "a8", // A8.net (affiliate marketing)
         "ad_id",
         "adid",
@@ -356,18 +355,15 @@ import { ShopifyPlugin } from "speed-kit-config/ShopifyPlugin";
         "clickref",
         "cstrackid", // ChannelSight
         "cto_pld",
-        "dclid", // another Click ID
         "dicbo",
         "ds_rl",
         "ef_id", // Adobe Advertising Cloud
         "epik",
         "fb_audience", // Facebook Ads
-        "fbclid", // Facebook Click ID
         "gQT",
         "gb_clk", // Click tracking
         "gtm_debug", // Google Tag Manager
         "irclickid",
-        "kgclid",
         "kk", // Kelkoo Shopping Search Engine Key
         "ldtag_cl", // LINE Ads
         "lt_r", // LINE Ads
@@ -378,16 +374,12 @@ import { ShopifyPlugin } from "speed-kit-config/ShopifyPlugin";
         "rdt_cid", // Reddit Ad Click ID
         "rtbhc", // RTB House
         "s_kwcid", // AMO ID, Adobe Advertising Cloud
-        "soluteclid", // Solute Click ID
         "srclt", // LINE Ads
         "srsltid", // google search engine
-        "syclid",
         "tblci", // Taboola Click ID
         "tduid", // Tradedoubler UID
         "trackingtoken",
-        "ttclid", // TikTok Click ID
         "ved",
-        "yclid", // Yandex Click ID
         "yj_r", // Yahoo! JAPAN Ads
         "zanpid", // AWIN (former Zanox Affiliate Network)
         /^(mb|nb|nx|ny)$/,

package/dist/services/customer-config/templates/config_customer.json.hbs

@@ -2,16 +2,8 @@
   "production": {
     "_meta": {
       "shopSystem":
-      {{#if isShopify}}
-        "Shopify"
-      {{else if isShopware}}
-        "Shopware"
-      {{else if isSalesforce}}
-        "Salesforce Commerce Cloud"
-      {{else if isOxid}}
-        "OXID eShop"
-      {{else if isPlentymarkets}}
-        "Plentymarkets"
+      {{#if shopSystemName}}
+        "{{shopSystemName}}"
       {{else}}
         "TODO: enter name of system in use"
       {{/if}}

package/dist/services/deploy/checks/pre-deploy/device-detection-changed-check.d.ts

@@ -11,8 +11,5 @@ export declare class DeviceDetectionChangedCheck {
     constructor(cli: CliServiceInterface, fileList: FileListInterface, configApi: ConfigApiService, customerConfig: CustomerConfig, configName: string, isProduction: boolean);
     check(): Promise<void>;
     private checkForChangedDeviceDetection;
-    private evaluateLocalAndRemoteSpeedKit;
     private getActiveInstallResource;
-    private buildBrowserMock;
-    safeFileContentWrapper(fileContent: string): string;
 }

package/dist/services/deploy/checks/pre-deploy/device-detection-changed-check.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceDetectionChangedCheck = void 0;
-const tslib_1 = require("tslib");
 const cli_1 = require("../../../cli");
 const files_1 = require("../../../../models/files");
-const vm = tslib_1.__importStar(require("node:vm"));
 const safe_1 = require("../../../../helpers/safe");
-const evaluate_sk_config_error_1 = require("../../error/evaluate-sk-config-error");
+const evaluate_speed_kit_config_1 = require("../../../../helpers/evaluate-speed-kit-config");
 class DeviceDetectionChangedCheck {
     cli;
     fileList;
@@ -41,9 +39,7 @@ class DeviceDetectionChangedCheck {
         this.cli.startAction("Checking for customDeviceDetection");
         const speedKitConfigFile = this.fileList.getByName(files_1.INTEGRATION_FILES.CONFIG.SPEED_KIT);
         const activeSpeedKitConfig = activeInstallResource[speedKitConfigFile.remoteKey];
-        const changesResponse = (0, safe_1.safe)(() => {
-            return this.checkForChangedDeviceDetection(speedKitConfigFile, activeSpeedKitConfig);
-        });
+        const changesResponse = await (0, safe_1.safe)(this.checkForChangedDeviceDetection(speedKitConfigFile, activeSpeedKitConfig));
         if (changesResponse.success === false) {
             this.cli.endAction(cli_1.CliActionStatus.FAILED);
             this.cli.writeError(`Unable to evaluate changes: ${changesResponse.error}`);
@@ -62,9 +58,9 @@ class DeviceDetectionChangedCheck {
             this.cli.exit(0);
         }
     }
-    checkForChangedDeviceDetection(speedKitConfigFile, activeSpeedKitConfig) {
+    async checkForChangedDeviceDetection(speedKitConfigFile, activeSpeedKitConfig) {
         const changes = [];
-        const { localSpeedKit, remoteSpeedKit } = this.evaluateLocalAndRemoteSpeedKit(this.customerConfig.origins[0], speedKitConfigFile, activeSpeedKitConfig);
+        const { localSpeedKit, remoteSpeedKit } = await (0, evaluate_speed_kit_config_1.evaluateLocalAndRemoteSpeedKit)(this.customerConfig.app, this.customerConfig.origins[0], speedKitConfigFile, activeSpeedKitConfig);
         if ((localSpeedKit.detectDevice && !remoteSpeedKit.detectDevice) ||
             (!localSpeedKit.detectDevice && remoteSpeedKit.detectDevice)) {
             changes.push("detectDevice");
@@ -96,28 +92,6 @@ class DeviceDetectionChangedCheck {
         }
         return changes;
     }
-    evaluateLocalAndRemoteSpeedKit(origin, speedKitConfigFile, activeSpeedKitConfig) {
-        const localBrowserContext = this.buildBrowserMock(origin, this.customerConfig.app);
-        vm.runInNewContext(this.safeFileContentWrapper(speedKitConfigFile.getContent()), localBrowserContext, {
-            filename: speedKitConfigFile.path,
-            displayErrors: false,
-            breakOnSigint: true,
-        });
-        const remoteBrowserContext = this.buildBrowserMock(origin, this.customerConfig.app);
-        vm.runInNewContext(this.safeFileContentWrapper(activeSpeedKitConfig), remoteBrowserContext, {
-            displayErrors: false,
-            breakOnSigint: true,
-        });
-        if (localBrowserContext.vmError !== null) {
-            throw new evaluate_sk_config_error_1.EvaluateSkConfigError(`[config_Speedkit.js] ${localBrowserContext.vmError?.message}`);
-        }
-        if (remoteBrowserContext.vmError !== null) {
-            throw new evaluate_sk_config_error_1.EvaluateSkConfigError(`[remote_config] ${JSON.stringify(remoteBrowserContext.vmError?.message)}`);
-        }
-        const localSpeedKit = localBrowserContext.window.speedKit;
-        const remoteSpeedKit = remoteBrowserContext.window.speedKit;
-        return { localSpeedKit, remoteSpeedKit };
-    }
     async getActiveInstallResource() {
         const activeInstallResourceResponse = await (0, safe_1.safe)(this.configApi.getActiveInstall(this.configName));
         if (activeInstallResourceResponse.success !== true) {
@@ -128,62 +102,5 @@ class DeviceDetectionChangedCheck {
         }
         return activeInstallResourceResponse.data;
     }
-    buildBrowserMock(origin, app) {
-        const originUrl = new URL(origin);
-        const window = {
-            location: originUrl,
-            APP: app,
-            speedKit: {
-                split: undefined,
-                splitTestId: undefined,
-            },
-            serviceWorkerUrl: "",
-            screen: { width: 0, height: 0 },
-            devicePixelRatio: 1,
-            navigator: {
-                userAgent: "",
-                connection: {},
-                cookieEnabled: false,
-                languages: [],
-                online: true,
-            },
-            top: {},
-        };
-        window.top = window;
-        const document = {
-            cookie: "",
-            querySelector: () => { },
-            querySelectorAll: () => { },
-            createElement: () => { },
-            addEventListener: () => { },
-            head: {},
-            body: {},
-        };
-        document.head = document;
-        document.body = document;
-        return {
-            vmError: null,
-            ...window,
-            window,
-            document,
-            navigator: { userAgent: "" },
-            localStorage: {
-                getItem: () => { },
-                setItem: () => { },
-            },
-            JSON: JSON,
-            decodeURIComponent: decodeURIComponent,
-            URL: URL,
-        };
-    }
-    safeFileContentWrapper(fileContent) {
-        return `
-      try{
-        ${fileContent}
-      } catch (error){
-        vmError = error
-      }
-    `;
-    }
 }
 exports.DeviceDetectionChangedCheck = DeviceDetectionChangedCheck;

package/dist/services/deploy/checks/pre-deploy/split-change-check.d.ts

@@ -11,8 +11,5 @@ export declare class SplitChangeCheck {
     constructor(cli: CliServiceInterface, fileList: FileListInterface, configApi: ConfigApiService, customerConfig: CustomerConfig, configName: string, isProduction: boolean);
     check(): Promise<void>;
     private checkSplitsForEachOrigin;
-    private evaluateLocalAndRemoteSpeedKit;
     private getActiveInstallResource;
-    private buildBrowserMock;
-    safeFileContentWrapper(fileContent: string): string;
 }

package/dist/services/deploy/checks/pre-deploy/split-change-check.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplitChangeCheck = void 0;
-const tslib_1 = require("tslib");
 const cli_1 = require("../../../cli");
 const files_1 = require("../../../../models/files");
-const vm = tslib_1.__importStar(require("node:vm"));
 const safe_1 = require("../../../../helpers/safe");
-const evaluate_sk_config_error_1 = require("../../error/evaluate-sk-config-error");
+const evaluate_speed_kit_config_1 = require("../../../../helpers/evaluate-speed-kit-config");
 class SplitChangeCheck {
     cli;
     fileList;
@@ -41,9 +39,7 @@ class SplitChangeCheck {
         this.cli.startAction("Checking Split Test ID");
         const speedKitConfigFile = this.fileList.getByName(files_1.INTEGRATION_FILES.CONFIG.SPEED_KIT);
         const activeSpeedKitConfig = activeInstallResource[speedKitConfigFile.remoteKey];
-        const changesResponse = (0, safe_1.safe)(() => {
-            return this.checkSplitsForEachOrigin(speedKitConfigFile, activeSpeedKitConfig);
-        });
+        const changesResponse = await (0, safe_1.safe)(this.checkSplitsForEachOrigin(speedKitConfigFile, activeSpeedKitConfig));
         if (changesResponse.success === false) {
             this.cli.endAction(cli_1.CliActionStatus.FAILED);
             this.cli.writeError(`Unable to evaluate changes: ${changesResponse.error}`);
@@ -60,10 +56,10 @@ class SplitChangeCheck {
             this.cli.exit(0);
         }
     }
-    checkSplitsForEachOrigin(speedKitConfigFile, activeSpeedKitConfig) {
+    async checkSplitsForEachOrigin(speedKitConfigFile, activeSpeedKitConfig) {
         const changes = [];
         for (const origin of this.customerConfig.origins) {
-            const { localSpeedKit, remoteSpeedKit } = this.evaluateLocalAndRemoteSpeedKit(origin, speedKitConfigFile, activeSpeedKitConfig);
+            const { localSpeedKit, remoteSpeedKit } = await (0, evaluate_speed_kit_config_1.evaluateLocalAndRemoteSpeedKit)(this.customerConfig.app, origin, speedKitConfigFile, activeSpeedKitConfig);
             // check for split change
             if (localSpeedKit.split !== remoteSpeedKit.split) {
                 changes.push({
@@ -114,28 +110,6 @@ class SplitChangeCheck {
         }
         return changes;
     }
-    evaluateLocalAndRemoteSpeedKit(origin, speedKitConfigFile, activeSpeedKitConfig) {
-        const localBrowserContext = this.buildBrowserMock(origin, this.customerConfig.app);
-        vm.runInNewContext(this.safeFileContentWrapper(speedKitConfigFile.getContent()), localBrowserContext, {
-            filename: speedKitConfigFile.path,
-            displayErrors: false,
-            breakOnSigint: true,
-        });
-        const remoteBrowserContext = this.buildBrowserMock(origin, this.customerConfig.app);
-        vm.runInNewContext(this.safeFileContentWrapper(activeSpeedKitConfig), remoteBrowserContext, {
-            displayErrors: false,
-            breakOnSigint: true,
-        });
-        if (localBrowserContext.vmError !== null) {
-            throw new evaluate_sk_config_error_1.EvaluateSkConfigError(`[config_Speedkit.js] ${localBrowserContext.vmError?.message}`);
-        }
-        if (remoteBrowserContext.vmError !== null) {
-            throw new evaluate_sk_config_error_1.EvaluateSkConfigError(`[remote_config] ${JSON.stringify(remoteBrowserContext.vmError?.message)}`);
-        }
-        const localSpeedKit = localBrowserContext.window.speedKit;
-        const remoteSpeedKit = remoteBrowserContext.window.speedKit;
-        return { localSpeedKit, remoteSpeedKit };
-    }
     async getActiveInstallResource() {
         const activeInstallResourceResponse = await (0, safe_1.safe)(this.configApi.getActiveInstall(this.configName));
         if (activeInstallResourceResponse.success !== true) {
@@ -146,62 +120,5 @@ class SplitChangeCheck {
         }
         return activeInstallResourceResponse.data;
     }
-    buildBrowserMock(origin, app) {
-        const originUrl = new URL(origin);
-        const window = {
-            location: originUrl,
-            APP: app,
-            speedKit: {
-                split: undefined,
-                splitTestId: undefined,
-            },
-            serviceWorkerUrl: "",
-            screen: { width: 0, height: 0 },
-            devicePixelRatio: 1,
-            navigator: {
-                userAgent: "",
-                connection: {},
-                cookieEnabled: false,
-                languages: [],
-                online: true,
-            },
-            top: {},
-        };
-        window.top = window;
-        const document = {
-            cookie: "",
-            querySelector: () => { },
-            querySelectorAll: () => { },
-            createElement: () => { },
-            addEventListener: () => { },
-            head: {},
-            body: {},
-        };
-        document.head = document;
-        document.body = document;
-        return {
-            vmError: null,
-            ...window,
-            window,
-            document,
-            navigator: { userAgent: "" },
-            localStorage: {
-                getItem: () => { },
-                setItem: () => { },
-            },
-            JSON: JSON,
-            decodeURIComponent: decodeURIComponent,
-            URL: URL,
-        };
-    }
-    safeFileContentWrapper(fileContent) {
-        return `
-      try{
-        ${fileContent}
-      } catch (error){
-        vmError = error
-      }
-    `;
-    }
 }
 exports.SplitChangeCheck = SplitChangeCheck;

package/dist/services/onboarding/fetch-events/customer-service-worker-js.d.ts

@@ -10,5 +10,5 @@ export declare class CustomerServiceWorkerJs implements FetchRequestPausedEventH
     private customerConfig;
     get patterns(): Protocol.Fetch.RequestPattern[];
     constructor(customerConfig: CustomerConfig);
-    handle(): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
+    handle(event: Protocol.Fetch.RequestPausedEvent): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
 }

package/dist/services/onboarding/fetch-events/customer-service-worker-js.js

@@ -22,7 +22,13 @@ class CustomerServiceWorkerJs {
     constructor(customerConfig) {
         this.customerConfig = customerConfig;
     }
-    async handle() {
+    async handle(event) {
+        // When the SW is registered with `?empty=1`, the caller wants a no-op
+        // service worker on that scope — serve an empty script instead of the
+        // skonboarding wrapper that imports Speed Kit's sw.js.
+        if (new URL(event.request.url).searchParams.get("empty") === "1") {
+            return new baqend_response_1.BaqendResponse("// skonboarding empty sw", "text/javascript; charset=utf-8");
+        }
         const wrapperSwCode = `importScripts(\`https://${this.customerConfig.appDomain}/v1/speedkit/sw.js\${location.search}\`); // skonboarding`;
         return new baqend_response_1.BaqendResponse(wrapperSwCode, "text/javascript; charset=utf-8");
     }

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

@@ -9,8 +9,11 @@ const DEFAULT_BROWSER_ARGS = [
     "--enable-features=Translate,NetworkService",
     "--no-first-run",
     "--no-default-browser-check",
-    "--disable-infobars",
-    // "--enable-automation",
+    // Hides the `navigator.webdriver` fingerprint so customer CDN/WAF rules don't treat the session as a bot.
+    "--disable-blink-features=AutomationControlled",
+    // Signals a test environment so Chrome suppresses the "unsupported command-line flag" infobar
+    // triggered by the flag above. Value is arbitrary and only used as an identifier.
+    "--test-type=speed-kit-cli",
 ];
 exports.BROWSER_EVENTS = {
     DISCONNECTED: "disconnected",
@@ -91,6 +94,9 @@ class BrowserContext {
             headless: this.headless,
             executablePath: this.chromePath,
             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"],
         };
         if (this.userConfig?.chromeExtensionPaths) {
             if (this.isChromeBrowser()) {

package/oclif.manifest.json

@@ -751,5 +751,5 @@
       ]
     }
   },
-  "version": "3.41.0"
+  "version": "3.43.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@speedkit/cli",
   "description": "Speed Kit CLI",
-  "version": "3.41.0",
+  "version": "3.43.0",
   "author": {
     "name": "Baqend.com",
     "email": "info@baqend.com"
@@ -66,7 +66,7 @@
   "type": "commonjs",
   "dependencies": {
     "@aws-sdk/client-athena": "^3.529",
-    "@inquirer/prompts": "^3.3.2",
+    "@inquirer/prompts": "^5.5.0",
     "@nats-io/transport-node": "^3.3.1",
     "@oclif/core": "^3.23",
     "@oclif/plugin-autocomplete": "^3.0",