@flowscripter/dynamic-cli-framework 2.1.0 → 2.3.0

package/dist/src/service/upgrade/DefaultUpgradeService.js

@@ -0,0 +1,312 @@
+import process from "node:process";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { InstallMethod, SupportedArch, SupportedOs, } from "@flowscripter/dynamic-cli-framework-api";
+import semver from "semver";
+import getLogger from "../../util/logger.js";
+const logger = getLogger("DefaultUpgradeService");
+const OS_LABELS = {
+    [SupportedOs.LINUX]: "Linux",
+    [SupportedOs.MACOS]: "MacOS",
+    [SupportedOs.WINDOWS]: "Windows",
+};
+export default class DefaultUpgradeService {
+    #spawnService;
+    #config;
+    #cliConfig;
+    constructor(config, cliConfig) {
+        this.#config = config;
+        this.#cliConfig = cliConfig;
+    }
+    setDependencies(spawnService) {
+        this.#spawnService = spawnService;
+    }
+    detectOs() {
+        switch (process.platform) {
+            case "linux":
+                return SupportedOs.LINUX;
+            case "darwin":
+                return SupportedOs.MACOS;
+            case "win32":
+                return SupportedOs.WINDOWS;
+            default:
+                return undefined;
+        }
+    }
+    detectArch() {
+        switch (process.arch) {
+            case "x64":
+                return SupportedArch.X64;
+            case "arm64":
+                return SupportedArch.ARM64;
+            default:
+                return undefined;
+        }
+    }
+    async detectInstallMethod(os) {
+        if (os === SupportedOs.MACOS && this.#config.homebrew && (await this.#isHomebrewInstalled())) {
+            return InstallMethod.HOMEBREW;
+        }
+        if (os === SupportedOs.WINDOWS && this.#config.winget && (await this.#isWingetInstalled())) {
+            return InstallMethod.WINGET;
+        }
+        if (os === SupportedOs.LINUX && this.#config.linuxScript && this.#isLinuxScriptInstall()) {
+            return InstallMethod.LINUX_SCRIPT;
+        }
+        if (this.#config.githubRelease) {
+            return InstallMethod.GITHUB_RELEASE;
+        }
+        return undefined;
+    }
+    async checkForUpgrade(osOverride, archOverride, installMethodOverride) {
+        const os = osOverride ?? this.detectOs();
+        const arch = archOverride ?? this.detectArch();
+        if (!os || !arch || !this.#isPlatformSupported(os, arch)) {
+            return undefined;
+        }
+        const installMethod = installMethodOverride ?? (await this.detectInstallMethod(os));
+        if (!installMethod) {
+            return undefined;
+        }
+        const latestVersion = await this.#getLatestVersion(installMethod);
+        if (!latestVersion) {
+            return undefined;
+        }
+        const currentVersion = this.#cliConfig.version;
+        const coercedCurrent = semver.coerce(currentVersion);
+        const coercedLatest = semver.coerce(latestVersion);
+        if (!coercedCurrent || !coercedLatest) {
+            logger.debug(() => `Unable to compare versions '${currentVersion}' and '${latestVersion}'`);
+            return undefined;
+        }
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable: semver.gt(coercedLatest, coercedCurrent),
+            os,
+            arch,
+            installMethod,
+        };
+    }
+    async upgrade(osOverride, archOverride, installMethodOverride) {
+        const oldVersion = this.#cliConfig.version;
+        const checkResult = await this.checkForUpgrade(osOverride, archOverride, installMethodOverride);
+        if (!checkResult) {
+            return {
+                ok: false,
+                oldVersion,
+                error: new Error("No upgrade location configured for the detected or requested platform"),
+            };
+        }
+        if (!this.#spawnService) {
+            return { ok: false, oldVersion, error: new Error("SpawnService is not available") };
+        }
+        try {
+            switch (checkResult.installMethod) {
+                case InstallMethod.LINUX_SCRIPT:
+                    await this.#upgradeViaLinuxScript();
+                    break;
+                case InstallMethod.HOMEBREW:
+                    await this.#upgradeViaHomebrew();
+                    break;
+                case InstallMethod.WINGET:
+                    await this.#upgradeViaWinget();
+                    break;
+                case InstallMethod.GITHUB_RELEASE:
+                    await this.#upgradeViaGithubRelease(checkResult.os, checkResult.arch);
+                    break;
+            }
+            return { ok: true, oldVersion, newVersion: checkResult.latestVersion };
+        }
+        catch (error) {
+            return { ok: false, oldVersion, error: error };
+        }
+    }
+    #isPlatformSupported(os, arch) {
+        return this.#config.supportedPlatforms.some((platform) => platform.os === os && platform.arch === arch);
+    }
+    async #isHomebrewInstalled() {
+        if (!this.#spawnService || !this.#config.homebrew) {
+            return false;
+        }
+        const result = await this.#spawnService.spawn(["brew", "list", "--versions", this.#config.homebrew.formula], { stdio: "wrapped", longRunning: false });
+        return result.ok;
+    }
+    async #isWingetInstalled() {
+        if (!this.#spawnService || !this.#config.winget) {
+            return false;
+        }
+        const result = await this.#spawnService.spawn(["winget", "list", "--id", this.#config.winget.packageId], { stdio: "wrapped", longRunning: false });
+        return result.ok;
+    }
+    #isLinuxScriptInstall() {
+        return process.execPath.startsWith("/usr/local/bin/");
+    }
+    async #getLatestVersion(installMethod) {
+        switch (installMethod) {
+            case InstallMethod.GITHUB_RELEASE:
+            case InstallMethod.LINUX_SCRIPT:
+                return this.#getLatestGithubReleaseVersion();
+            case InstallMethod.HOMEBREW:
+                return this.#getLatestHomebrewVersion();
+            case InstallMethod.WINGET:
+                return this.#getLatestWingetVersion();
+            default:
+                return undefined;
+        }
+    }
+    async #getLatestGithubReleaseVersion() {
+        if (!this.#config.githubRelease) {
+            return undefined;
+        }
+        const { owner, repo } = this.#config.githubRelease;
+        try {
+            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/releases/latest`);
+            if (!response.ok) {
+                return undefined;
+            }
+            const data = (await response.json());
+            return data.tag_name?.replace(/^v/, "");
+        }
+        catch (error) {
+            logger.debug(() => `Failed to fetch latest GitHub release for ${owner}/${repo}: ${error}`);
+            return undefined;
+        }
+    }
+    async #getLatestHomebrewVersion() {
+        if (!this.#config.homebrew) {
+            return undefined;
+        }
+        const { tap, formula } = this.#config.homebrew;
+        const [tapOwner, tapName] = tap.split("/");
+        if (!tapOwner || !tapName) {
+            return undefined;
+        }
+        try {
+            const response = await fetch(`https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`);
+            if (!response.ok) {
+                return undefined;
+            }
+            const text = await response.text();
+            return /version\s+"v?([^"]+)"/.exec(text)?.[1];
+        }
+        catch (error) {
+            logger.debug(() => `Failed to fetch homebrew formula for ${tap}/${formula}: ${error}`);
+            return undefined;
+        }
+    }
+    async #getLatestWingetVersion() {
+        if (!this.#spawnService || !this.#config.winget) {
+            return undefined;
+        }
+        const lines = [];
+        const result = await this.#spawnService.spawn(["winget", "show", "--id", this.#config.winget.packageId], {
+            stdio: "wrapped",
+            longRunning: false,
+            onOutput: (line) => lines.push(line),
+        });
+        if (!result.ok) {
+            return undefined;
+        }
+        for (const line of lines) {
+            const match = /Version:\s*(\S+)/.exec(line);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+        return undefined;
+    }
+    async #upgradeViaLinuxScript() {
+        const { scriptUrl } = this.#config.linuxScript;
+        const result = await this.#spawnService.spawn(["sh", "-c", `curl -fsSL ${scriptUrl} | sh`]);
+        if (!result.ok) {
+            throw new Error(`Install script failed: ${result.error?.message ?? `exit code ${result.exitCode}`}`);
+        }
+    }
+    async #upgradeViaHomebrew() {
+        const { tap, formula } = this.#config.homebrew;
+        const result = await this.#spawnService.spawn(["brew", "upgrade", `${tap}/${formula}`]);
+        if (!result.ok) {
+            throw new Error(`brew upgrade failed: ${result.error?.message ?? `exit code ${result.exitCode}`}`);
+        }
+    }
+    async #upgradeViaWinget() {
+        const { packageId } = this.#config.winget;
+        const result = await this.#spawnService.spawn([
+            "winget",
+            "upgrade",
+            "--id",
+            packageId,
+            "--silent",
+            "--accept-package-agreements",
+            "--accept-source-agreements",
+        ]);
+        if (!result.ok) {
+            throw new Error(`winget upgrade failed: ${result.error?.message ?? `exit code ${result.exitCode}`}`);
+        }
+    }
+    async #upgradeViaGithubRelease(os, arch) {
+        const { owner, repo, assetPattern } = this.#config.githubRelease;
+        const archLabel = os === SupportedOs.MACOS ? "aarch64" : arch === SupportedArch.X64 ? "x64" : "arm64";
+        const assetName = assetPattern.replace("{os}", OS_LABELS[os]).replace("{arch}", archLabel);
+        const url = `https://github.com/${owner}/${repo}/releases/latest/download/${assetName}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to download release asset '${assetName}': HTTP ${response.status}`);
+        }
+        const tmpDir = await mkdtemp(join(tmpdir(), "upgrade-"));
+        const archivePath = join(tmpDir, assetName);
+        await Bun.write(archivePath, await response.arrayBuffer());
+        const currentExecutable = process.execPath;
+        if (os === SupportedOs.WINDOWS) {
+            const extractResult = await this.#spawnService.spawn([
+                "powershell",
+                "-Command",
+                `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpDir}' -Force`,
+            ]);
+            if (!extractResult.ok) {
+                throw new Error("Failed to extract release archive");
+            }
+            const extractedBinary = join(tmpDir, `${this.#cliConfig.name}.exe`);
+            const oldPath = `${currentExecutable}.old.exe`;
+            const moveResult = await this.#spawnService.spawn([
+                "cmd",
+                "/c",
+                "move",
+                "/y",
+                currentExecutable,
+                oldPath,
+            ]);
+            if (!moveResult.ok) {
+                throw new Error("Failed to move current executable aside");
+            }
+            const copyResult = await this.#spawnService.spawn([
+                "cmd",
+                "/c",
+                "copy",
+                "/y",
+                extractedBinary,
+                currentExecutable,
+            ]);
+            if (!copyResult.ok) {
+                throw new Error("Failed to copy new executable into place");
+            }
+        }
+        else {
+            const extractResult = await this.#spawnService.spawn([
+                "unzip",
+                "-o",
+                archivePath,
+                "-d",
+                tmpDir,
+            ]);
+            if (!extractResult.ok) {
+                throw new Error("Failed to extract release archive");
+            }
+            const extractedBinary = join(tmpDir, this.#cliConfig.name);
+            await Bun.write(currentExecutable, Bun.file(extractedBinary));
+            await this.#spawnService.spawn(["chmod", "+x", currentExecutable]);
+        }
+    }
+}

