@speedkit/cli 4.27.1 → 4.27.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [4.27.2](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.27.1...v4.27.2) (2026-09-11)
+
+
+### Bug Fixes
+
+* query define awsCatalog via --catalog, disable spinners while CI or not a tty ([e949dbb](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/e949dbbaf73521267e03c4c043b393e76e174ece))
+
 ## [4.27.1](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.27.0...v4.27.1) (2026-09-11)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.27.1 linux-x64 node-v22.23.2
+@speedkit/cli/4.27.2 linux-x64 node-v22.23.2
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND
@@ -103,9 +103,10 @@ Build and execute the prewarm query for a customer config and start a prewarm jo
 
 ```
 USAGE
-  $ sk auto-prewarm CUSTOMERPATH [--workgroup <value>] [-c <value>] [-d <value>] [--excludeNoindex]
-    [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [--excludeNotFound] [--limit <value>] [--match <value>...]
-    [--minHits <value>] [-p <value> | [--device desktop|mobile|tablet... | -v <value>...] | ] [-k] [-q] [--verbose]
+  $ sk auto-prewarm CUSTOMERPATH [--catalog <value>] [--workgroup <value>] [-c <value>] [-d <value>]
+    [--excludeNoindex] [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [--excludeNotFound] [--limit <value>]
+    [--match <value>...] [--minHits <value>] [-p <value> | [--device desktop|mobile|tablet... | -v <value>...] | ] [-k]
+    [-q] [--verbose]
 
 ARGUMENTS
   CUSTOMERPATH  The customer config path
@@ -118,6 +119,8 @@ FLAGS
   -q, --quiet                  less output non interactive
   -v, --variation=<value>...   Pair every url of the list with each of these variations. For the custom variations no
                                traffic can reveal, e.g. 'desktop-pdp-a,mobile-pdp-a'
+      --catalog=<value>        [default: live, env: SK_ATHENA_CATALOG] Athena data catalog holding the rum tables. Names
+                               the catalog both in the query and in the context it runs in, so the two always agree
       --device=<option>...     Split the list by device class, so every url is warmed in the variations it was actually
                                requested in. A class not named is left out
                                <options: desktop|mobile|tablet>
@@ -261,8 +264,9 @@ Build a parameter query that can be executed in Athena
 
 ```
 USAGE
-  $ sk build-parameter-query CUSTOMERPATH [--workgroup <value>] [-c <value>] [-d <value>] [--excludeNoindex]
-    [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-e] [-q] [--bySet] [--minImpressions <value>]
+  $ sk build-parameter-query CUSTOMERPATH [--catalog <value>] [--workgroup <value>] [-c <value>] [-d <value>]
+    [--excludeNoindex] [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-e] [-q] [--bySet] [--minImpressions
+    <value>]
 
 ARGUMENTS
   CUSTOMERPATH  The customer config path
@@ -274,6 +278,9 @@ FLAGS
   -q, --quiet                   Output only the raw query without clipboard copy or styling
       --bySet                   Rank whole sets of parameters instead of single parameters, to see which ones travel
                                 together
+      --catalog=<value>         [default: live, env: SK_ATHENA_CATALOG] Athena data catalog holding the rum tables.
+                                Names the catalog both in the query and in the context it runs in, so the two always
+                                agree
       --excludeNoindex          Exclude page impressions of pages marked noindex
       --excludeSuspicious       Exclude page impressions Speed Kit classified as suspicious
       --explain                 Account for every rule the query leaves out, reduces or approximates
@@ -302,9 +309,9 @@ Build a prewarm query that can be executed in Athena
 
 ```
 USAGE
-  $ sk build-prewarm-query CUSTOMERPATH [--workgroup <value>] [-c <value>] [-d <value>] [--excludeNoindex]
-    [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-q] [--device desktop|mobile|tablet... | -v <value>...]
-    [--excludeNotFound] [--limit <value>] [--match <value>...] [--minHits <value>] [--count | -e]
+  $ sk build-prewarm-query CUSTOMERPATH [--catalog <value>] [--workgroup <value>] [-c <value>] [-d <value>]
+    [--excludeNoindex] [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-q] [--device desktop|mobile|tablet...
+    | -v <value>...] [--excludeNotFound] [--limit <value>] [--match <value>...] [--minHits <value>] [--count | -e]
 
 ARGUMENTS
   CUSTOMERPATH  The customer config path
@@ -316,6 +323,8 @@ FLAGS
   -q, --quiet                 Output only the raw query without clipboard copy or styling
   -v, --variation=<value>...  Pair every url of the list with each of these variations. For the custom variations no
                               traffic can reveal, e.g. 'desktop-pdp-a,mobile-pdp-a'
+      --catalog=<value>       [default: live, env: SK_ATHENA_CATALOG] Athena data catalog holding the rum tables. Names
+                              the catalog both in the query and in the context it runs in, so the two always agree
       --count                 Run the query and report how large the list is instead of what is in it: urls, the
                               impressions they stand for, and a row per variation where the list carries variations.
                               Every other flag still applies, so this counts the list the same command would produce
@@ -838,8 +847,9 @@ Build a parameter query that can be executed in Athena
 
 ```
 USAGE
-  $ sk query parameter CUSTOMERPATH [--workgroup <value>] [-c <value>] [-d <value>] [--excludeNoindex]
-    [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-e] [-q] [--bySet] [--minImpressions <value>]
+  $ sk query parameter CUSTOMERPATH [--catalog <value>] [--workgroup <value>] [-c <value>] [-d <value>]
+    [--excludeNoindex] [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-e] [-q] [--bySet] [--minImpressions
+    <value>]
 
 ARGUMENTS
   CUSTOMERPATH  The customer config path
@@ -851,6 +861,9 @@ FLAGS
   -q, --quiet                   Output only the raw query without clipboard copy or styling
       --bySet                   Rank whole sets of parameters instead of single parameters, to see which ones travel
                                 together
+      --catalog=<value>         [default: live, env: SK_ATHENA_CATALOG] Athena data catalog holding the rum tables.
+                                Names the catalog both in the query and in the context it runs in, so the two always
+                                agree
       --excludeNoindex          Exclude page impressions of pages marked noindex
       --excludeSuspicious       Exclude page impressions Speed Kit classified as suspicious
       --explain                 Account for every rule the query leaves out, reduces or approximates
