@speedkit/cli 4.20.5 → 4.22.0

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

@@ -1,9 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import Handlebars from "handlebars";
 import { analyzeSite, } from "../../helpers/site-analyzer.js";
-import { DirectoryOverwriteOption, EnvironmentType, ShopSystem, } from "./customer-config-service-model.js";
-import { fileURLToPath } from "node:url";
+import { DirectoryOverwriteOption, EnvironmentType, ShopSystem, TEMPLATE_VARIABLES, } from "./customer-config-service-model.js";
+import { findUnknownVariables, resolveTemplateSource, } from "./template-source.js";
 export class CustomerConfigService {
     context;
     cli;
@@ -22,14 +21,8 @@ export class CustomerConfigService {
     get outputDirPath() {
         return this._outputDirPath;
     }
-    templates = [
-        "config_customer.json.hbs",
-        "config_documentHandler.js.hbs",
-        "config_dynamicBlocks.es6.hbs",
-        "config_dynamicStyles.css.hbs",
-        "config_loadHandler.js.hbs",
-        "config_SpeedKit.js.hbs",
-    ];
+    /** Set from the "Downtime Detection" feature answer in the wizard. */
+    includeDowntimeDetection = false;
     constructor(context, cli) {
         this.context = context;
         const { appName } = this.context;
@@ -39,8 +32,8 @@ export class CustomerConfigService {
     getOutputDirPath(directoryName = "") {
         return path.join(process.cwd(), this.context.customersDirectory, directoryName);
     }
-    getHandlebarsOutputFileName(fileName) {
-        return fileName.replace(".hbs", "");
+    getOutputFileName(fileName) {
+        return fileName.replace(/\.njk$/, "");
     }
     getPathWithChangedDir(directoryPath, newDirectory) {
         return path.join(path.dirname(directoryPath), newDirectory);
@@ -65,7 +58,41 @@ export class CustomerConfigService {
         });
         return this.selectOutputDirectory(this.getPathWithChangedDir(directoryPath, newDirectoryName));
     }
+    /** A pre-PoC config marks itself via splitTestId "pre_poc" in config_SpeedKit.js. */
+    isPrePocConfig(directoryPath) {
+        const speedKitConfigPath = path.join(directoryPath, "config_SpeedKit.js");
+        if (!fs.existsSync(speedKitConfigPath)) {
+            return false;
+        }
+        return /["']pre_poc["']/.test(fs.readFileSync(speedKitConfigPath, "utf-8"));
+    }
+    /** Parks every config_* file as *_pre-poc (suffix before the extension). */
+    renamePrePocFiles(directoryPath) {
+        const configFilePattern = /^(config_[^.]+)\.(.+)$/;
+        for (const fileName of fs.readdirSync(directoryPath)) {
+            const match = fileName.match(configFilePattern);
+            if (!match) {
+                continue;
+            }
+            fs.renameSync(path.join(directoryPath, fileName), path.join(directoryPath, `${match[1]}_pre-poc.${match[2]}`));
+        }
+    }
     async selectOutputDirectory(directoryPath) {
+        // Graduation: a full-config run over an existing pre-PoC config parks the
+        // pre-PoC files as *_pre-poc so both versions can be merged afterwards.
+        if (this.context.mode !== "pre-poc" && this.isPrePocConfig(directoryPath)) {
+            this.cli.spacer();
+            this.cli.write(`${directoryPath} holds a pre-PoC config (splitTestId "pre_poc").\n` +
+                "On continue, its config_* files are renamed to *_pre-poc and the full " +
+                "config is scaffolded next to them. Merge the verified trackers into the " +
+                "new config_loadHandler.js afterwards, then delete the *_pre-poc files.\n");
+            const graduate = await this.cli.confirm("Rename the pre-PoC files and continue?");
+            if (graduate) {
+                this.renamePrePocFiles(directoryPath);
+                return directoryPath;
+            }
+            // declined → fall through to the regular not-empty protection
+        }
         // protect output directory if already existing and not empty:
         if (this.isDirNotEmpty(directoryPath)) {
             this.cli.spacer();
@@ -86,13 +113,22 @@ export class CustomerConfigService {
         }
         return directoryPath;
     }
-    async compileHandlebarsFiles(configSettings) {
+    async compileTemplateFiles(configSettings) {
+        const source = await resolveTemplateSource(this.context.templatesPath, this.context.mode);
+        this.cli.write(`Templates: ${source.origin}\n`);
+        // Contract check: the templates may only use variables this CLI knows.
+        const unknown = findUnknownVariables(source.manifest, TEMPLATE_VARIABLES);
+        if (unknown.length > 0) {
+            throw new Error(`The templates use variables this CLI does not know: ${unknown.join(", ")}. ` +
+                "Your sk CLI is older than the templates — update it (npm i) and retry.");
+        }
         // overwriting protection for output directory:
         this.outputDirPath = await this.selectOutputDirectory(this.outputDirPath);
         this.cli.spacer();
+        const templateFiles = source.manifest.files.filter((file) => file !== "downtimeDetection.js.njk" || this.includeDowntimeDetection);
         // write files:
-        for (const templateFile of this.templates) {
-            const outputFileName = this.getHandlebarsOutputFileName(templateFile);
+        for (const templateFile of templateFiles) {
+            const outputFileName = this.getOutputFileName(templateFile);
             this.cli.startAction(`CREATE:CUSTOMER:CONFIG:${outputFileName}`, `Adding ${outputFileName}`);
             try {
                 const outputFilePath = path.join(this.outputDirPath, outputFileName);
@@ -100,11 +136,7 @@ export class CustomerConfigService {
                     this.cli.endAction(`CREATE:CUSTOMER:CONFIG:${outputFileName}`, "skipped!");
                     continue;
                 }
-                const __dirname = path.dirname(fileURLToPath(import.meta.url));
-                const filePath = path.resolve(__dirname, "templates", templateFile);
-                const content = fs.readFileSync(filePath, "utf8");
-                const template = Handlebars.compile(content);
-                const result = template(configSettings);
+                const result = await source.render(templateFile, configSettings);
                 fs.mkdirSync(path.dirname(outputFilePath), { recursive: true });
                 fs.writeFileSync(outputFilePath, result);
                 this.cli.successAction(`CREATE:CUSTOMER:CONFIG:${outputFileName}`);
@@ -238,6 +270,22 @@ export class CustomerConfigService {
             }
             this.cli.spacer();
         }
+        // Pre-PoC: the tracking-only set uses no acceleration answers — stop asking here.
+        if (this.context.mode === "pre-poc") {
+            return {
+                appName: this.appName,
+                production,
+                staging,
+                shopSystemName: selectedShopSystem === ShopSystem.OTHER
+                    ? undefined
+                    : selectedShopSystem,
+                isShopify,
+                isShopware,
+                isSalesforce,
+                isOxid,
+                isPlentymarkets,
+            };
+        }
         const resolve = (feature, fallback) => {
             if (!siteAnalysis)
                 return { label: "", checked: fallback };
@@ -420,10 +468,8 @@ export class CustomerConfigService {
     async generateConfig() {
         this.cli.write("\nLet's generate a config...\n");
         const configSettings = await this.getConfigSettings();
-        if (configSettings.addDowntimeDetection) {
-            this.templates.push("downtimeDetection.js.hbs");
-        }
-        await this.compileHandlebarsFiles(configSettings);
+        this.includeDowntimeDetection = Boolean(configSettings.addDowntimeDetection);
+        await this.compileTemplateFiles(configSettings);
         await this.logWarnings(configSettings);
         this.cli.writeSuccess("\nConfig generation completed 👏\n");
     }

package/dist/services/customer-config/template-source.d.ts

@@ -0,0 +1,33 @@
+/** The templates/<set>/manifest.json contract in sk-onboarding. */
+export interface TemplateManifest {
+    engine: string;
+    engineOptions: Record<string, boolean>;
+    files: string[];
+    partials?: string[];
+    variables: Record<string, {
+        type: "boolean" | "string" | "string?";
+        sample?: unknown;
+    }>;
+}
+export interface TemplateSource {
+    /** Where the templates come from — shown to the user. */
+    origin: string;
+    manifest: TemplateManifest;
+    /** Renders one of manifest.files with the wizard settings ({% include %} resolves). */
+    render(file: string, settings: Record<string, unknown>): Promise<string>;
+}
+/**
+ * Resolves where the wizard templates come from, in order:
+ * 1. an explicit --templates path (the templates/ root),
+ * 2. the sk-onboarding checkout the CLI runs in (walking up from cwd).
+ *
+ * `set` picks the template set (wizard mode), e.g. "customer-config" or "pre-poc".
+ */
+export declare function resolveTemplateSource(explicitPath?: string, set?: string): Promise<TemplateSource>;
+/**
+ * The templates may only use variables this CLI knows — conditional wizard
+ * answers are legitimately absent at runtime, so the contract is checked
+ * against the CLI's variable inventory, not one run's settings object.
+ * A non-empty result means this CLI is older than the templates.
+ */
+export declare function findUnknownVariables(manifest: TemplateManifest, knownVariables: readonly string[]): string[];

package/dist/services/customer-config/template-source.js

@@ -0,0 +1,49 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import nunjucks from "nunjucks";
+const TEMPLATES_DIR = "templates";
+/**
+ * Resolves where the wizard templates come from, in order:
+ * 1. an explicit --templates path (the templates/ root),
+ * 2. the sk-onboarding checkout the CLI runs in (walking up from cwd).
+ *
+ * `set` picks the template set (wizard mode), e.g. "customer-config" or "pre-poc".
+ */
+export async function resolveTemplateSource(explicitPath, set = "customer-config") {
+    if (explicitPath)
+        return localSource(path.resolve(explicitPath), set);
+    for (let dir = process.cwd();; dir = path.dirname(dir)) {
+        const candidate = path.join(dir, TEMPLATES_DIR);
+        if (fs.existsSync(path.join(candidate, set, "manifest.json"))) {
+            return localSource(candidate, set);
+        }
+        if (dir === path.dirname(dir))
+            break;
+    }
+    throw new Error("No wizard templates found. Run inside an sk-onboarding checkout or " +
+        "pass --templates <path>.");
+}
+function buildEnvironment(loader, manifest) {
+    return new nunjucks.Environment(loader, manifest.engineOptions);
+}
+function localSource(templatesRoot, set) {
+    const setDir = path.join(templatesRoot, set);
+    const manifest = JSON.parse(fs.readFileSync(path.join(setDir, "manifest.json"), "utf8"));
+    const env = buildEnvironment(new nunjucks.FileSystemLoader(templatesRoot), manifest);
+    const origin = setDir;
+    return {
+        origin,
+        manifest,
+        render: async (file, settings) => env.renderString(fs.readFileSync(path.join(setDir, file), "utf8"), settings),
+    };
+}
+/**
+ * The templates may only use variables this CLI knows — conditional wizard
+ * answers are legitimately absent at runtime, so the contract is checked
+ * against the CLI's variable inventory, not one run's settings object.
+ * A non-empty result means this CLI is older than the templates.
+ */
+export function findUnknownVariables(manifest, knownVariables) {
+    const known = new Set(knownVariables);
+    return Object.keys(manifest.variables).filter((name) => !known.has(name));
+}

package/dist/services/integration-api/integration-api-model.js

@@ -26,7 +26,9 @@ export const DEFAULT_BLOCKED_FOLDERS = [
     ".idea",
     "page-examples",
 ];
-export const DEFAULT_BLOCKED_FILES = ["page-examples"];
+// "_pre-poc": parked pre-PoC files created by the graduation flow of
+// generate-customer-config — kept for the manual merge, never deployed.
+export const DEFAULT_BLOCKED_FILES = ["page-examples", "_pre-poc"];
 export class IntegrationApiContext {
     basePath;
     configName;

package/dist/services/setup/extension/crx.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A CRX file is a ZIP archive prefixed with a header. Because the header shifts
+ * the archive's byte offsets, a plain unzip cannot read it directly — the header
+ * has to be stripped first. This returns the byte offset at which the embedded
+ * ZIP begins. A buffer without the `Cr24` magic is assumed to already be a ZIP
+ * (offset 0).
+ */
+export declare function getZipOffset(buffer: Buffer): number;
+/**
+ * Extracts a CRX (or plain ZIP) buffer into `destDir` as an unpacked extension.
+ * The destination is cleared first so re-installs/updates replace it cleanly.
+ */
+export declare function extractCrx(crxBuffer: Buffer, destDir: string, tempFolder: string): Promise<void>;

package/dist/services/setup/extension/crx.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+import extract from "extract-zip";
+/**
+ * A CRX file is a ZIP archive prefixed with a header. Because the header shifts
+ * the archive's byte offsets, a plain unzip cannot read it directly — the header
+ * has to be stripped first. This returns the byte offset at which the embedded
+ * ZIP begins. A buffer without the `Cr24` magic is assumed to already be a ZIP
+ * (offset 0).
+ */
+export function getZipOffset(buffer) {
+    const magic = buffer.toString("utf8", 0, 4);
+    if (magic !== "Cr24") {
+        return 0;
+    }
+    const version = buffer.readUInt32LE(4);
+    // CRX2: magic(4) version(4) pubKeyLen(4) sigLen(4) pubKey sig zip
+    if (version === 2) {
+        const publicKeyLength = buffer.readUInt32LE(8);
+        const signatureLength = buffer.readUInt32LE(12);
+        return 16 + publicKeyLength + signatureLength;
+    }
+    // CRX3: magic(4) version(4) headerLen(4) header zip
+    if (version === 3) {
+        const headerLength = buffer.readUInt32LE(8);
+        return 12 + headerLength;
+    }
+    throw new Error(`Unsupported CRX version: ${version}`);
+}
+/**
+ * Extracts a CRX (or plain ZIP) buffer into `destDir` as an unpacked extension.
+ * The destination is cleared first so re-installs/updates replace it cleanly.
+ */
+export async function extractCrx(crxBuffer, destDir, tempFolder) {
+    const offset = getZipOffset(crxBuffer);
+    const zipBuffer = offset > 0 ? crxBuffer.subarray(offset) : crxBuffer;
+    const resolvedDest = path.resolve(destDir);
+    // extract-zip needs a file path, so stage the embedded zip on disk first
+    const tempZipPath = path.resolve(tempFolder, `${path.basename(resolvedDest)}.crx.zip`);
+    fs.writeFileSync(tempZipPath, zipBuffer);
+    fs.rmSync(resolvedDest, { recursive: true, force: true });
+    try {
+        await extract(tempZipPath, { dir: resolvedDest });
+    }
+    finally {
+        fs.rmSync(tempZipPath, { force: true });
+    }
+}

package/dist/services/setup/extension/crx.spec.d.ts

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

package/dist/services/setup/extension/crx.spec.js

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { getZipOffset } from "./crx.js";
+function crx3Header(headerLength) {
+    const buffer = Buffer.alloc(12);
+    buffer.write("Cr24", 0, "utf8");
+    buffer.writeUInt32LE(3, 4);
+    buffer.writeUInt32LE(headerLength, 8);
+    return buffer;
+}
+function crx2Header(publicKeyLength, signatureLength) {
+    const buffer = Buffer.alloc(16);
+    buffer.write("Cr24", 0, "utf8");
+    buffer.writeUInt32LE(2, 4);
+    buffer.writeUInt32LE(publicKeyLength, 8);
+    buffer.writeUInt32LE(signatureLength, 12);
+    return buffer;
+}
+describe("crx.getZipOffset", () => {
+    it("returns 0 for a plain zip (no Cr24 magic)", () => {
+        const zip = Buffer.from([0x50, 0x4b, 0x03, 0x04, 0, 0, 0, 0]);
+        expect(getZipOffset(zip)).to.equal(0);
+    });
+    it("computes the offset for a CRX3 file", () => {
+        // 12 fixed bytes + headerLength
+        expect(getZipOffset(crx3Header(42))).to.equal(54);
+    });
+    it("computes the offset for a CRX2 file", () => {
+        // 16 fixed bytes + pubKeyLen + sigLen
+        expect(getZipOffset(crx2Header(3, 4))).to.equal(23);
+    });
+    it("throws on an unsupported CRX version", () => {
+        const buffer = Buffer.alloc(12);
+        buffer.write("Cr24", 0, "utf8");
+        buffer.writeUInt32LE(9, 4);
+        expect(() => getZipOffset(buffer)).to.throw(/Unsupported CRX version/);
+    });
+});

package/dist/services/setup/extension/extension-installer.d.ts

@@ -0,0 +1,31 @@
+import { ManagedExtension } from "../../../helpers/cli-config.js";
+/**
+ * Derives the Chrome major version to send as `prodversion` to Google's update
+ * service. Prefers the configured puppeteer build, falling back to a recent
+ * constant (the endpoint is lenient about this value).
+ */
+export declare function resolveChromeMajorVersion(browserBuildId: string): string;
+/**
+ * Downloads, extracts and inspects Chrome Web Store extensions. Purely handles
+ * files and network; persistence/prompts live in the setup service.
+ */
+export declare class ExtensionInstaller {
+    private readonly tempFolder;
+    private readonly chromeMajorVersion;
+    constructor(tempFolder: string, chromeMajorVersion: string);
+    get extensionsDir(): string;
+    /**
+     * Installs an extension from a bare id or a Web Store URL and returns its
+     * tracked metadata. Throws on an unparseable input or a failed download.
+     */
+    install(input: string): Promise<ManagedExtension>;
+    /**
+     * Returns the latest available version for an extension, or null when the
+     * check fails or reports no update.
+     */
+    checkLatestVersion(id: string): Promise<string | null>;
+    /** Removes an unpacked extension directory from disk. */
+    removeFiles(extensionPath: string): void;
+    private download;
+    private readManifest;
+}

package/dist/services/setup/extension/extension-installer.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+import { extractCrx } from "./crx.js";
+import { buildCrxUrl, buildUpdateCheckUrl, parseExtensionId, parseUpdateCheckVersion, } from "./webstore.js";
+const EXTENSIONS_DIRNAME = "extensions";
+const FALLBACK_CHROME_MAJOR = "131";
+/**
+ * Derives the Chrome major version to send as `prodversion` to Google's update
+ * service. Prefers the configured puppeteer build, falling back to a recent
+ * constant (the endpoint is lenient about this value).
+ */
+export function resolveChromeMajorVersion(browserBuildId) {
+    const major = (browserBuildId ?? "").split(".")[0];
+    return /^\d+$/.test(major) ? major : FALLBACK_CHROME_MAJOR;
+}
+/**
+ * Downloads, extracts and inspects Chrome Web Store extensions. Purely handles
+ * files and network; persistence/prompts live in the setup service.
+ */
+export class ExtensionInstaller {
+    tempFolder;
+    chromeMajorVersion;
+    constructor(tempFolder, chromeMajorVersion) {
+        this.tempFolder = tempFolder;
+        this.chromeMajorVersion = chromeMajorVersion;
+    }
+    get extensionsDir() {
+        return path.resolve(this.tempFolder, EXTENSIONS_DIRNAME);
+    }
+    /**
+     * Installs an extension from a bare id or a Web Store URL and returns its
+     * tracked metadata. Throws on an unparseable input or a failed download.
+     */
+    async install(input) {
+        const id = parseExtensionId(input);
+        if (!id) {
+            throw new Error(`Could not parse a Chrome extension id from: "${input}"`);
+        }
+        const crxBuffer = await this.download(buildCrxUrl(id, this.chromeMajorVersion));
+        const destDir = path.resolve(this.extensionsDir, id);
+        await extractCrx(crxBuffer, destDir, this.tempFolder);
+        const manifest = this.readManifest(destDir, id);
+        return {
+            id,
+            name: manifest.name,
+            version: manifest.version,
+            path: destDir,
+        };
+    }
+    /**
+     * Returns the latest available version for an extension, or null when the
+     * check fails or reports no update.
+     */
+    async checkLatestVersion(id) {
+        const url = buildUpdateCheckUrl(id, this.chromeMajorVersion);
+        const response = await fetch(url);
+        if (!response.ok) {
+            return null;
+        }
+        const xml = await response.text();
+        return parseUpdateCheckVersion(xml);
+    }
+    /** Removes an unpacked extension directory from disk. */
+    removeFiles(extensionPath) {
+        fs.rmSync(extensionPath, { recursive: true, force: true });
+    }
+    async download(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to download extension: HTTP ${response.status}`);
+        }
+        return Buffer.from(await response.arrayBuffer());
+    }
+    readManifest(dir, id) {
+        const manifestPath = path.resolve(dir, "manifest.json");
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`No manifest.json in extracted extension: ${dir}`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const rawName = manifest.name ?? "";
+        // extension names can be i18n placeholders (__MSG_appName__); fall back to id
+        const name = /^__MSG_.*__$/.test(rawName)
+            ? `Chrome extension ${id}`
+            : rawName || `Chrome extension ${id}`;
+        return { name, version: manifest.version ?? "0.0.0" };
+    }
+}

package/dist/services/setup/extension/extension-setup-service.d.ts

@@ -0,0 +1,40 @@
+import { CliServiceInterface } from "../../cli/index.js";
+import { CliConfig, ManagedExtension, UserCliConfig } from "../../../helpers/cli-config.js";
+import { ExtensionInstaller } from "./extension-installer.js";
+export declare class ExtensionSetupService {
+    private readonly cli;
+    private readonly cliConfig;
+    private readonly userConfig;
+    private readonly installer;
+    constructor(cli: CliServiceInterface, cliConfig: CliConfig, userConfig: UserCliConfig, installer: ExtensionInstaller);
+    /**
+     * Wizard step: optionally install one or more Chrome extensions by id/URL.
+     */
+    run(): Promise<void>;
+    /** Installs (or reinstalls) an extension from input and persists it. */
+    addFromInput(input: string): Promise<ManagedExtension>;
+    list(): ManagedExtension[];
+    /** Removes an installed extension (files + config). Returns false if unknown. */
+    remove(id: string): Promise<boolean>;
+    /**
+     * Daily update check across all managed extensions; prompts before each
+     * update. Callers must ensure the session is interactive first.
+     */
+    remindIfDue(): Promise<void>;
+    /**
+     * Checks every managed extension for updates now (ignores the daily gate).
+     * Used by `sk extension update`.
+     */
+    updateAll(): Promise<void>;
+    private remindOne;
+    private current;
+    private upsert;
+    /**
+     * Persists the managed list and mirrors the unpacked dirs into
+     * chromeExtensionPaths (the list the onboarding browser actually loads),
+     * preserving any manually configured paths outside our extensions folder.
+     */
+    private persist;
+    private isCheckDue;
+    private nowIso;
+}

package/dist/services/setup/extension/extension-setup-service.js

@@ -0,0 +1,152 @@
+import { compareVersions } from "./webstore.js";
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+export class ExtensionSetupService {
+    cli;
+    cliConfig;
+    userConfig;
+    installer;
+    constructor(cli, cliConfig, userConfig, installer) {
+        this.cli = cli;
+        this.cliConfig = cliConfig;
+        this.userConfig = userConfig;
+        this.installer = installer;
+    }
+    /**
+     * Wizard step: optionally install one or more Chrome extensions by id/URL.
+     */
+    async run() {
+        const wanted = await this.cli.confirm("Do you want to install Chrome extensions into the onboarding browser?", false);
+        if (!wanted) {
+            return;
+        }
+        this.cli.writeWarning("Only add extensions you trust — they are loaded into the onboarding browser.");
+        let addMore = true;
+        while (addMore) {
+            const input = await this.cli.prompt("Paste a Chrome Web Store link or extension id (leave empty to stop)", { defaultAnswer: "" });
+            if (!input.trim()) {
+                break;
+            }
+            try {
+                const ext = await this.addFromInput(input);
+                this.cli.writeSuccess(`Installed ${ext.name} ${ext.version}`);
+            }
+            catch (error) {
+                this.cli.writeError(`Could not install extension: ${error?.message ?? error}`);
+            }
+            addMore = await this.cli.confirm("Add another extension?", false);
+        }
+    }
+    /** Installs (or reinstalls) an extension from input and persists it. */
+    async addFromInput(input) {
+        this.cli.startAction("EXT:INSTALL", "Downloading extension…");
+        try {
+            const ext = await this.installer.install(input);
+            this.persist(this.upsert(this.current(), ext));
+            this.cli.endAction("EXT:INSTALL");
+            return ext;
+        }
+        catch (error) {
+            this.cli.failAction("EXT:INSTALL");
+            throw error;
+        }
+    }
+    list() {
+        return this.current();
+    }
+    /** Removes an installed extension (files + config). Returns false if unknown. */
+    async remove(id) {
+        const list = this.current();
+        const target = list.find((ext) => ext.id === id);
+        if (!target) {
+            return false;
+        }
+        this.installer.removeFiles(target.path);
+        this.persist(list.filter((ext) => ext.id !== id));
+        return true;
+    }
+    /**
+     * Daily update check across all managed extensions; prompts before each
+     * update. Callers must ensure the session is interactive first.
+     */
+    async remindIfDue() {
+        if (this.current().length === 0 || !this.isCheckDue()) {
+            return;
+        }
+        await this.updateAll();
+    }
+    /**
+     * Checks every managed extension for updates now (ignores the daily gate).
+     * Used by `sk extension update`.
+     */
+    async updateAll() {
+        const list = this.current();
+        // stamp so the daily reminder does not immediately ask again
+        this.cliConfig.save({ lastExtensionUpdateCheck: this.nowIso() });
+        for (const ext of list) {
+            await this.remindOne(ext);
+        }
+    }
+    async remindOne(ext) {
+        let latest;
+        try {
+            latest = await this.installer.checkLatestVersion(ext.id);
+        }
+        catch {
+            return;
+        }
+        if (!latest || compareVersions(latest, ext.version) <= 0) {
+            return;
+        }
+        const update = await this.cli.confirm(`Update available for ${ext.name}: ${ext.version} → ${latest}. Install?`, true);
+        if (!update) {
+            return;
+        }
+        try {
+            const updated = await this.addFromInput(ext.id);
+            this.cli.writeSuccess(`Updated ${updated.name} to ${updated.version}`);
+        }
+        catch (error) {
+            this.cli.writeError(`Update failed: ${error?.message ?? error}`);
+        }
+    }
+    current() {
+        return this.userConfig.managedChromeExtensions ?? [];
+    }
+    upsert(list, ext) {
+        return [...list.filter((entry) => entry.id !== ext.id), ext];
+    }
+    /**
+     * Persists the managed list and mirrors the unpacked dirs into
+     * chromeExtensionPaths (the list the onboarding browser actually loads),
+     * preserving any manually configured paths outside our extensions folder.
+     */
+    persist(managed) {
+        const managedDir = this.installer.extensionsDir;
+        const managedPaths = new Set(managed.map((ext) => ext.path));
+        const manualPaths = this.userConfig.chromeExtensionPaths
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0 &&
+            !entry.startsWith(managedDir) &&
+            !managedPaths.has(entry));
+        const combined = [...manualPaths, ...managed.map((ext) => ext.path)];
+        this.cliConfig.save({
+            managedChromeExtensions: managed,
+            chromeExtensionPaths: combined.join(","),
+        });
+    }
+    isCheckDue() {
+        const last = this.userConfig.lastExtensionUpdateCheck;
+        if (!last) {
+            return true;
+        }
+        const lastMs = new Date(last).getTime();
+        if (Number.isNaN(lastMs)) {
+            return true;
+        }
+        return Date.now() - lastMs >= MS_PER_DAY;
+    }
+    nowIso() {
+        return new Date().toISOString();
+    }
+}