package/dist/src/service/upgrade/UpgradeLocationsConfig.d.ts

@@ -0,0 +1,51 @@
+import type { SupportedArch, SupportedOs } from "@flowscripter/dynamic-cli-framework-api";
+/**
+ * Location of a manual GitHub release asset, and how to determine the latest available version.
+ */
+export interface GithubReleaseLocation {
+    readonly owner: string;
+    readonly repo: string;
+    /**
+     * Asset filename pattern for a release, e.g. `"example-cli_{os}_{arch}.zip"`.
+     * `{os}` is substituted with `Linux`, `MacOS` or `Windows`; `{arch}` with `x64`, `arm64` or
+     * `aarch64` (macOS).
+     */
+    readonly assetPattern: string;
+}
+/**
+ * Location of a Linux install script, e.g. as documented for `curl -fsSL <scriptUrl> | sh`.
+ */
+export interface LinuxScriptLocation {
+    readonly scriptUrl: string;
+}
+/**
+ * Location of a Homebrew tap formula, e.g. `brew install <tap>/<formula>`.
+ */
+export interface HomebrewLocation {
+    readonly tap: string;
+    readonly formula: string;
+}
+/**
+ * Identifier of a Winget package, e.g. `winget install <packageId>`.
+ */
+export interface WingetLocation {
+    readonly packageId: string;
+}
+/**
+ * CLI-author supplied configuration describing which os/arch combinations a CLI supports
+ * upgrading, and where to find the latest release for each supported install method.
+ *
+ * An install method is only usable for an os/arch combination if both its config block is
+ * present here AND that combination appears in {@link supportedPlatforms}.
+ */
+export interface UpgradeLocationsConfig {
+    readonly supportedPlatforms: ReadonlyArray<{
+        os: SupportedOs;
+        arch: SupportedArch;
+    }>;
+    readonly githubRelease?: GithubReleaseLocation;
+    readonly linuxScript?: LinuxScriptLocation;
+    readonly homebrew?: HomebrewLocation;
+    readonly winget?: WingetLocation;
+}
+//# sourceMappingURL=UpgradeLocationsConfig.d.ts.map