@@ -879,9 +892,9 @@ Build a prewarm query that can be executed in Athena
 
 ```
 USAGE
-  $ sk query prewarm CUSTOMERPATH [--workgroup <value>] [-c <value>] [-d <value>] [--excludeNoindex]
-    [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-q] [--device desktop|mobile|tablet... | -v <value>...]
-    [--excludeNotFound] [--limit <value>] [--match <value>...] [--minHits <value>] [--count | -e]
+  $ sk query prewarm CUSTOMERPATH [--catalog <value>] [--workgroup <value>] [-c <value>] [-d <value>]
+    [--excludeNoindex] [--excludeSuspicious] [--explain] [--hardNavigationsOnly] [-q] [--device desktop|mobile|tablet...
+    | -v <value>...] [--excludeNotFound] [--limit <value>] [--match <value>...] [--minHits <value>] [--count | -e]
 
 ARGUMENTS
   CUSTOMERPATH  The customer config path
@@ -893,6 +906,8 @@ FLAGS
   -q, --quiet                 Output only the raw query without clipboard copy or styling
   -v, --variation=<value>...  Pair every url of the list with each of these variations. For the custom variations no
                               traffic can reveal, e.g. 'desktop-pdp-a,mobile-pdp-a'
+      --catalog=<value>       [default: live, env: SK_ATHENA_CATALOG] Athena data catalog holding the rum tables. Names
+                              the catalog both in the query and in the context it runs in, so the two always agree
       --count                 Run the query and report how large the list is instead of what is in it: urls, the
                               impressions they stand for, and a row per variation where the list carries variations.
                               Every other flag still applies, so this counts the list the same command would produce

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

@@ -24,6 +24,7 @@ export default class AutoPrewarm extends Command {
         hardNavigationsOnly: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         days: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         configName: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        catalog: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workgroup: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/auto-prewarm.js

@@ -46,7 +46,7 @@ export default class AutoPrewarm extends Command {
         }),
     };
     async run() {
-        const { args: { customerPath }, flags: { configName, days, device, excludeNoindex, excludeNotFound, excludeSuspicious, hardNavigationsOnly, keepParameterSorting, limit, match, minHits, quiet, variation, variationPath, verbose, workgroup, }, } = await this.parse(AutoPrewarm);
+        const { args: { customerPath }, flags: { configName, days, device, excludeNoindex, excludeNotFound, excludeSuspicious, hardNavigationsOnly, keepParameterSorting, limit, match, minHits, quiet, variation, variationPath, verbose, workgroup, catalog, }, } = await this.parse(AutoPrewarm);
         const service = await new AutoPreWarmFactory({
             customerPath,
             configName,
@@ -65,6 +65,7 @@ export default class AutoPrewarm extends Command {
             quiet,
             verbose,
             workgroup,
+            catalog,
             isWindows: this.config.windows,
         }, new CliConfig(this.config).load()).getService();
         await service.run();

package/dist/commands/query/parameter.d.ts

@@ -21,6 +21,7 @@ export default class QueryParameter extends Command {
         hardNavigationsOnly: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         days: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         configName: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        catalog: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workgroup: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

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

@@ -26,6 +26,7 @@ export default class QueryPrewarm extends Command {
         hardNavigationsOnly: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         days: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         configName: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        catalog: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workgroup: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/helpers/clipboard.d.ts

@@ -14,6 +14,12 @@
  * behind a timeout, so no clipboard tool can ever be the reason a command
  * appears to do nothing.
  *
+ * `clipboardy` is loaded here rather than at module scope so that importing
+ * anything that can copy does not drag it in. It pulls a dependency that some
+ * Node/loader combinations refuse to resolve, which made every module on this
+ * path impossible to import from a test — and a clipboard that cannot load is
+ * already the case this function answers with `false`.
+ *
  * @returns whether the text reached the clipboard.
  */
 export declare function copyToClipboard(text: string): Promise<boolean>;

package/dist/helpers/clipboard.js

@@ -1,5 +1,4 @@
 import { spawn } from "node:child_process";
-import clipboardy from "clipboardy";
 /** How long a clipboard tool may take before the CLI stops waiting for it. */
 const TIMEOUT_IN_MS = 2000;
 /**
@@ -18,6 +17,12 @@ const TIMEOUT_IN_MS = 2000;
  * behind a timeout, so no clipboard tool can ever be the reason a command
  * appears to do nothing.
  *
+ * `clipboardy` is loaded here rather than at module scope so that importing
+ * anything that can copy does not drag it in. It pulls a dependency that some
+ * Node/loader combinations refuse to resolve, which made every module on this
+ * path impossible to import from a test — and a clipboard that cannot load is
+ * already the case this function answers with `false`.
+ *
  * @returns whether the text reached the clipboard.
  */
 export async function copyToClipboard(text) {
@@ -28,6 +33,7 @@ export async function copyToClipboard(text) {
         }
     }
     try {
+        const { default: clipboardy } = await import("clipboardy");
         return await withTimeout(clipboardy.write(text).then(() => true));
     }
     catch {

package/dist/models/cli-parameters.d.ts

@@ -3,6 +3,7 @@ export declare enum CLIParameters {
     Artifacts = "artifacts",
     ConfigName = "configName",
     ContentTypes = "contentTypes",
+    Catalog = "catalog",
     Cookies = "cookies",
     Count = "count",
     CreateTests = "CreateTests",
@@ -170,6 +171,10 @@ export declare const CLI_QUERY_PREWARM: {
 /**
  * Where a query that is executed actually runs.
  *
+ * The catalog is the account's, not the query's: our own logins reach the rum
+ * tables under `live`, while a role scoped to one account reaches the same
+ * tables under `AwsDataCatalog`. `SK_ATHENA_CATALOG` lets a CI job say so once.
+ *
  * Athena resolves the account's default workgroup when none is named, which is
  * only right where the credentials are allowed to use it — a role scoped to one
  * workgroup is refused on any other, and the result location is a workgroup
@@ -177,6 +182,7 @@ export declare const CLI_QUERY_PREWARM: {
  * command in the job.
  */
 export declare const CLI_ATHENA: {
+    catalog: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     workgroup: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
 };
 /** How the parameter query presents what it found. */

package/dist/models/cli-parameters.js

@@ -4,12 +4,14 @@ import { Args, Flags } from "@oclif/core";
 // library.
 import { parseMatchPattern } from "../services/query-builder/rules/match-pattern.js";
 import { DEVICE_VARIATIONS } from "../services/query-builder/queries/device.js";
+import { DEFAULT_ATHENA_CATALOG } from "../services/athena/athena-service-model.js";
 export var CLIParameters;
 (function (CLIParameters) {
     CLIParameters["AppName"] = "app";
     CLIParameters["Artifacts"] = "artifacts";
     CLIParameters["ConfigName"] = "configName";
     CLIParameters["ContentTypes"] = "contentTypes";
+    CLIParameters["Catalog"] = "catalog";
     CLIParameters["Cookies"] = "cookies";
     CLIParameters["Count"] = "count";
     CLIParameters["CreateTests"] = "CreateTests";
@@ -253,6 +255,10 @@ export const CLI_QUERY_PREWARM = {
 /**
  * Where a query that is executed actually runs.
  *
+ * The catalog is the account's, not the query's: our own logins reach the rum
+ * tables under `live`, while a role scoped to one account reaches the same
+ * tables under `AwsDataCatalog`. `SK_ATHENA_CATALOG` lets a CI job say so once.
+ *
  * Athena resolves the account's default workgroup when none is named, which is
  * only right where the credentials are allowed to use it — a role scoped to one
  * workgroup is refused on any other, and the result location is a workgroup
@@ -260,6 +266,12 @@ export const CLI_QUERY_PREWARM = {
  * command in the job.
  */
 export const CLI_ATHENA = {
+    [CLIParameters.Catalog]: Flags.string({
+        default: DEFAULT_ATHENA_CATALOG,
+        description: "Athena data catalog holding the rum tables. Names the catalog both in the query and in the context it runs in, so the two always agree",
+        env: "SK_ATHENA_CATALOG",
+        required: false,
+    }),
     [CLIParameters.Workgroup]: Flags.string({
         description: "Athena workgroup to run the query in, e.g. 'prewarming'. Defaults to the account's default workgroup",
         env: "SK_ATHENA_WORKGROUP",

package/dist/services/athena/athena-service-factory.d.ts

@@ -2,6 +2,7 @@ import { AthenaService } from "./athena-query-service.js";
 export declare class AthenaServiceFactory {
     private app?;
     private workgroup?;
+    private catalog?;
     service?: AthenaService;
     /**
      * @param app - the app to query. Enables the Baqend native query path (app
@@ -9,8 +10,11 @@ export declare class AthenaServiceFactory {
      * the AWS path is available.
      * @param workgroup - Athena workgroup for the AWS path. The Baqend path has
      * no such notion, so it is ignored there.
+     * @param catalog - the data catalog the tables live in. The Baqend path is
+     * told so it can recognise the prefix, not so it can use it: the server
+     * resolves the catalog itself.
      */
-    constructor(app?: string, workgroup?: string);
+    constructor(app?: string, workgroup?: string, catalog?: string);
     getService(): Promise<AthenaService>;
     /**
      * Prefer direct AWS Athena whenever AWS credentials are present — they

package/dist/services/athena/athena-service-factory.js

@@ -9,6 +9,7 @@ import { EntityManagerFactory } from "../config-api/entity-manager-factory.js";
 export class AthenaServiceFactory {
     app;
     workgroup;
+    catalog;
     service;
     /**
      * @param app - the app to query. Enables the Baqend native query path (app
@@ -16,10 +17,14 @@ export class AthenaServiceFactory {
      * the AWS path is available.
      * @param workgroup - Athena workgroup for the AWS path. The Baqend path has
      * no such notion, so it is ignored there.
+     * @param catalog - the data catalog the tables live in. The Baqend path is
+     * told so it can recognise the prefix, not so it can use it: the server
+     * resolves the catalog itself.
      */
-    constructor(app, workgroup) {
+    constructor(app, workgroup, catalog) {
         this.app = app;
         this.workgroup = workgroup;
+        this.catalog = catalog;
     }
     async getService() {
         if (!this.service) {
@@ -40,10 +45,10 @@ export class AthenaServiceFactory {
             cli.comment(this.workgroup
                 ? `Using AWS credentials for Athena queries, workgroup ${this.workgroup}.`
                 : "Using AWS credentials for Athena queries.");
-            return new AwsAthenaService(client, cli, this.workgroup);
+            return new AwsAthenaService(client, cli, this.workgroup, this.catalog);
         }
         if (this.app) {
-            return new BaqendAthenaService(this.app, new EntityManagerFactory(), cli);
+            return new BaqendAthenaService(this.app, new EntityManagerFactory(), cli, this.catalog);
         }
         throw new FetchCredentialsError("Cannot send Athena queries: no AWS credentials found and no app given for the Baqend API.");
     }

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

@@ -1,4 +1,21 @@
 export declare const DEFAULT_MAX_AGE_IN_MINUTES = 60;
+/**
+ * The Athena data catalog holding the Speed Kit tables.
+ *
+ * Which catalog that is depends on the credentials: the name below is the one
+ * our own logins see, while a role scoped to one account reaches the same
+ * tables under `AwsDataCatalog`. It is therefore a default, not a constant —
+ * see the `--catalog` flag.
+ */
+export declare const DEFAULT_ATHENA_CATALOG = "live";
+/**
+ * The catalog to use, given what a caller asked for.
+ *
+ * A blank name is the default rather than an error: it reaches here from an
+ * unset environment variable in a CI file as easily as from a typo, and a
+ * query that reads `from .rum.pi` is no way to report it.
+ */
+export declare function athenaCatalog(catalog?: string): string;
 export declare const ATHENA_CONFIG: {
     region: string;
 };

package/dist/services/athena/athena-service-model.js

@@ -1,4 +1,23 @@
 export const DEFAULT_MAX_AGE_IN_MINUTES = 60;
+/**
+ * The Athena data catalog holding the Speed Kit tables.
+ *
+ * Which catalog that is depends on the credentials: the name below is the one
+ * our own logins see, while a role scoped to one account reaches the same
+ * tables under `AwsDataCatalog`. It is therefore a default, not a constant —
+ * see the `--catalog` flag.
+ */
+export const DEFAULT_ATHENA_CATALOG = "live";
+/**
+ * The catalog to use, given what a caller asked for.
+ *
+ * A blank name is the default rather than an error: it reaches here from an
+ * unset environment variable in a CI file as easily as from a typo, and a
+ * query that reads `from .rum.pi` is no way to report it.
+ */
+export function athenaCatalog(catalog) {
+    return catalog?.trim() || DEFAULT_ATHENA_CATALOG;
+}
 export const ATHENA_CONFIG = {
     region: "eu-central-1",
 };

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

@@ -15,12 +15,22 @@ export declare class AwsAthenaService implements AthenaService {
      * which is only right where the credentials are allowed to use it.
      */
     private workgroup?;
+    /**
+     * The data catalog the query runs against. It has to be the one the query
+     * text names too, or Athena rejects the reference rather than the context.
+     */
+    private catalog?;
     constructor(client: AthenaClient, cli: CliServiceInterface, 
     /**
      * Athena falls back to the account's default workgroup when this is unset,
      * which is only right where the credentials are allowed to use it.
      */
-    workgroup?: string);
+    workgroup?: string, 
+    /**
+     * The data catalog the query runs against. It has to be the one the query
+     * text names too, or Athena rejects the reference rather than the context.
+     */
+    catalog?: string);
     getResult<T>(query: string, parameters?: string[], maxAgeInMinutes?: number): Promise<T[]>;
     /** The query, from sending it off to the rows it produced. */
     private runAndFetch;

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

@@ -1,5 +1,5 @@
 import { GetQueryExecutionCommand, GetQueryResultsCommand, QueryExecutionState, StartQueryExecutionCommand, } from "@aws-sdk/client-athena";
-import { DEFAULT_MAX_AGE_IN_MINUTES } from "./athena-service-model.js";
+import { athenaCatalog, DEFAULT_MAX_AGE_IN_MINUTES, } from "./athena-service-model.js";
 import { AthenaQueryError } from "./error/athena-query-error.js";
 import { safe } from "../../helpers/safe.js";
 /**
@@ -12,15 +12,22 @@ export class AwsAthenaService {
     client;
     cli;
     workgroup;
+    catalog;
     constructor(client, cli, 
     /**
      * Athena falls back to the account's default workgroup when this is unset,
      * which is only right where the credentials are allowed to use it.
      */
-    workgroup) {
+    workgroup, 
+    /**
+     * The data catalog the query runs against. It has to be the one the query
+     * text names too, or Athena rejects the reference rather than the context.
+     */
+    catalog) {
         this.client = client;
         this.cli = cli;
         this.workgroup = workgroup;
+        this.catalog = catalog;
     }
     async getResult(query, parameters = [], maxAgeInMinutes = DEFAULT_MAX_AGE_IN_MINUTES) {
         this.cli.startAction("ATHENA:QUERY", "execute athena query");
@@ -106,7 +113,7 @@ export class AwsAthenaService {
         const command = new StartQueryExecutionCommand({
             ExecutionParameters: executionParameters.length > 0 ? executionParameters : null,
             QueryExecutionContext: {
-                Catalog: "live",
+                Catalog: athenaCatalog(this.catalog),
             },
             QueryString: sql,
             ResultReuseConfiguration: {

package/dist/services/athena/athena-service.spec.js

@@ -81,6 +81,22 @@ describe("AwsAthenaService", () => {
         const start = sent.find((command) => command instanceof StartQueryExecutionCommand);
         expect(start.input).to.not.have.property("WorkGroup");
     });
+    it("should run against the catalog it was given", async () => {
+        // The context and the query text have to name the same catalog, or Athena
+        // rejects the reference in the query rather than the context.
+        const sent = [];
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED", undefined, sent), recordingCli().cli, undefined, "AwsDataCatalog");
+        await service.getResult("select 1", [], 0);
+        const [start] = sent.filter((command) => command instanceof StartQueryExecutionCommand);
+        expect(start.input.QueryExecutionContext.Catalog).to.equal("AwsDataCatalog");
+    });
+    it("should fall back to the live catalog", async () => {
+        const sent = [];
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED", undefined, sent), recordingCli().cli);
+        await service.getResult("select 1", [], 0);
+        const [start] = sent.filter((command) => command instanceof StartQueryExecutionCommand);
+        expect(start.input.QueryExecutionContext.Catalog).to.equal("live");
+    });
     it("should not pass a failed query off as an empty result", async () => {
         const { cli } = recordingCli();
         const service = new AwsAthenaService(clientAnswering("CANCELLED"), cli);

package/dist/services/athena/baqend-athena-service.d.ts

@@ -8,8 +8,8 @@ import { CliServiceInterface } from "../cli/index.js";
  *
  * Two normalizations vs the AWS path:
  *  - `?` placeholders are inlined (the native path has no parameter binding).
- *  - the `live.` catalog prefix is stripped — the server derives catalog and
- *    database itself, and a 3-part `live.<db>.<table>` reference fails there
+ *  - the catalog prefix is stripped — the server derives catalog and database
+ *    itself, and a 3-part `<catalog>.<db>.<table>` reference fails there
  *    (verified against a live app), whereas 2-part `<db>.<table>` works.
  */
 export declare class BaqendAthenaService implements AthenaService {
@@ -17,8 +17,17 @@ export declare class BaqendAthenaService implements AthenaService {
     private entityManagerFactory;
     private cli;
     private static readonly TRIGGERED_BY;
-    private static readonly CATALOG_PREFIX;
-    constructor(app: string, entityManagerFactory: EntityManagerFactory, cli: CliServiceInterface);
+    /** A catalog qualifier in front of a `<db>.<table>` reference. */
+    private readonly catalogPrefix;
+    /** The catalog whose qualifier has to come back out of the query. */
+    private readonly catalog;
+    constructor(app: string, entityManagerFactory: EntityManagerFactory, cli: CliServiceInterface, 
+    /**
+     * The catalog the queries name. Whichever one the caller runs under, the
+     * prefix has to come back out here — so the name is read rather than
+     * assumed.
+     */
+    catalog?: string);
     getResult<T>(query: string, parameters?: AthenaParameter[], maxAgeInMinutes?: number, bucket?: AthenaBucket): Promise<T[]>;
     /**
      * Inline the `?` placeholders with the given parameters (same quoting as the

package/dist/services/athena/baqend-athena-service.js

@@ -1,5 +1,9 @@
-import { DEFAULT_MAX_AGE_IN_MINUTES } from "./athena-service-model.js";
+import { athenaCatalog, DEFAULT_MAX_AGE_IN_MINUTES, } from "./athena-service-model.js";
 import { safe } from "../../helpers/safe.js";
+/** A literal for use inside a regular expression. */
+function escapeRegExp(value) {
+    return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
+}
 /**
  * Runs Athena SQL through the Baqend API, authenticated by the app token only
  * (no AWS login). Hits the native query path via
@@ -7,8 +11,8 @@ import { safe } from "../../helpers/safe.js";
  *
  * Two normalizations vs the AWS path:
  *  - `?` placeholders are inlined (the native path has no parameter binding).
- *  - the `live.` catalog prefix is stripped — the server derives catalog and
- *    database itself, and a 3-part `live.<db>.<table>` reference fails there
+ *  - the catalog prefix is stripped — the server derives catalog and database
+ *    itself, and a 3-part `<catalog>.<db>.<table>` reference fails there
  *    (verified against a live app), whereas 2-part `<db>.<table>` works.
  */
 export class BaqendAthenaService {
@@ -16,12 +20,22 @@ export class BaqendAthenaService {
     entityManagerFactory;
     cli;
     static TRIGGERED_BY = "speed-kit-cli";
-    // a `live.` catalog qualifier in front of a `<db>.<table>` reference
-    static CATALOG_PREFIX = /^live\.[a-z_]\w*\.[a-z_]/i;
-    constructor(app, entityManagerFactory, cli) {
+    /** A catalog qualifier in front of a `<db>.<table>` reference. */
+    catalogPrefix;
+    /** The catalog whose qualifier has to come back out of the query. */
+    catalog;
+    constructor(app, entityManagerFactory, cli, 
+    /**
+     * The catalog the queries name. Whichever one the caller runs under, the
+     * prefix has to come back out here — so the name is read rather than
+     * assumed.
+     */
+    catalog) {
         this.app = app;
         this.entityManagerFactory = entityManagerFactory;
         this.cli = cli;
+        this.catalog = athenaCatalog(catalog);
+        this.catalogPrefix = new RegExp(`^${escapeRegExp(this.catalog)}\\.[a-z_]\\w*\\.[a-z_]`, "i");
     }
     async getResult(query, parameters = [], maxAgeInMinutes = DEFAULT_MAX_AGE_IN_MINUTES, bucket) {
         if (!bucket) {
@@ -78,11 +92,12 @@ export class BaqendAthenaService {
                 out += typeof value === "string" ? `'${value}'` : String(value);
                 continue;
             }
-            // strip a `live.` catalog qualifier at a word boundary
-            if ((char === "l" || char === "L") &&
+            // strip the catalog qualifier at a word boundary
+            if (char.toLowerCase() === this.catalog[0].toLowerCase() &&
                 (index === 0 || !/\w/.test(query[index - 1])) &&
-                BaqendAthenaService.CATALOG_PREFIX.test(query.slice(index))) {
-                index += 4; // skip "live." (the loop's index++ skips the dot)
+                this.catalogPrefix.test(query.slice(index))) {
+                // skip the name; the loop's index++ skips the dot behind it
+                index += this.catalog.length;
                 continue;
             }
             out += char;

package/dist/services/athena/baqend-athena-service.spec.d.ts

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

package/dist/services/athena/baqend-athena-service.spec.js

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { AthenaBucket } from "./athena-query-service.js";
+import { BaqendAthenaService } from "./baqend-athena-service.js";
+const cli = {
+    failAction: () => undefined,
+    startAction: () => undefined,
+    successAction: () => undefined,
+    writeError: () => undefined,
+};
+/** An entity manager that records the sql it was asked to run. */
+function factoryCapturing(sent) {
+    return {
+        getEntityManager: async () => ({
+            [AthenaBucket.RumPi]: {
+                executeQuery: async (sql) => {
+                    sent.push(sql);
+                    return [];
+                },
+            },
+        }),
+    };
+}
+/** The sql that reached the Baqend API for a query run under `catalog`. */
+async function sentFor(query, catalog) {
+    const sent = [];
+    const service = new BaqendAthenaService("shop-de", factoryCapturing(sent), cli, catalog);
+    await service.getResult(query, [], 60, AthenaBucket.RumPi);
+    return sent[0];
+}
+describe("BaqendAthenaService", () => {
+    it("should strip the default catalog qualifier", async () => {
+        // The native path derives catalog and database itself and rejects a
+        // three-part reference.
+        expect(await sentFor("select url from live.rum.pi")).to.equal("select url from rum.pi");
+    });
+    it("should strip whichever catalog the query names", async () => {
+        expect(await sentFor("select url from AwsDataCatalog.rum.pi", "AwsDataCatalog")).to.equal("select url from rum.pi");
+    });
+    it("should leave a catalog name inside a string literal alone", async () => {
+        expect(await sentFor("select 'https://live.foo.com' from live.rum.pi")).to.equal("select 'https://live.foo.com' from rum.pi");
+    });
+    it("should fall back to the default catalog when given a blank one", async () => {
+        // An unset variable in a CI file arrives as an empty string, and the
+        // stripping reads the first character of the name.
+        expect(await sentFor("select url from live.rum.pi", "  ")).to.equal("select url from rum.pi");
+    });
+    it("should leave a word that merely starts like the catalog alone", async () => {
+        expect(await sentFor("select liveliness from live.rum.pi")).to.equal("select liveliness from rum.pi");
+    });
+});

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

@@ -8,6 +8,9 @@ export declare class CliService implements CliServiceInterface {
     private buffer;
     private progressBar?;
     private spinners;
+    private readonly animates;
+    /** The text of each running action, for the log line that replaces it. */
+    private readonly actions;
     constructor(quiet?: boolean);
     code(code: string, buffered?: boolean): void;
     codeStyle(code: string): string;
@@ -30,6 +33,12 @@ export declare class CliService implements CliServiceInterface {
     endAction(name: string, message?: string): void;
     failAction(name: string, message?: string): void;
     successAction(name: string, message?: string): void;
+    /**
+     * One line for an action that ended, where a spinner cannot be drawn. The
+     * text comes from the action that started, so a caller that ends one without
+     * a message still says which one it ended.
+     */
+    private logAction;
     startProgress(total: number, start?: number, payload?: object, config?: Options): void;
     updateProgress(current: number, payload?: object): void;
     stopProgress(): void;

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

@@ -6,12 +6,27 @@ import Spinnies from "spinnies";
 import { safe } from "../../helpers/safe.js";
 import { execSync } from "node:child_process";
 import ApplicationError from "../error-handling/error/application-error.js";
+/**
+ * Whether a spinner can actually spin here.
+ *
+ * The same condition spinnies itself uses to decide, so the two never
+ * disagree: without it spinnies falls back to re-rendering *every* spinner it
+ * knows on every update, which in a CI log means the first action's line is
+ * printed again under each later one — a page of "build prewarm-query" for a
+ * job that only ever built one.
+ */
+function canAnimate() {
+    return Boolean(!process.env.CI && process.stderr && process.stderr.isTTY);
+}
 export class CliService {
     quiet;
     style;
     buffer = [];
     progressBar;
     spinners;
+    animates = canAnimate();
+    /** The text of each running action, for the log line that replaces it. */
+    actions = new Map();
     constructor(quiet = false) {
         this.quiet = quiet;
         this.spinners = new Spinnies();
@@ -90,26 +105,65 @@ export class CliService {
         if (this.quiet) {
             return;
         }
+        // Nothing is logged while the action runs: a log that cannot animate has
+        // no use for "this is happening", only for what happened.
+        if (!this.animates) {
+            this.actions.set(name, message);
+            return;
+        }
         this.spinners.add(name, { text: message });
     }
     endAction(name, message) {
-        if (this.quiet || !this.spinners.pick(name)) {
+        if (this.quiet) {
+            return;
+        }
+        if (!this.animates) {
+            this.logAction("-", name, message);
+            return;
+        }
+        if (!this.spinners.pick(name)) {
             return;
         }
         this.spinners.update(name, { status: "stopped", text: message });
     }
     failAction(name, message) {
-        if (this.quiet || !this.spinners.pick(name)) {
+        if (this.quiet) {
+            return;
+        }
+        if (!this.animates) {
+            this.logAction(this.style.red("✖"), name, message);
+            return;
+        }
+        if (!this.spinners.pick(name)) {
             return;
         }
         this.spinners.fail(name, { text: message });
     }
     successAction(name, message) {
-        if (this.quiet || !this.spinners.pick(name)) {
+        if (this.quiet) {
+            return;
+        }
+        if (!this.animates) {
+            this.logAction(this.style.green("✔"), name, message);
+            return;
+        }
+        if (!this.spinners.pick(name)) {
             return;
         }
         this.spinners.succeed(name, { text: message, succeedColor: "white" });
     }
+    /**
+     * One line for an action that ended, where a spinner cannot be drawn. The
+     * text comes from the action that started, so a caller that ends one without
+     * a message still says which one it ended.
+     */
+    logAction(symbol, name, message) {
+        const text = message ?? this.actions.get(name);
+        if (!this.actions.delete(name) && !message) {
+            return;
+        }
+        console.log(`${symbol} ${text}`);
+    }
     startProgress(total, start = 0, payload, config) {
         if (this.quiet) {
             return;

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

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

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

@@ -0,0 +1,67 @@
+import { expect } from "chai";
+import { afterEach, beforeEach, describe, it } from "mocha";
+import { CliService } from "./cli-service.js";
+/** The lines a block of work put on stdout. */
+function captured(work) {
+    const lines = [];
+    const log = console.log;
+    console.log = (line) => lines.push(line);
+    try {
+        work();
+    }
+    finally {
+        console.log = log;
+    }
+    return lines;
+}
+describe("CliService actions without a terminal", () => {
+    let ci;
+    beforeEach(() => {
+        ci = process.env.CI;
+        // What a CI runner sets, and what spinnies reads to decide it cannot spin.
+        process.env.CI = "true";
+    });
+    afterEach(() => {
+        if (ci === undefined) {
+            delete process.env.CI;
+            return;
+        }
+        process.env.CI = ci;
+    });
+    it("should say nothing while an action runs", () => {
+        const cli = new CliService();
+        expect(captured(() => cli.startAction("BUILD", "build prewarm-query"))).to.have.lengthOf(0);
+    });
+    it("should log an action that ended exactly once", () => {
+        // Spinnies re-renders every spinner it knows on each update when it cannot
+        // animate, so a running action reappears under each later one — a job with
+        // four actions logged "build prewarm-query" four times.
+        const cli = new CliService();
+        const lines = captured(() => {
+            cli.startAction("BUILD", "build prewarm-query");
+            cli.successAction("BUILD");
+            cli.startAction("QUERY", "execute athena query");
+            cli.failAction("QUERY");
+        });
+        expect(lines).to.have.lengthOf(2);
+        expect(lines[0]).to.contain("build prewarm-query");
+        expect(lines[1]).to.contain("execute athena query");
+        expect(lines.join("\n")).to.not.contain("build prewarm-query\n✖ execute athena query\n✔ build prewarm-query");
+    });
+    it("should keep the text of the action it ends", () => {
+        const cli = new CliService();
+        const lines = captured(() => {
+            cli.startAction("WARM", "warm the list");
+            cli.endAction("WARM");
+        });
+        expect(lines).to.deep.equal(["- warm the list"]);
+    });
+    it("should stay silent when it was told to be quiet", () => {
+        const cli = new CliService(true);
+        const lines = captured(() => {
+            cli.startAction("BUILD", "build prewarm-query");
+            cli.successAction("BUILD");
+        });
+        expect(lines).to.have.lengthOf(0);
+    });
+});

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

@@ -16,6 +16,8 @@ export interface AutoPreWarmContext extends QueryFilterOptions {
     readonly minHits?: number;
     /** Athena workgroup the query runs in. */
     readonly workgroup?: string;
+    /** Athena data catalog the rum tables live in. */
+    readonly catalog?: string;
     /** Variations to pair every url with, when no traffic can reveal them. */
     readonly variation?: readonly string[];
     readonly variationPath?: string;

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

@@ -45,6 +45,7 @@ export class AutoPreWarmFactory {
             quiet: this.context.quiet,
             variations: this.context.variation,
             workgroup: this.context.workgroup,
+            catalog: this.context.catalog,
         }, this.userConfig).buildService(QueryType.prewarm);
         const app = queryService.app;
         const rows = await queryService.execute();

package/dist/services/query-builder/queries/page-source.d.ts

@@ -1,7 +1,16 @@
 import { RuleSubjectExpressions } from "../rules/index.js";
 import { QueryInput } from "./query-model.js";
-/** The relation every query reads from. */
-export declare const PAGE_IMPRESSIONS = "live.rum.pi";
+/** The database and table every query reads from, within its catalog. */
+export declare const PAGE_IMPRESSIONS = "rum.pi";
+/**
+ * The relation every query reads from, qualified by the catalog it lives in.
+ *
+ * The catalog is named in the query and not only in the context it runs in, so
+ * that a query pasted into the Athena console reads the same tables as the one
+ * the CLI ran — the console resolves an unqualified name against whichever
+ * catalog its dropdown happens to hold.
+ */
+export declare function pageImpressions(catalog?: string): string;
 /** The name of the common table expression the queries select from. */
 export declare const PAGE_SOURCE = "pages";
 export interface PageSource {

package/dist/services/query-builder/queries/page-source.js

@@ -2,8 +2,20 @@ import { column, formatPredicate } from "../sql/index.js";
 import { resolvedSubject, urlSubjects, } from "../rules/index.js";
 import { normalizeDevices } from "./device.js";
 import { buildRowFilter } from "./page-filter.js";
-/** The relation every query reads from. */
-export const PAGE_IMPRESSIONS = "live.rum.pi";
+import { athenaCatalog } from "../../athena/athena-service-model.js";
+/** The database and table every query reads from, within its catalog. */
+export const PAGE_IMPRESSIONS = "rum.pi";
+/**
+ * The relation every query reads from, qualified by the catalog it lives in.
+ *
+ * The catalog is named in the query and not only in the context it runs in, so
+ * that a query pasted into the Athena console reads the same tables as the one
+ * the CLI ran — the console resolves an unqualified name against whichever
+ * catalog its dropdown happens to hold.
+ */
+export function pageImpressions(catalog) {
+    return `${athenaCatalog(catalog)}.${PAGE_IMPRESSIONS}`;
+}
 /** The name of the common table expression the queries select from. */
 export const PAGE_SOURCE = "pages";
 const COLUMN_NAMES = {
@@ -37,7 +49,7 @@ export function buildPageSource(input, options = {}) {
     const cte = `${PAGE_SOURCE} as (
   select
     ${projections.join(",\n    ")}
-  from ${PAGE_IMPRESSIONS}
+  from ${pageImpressions(input.catalog)}
   where ${formatPredicate(buildRowFilter(input), { level: 2 })}
 )`;
     // An unused subject keeps its inline expression: nothing refers to it, and

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

@@ -61,6 +61,8 @@ export interface ParameterOptions {
 /** Everything a query is built from. */
 export interface QueryInput extends ParameterOptions, PrewarmOptions {
     readonly app: string;
+    /** The data catalog the rum tables live in. Defaults to `live`. */
+    readonly catalog?: string;
     /** Size of the window the query looks at, in days. */
     readonly days: number;
     /** Drop page impressions of pages marked `noindex`. */

package/dist/services/query-builder/queries/spec/queries.spec.js

@@ -188,6 +188,23 @@ describe("the --variation pairing", () => {
         expect(buildPrewarmQuery(inputFor(CONFIG, { variations: ["it's"] })).sql).to.contain("array['it''s']");
     });
 });
+describe("the --catalog the query reads from", () => {
+    it("should read the rum tables from the live catalog by default", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG)).sql).to.contain("from live.rum.pi");
+        expect(buildParameterQuery(inputFor(CONFIG)).sql).to.contain("from live.rum.pi");
+    });
+    it("should read from the live catalog when given a blank one", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG, { catalog: "" })).sql).to.contain("from live.rum.pi");
+    });
+    it("should name the catalog it was given instead", () => {
+        // Which catalog holds the tables depends on the credentials: our own
+        // logins see them under `live`, a role scoped to one account under
+        // `AwsDataCatalog`.
+        const options = { catalog: "AwsDataCatalog" };
+        expect(buildPrewarmQuery(inputFor(CONFIG, options)).sql).to.contain("from AwsDataCatalog.rum.pi");
+        expect(buildParameterQuery(inputFor(CONFIG, options)).sql).to.not.contain("live.rum.pi");
+    });
+});
 describe("the --count report", () => {
     it("should count the urls and the traffic they stand for", () => {
         const { sql } = buildPrewarmQuery(inputFor(CONFIG, { count: true }));

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

@@ -25,6 +25,7 @@ export class QueryBuilderFactory {
         const serviceContext = {
             app,
             bySet: this.context.bySet,
+            catalog: this.context.catalog,
             count: this.context.count,
             days: this.context.days,
             devices: this.context.devices,
@@ -47,7 +48,7 @@ export class QueryBuilderFactory {
         // The Athena service is only needed when the query is executed directly —
         // which `--count` is, a count query being of no use as text.
         const athenaService = this.context.execute || this.context.count
-            ? await new AthenaServiceFactory(app, this.context.workgroup).getService()
+            ? await new AthenaServiceFactory(app, this.context.workgroup, this.context.catalog).getService()
             : undefined;
         return new QueryBuilderService(serviceContext, parseRuleSets(speedKitConfig), cli, athenaService);
     }

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

@@ -16,6 +16,8 @@ export interface QueryFilterOptions {
 }
 export interface QueryBuilderContext extends ParameterOptions, PrewarmOptions, QueryFilterOptions {
     readonly app: string;
+    /** Athena data catalog the rum tables live in. */
+    readonly catalog?: string;
     readonly execute?: boolean;
     /** Report every rule the query leaves out, reduces or approximates. */
     readonly explain?: boolean;
@@ -26,6 +28,8 @@ export interface QueryBuilderContext extends ParameterOptions, PrewarmOptions, Q
     readonly quiet?: boolean;
 }
 export interface QueryBuilderFactoryContext extends ParameterOptions, PrewarmOptions, QueryFilterOptions {
+    /** Athena data catalog the rum tables live in. */
+    readonly catalog?: string;
     readonly configName: string;
     readonly customerPath: string;
     readonly execute?: boolean;

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

@@ -44,10 +44,10 @@ export class QueryBuilderService {
         this.cli.startAction(action, `build ${this.context.queryType}-query`);
         const result = safe(() => this.build());
         if (result.success !== true) {
+            // Fail the action before throwing: the spinner is a timer, and one left
+            // running keeps the process alive with nothing to do.
             this.cli.failAction(action, result.error);
-            this.cli.writeError(result.error);
-            console.error(result.errorObj);
-            return;
+            throw result.errorObj ?? new Error(result.error);
         }
         this.cli.successAction(action);
         const query = result.data;
@@ -99,6 +99,7 @@ export class QueryBuilderService {
     build() {
         const input = {
             app: this.context.app,
+            catalog: this.context.catalog,
             bySet: this.context.bySet,
             count: this.context.count,
             days: this.context.days ?? DEFAULT_QUERY_DAYS[this.context.queryType],
@@ -178,9 +179,12 @@ export class QueryBuilderService {
         this.cli.startAction("QUERY:COUNT", "count the pre-warm list");
         const result = await safe(this.runQuery(query));
         if (result.success !== true) {
+            // Thrown, not reported and swallowed. A count that did not run is a
+            // failed command, and something driving this from a script — a CI job
+            // reading the exit code — has no other way to find that out. Printing
+            // the message and exiting 0 made a broken query look like a clean run.
             this.cli.failAction("QUERY:COUNT");
-            this.cli.writeError(result.error);
-            return;
+            throw result.errorObj ?? new Error(result.error);
         }
         this.cli.successAction("QUERY:COUNT");
         const rows = result.data;
@@ -210,9 +214,10 @@ export class QueryBuilderService {
         this.cli.startAction("QUERY:EXECUTE", "execute query and export csv");
         const result = await safe(this.runQuery(query));
         if (result.success !== true) {
+            // Thrown for the same reason as the count path: an export that produced
+            // no file must not exit 0.
             this.cli.failAction("QUERY:EXECUTE");
-            this.cli.writeError(result.error);
-            return;
+            throw result.errorObj ?? new Error(result.error);
         }
         const rows = result.data;
         const date = new Date().toISOString().split("T")[0];

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

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

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

@@ -0,0 +1,65 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { QueryBuilderService } from "./query-builder-service.js";
+import { QueryType } from "./query-builder-model.js";
+import { parseRuleSets } from "./rules/index.js";
+/** Records the actions so a left-running spinner shows up as a missing fail. */
+function recordingCli() {
+    const calls = [];
+    const cli = {
+        comment: () => calls.push("comment"),
+        failAction: (name) => calls.push(`fail:${name}`),
+        startAction: (name) => calls.push(`start:${name}`),
+        successAction: (name) => calls.push(`success:${name}`),
+        table: () => calls.push("table"),
+        writeError: (message) => calls.push(`error:${message}`),
+        writeSuccess: () => calls.push("success"),
+        writeWarning: () => calls.push("warning"),
+    };
+    return { calls, cli };
+}
+/** An Athena that always refuses, the way a bad catalog or workgroup does. */
+const refusingAthena = {
+    getResult: () => Promise.reject(new Error("The Amazon Athena query failed to run with error message: CATALOG_NOT_FOUND")),
+};
+function countService(cli) {
+    return new QueryBuilderService({
+        app: "obi-de",
+        count: true,
+        hosts: ["www.obi.de"],
+        queryType: QueryType.prewarm,
+        quiet: true,
+    }, 
+    // The real parser on an empty config: a hand-rolled stand-in would fail the
+    // build step and the test would pass for the wrong reason.
+    parseRuleSets({}), cli, refusingAthena);
+}
+describe("QueryBuilderService — a query that could not run", () => {
+    // Regression: this used to print the message and return, so the process
+    // exited 0. A CI job counting urls then reported success with no count, and
+    // the pipeline that read it had no way to tell a broken query from an empty
+    // one.
+    it("fails the command instead of exiting cleanly", async () => {
+        const { cli } = recordingCli();
+        const outcome = await countService(cli)
+            .run()
+            .then(() => "resolved")
+            .catch(() => "rejected");
+        expect(outcome).to.equal("rejected");
+    });
+    it("carries the reason, so the log says what went wrong", async () => {
+        const { cli } = recordingCli();
+        const error = await countService(cli)
+            .run()
+            .then(() => undefined)
+            .catch((thrown) => thrown);
+        expect(error?.message).to.contain("CATALOG_NOT_FOUND");
+    });
+    it("ends the spinner before throwing — it is a timer that holds the process open", async () => {
+        const { calls, cli } = recordingCli();
+        await countService(cli)
+            .run()
+            .catch(() => undefined);
+        expect(calls).to.contain("fail:QUERY:COUNT");
+    });
+});

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

@@ -8,6 +8,7 @@ import { QueryFilterOptions, QueryType } from "./query-builder-model.js";
  * the two the caller gives rather than the list the builder works on.
  */
 export interface QueryCommandFlags extends ParameterOptions, Omit<PrewarmOptions, "devices" | "variations">, QueryFilterOptions {
+    readonly catalog?: string;
     readonly configName: string;
     readonly device?: readonly string[];
     readonly execute?: boolean;

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

@@ -12,6 +12,7 @@ import { normalizeDevices } from "./queries/device.js";
 export async function runQuery(queryType, customerPath, flags, config) {
     const service = await new QueryBuilderFactory({
         bySet: flags.bySet,
+        catalog: flags.catalog,
         configName: flags.configName,
         count: flags.count,
         customerPath,

package/oclif.manifest.json

@@ -19,6 +19,16 @@
         "$ sk auto-prewarm customers/decathlon.de --workgroup prewarming"
       ],
       "flags": {
+        "catalog": {
+          "description": "Athena data catalog holding the rum tables. Names the catalog both in the query and in the context it runs in, so the two always agree",
+          "env": "SK_ATHENA_CATALOG",
+          "name": "catalog",
+          "required": false,
+          "default": "live",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "workgroup": {
           "description": "Athena workgroup to run the query in, e.g. 'prewarming'. Defaults to the account's default workgroup",
           "env": "SK_ATHENA_WORKGROUP",
@@ -1342,6 +1352,16 @@
         "$ sk query parameter customers/decathlon.de --explain"
       ],
       "flags": {
+        "catalog": {
+          "description": "Athena data catalog holding the rum tables. Names the catalog both in the query and in the context it runs in, so the two always agree",
+          "env": "SK_ATHENA_CATALOG",
+          "name": "catalog",
+          "required": false,
+          "default": "live",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "workgroup": {
           "description": "Athena workgroup to run the query in, e.g. 'prewarming'. Defaults to the account's default workgroup",
           "env": "SK_ATHENA_WORKGROUP",
@@ -1462,6 +1482,16 @@
         "$ sk query prewarm customers/decathlon.de --count"
       ],
       "flags": {
+        "catalog": {
+          "description": "Athena data catalog holding the rum tables. Names the catalog both in the query and in the context it runs in, so the two always agree",
+          "env": "SK_ATHENA_CATALOG",
+          "name": "catalog",
+          "required": false,
+          "default": "live",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "workgroup": {
           "description": "Athena workgroup to run the query in, e.g. 'prewarming'. Defaults to the account's default workgroup",
           "env": "SK_ATHENA_WORKGROUP",
@@ -1615,5 +1645,5 @@
       ]
     }
   },
-  "version": "4.27.1"
+  "version": "4.27.2"
 }

package/package.json

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