@speedkit/cli 4.17.1 → 4.19.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [4.19.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.18.0...v4.19.0) (2026-08-06)
+
+
+### Features
+
+* **customer-config:** default /services/login_with_shop for Shopify, tighten comment ([8299dfb](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/8299dfba0248cc6e38ba86f722e14082b5c960ec))
+* **customer-config:** scaffold native disabledScopes in config_SpeedKit template ([7535c7d](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/7535c7db670ff653be91f249cdaec664d08d9f05))
+
+# [4.18.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.17.1...v4.18.0) (2026-08-03)
+
+
+### Features
+
+* implement first run wizzard ([2757cb3](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/2757cb340d28b562b4728a6a98badd583a54e444))
+
 ## [4.17.1](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v4.17.0...v4.17.1) (2026-07-17)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/4.17.1 linux-x64 node-v22.23.1
+@speedkit/cli/4.19.0 linux-x64 node-v22.23.2
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND
@@ -68,9 +68,13 @@ By either...
 * [`sk auto-prewarm CUSTOMERPATH`](#sk-auto-prewarm-customerpath)
 * [`sk autocomplete [SHELL]`](#sk-autocomplete-shell)
 * [`sk autocomplete fish`](#sk-autocomplete-fish)
+* [`sk browser clean`](#sk-browser-clean)
+* [`sk browser list`](#sk-browser-list)
+* [`sk browser update`](#sk-browser-update)
 * [`sk build-parameter-query CUSTOMERPATH`](#sk-build-parameter-query-customerpath)
 * [`sk build-prewarm-query CUSTOMERPATH`](#sk-build-prewarm-query-customerpath)
 * [`sk config edit`](#sk-config-edit)
+* [`sk config setup`](#sk-config-setup)
 * [`sk deploy CUSTOMERPATH`](#sk-deploy-customerpath)
 * [`sk diff-url-parameters PAGEURL`](#sk-diff-url-parameters-pageurl)
 * [`sk document-handler CUSTOMERPATH`](#sk-document-handler-customerpath)
@@ -167,6 +171,56 @@ EXAMPLES
   $ sk autocomplete fish --print > sk.fish
 ```
 
+## `sk browser clean`
+
+Remove puppeteer-managed browser builds from the cache
+
+```
+USAGE
+  $ sk browser clean [-a]
+
+FLAGS
+  -a, --all  Remove all cached browser builds without prompting
+
+DESCRIPTION
+  Remove puppeteer-managed browser builds from the cache
+
+EXAMPLES
+  $ sk browser clean
+
+  $ sk browser clean --all
+```
+
+## `sk browser list`
+
+List detected system browsers and puppeteer-managed builds
+
+```
+USAGE
+  $ sk browser list
+
+DESCRIPTION
+  List detected system browsers and puppeteer-managed builds
+
+EXAMPLES
+  $ sk browser list
+```
+
+## `sk browser update`
+
+Update the puppeteer-managed browser to the latest build of its channel
+
+```
+USAGE
+  $ sk browser update
+
+DESCRIPTION
+  Update the puppeteer-managed browser to the latest build of its channel
+
+EXAMPLES
+  $ sk browser update
+```
+
 ## `sk build-parameter-query CUSTOMERPATH`
 
 Build a parameter query that can be executed in Athena
@@ -230,6 +284,26 @@ EXAMPLES
   $ sk config edit
 ```
 
+## `sk config setup`
+
+Run the Speed Kit CLI setup wizard (choose browser and diff tool)
+
+```
+USAGE
+  $ sk config setup [-f]
+
+FLAGS
+  -f, --force  Re-run even if setup was already completed
+
+DESCRIPTION
+  Run the Speed Kit CLI setup wizard (choose browser and diff tool)
+
+EXAMPLES
+  $ sk config setup
+
+  $ sk config setup --force
+```
+
 ## `sk deploy CUSTOMERPATH`
 
 Deploys the specified customer config while comparing to the live version before

package/dist/commands/browser/clean.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@oclif/core";
+export default class BrowserClean extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/browser/clean.js

@@ -0,0 +1,43 @@
+import { Command, Flags } from "@oclif/core";
+import { CliServiceFactory } from "../../services/cli/index.js";
+import { CliConfig } from "../../helpers/cli-config.js";
+import { BrowserManager, } from "../../services/setup/index.js";
+export default class BrowserClean extends Command {
+    static description = "Remove puppeteer-managed browser builds from the cache";
+    static examples = ["$ sk browser clean", "$ sk browser clean --all"];
+    static flags = {
+        all: Flags.boolean({
+            char: "a",
+            description: "Remove all cached browser builds without prompting",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(BrowserClean);
+        const cli = new CliServiceFactory().getService();
+        const userConfig = new CliConfig(this.config).load();
+        const manager = new BrowserManager(userConfig.tempFolder, cli);
+        const installed = manager.list();
+        if (installed.length === 0) {
+            cli.writeWarning("No puppeteer-managed browsers to clean.");
+            return;
+        }
+        let toRemove;
+        if (flags.all) {
+            toRemove = installed;
+        }
+        else {
+            toRemove = await cli.multiSelect("Select browser builds to remove", installed.map((browser) => ({
+                name: `${browser.browser} ${browser.buildId}`,
+                value: browser,
+            })));
+        }
+        if (toRemove.length === 0) {
+            cli.comment("Nothing selected.");
+            return;
+        }
+        for (const browser of toRemove) {
+            await manager.remove(browser.browser, browser.buildId);
+            cli.writeSuccess(`Removed ${browser.browser} ${browser.buildId}`);
+        }
+    }
+}

package/dist/commands/browser/list.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "@oclif/core";
+export default class BrowserList extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/browser/list.js

@@ -0,0 +1,29 @@
+import { Command } from "@oclif/core";
+import { CliServiceFactory } from "../../services/cli/index.js";
+import { CliConfig } from "../../helpers/cli-config.js";
+import { BrowserDetector, normalizePlatform, } from "../../services/setup/index.js";
+export default class BrowserList extends Command {
+    static description = "List detected system browsers and puppeteer-managed builds";
+    static examples = ["$ sk browser list"];
+    async run() {
+        const cli = new CliServiceFactory().getService();
+        const userConfig = new CliConfig(this.config).load();
+        const detector = new BrowserDetector(normalizePlatform(this.config.platform), this.config.home, userConfig.tempFolder);
+        const browsers = detector.detectAll();
+        if (browsers.length === 0) {
+            cli.writeWarning("No browsers detected.");
+            return;
+        }
+        cli.table(browsers.map((browser) => ({
+            name: browser.name,
+            source: browser.source,
+            path: browser.executablePath,
+            active: browser.executablePath === userConfig.chromePath ? "✔" : "",
+        })), {
+            name: { header: "Browser" },
+            source: { header: "Source" },
+            path: { header: "Path" },
+            active: { header: "In use" },
+        });
+    }
+}

package/dist/commands/browser/update.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "@oclif/core";
+export default class BrowserUpdate extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/browser/update.js

@@ -0,0 +1,32 @@
+import { Command } from "@oclif/core";
+import { CliServiceFactory } from "../../services/cli/index.js";
+import { CliConfig } from "../../helpers/cli-config.js";
+import { BrowserManager } from "../../services/setup/index.js";
+export default class BrowserUpdate extends Command {
+    static description = "Update the puppeteer-managed browser to the latest build of its channel";
+    static examples = ["$ sk browser update"];
+    async run() {
+        const cli = new CliServiceFactory().getService();
+        const cliConfig = new CliConfig(this.config);
+        const userConfig = cliConfig.load();
+        const channel = userConfig.browserChannel;
+        if (channel !== "stable" && channel !== "experimental") {
+            cli.writeWarning("No puppeteer-managed browser configured. Run `sk config setup` first.");
+            return;
+        }
+        const manager = new BrowserManager(userConfig.tempFolder, cli);
+        const latest = await manager.resolveBuildId(channel);
+        if (latest === userConfig.browserBuildId) {
+            cli.writeSuccess(`Already on the latest ${channel} build (${latest}).`);
+            cliConfig.save({ lastBrowserUpdateCheck: new Date().toISOString() });
+            return;
+        }
+        const installed = await manager.installChannel(channel);
+        cliConfig.save({
+            chromePath: installed.executablePath,
+            browserBuildId: installed.buildId,
+            lastBrowserUpdateCheck: new Date().toISOString(),
+        });
+        cli.writeSuccess(`Updated to Chrome ${channel} ${installed.buildId}.`);
+    }
+}

package/dist/commands/config/setup.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@oclif/core";
+export default class Setup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        postInstall: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/setup.js

@@ -0,0 +1,28 @@
+import { Command, Flags } from "@oclif/core";
+import { SetupContext, SetupServiceFactory, } from "../../services/setup/index.js";
+import { isNonInteractive } from "../../helpers/environment.js";
+export default class Setup extends Command {
+    static description = "Run the Speed Kit CLI setup wizard (choose browser and diff tool)";
+    static examples = ["$ sk config setup", "$ sk config setup --force"];
+    static flags = {
+        force: Flags.boolean({
+            char: "f",
+            description: "Re-run even if setup was already completed",
+        }),
+        postInstall: Flags.boolean({
+            hidden: true,
+            description: "Internal flag used by the npm postinstall hook",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Setup);
+        const context = new SetupContext(flags.postInstall, flags.force);
+        const service = new SetupServiceFactory(this.config, context).getService();
+        // When triggered by postinstall, only run if it is safe and not yet done.
+        if (flags.postInstall &&
+            (isNonInteractive() || service.isFirstRunCompleted())) {
+            return;
+        }
+        await service.run();
+    }
+}

package/dist/helpers/cli-config.d.ts

@@ -5,9 +5,16 @@ export interface UserCliConfig {
     chromeUserProfilePath: string;
     diffExec: string;
     diffExecTemplate: string;
+    diffTool: string;
     ideaDirectory: string;
     slackToken: string;
     testApp: string;
+    browserChannel: string;
+    browserBuildId: string;
+    browserAutoUpdate: boolean;
+    updateReminderDays: number;
+    lastBrowserUpdateCheck: string;
+    firstRunCompleted: boolean;
     tempFolder: string;
     runtimeConfig: Config;
     nodeModulesPath: string;
@@ -19,9 +26,21 @@ export declare class CliConfig {
     load(customerPath?: string): UserCliConfig;
     private createEmptyConfigFile;
     private createEmptyUserConfig;
+    /**
+     * Persists the given settings into the user config.json, merging with what
+     * is already there. Runtime-only keys are stripped so they never leak into
+     * the file. Also reflects the change in the in-memory config so the running
+     * command sees it immediately.
+     */
+    save(partial: Partial<UserCliConfig>): void;
     private getConfigFilePath;
     private loadConfigFromConfigFile;
     private loadConfigFromEnvironment;
     private resolveExtensionConfigPaths;
     private readCliConfigFromFile;
+    /**
+     * Reads and parses config.json without any side effects. Returns null when
+     * the file is missing or cannot be parsed.
+     */
+    private readRawConfigFile;
 }

package/dist/helpers/cli-config.js

@@ -13,6 +13,12 @@ const environmentMapping = {
     testApp: "TEST_APP",
 };
 const CONFIG_FILE_NAME = "config.json";
+// keys that only exist at runtime and must never be written to config.json
+const RUNTIME_ONLY_KEYS = [
+    "tempFolder",
+    "runtimeConfig",
+    "nodeModulesPath",
+];
 export class CliConfig {
     config;
     userCliConfig = {
@@ -21,9 +27,16 @@ export class CliConfig {
         chromeUserProfilePath: "",
         diffExec: "",
         diffExecTemplate: "$exec $file1 $file2",
+        diffTool: "",
         ideaDirectory: "",
         slackToken: "",
         testApp: "",
+        browserChannel: "",
+        browserBuildId: "",
+        browserAutoUpdate: false,
+        updateReminderDays: 3,
+        lastBrowserUpdateCheck: "",
+        firstRunCompleted: false,
         tempFolder: "/tmp",
         runtimeConfig: {},
     };
@@ -51,11 +64,38 @@ export class CliConfig {
             chromePath: "",
             chromeUserProfilePath: "",
             diffExec: "",
+            diffExecTemplate: "$exec $file1 $file2",
+            diffTool: "",
             ideaDirectory: "",
             slackToken: "",
             testApp: "",
+            browserChannel: "",
+            browserBuildId: "",
+            browserAutoUpdate: false,
+            updateReminderDays: 3,
+            lastBrowserUpdateCheck: "",
+            firstRunCompleted: false,
         };
     }
+    /**
+     * Persists the given settings into the user config.json, merging with what
+     * is already there. Runtime-only keys are stripped so they never leak into
+     * the file. Also reflects the change in the in-memory config so the running
+     * command sees it immediately.
+     */
+    save(partial) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(partial)) {
+            if (!RUNTIME_ONLY_KEYS.includes(key)) {
+                sanitized[key] = value;
+            }
+        }
+        const existing = this.readRawConfigFile() ?? {};
+        const merged = { ...existing, ...sanitized };
+        fs.mkdirSync(path.resolve(this.config.configDir), { recursive: true });
+        fs.writeFileSync(this.getConfigFilePath(), JSON.stringify(merged, null, `\t`));
+        Object.assign(this.userCliConfig, sanitized);
+    }
     getConfigFilePath() {
         return path.resolve(this.config.configDir, CONFIG_FILE_NAME);
     }
@@ -65,9 +105,20 @@ export class CliConfig {
             return;
         }
         for (const configKey in this.userCliConfig) {
-            if (configKey in configJson && configJson[configKey].length > 0) {
-                this.userCliConfig[configKey] = configJson[configKey];
+            if (!(configKey in configJson)) {
+                continue;
+            }
+            const value = configJson[configKey];
+            // skip null/undefined and empty strings so file values only override
+            // defaults when they carry an actual setting (keeps booleans/numbers,
+            // unlike the previous `.length`-only check which dropped them)
+            if (value === undefined || value === null) {
+                continue;
             }
+            if (typeof value === "string" && value.length === 0) {
+                continue;
+            }
+            this.userCliConfig[configKey] = value;
         }
     }
     loadConfigFromEnvironment() {
@@ -98,7 +149,22 @@ export class CliConfig {
             this.createEmptyConfigFile();
             return;
         }
-        const configFileContent = fs.readFileSync(this.getConfigFilePath(), "utf8");
-        return JSON.parse(configFileContent);
+        return this.readRawConfigFile();
+    }
+    /**
+     * Reads and parses config.json without any side effects. Returns null when
+     * the file is missing or cannot be parsed.
+     */
+    readRawConfigFile() {
+        if (!fs.existsSync(this.getConfigFilePath())) {
+            return null;
+        }
+        try {
+            const configFileContent = fs.readFileSync(this.getConfigFilePath(), "utf8");
+            return JSON.parse(configFileContent);
+        }
+        catch {
+            return null;
+        }
     }
 }

package/dist/helpers/cli-config.spec.d.ts

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

package/dist/helpers/cli-config.spec.js

@@ -0,0 +1,70 @@
+import { expect } from "chai";
+import { describe, beforeEach, afterEach, it } from "mocha";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { CliConfig } from "./cli-config.js";
+function fakeOclifConfig(dir) {
+    return {
+        configDir: dir,
+        cacheDir: dir,
+        home: "/home/tester",
+        windows: false,
+    };
+}
+describe("CliConfig save/load", () => {
+    let dir;
+    beforeEach(() => {
+        dir = mkdtempSync(path.join(tmpdir(), "sk-cli-config-"));
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("persists and reloads boolean and number settings with their types", () => {
+        const cfg = new CliConfig(fakeOclifConfig(dir));
+        cfg.load();
+        cfg.save({
+            browserAutoUpdate: true,
+            updateReminderDays: 7,
+            firstRunCompleted: true,
+            browserChannel: "stable",
+        });
+        const reloaded = new CliConfig(fakeOclifConfig(dir)).load();
+        expect(reloaded.browserAutoUpdate).to.equal(true);
+        expect(reloaded.updateReminderDays).to.equal(7);
+        expect(reloaded.firstRunCompleted).to.equal(true);
+        expect(reloaded.browserChannel).to.equal("stable");
+    });
+    it("merges partial saves instead of overwriting the whole file", () => {
+        const cfg = new CliConfig(fakeOclifConfig(dir));
+        cfg.load();
+        cfg.save({ diffTool: "code", diffExec: "/usr/bin/code" });
+        cfg.save({ browserChannel: "experimental" });
+        const reloaded = new CliConfig(fakeOclifConfig(dir)).load();
+        expect(reloaded.diffTool).to.equal("code");
+        expect(reloaded.diffExec).to.equal("/usr/bin/code");
+        expect(reloaded.browserChannel).to.equal("experimental");
+    });
+    it("never writes runtime-only keys to config.json", () => {
+        const cfg = new CliConfig(fakeOclifConfig(dir));
+        cfg.load();
+        cfg.save({
+            firstRunCompleted: true,
+            // runtime-only keys must be stripped
+            tempFolder: "/should/not/be/persisted",
+            nodeModulesPath: "/should/not/be/persisted",
+        });
+        const raw = JSON.parse(readFileSync(path.join(dir, "config.json"), "utf8"));
+        expect(raw).to.not.have.property("tempFolder");
+        expect(raw).to.not.have.property("nodeModulesPath");
+        expect(raw).to.not.have.property("runtimeConfig");
+        expect(raw.firstRunCompleted).to.equal(true);
+    });
+    it("keeps defaults for a false boolean stored in the file", () => {
+        const cfg = new CliConfig(fakeOclifConfig(dir));
+        cfg.load();
+        cfg.save({ browserAutoUpdate: false });
+        const reloaded = new CliConfig(fakeOclifConfig(dir)).load();
+        expect(reloaded.browserAutoUpdate).to.equal(false);
+    });
+});

package/dist/helpers/environment.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Environment detection helpers used to decide whether interactive flows
+ * (e.g. the first-run wizard) may prompt the user.
+ */
+/**
+ * Detects common CI environments. Most CI providers set `CI=true`, and several
+ * set their own dedicated variable, so we check both.
+ */
+export declare function isCI(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * True when we cannot safely prompt the user: running in CI, without an
+ * attached TTY (e.g. piped output, npm background install), or when the user
+ * explicitly opted out via SK_NON_INTERACTIVE.
+ */
+export declare function isNonInteractive(env?: NodeJS.ProcessEnv): boolean;

package/dist/helpers/environment.js

@@ -0,0 +1,40 @@
+/**
+ * Environment detection helpers used to decide whether interactive flows
+ * (e.g. the first-run wizard) may prompt the user.
+ */
+/**
+ * Detects common CI environments. Most CI providers set `CI=true`, and several
+ * set their own dedicated variable, so we check both.
+ */
+export function isCI(env = process.env) {
+    if (env.CI !== undefined && env.CI !== "false" && env.CI !== "0") {
+        return true;
+    }
+    const ciMarkers = [
+        "CONTINUOUS_INTEGRATION",
+        "BUILD_NUMBER",
+        "GITLAB_CI",
+        "GITHUB_ACTIONS",
+        "JENKINS_URL",
+        "TEAMCITY_VERSION",
+        "TF_BUILD",
+        "BITBUCKET_BUILD_NUMBER",
+        "CIRCLECI",
+        "TRAVIS",
+    ];
+    return ciMarkers.some((marker) => Boolean(env[marker]));
+}
+/**
+ * True when we cannot safely prompt the user: running in CI, without an
+ * attached TTY (e.g. piped output, npm background install), or when the user
+ * explicitly opted out via SK_NON_INTERACTIVE.
+ */
+export function isNonInteractive(env = process.env) {
+    if (env.SK_NON_INTERACTIVE !== undefined && env.SK_NON_INTERACTIVE !== "") {
+        return true;
+    }
+    if (isCI(env)) {
+        return true;
+    }
+    return !process.stdin.isTTY || !process.stdout.isTTY;
+}

package/dist/helpers/environment.spec.d.ts

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

package/dist/helpers/environment.spec.js

@@ -0,0 +1,28 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { isCI, isNonInteractive } from "./environment.js";
+describe("environment.isCI", () => {
+    it("is false for an empty environment", () => {
+        expect(isCI({})).to.equal(false);
+    });
+    it("is true when CI is set to a truthy value", () => {
+        expect(isCI({ CI: "true" })).to.equal(true);
+        expect(isCI({ CI: "1" })).to.equal(true);
+    });
+    it("treats CI=false / CI=0 as not CI", () => {
+        expect(isCI({ CI: "false" })).to.equal(false);
+        expect(isCI({ CI: "0" })).to.equal(false);
+    });
+    it("detects provider-specific markers", () => {
+        expect(isCI({ GITLAB_CI: "true" })).to.equal(true);
+        expect(isCI({ GITHUB_ACTIONS: "true" })).to.equal(true);
+    });
+});
+describe("environment.isNonInteractive", () => {
+    it("is true when SK_NON_INTERACTIVE is set", () => {
+        expect(isNonInteractive({ SK_NON_INTERACTIVE: "1" })).to.equal(true);
+    });
+    it("is true when running in CI", () => {
+        expect(isNonInteractive({ CI: "true" })).to.equal(true);
+    });
+});

package/dist/hooks/init/first-run.d.ts

@@ -0,0 +1,8 @@
+import { Hook } from "@oclif/core";
+/**
+ * Runs before every command. When interactive it either nudges the user to run
+ * the setup wizard (first time) or performs the periodic browser update check.
+ * Any failure is swallowed so CLI housekeeping never blocks a real command.
+ */
+declare const hook: Hook<"init">;
+export default hook;

package/dist/hooks/init/first-run.js

@@ -0,0 +1,36 @@
+import { CliConfig } from "../../helpers/cli-config.js";
+import { SetupServiceFactory } from "../../services/setup/index.js";
+import { isNonInteractive } from "../../helpers/environment.js";
+// commands the hook must never interfere with (setup itself, help, plugins)
+const IGNORED_PREFIXES = ["config:setup", "help", "autocomplete", "plugins"];
+/**
+ * Runs before every command. When interactive it either nudges the user to run
+ * the setup wizard (first time) or performs the periodic browser update check.
+ * Any failure is swallowed so CLI housekeeping never blocks a real command.
+ */
+const hook = async function (opts) {
+    try {
+        if (isNonInteractive()) {
+            return;
+        }
+        const id = opts.id ?? "";
+        if (id === "" || IGNORED_PREFIXES.some((prefix) => id.startsWith(prefix))) {
+            return;
+        }
+        // opts.config is the runtime Config instance, typed here as the interface
+        const config = opts.config;
+        const cliConfig = new CliConfig(config);
+        const userConfig = cliConfig.load();
+        if (!userConfig.firstRunCompleted) {
+            this.log(`${opts.config.bin}: first-time setup has not run yet. ` +
+                `Run \`${opts.config.bin} config setup\` to choose a browser and diff tool.`);
+            return;
+        }
+        const service = new SetupServiceFactory(config).getService();
+        await service.remindBrowserUpdate();
+    }
+    catch {
+        // never block a command because of setup housekeeping
+    }
+};
+export default hook;