package/dist/src/service/upgrade/UpgradeLocationsConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpgradeLocationsConfig.d.ts","sourceRoot":"","sources":["../../../../src/service/upgrade/UpgradeLocationsConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,kBAAkB,EAAE,aAAa,CAAC;QAAE,EAAE,EAAE,WAAW,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;IACrF,QAAQ,CAAC,aAAa,CAAC,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;CAClC"}

package/dist/src/service/upgrade/UpgradeServiceProvider.d.ts

@@ -0,0 +1,13 @@
+import type { ServiceInfo, ServiceProvider } from "@flowscripter/dynamic-cli-framework-api";
+import type { Context } from "@flowscripter/dynamic-cli-framework-api";
+import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
+import type { UpgradeLocationsConfig } from "./UpgradeLocationsConfig.ts";
+export default class UpgradeServiceProvider implements ServiceProvider {
+    #private;
+    readonly serviceId: string;
+    readonly servicePriority: number;
+    constructor(servicePriority: number, config: UpgradeLocationsConfig);
+    getServiceInfo(cliConfig: CLIConfig): Promise<ServiceInfo>;
+    initService(context: Context): Promise<void>;
+}
+//# sourceMappingURL=UpgradeServiceProvider.d.ts.map

package/dist/src/service/upgrade/UpgradeServiceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpgradeServiceProvider.d.ts","sourceRoot":"","sources":["../../../../src/service/upgrade/UpgradeServiceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAYzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAK1E,MAAM,CAAC,OAAO,OAAO,sBAAuB,YAAW,eAAe;;IACpE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAsB;IAChD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;gBAKd,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,sBAAsB;IAKnE,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IASpD,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CA6G1D"}

