@flowscripter/dynamic-cli-framework 2.2.0 → 2.3.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowscripter/dynamic-cli-framework",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "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.1.1",
-    "@flowscripter/dynamic-plugin-framework": "1.11.0",
+    "@flowscripter/dynamic-cli-framework-api": "^1.2.0",
+    "@flowscripter/dynamic-plugin-framework": "1.11.1",
     "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"
   },

package/src/cli/BaseCLI.ts

@@ -52,6 +52,7 @@ import DefaultCompletionService from "../service/completion/DefaultCompletionSer
 import CompletionServiceProvider from "../service/completion/CompletionServiceProvider.ts";
 import ImagePrinterServiceProvider from "../service/imagePrinter/ImagePrinterServiceProvider.ts";
 import SpawnServiceProvider from "../service/spawn/SpawnServiceProvider.ts";
+import UpgradeServiceProvider from "../service/upgrade/UpgradeServiceProvider.ts";
 const logger = getLogger("BaseCLI");
 
 /**
@@ -71,6 +72,8 @@ const logger = getLogger("BaseCLI");
  *
  * * {@link ImagePrinterServiceProvider}
  * * {@link SpawnServiceProvider}
+ * * {@link CompletionServiceProvider}
+ * * {@link UpgradeServiceProvider}
  *
  * `keyReader` is optional. If omitted, or if the stderr {@link Terminal} is not a TTY, prompting is
  * unavailable: {@link PrompterServiceProvider} (and {@link ArgumentPrompterServiceProvider}, if
@@ -133,6 +136,8 @@ export default class BaseCLI implements CLI {
       completionServiceEnabled: false,
       imagePrinterServiceEnabled: false,
       spawnServiceEnabled: false,
+      upgradeServiceEnabled: false,
+      upgradeLocationsConfig: { supportedPlatforms: [] },
       validateAllCommands: false,
       promptingEnabled: true,
       ...options,
@@ -276,6 +281,10 @@ export default class BaseCLI implements CLI {
       );
     }
 
+    if (this.#options.upgradeServiceEnabled) {
+      this.addServiceProvider(new UpgradeServiceProvider(6, this.#options.upgradeLocationsConfig));
+    }
+
     const configurationServiceProvider = new ConfigurationServiceProvider(
       90,
       this.#options.envVarsSupportEnabled,

package/src/cli/BaseCLIFeatureOptions.ts

@@ -1,3 +1,5 @@
+import type { UpgradeLocationsConfig } from "../service/upgrade/UpgradeLocationsConfig.ts";
+
 export default interface BaseCLIFeatureOptions {
   readonly configFileSupportEnabled?: boolean;
   readonly envVarsSupportEnabled?: boolean;
@@ -7,6 +9,8 @@ export default interface BaseCLIFeatureOptions {
   readonly completionServiceEnabled?: boolean;
   readonly imagePrinterServiceEnabled?: boolean;
   readonly spawnServiceEnabled?: boolean;
+  readonly upgradeServiceEnabled?: boolean;
+  readonly upgradeLocationsConfig?: UpgradeLocationsConfig;
   readonly validateAllCommands?: boolean;
   readonly promptingEnabled?: boolean;
 }

package/src/command/VersionCommand.ts

@@ -2,6 +2,8 @@ import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
 import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { UPGRADE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import type { UpgradeService } from "@flowscripter/dynamic-cli-framework-api";
 
 /**
  * Implementation of a {@link GlobalCommand} which outputs the version of the CLI.
@@ -13,6 +15,16 @@ export default class VersionCommand implements GlobalCommand {
 
   public async execute(context: Context): Promise<void> {
     const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
-    await printerService.print(`${context.cliConfig.version}\n`);
+
+    let line = context.cliConfig.version;
+    if (context.doesServiceExist(UPGRADE_SERVICE_ID)) {
+      const upgradeService = context.getServiceById(UPGRADE_SERVICE_ID) as UpgradeService;
+      const result = await upgradeService.checkForUpgrade().catch(() => undefined);
+      if (result?.updateAvailable) {
+        line += ` (${result.latestVersion} available, run '${context.cliConfig.name} upgrade')`;
+      }
+    }
+
+    await printerService.print(`${line}\n`);
   }
 }

package/src/service/banner/BannerServiceProvider.ts

@@ -7,6 +7,8 @@ import type ConfigurationServiceProvider from "../configuration/ConfigurationSer
 import type { AsciiBannerGeneratorService } from "@flowscripter/dynamic-cli-framework-api";
 import { ASCII_BANNER_GENERATOR_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
+import { UPGRADE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import type { UpgradeService } from "@flowscripter/dynamic-cli-framework-api";
 export const BANNER_SERVICE_ID = "@flowscripter/dynamic-cli-framework/banner-service";
 
 /**
@@ -68,6 +70,17 @@ export default class BannerServiceProvider implements ServiceProvider {
     if (cliConfig.version.length > 0) {
       await printerService.info(`  ${printerService.secondary("version: " + cliConfig.version)}\n`);
     }
+    if (context.doesServiceExist(UPGRADE_SERVICE_ID)) {
+      const upgradeService = context.getServiceById(UPGRADE_SERVICE_ID) as UpgradeService;
+      const result = await upgradeService.checkForUpgrade().catch(() => undefined);
+      if (result?.updateAvailable) {
+        await printerService.info(
+          `  ${printerService.secondary(
+            `(${result.latestVersion} available, run '${cliConfig.name} upgrade')`,
+          )}\n`,
+        );
+      }
+    }
     if (this.#configurationServiceProvider) {
       const configLocation = this.#configurationServiceProvider.configLocation;
       if (configLocation && configLocation.length > 0) {

package/src/service/spawn/DefaultSpawnService.ts

@@ -1,3 +1,4 @@
+import process from "node:process";
 import type {
   PrinterService,
   ShutdownService,
@@ -11,6 +12,26 @@ const logger = getLogger("DefaultSpawnService");
 
 const SHUTDOWN_GRACE_PERIOD_MS = 5000;
 
+/**
+ * On Windows, batch-file shims (e.g. `npm.cmd`, `bun.cmd`) cannot be launched directly via
+ * `CreateProcess` - they must be run through `cmd.exe /c`. Resolve the command through the shell
+ * in that case; leave it untouched on other platforms.
+ */
+export function resolveForPlatform(command: ReadonlyArray<string>): string[] {
+  if (process.platform !== "win32") {
+    return [...command];
+  }
+  const [bin, ...args] = command;
+  if (bin === undefined) {
+    return [...command];
+  }
+  const resolved = Bun.which(bin) ?? bin;
+  if (!/\.(cmd|bat)$/i.test(resolved)) {
+    return [resolved, ...args];
+  }
+  return ["cmd.exe", "/d", "/s", "/c", resolved, ...args];
+}
+
 export default class DefaultSpawnService implements SpawnService {
   #printerService: PrinterService | undefined;
   #shutdownService: ShutdownService | undefined;
@@ -68,8 +89,9 @@ export default class DefaultSpawnService implements SpawnService {
 
     let proc;
     try {
-      proc = Bun.spawn([...command], {
+      proc = Bun.spawn(resolveForPlatform(command), {
         cwd: options.cwd,
+        stdin: stdio === "wrapped" ? "ignore" : "inherit",
         stdout: stdio === "wrapped" ? "pipe" : "inherit",
         stderr: stdio === "wrapped" ? "pipe" : "inherit",
       });