@speedkit/cli 4.12.0 → 4.14.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [4.14.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.13.0...v4.14.0) (2026-06-29)
+
+
+### Features
+
+* implement autoPrewarmService ([102d893](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/102d8931b985ef270d6dd9cadc879158d867b9ba))
+
+# [4.13.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.12.0...v4.13.0) (2026-06-25)
+
+
+### Features
+
+* **site-analyzer:** rocket loader check ([229a037](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/229a037e0dc7eebb6bd46ac934799b6874556c88))
+
 # [4.12.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.11.0...v4.12.0) (2026-06-19)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.12.0 linux-x64 node-v22.23.0
+@speedkit/cli/4.14.0 linux-x64 node-v22.23.1
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND
@@ -65,6 +65,7 @@ By either...
 
 # Commands
 <!-- commands -->
+* [`sk auto-prewarm CUSTOMERPATH`](#sk-auto-prewarm-customerpath)
 * [`sk autocomplete [SHELL]`](#sk-autocomplete-shell)
 * [`sk build-parameter-query CUSTOMERPATH`](#sk-build-parameter-query-customerpath)
 * [`sk build-prewarm-query CUSTOMERPATH`](#sk-build-prewarm-query-customerpath)
@@ -83,6 +84,37 @@ By either...
 * [`sk pull CUSTOMERPATH`](#sk-pull-customerpath)
 * [`sk wpt-launcher URLS TESTID`](#sk-wpt-launcher-urls-testid)
 
+## `sk auto-prewarm CUSTOMERPATH`
+
+Build and execute the prewarm query for a customer config and start a prewarm job from the resulting URLs — no CSV needed
+
+```
+USAGE
+  $ sk auto-prewarm CUSTOMERPATH [-c <value>] [-p <value> | -v <value>] [-k] [-q] [--verbose]
+
+ARGUMENTS
+  CUSTOMERPATH  The customer config path
+
+FLAGS
+  -c, --configName=<value>     [default: production] The costumer config name
+  -k, --keepParameterSorting   Prevents alphabetical sorting of the URL parameters
+  -p, --variationPath=<value>  path to variations.csv
+  -q, --quiet                  less output non interactive
+  -v, --variation=<value>      [default: default]
+      --verbose                Log information about failed requests
+
+DESCRIPTION
+  Build and execute the prewarm query for a customer config and start a prewarm job from the resulting URLs — no CSV
+  needed
+
+EXAMPLES
+  $ sk auto-prewarm <customerPath> -c <configName>
+
+  $ sk auto-prewarm customers/decathlon.de -c production
+
+  $ sk auto-prewarm customers/decathlon.de -v MOBILE,DESKTOP
+```
+
 ## `sk autocomplete [SHELL]`
 
 Display autocomplete installation instructions.
@@ -143,13 +175,14 @@ Build a prewarm query that can be executed in Athena
 
 ```
 USAGE
-  $ sk build-prewarm-query CUSTOMERPATH [-c <value>] [-q]
+  $ sk build-prewarm-query CUSTOMERPATH [-c <value>] [-q] [-e]
 
 ARGUMENTS
   CUSTOMERPATH  The customer config path
 
 FLAGS
   -c, --configName=<value>  [default: production] The costumer config name
+  -e, --execute             Execute the query directly and write the result to a <app>-<date>-prewarm.csv file
   -q, --quiet               Output only the raw query without clipboard copy or styling
 
 DESCRIPTION

package/dist/commands/auto-prewarm.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "@oclif/core";
+export default class AutoPrewarm extends Command {
+    static args: {
+        customerPath: import("@oclif/core/interfaces").Arg<string, {
+            exists?: boolean;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        variation: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        variationPath: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        keepParameterSorting: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        configName: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/auto-prewarm.js

@@ -0,0 +1,53 @@
+import { Command, Flags } from "@oclif/core";
+import { CLI_CONFIG_NAME, CLI_CUSTOMER_CONFIG, CLIParameters, CLIParametersChar, CLIParametersExample, } from "../models/cli-parameters.js";
+import { CliConfig } from "../helpers/cli-config.js";
+import { AutoPreWarmFactory } from "../services/prewarm/index.js";
+export default class AutoPrewarm extends Command {
+    static args = CLI_CUSTOMER_CONFIG;
+    static description = "Build and execute the prewarm query for a customer config and start a prewarm job from the resulting URLs — no CSV needed";
+    static examples = [
+        `$ sk auto-prewarm <${CLIParameters.CustomerPath}> -${CLIParametersChar.ConfigName} <${CLIParameters.ConfigName}>`,
+        `$ sk auto-prewarm ${CLIParametersExample.CustomerPath} -${CLIParametersChar.ConfigName} ${CLIParametersExample.ConfigName}`,
+        `$ sk auto-prewarm ${CLIParametersExample.CustomerPath} -${CLIParametersChar.Variation} ${CLIParametersExample.Variations}`,
+    ];
+    static flags = {
+        ...CLI_CONFIG_NAME,
+        [CLIParameters.Variation]: Flags.string({
+            char: CLIParametersChar.Variation,
+            default: "default",
+        }),
+        [CLIParameters.VariationPath]: Flags.file({
+            char: CLIParametersChar.VariationPath,
+            exclusive: [CLIParameters.Variation],
+            description: "path to variations.csv",
+        }),
+        [CLIParameters.KeepParameterSorting]: Flags.boolean({
+            char: CLIParametersChar.KeepParameterSorting,
+            default: false,
+            description: "Prevents alphabetical sorting of the URL parameters",
+        }),
+        [CLIParameters.Quiet]: Flags.boolean({
+            char: CLIParametersChar.Quiet,
+            default: false,
+            description: "less output non interactive",
+        }),
+        [CLIParameters.Verbose]: Flags.boolean({
+            default: false,
+            description: "Log information about failed requests",
+        }),
+    };
+    async run() {
+        const { args: { customerPath }, flags: { configName, variation, variationPath, keepParameterSorting, quiet, verbose, }, } = await this.parse(AutoPrewarm);
+        const service = await new AutoPreWarmFactory({
+            customerPath,
+            configName,
+            variation,
+            variationPath,
+            sortParameters: !keepParameterSorting,
+            quiet,
+            verbose,
+            isWindows: this.config.windows,
+        }, new CliConfig(this.config).load()).getService();
+        await service.run();
+    }
+}

package/dist/commands/build-prewarm-query.d.ts

@@ -9,6 +9,7 @@ export default class BuildPrewarmQuery extends Command {
     static examples: string[];
     static flags: {
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        execute: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         configName: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/build-prewarm-query.js

@@ -17,14 +17,20 @@ export default class BuildPrewarmQuery extends Command {
             description: "Output only the raw query without clipboard copy or styling",
             default: false,
         }),
+        execute: Flags.boolean({
+            char: "e",
+            description: "Execute the query directly and write the result to a <app>-<date>-prewarm.csv file",
+            default: false,
+        }),
     };
     async run() {
-        const { args: { customerPath }, flags: { configName, quiet }, } = await this.parse(BuildPrewarmQuery);
+        const { args: { customerPath }, flags: { configName, quiet, execute }, } = await this.parse(BuildPrewarmQuery);
         const service = await new QueryBuilderFactory({
             configName,
             customerPath,
             isWindows: this.config.windows,
             quiet,
+            execute,
         }, new CliConfig(this.config).load()).buildService(QueryTpe.prewarm);
         await service.run();
     }

package/dist/helpers/site-analyzer.js

@@ -9,11 +9,11 @@ const EMPTY_FLAGS = {
     hasSoftNavigations: false,
     handleUsercentrics: false,
 };
-function detectFeatures(html, headers) {
+function detectFeatures(html) {
     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,
+        activateCfRocketLoaderPlugin: /data-cfasync|rocket-loader/.test(html),
         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),
@@ -98,7 +98,7 @@ async function fetchAndAnalyze(host, log) {
         const homePage = await fetchPage(`https://${host}`, controller.signal);
         if (!homePage)
             return null;
-        featureResults.push(detectFeatures(homePage.html, homePage.headers));
+        featureResults.push(detectFeatures(homePage.html));
         // 2. Detect shop system from homepage
         const shopSystem = detectShopSystem(homePage.html);
         // 3. Check install.js presence in homepage HTML
@@ -112,7 +112,7 @@ async function fetchAndAnalyze(host, log) {
             log(`Fetching PLP: ${plpUrl}`);
             plpPage = await fetchPage(plpUrl, controller.signal);
             if (plpPage) {
-                featureResults.push(detectFeatures(plpPage.html, plpPage.headers));
+                featureResults.push(detectFeatures(plpPage.html));
                 // 6. If homepage didn't have a PDP link, try extracting one from PLP
                 if (!pdpUrl) {
                     pdpUrl = findUrl(plpPage.html, host, PDP_PATTERN);
@@ -124,7 +124,7 @@ async function fetchAndAnalyze(host, log) {
             log(`Fetching PDP: ${pdpUrl}`);
             const pdpPage = await fetchPage(pdpUrl, controller.signal);
             if (pdpPage) {
-                featureResults.push(detectFeatures(pdpPage.html, pdpPage.headers));
+                featureResults.push(detectFeatures(pdpPage.html));
             }
         }
         return {

package/dist/services/prewarm/auto-pre-warm-factory.d.ts

@@ -0,0 +1,25 @@
+import { UserCliConfig } from "../../helpers/cli-config.js";
+import { PreWarmService } from "./pre-warm-service.js";
+export interface AutoPreWarmContext {
+    readonly customerPath: string;
+    readonly configName: string;
+    readonly variation?: string;
+    readonly variationPath?: string;
+    readonly sortParameters?: boolean;
+    readonly quiet?: boolean;
+    readonly verbose?: boolean;
+    readonly isWindows?: boolean;
+}
+/**
+ * Wires a {@link PreWarmService} that gets its URLs from a freshly built and
+ * executed prewarm query instead of a CSV file. Reads the app from the customer
+ * config, builds the prewarm query via {@link QueryBuilderFactory}, runs it
+ * against Athena (Baqend native path, AWS fallback), and feeds the resulting
+ * URLs straight into the prewarm job.
+ */
+export declare class AutoPreWarmFactory {
+    private context;
+    private userConfig;
+    constructor(context: AutoPreWarmContext, userConfig: UserCliConfig);
+    getService(): Promise<PreWarmService>;
+}

package/dist/services/prewarm/auto-pre-warm-factory.js

@@ -0,0 +1,42 @@
+import { CliContext, CliServiceFactory } from "../cli/index.js";
+import { QueryBuilderFactory } from "../query-builder/query-builder-factory.js";
+import { QueryTpe } from "../query-builder/query-builder-model.js";
+import { ConfigApiContext, ConfigApiServiceFactory, } from "../config-api/index.js";
+import { AssetApiClient } from "./assets/asset-api-client.js";
+import { CsvReader } from "./csv-reader.js";
+import { PreWarmService } from "./pre-warm-service.js";
+import { resolveVariations } from "./pre-warm-factory.js";
+/**
+ * Wires a {@link PreWarmService} that gets its URLs from a freshly built and
+ * executed prewarm query instead of a CSV file. Reads the app from the customer
+ * config, builds the prewarm query via {@link QueryBuilderFactory}, runs it
+ * against Athena (Baqend native path, AWS fallback), and feeds the resulting
+ * URLs straight into the prewarm job.
+ */
+export class AutoPreWarmFactory {
+    context;
+    userConfig;
+    constructor(context, userConfig) {
+        this.context = context;
+        this.userConfig = userConfig;
+    }
+    async getService() {
+        const cli = new CliServiceFactory(new CliContext(this.context.quiet)).getService();
+        const queryService = await new QueryBuilderFactory({
+            configName: this.context.configName,
+            customerPath: this.context.customerPath,
+            isWindows: this.context.isWindows,
+            quiet: this.context.quiet,
+            execute: true,
+        }, this.userConfig).buildService(QueryTpe.prewarm);
+        const app = queryService.app;
+        const rows = await queryService.execute();
+        const urls = rows.map((row) => row.url).filter(Boolean);
+        const configApi = new ConfigApiServiceFactory(new ConfigApiContext(app)).getService();
+        const entityManager = await configApi.client.getEntityManager();
+        const assetApiClient = new AssetApiClient(entityManager.token, app, this.context.sortParameters);
+        const csvReader = new CsvReader();
+        const variations = resolveVariations(csvReader, this.context.variation, this.context.variationPath);
+        return new PreWarmService(assetApiClient, cli, urls, variations, this.context.verbose);
+    }
+}

package/dist/services/prewarm/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./pre-warm-service.js";
 export * from "./pre-warm-factory.js";
+export * from "./auto-pre-warm-factory.js";
 export * from "./pre-warm-model.js";

package/dist/services/prewarm/index.js

@@ -1,3 +1,4 @@
 export * from "./pre-warm-service.js";
 export * from "./pre-warm-factory.js";
+export * from "./auto-pre-warm-factory.js";
 export * from "./pre-warm-model.js";

package/dist/services/prewarm/pre-warm-factory.d.ts

@@ -1,4 +1,5 @@
 import { PreWarmContext, PreWarmService } from "./index.js";
+import { CsvReader } from "./csv-reader.js";
 export declare class PreWarmFactory {
     private context;
     constructor(context: PreWarmContext);
@@ -6,3 +7,10 @@ export declare class PreWarmFactory {
     private getUrls;
     private getVariations;
 }
+/**
+ * Resolve the list of variations to prewarm: a `variationPath` CSV takes
+ * precedence over a comma-separated `variation` string, falling back to the
+ * default variation. Shared by {@link PreWarmFactory} and the `auto-prewarm`
+ * factory.
+ */
+export declare function resolveVariations(csvReader: CsvReader, variation?: string, variationPath?: string): string[];

package/dist/services/prewarm/pre-warm-factory.js

@@ -22,13 +22,22 @@ export class PreWarmFactory {
         return csvReader.readPath(this.context.path);
     }
     getVariations(csvReader) {
-        let variations = DEFAULT_VARIATION;
-        if (this.context.variation) {
-            variations = this.context.variation.split(VARIATION_SEPARATOR);
-        }
-        if (this.context.variationPath) {
-            variations = csvReader.readPath(this.context.variationPath);
-        }
-        return variations;
+        return resolveVariations(csvReader, this.context.variation, this.context.variationPath);
     }
 }
+/**
+ * Resolve the list of variations to prewarm: a `variationPath` CSV takes
+ * precedence over a comma-separated `variation` string, falling back to the
+ * default variation. Shared by {@link PreWarmFactory} and the `auto-prewarm`
+ * factory.
+ */
+export function resolveVariations(csvReader, variation, variationPath) {
+    let variations = DEFAULT_VARIATION;
+    if (variation) {
+        variations = variation.split(VARIATION_SEPARATOR);
+    }
+    if (variationPath) {
+        variations = csvReader.readPath(variationPath);
+    }
+    return variations;
+}

package/dist/services/query-builder/query-builder-factory.js

@@ -2,6 +2,7 @@ import { QueryBuilderService } from "./query-builder-service.js";
 import { IntegrationApiContext, IntegrationApiFactory, } from "../integration-api/index.js";
 import { INTEGRATION_FILES } from "../../models/files.js";
 import { CliServiceFactory } from "../cli/index.js";
+import { AthenaServiceFactory } from "../athena/index.js";
 import { safe } from "../../helpers/safe.js";
 import { ParseConfigSpeedKitError } from "./error/parse-config-speed-kit-error.js";
 import { evaluateLocalSpeedKitConfig } from "../../helpers/evaluate-speed-kit-config.js";
@@ -25,8 +26,13 @@ export class QueryBuilderFactory {
             queryType,
             isWindows: this.context.isWindows,
             quiet: this.context.quiet,
+            execute: this.context.execute,
         };
-        return new QueryBuilderService(serviceContext, speedKitConfig, cli);
+        // The Athena service is only needed when the query is executed directly.
+        const athenaService = this.context.execute
+            ? await new AthenaServiceFactory(app).getService()
+            : undefined;
+        return new QueryBuilderService(serviceContext, speedKitConfig, cli, athenaService);
     }
     async getIntegrationFiles() {
         const integrationApiContext = new IntegrationApiContext(this.context.customerPath, this.context.configName, ["config_SpeedKit"]);

package/dist/services/query-builder/query-builder-model.d.ts

@@ -1,6 +1,7 @@
 export interface QueryBuilderContext {
     isWindows?: boolean;
     quiet?: boolean;
+    execute?: boolean;
     queryType: QueryTpe;
     app: string;
 }
@@ -9,6 +10,7 @@ export interface QueryBuilderFactoryContext {
     readonly configName: string;
     readonly isWindows?: boolean;
     readonly quiet?: boolean;
+    readonly execute?: boolean;
 }
 export declare enum QueryTpe {
     prewarm = "prewarm",

package/dist/services/query-builder/query-builder-service.d.ts

@@ -1,11 +1,28 @@
 import { QueryBuilderContext, SpeedKitConfig } from "./query-builder-model.js";
 import { CliServiceInterface } from "../cli/index.js";
+import { AthenaService } from "../athena/index.js";
 export declare class QueryBuilderService {
     private context;
     private speedKitConfig;
     private cli;
-    constructor(context: QueryBuilderContext, speedKitConfig: SpeedKitConfig, cli: CliServiceInterface);
+    private athenaService?;
+    constructor(context: QueryBuilderContext, speedKitConfig: SpeedKitConfig, cli: CliServiceInterface, athenaService?: AthenaService);
+    /** The app the query targets, as read from the customer config. */
+    get app(): string;
     run(): Promise<void>;
+    /**
+     * Build and execute the query against Athena (Baqend native path, AWS
+     * fallback) and return the raw rows. Used by callers that consume the result
+     * directly instead of exporting it (e.g. `auto-prewarm`).
+     */
+    execute<T>(): Promise<T[]>;
+    private runQuery;
+    /**
+     * Execute the built query against Athena (Baqend native path, AWS fallback)
+     * and write the rows to a `<app>-<YYYY-MM-DD>-<queryType>.csv` file in the
+     * current working directory.
+     */
+    private executeAndExport;
     query(): string;
     private buildQuery;
 }

package/dist/services/query-builder/query-builder-service.js

@@ -1,18 +1,28 @@
 import { getSpeedKitConfigVersion } from "../../helpers/get-parsed-config.js";
 import { getBlacklistedFilter, getParameterFilter, getParameterReplaceFilter, getStrippedParameters, getWhitelistedFilter, } from "../../helpers/build-query-helper.js";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import clipboardy from "clipboardy";
+import json2Csv from "json2csv";
 import { QueryTpe, } from "./query-builder-model.js";
 import { Prewarm } from "./query/prewarm.js";
 import { Parameter } from "./query/parameter.js";
+import { AthenaBucket } from "../athena/index.js";
 import { safe } from "../../helpers/safe.js";
 export class QueryBuilderService {
     context;
     speedKitConfig;
     cli;
-    constructor(context, speedKitConfig, cli) {
+    athenaService;
+    constructor(context, speedKitConfig, cli, athenaService) {
         this.context = context;
         this.speedKitConfig = speedKitConfig;
         this.cli = cli;
+        this.athenaService = athenaService;
+    }
+    /** The app the query targets, as read from the customer config. */
+    get app() {
+        return this.context.app;
     }
     async run() {
         this.cli.startAction(`QUERY:BUILD:${this.context.queryType}`, `build ${this.context.queryType}-query`);
@@ -31,6 +41,10 @@ export class QueryBuilderService {
             return;
         }
         this.cli.successAction(`QUERY:BUILD:${this.context.queryType}`);
+        if (this.context.execute) {
+            await this.executeAndExport(result.data);
+            return;
+        }
         if (this.context.quiet) {
             process.stdout.write(result.data);
             return;
@@ -43,6 +57,42 @@ export class QueryBuilderService {
             this.cli.writeSuccess("Result has been copied to the clipboard 📋");
         }
     }
+    /**
+     * Build and execute the query against Athena (Baqend native path, AWS
+     * fallback) and return the raw rows. Used by callers that consume the result
+     * directly instead of exporting it (e.g. `auto-prewarm`).
+     */
+    async execute() {
+        return this.runQuery(this.query());
+    }
+    async runQuery(query) {
+        if (!this.athenaService) {
+            throw new Error("No Athena service available to execute the query");
+        }
+        return this.athenaService.getResult(query, [], undefined, AthenaBucket.RumPi);
+    }
+    /**
+     * Execute the built query against Athena (Baqend native path, AWS fallback)
+     * and write the rows to a `<app>-<YYYY-MM-DD>-<queryType>.csv` file in the
+     * current working directory.
+     */
+    async executeAndExport(query) {
+        this.cli.startAction("QUERY:EXECUTE", "execute query and export csv");
+        const result = await safe(this.runQuery(query));
+        if (result.success !== true) {
+            this.cli.failAction("QUERY:EXECUTE", result.error);
+            this.cli.writeError(result.error);
+            return;
+        }
+        const rows = result.data;
+        const date = new Date().toISOString().split("T")[0];
+        const fileName = `${this.context.app}-${date}-${this.context.queryType}.csv`;
+        const filePath = join(process.cwd(), fileName);
+        const csv = rows.length > 0 ? json2Csv.parse(rows) : "";
+        await writeFile(filePath, csv, "utf8");
+        this.cli.successAction("QUERY:EXECUTE");
+        this.cli.writeSuccess(`Wrote ${rows.length} rows to ${filePath} 📄`);
+    }
     query() {
         const parameters = getStrippedParameters(this.speedKitConfig);
         const parameterReplaceFilter = getParameterReplaceFilter(parameters, getSpeedKitConfigVersion(this.speedKitConfig));

package/oclif.manifest.json

@@ -1,5 +1,86 @@
 {
   "commands": {
+    "auto-prewarm": {
+      "aliases": [],
+      "args": {
+        "customerPath": {
+          "description": "The customer config path",
+          "name": "customerPath",
+          "required": true
+        }
+      },
+      "description": "Build and execute the prewarm query for a customer config and start a prewarm job from the resulting URLs — no CSV needed",
+      "examples": [
+        "$ sk auto-prewarm <customerPath> -c <configName>",
+        "$ sk auto-prewarm customers/decathlon.de -c production",
+        "$ sk auto-prewarm customers/decathlon.de -v MOBILE,DESKTOP"
+      ],
+      "flags": {
+        "configName": {
+          "char": "c",
+          "description": "The costumer config name",
+          "name": "configName",
+          "required": false,
+          "default": "production",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "variation": {
+          "char": "v",
+          "name": "variation",
+          "default": "default",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "variationPath": {
+          "char": "p",
+          "description": "path to variations.csv",
+          "exclusive": [
+            "variation"
+          ],
+          "name": "variationPath",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "keepParameterSorting": {
+          "char": "k",
+          "description": "Prevents alphabetical sorting of the URL parameters",
+          "name": "keepParameterSorting",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "less output non interactive",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "verbose": {
+          "description": "Log information about failed requests",
+          "name": "verbose",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "auto-prewarm",
+      "pluginAlias": "@speedkit/cli",
+      "pluginName": "@speedkit/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "auto-prewarm.js"
+      ]
+    },
     "build-parameter-query": {
       "aliases": [],
       "args": {
@@ -72,6 +153,13 @@
           "name": "quiet",
           "allowNo": false,
           "type": "boolean"
+        },
+        "execute": {
+          "char": "e",
+          "description": "Execute the query directly and write the result to a <app>-<date>-prewarm.csv file",
+          "name": "execute",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -759,5 +847,5 @@
       ]
     }
   },
-  "version": "4.12.0"
+  "version": "4.14.0"
 }

package/package.json

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