package/dist/src/service/upgrade/UpgradeServiceProvider.js

@@ -0,0 +1,120 @@
+import { UPGRADE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { PROMPTER_SERVICE_ID, PromptType } from "@flowscripter/dynamic-cli-framework-api";
+import { KEY_VALUE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { Icon, PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import DefaultUpgradeService from "./DefaultUpgradeService.js";
+import { UpgradeSubCommand } from "./command/UpgradeSubCommand.js";
+import getLogger from "../../util/logger.js";
+const logger = getLogger("UpgradeServiceProvider");
+export default class UpgradeServiceProvider {
+    serviceId = UPGRADE_SERVICE_ID;
+    servicePriority;
+    #config;
+    #upgradeService;
+    #cliConfig;
+    constructor(servicePriority, config) {
+        this.servicePriority = servicePriority;
+        this.#config = config;
+    }
+    getServiceInfo(cliConfig) {
+        this.#cliConfig = cliConfig;
+        this.#upgradeService = new DefaultUpgradeService(this.#config, cliConfig);
+        return Promise.resolve({
+            service: this.#upgradeService,
+            commands: [new UpgradeSubCommand(this.#upgradeService)],
+        });
+    }
+    async initService(context) {
+        const upgradeService = this.#upgradeService;
+        const cliConfig = this.#cliConfig;
+        if (context.doesServiceExist(SPAWN_SERVICE_ID)) {
+            const spawnService = context.getServiceById(SPAWN_SERVICE_ID);
+            upgradeService.setDependencies(spawnService);
+        }
+        else {
+            logger.debug(() => "SpawnService not available, upgrade install methods will be unavailable");
+        }
+        if (!context.doesServiceExist(PROMPTER_SERVICE_ID)) {
+            logger.debug(() => "PrompterService not available, skipping auto-upgrade");
+            return;
+        }
+        if (!context.doesServiceExist(KEY_VALUE_SERVICE_ID)) {
+            logger.debug(() => "KeyValueService not available, skipping auto-upgrade");
+            return;
+        }
+        const keyValueService = context.getServiceById(KEY_VALUE_SERVICE_ID);
+        if (await keyValueService.hasKey("upgrade-status")) {
+            const status = await keyValueService.getKey("upgrade-status");
+            if (status === "declined") {
+                logger.debug(() => "Auto-upgrade previously declined, skipping");
+                return;
+            }
+            if (status === "enabled") {
+                await this.#checkAndUpgrade(context, upgradeService, cliConfig);
+                return;
+            }
+        }
+        const prompterService = context.getServiceById(PROMPTER_SERVICE_ID);
+        if (!prompterService.promptEnabled) {
+            logger.debug(() => "Prompting is disabled, skipping auto-upgrade prompt");
+            return;
+        }
+        const os = upgradeService.detectOs();
+        const arch = upgradeService.detectArch();
+        if (!os || !arch) {
+            logger.debug(() => "Unsupported OS/arch, skipping auto-upgrade prompt");
+            return;
+        }
+        const installMethod = await upgradeService.detectInstallMethod(os);
+        if (!installMethod) {
+            logger.debug(() => "No supported install method detected, skipping auto-upgrade prompt");
+            return;
+        }
+        let enableResult;
+        try {
+            enableResult = await prompterService.prompt({
+                name: "enable-upgrade",
+                promptText: "Would you like to enable automatic upgrades on startup?",
+                description: "This will check for and install newer versions of " +
+                    `${cliConfig.name} before it runs each time.`,
+                type: PromptType.TOGGLE,
+                options: [
+                    { displayValue: "Yes", returnedValue: true },
+                    { displayValue: "No", returnedValue: false },
+                ],
+            });
+        }
+        catch {
+            return;
+        }
+        if (enableResult.value !== true) {
+            await keyValueService.setKey("upgrade-status", "declined");
+            return;
+        }
+        await keyValueService.setKey("upgrade-status", "enabled");
+        await this.#checkAndUpgrade(context, upgradeService, cliConfig);
+    }
+    async #checkAndUpgrade(context, upgradeService, cliConfig) {
+        try {
+            const checkResult = await upgradeService.checkForUpgrade();
+            if (!checkResult?.updateAvailable) {
+                return;
+            }
+            const upgradeResult = await upgradeService.upgrade();
+            if (!context.doesServiceExist(PRINTER_SERVICE_ID)) {
+                return;
+            }
+            const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+            if (upgradeResult.ok) {
+                await printerService.info(`${cliConfig.name} upgraded (${upgradeResult.oldVersion} -> ${upgradeResult.newVersion})\n`, Icon.SUCCESS);
+            }
+            else {
+                await printerService.error(`Auto-upgrade failed: ${upgradeResult.error?.message ?? "unknown error"}\n`, Icon.FAILURE);
+            }
+        }
+        catch (error) {
+            logger.debug(() => `Auto-upgrade check failed: ${error}`);
+        }
+    }
+}

package/dist/src/service/upgrade/command/UpgradeSubCommand.d.ts

@@ -0,0 +1,16 @@
+import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
+import type { Option } from "@flowscripter/dynamic-cli-framework-api";
+import type { Context } from "@flowscripter/dynamic-cli-framework-api";
+import { type ArgumentValues } from "@flowscripter/dynamic-cli-framework-api";
+import type DefaultUpgradeService from "../DefaultUpgradeService.ts";
+export declare class UpgradeSubCommand implements SubCommand {
+    #private;
+    readonly name = "upgrade";
+    readonly description = "Upgrade to the latest available version";
+    readonly enableConfiguration = false;
+    readonly positionals: never[];
+    readonly options: ReadonlyArray<Option>;
+    constructor(upgradeService: DefaultUpgradeService);
+    execute(context: Context, argumentValues: ArgumentValues): Promise<void>;
+}
+//# sourceMappingURL=UpgradeSubCommand.d.ts.map

package/dist/src/service/upgrade/command/UpgradeSubCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpgradeSubCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/upgrade/command/UpgradeSubCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,yCAAyC,CAAC;AASjD,OAAO,KAAK,qBAAqB,MAAM,6BAA6B,CAAC;AAErE,qBAAa,iBAAkB,YAAW,UAAU;;IAClD,QAAQ,CAAC,IAAI,aAAa;IAC1B,QAAQ,CAAC,WAAW,6CAA6C;IACjE,QAAQ,CAAC,mBAAmB,SAAS;IACrC,QAAQ,CAAC,WAAW,UAAM;IAE1B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAerC;gBAIiB,cAAc,EAAE,qBAAqB;IAI3C,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAsCtF"}

package/dist/src/service/upgrade/command/UpgradeSubCommand.js

@@ -0,0 +1,50 @@
+import { ArgumentValueTypeName, } from "@flowscripter/dynamic-cli-framework-api";
+import { Icon, InstallMethod, PRINTER_SERVICE_ID, SupportedArch, SupportedOs, } from "@flowscripter/dynamic-cli-framework-api";
+export class UpgradeSubCommand {
+    name = "upgrade";
+    description = "Upgrade to the latest available version";
+    enableConfiguration = false;
+    positionals = [];
+    options = [
+        {
+            name: "os",
+            type: ArgumentValueTypeName.STRING,
+            isOptional: true,
+            allowableValues: Object.values(SupportedOs),
+            description: "Override the detected operating system",
+        },
+        {
+            name: "install-method",
+            type: ArgumentValueTypeName.STRING,
+            isOptional: true,
+            allowableValues: Object.values(InstallMethod),
+            description: "Override the detected install method",
+        },
+    ];
+    #upgradeService;
+    constructor(upgradeService) {
+        this.#upgradeService = upgradeService;
+    }
+    async execute(context, argumentValues) {
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        const cliName = context.cliConfig.name;
+        const os = argumentValues.os;
+        const arch = undefined;
+        const installMethod = argumentValues["install-method"];
+        const checkResult = await this.#upgradeService.checkForUpgrade(os, arch, installMethod);
+        if (!checkResult) {
+            await printerService.error(`No upgrade location is configured for the detected or requested platform.\n`, Icon.FAILURE);
+            return;
+        }
+        if (!checkResult.updateAvailable) {
+            await printerService.print(`${cliName} is already up to date (${checkResult.currentVersion}).\n`);
+            return;
+        }
+        const upgradeResult = await this.#upgradeService.upgrade(os, arch, installMethod);
+        if (!upgradeResult.ok) {
+            await printerService.error(`Failed to upgrade ${cliName}: ${upgradeResult.error?.message ?? "unknown error"}\n`, Icon.FAILURE);
+            return;
+        }
+        await printerService.print(`${cliName} upgraded (${upgradeResult.oldVersion} -> ${upgradeResult.newVersion})\n`, Icon.SUCCESS);
+    }
+}

package/index.ts

@@ -78,6 +78,15 @@ export type { ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
 export { default as DefaultShutdownService } from "./src/service/shutdown/DefaultShutdownService.ts";
 export { default as ShutdownServiceProvider } from "./src/service/shutdown/ShutdownServiceProvider.ts";
 
+export { SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+export type {
+  SpawnOptions,
+  SpawnResult,
+  SpawnService,
+} from "@flowscripter/dynamic-cli-framework-api";
+export { default as DefaultSpawnService } from "./src/service/spawn/DefaultSpawnService.ts";
+export { default as SpawnServiceProvider } from "./src/service/spawn/SpawnServiceProvider.ts";
+
 export { SYNTAX_HIGHLIGHTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 export type { SyntaxHighlighterService } from "@flowscripter/dynamic-cli-framework-api";
 export type { ColorScheme } from "@flowscripter/dynamic-cli-framework-api";
@@ -192,7 +201,7 @@ export { default as TtyKeyReader } from "./src/terminal/TtyKeyReader.ts";
 
 // Convenience functions
 export {
+  launchDynamicPluginMultiCommandCLI,
   launchMultiCommandCLI,
   launchSingleCommandCLI,
-  launchDynamicPluginMultiCommandCLI,
 } from "./src/launcher.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowscripter/dynamic-cli-framework",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "A framework for developing CLI applications which supports dynamic discovery and installation of new commands",
   "keywords": [
     "bun",
@@ -48,19 +48,21 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@flowscripter/dynamic-cli-framework-api": "^1.0.1",
-    "@flowscripter/dynamic-plugin-framework": "1.10.1",
+    "@flowscripter/dynamic-cli-framework-api": "^1.2.0",
+    "@flowscripter/dynamic-plugin-framework": "1.11.0",
     "emphasize": "^7.0.0",
     "fastest-levenshtein": "^1.0.16",
     "figlet": "^1.11.0",
     "highlight.js": "^11.11.1",
     "prettier": "^3.9.4",
+    "semver": "^7.7.3",
     "supports-color": "^10.2.2",
     "supports-terminal-graphics": "^0.1.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",
     "@types/node": "^26.1.0",
+    "@types/semver": "^7.7.1",
     "oxfmt": "0.57.0",
     "oxlint": "1.72.0"
   },