@flowscripter/dynamic-cli-framework 2.3.3 → 2.5.0

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

@@ -7,17 +7,12 @@ import semver from "semver";
 import getLogger from "../../util/logger.js";
 const logger = getLogger("DefaultUpgradeService");
 // checkForUpgrade() runs opportunistically on every CLI invocation (via BannerServiceProvider),
-// so its version-check network calls must never be allowed to stall CLI startup.
-const VERSION_CHECK_TIMEOUT_MS = 250;
-// SpawnService has no built-in cancellation, so a stalled `brew`/`winget` invocation (e.g. winget's
-// first-ever run on a machine prompting to accept Microsoft Store terms) can otherwise hang
-// checkForUpgrade() indefinitely. Racing against this bounds how long we wait for a result; the
-// underlying process is not killed, but the CLI stops blocking on it.
-async function withSpawnTimeout(spawnPromise, fallback) {
-    return Promise.race([
-        spawnPromise,
-        new Promise((resolve) => setTimeout(() => resolve(fallback), VERSION_CHECK_TIMEOUT_MS)),
-    ]);
+// so its version-check network/spawn calls must never be allowed to stall CLI startup.
+export const VERSION_CHECK_TIMEOUT_MS = 250;
+function describeSpawnFailure(result) {
+    return "timedOut" in result
+        ? "timed out"
+        : (result.error?.message ?? `exit code ${result.exitCode}`);
 }
 const OS_LABELS = {
     [SupportedOs.LINUX]: "Linux",
@@ -26,16 +21,29 @@ const OS_LABELS = {
 };
 export default class DefaultUpgradeService {
     #spawnService;
-    #shutdownService;
+    #fetchService;
+    #upgradeCheckPromise;
     #config;
     #cliConfig;
     constructor(config, cliConfig) {
         this.#config = config;
         this.#cliConfig = cliConfig;
     }
-    setDependencies(spawnService, shutdownService) {
+    setDependencies(spawnService, fetchService) {
         this.#spawnService = spawnService;
-        this.#shutdownService = shutdownService;
+        this.#fetchService = fetchService;
+    }
+    getUpgradeCheckResult(waitForResult = false) {
+        if (!this.#upgradeCheckPromise) {
+            this.#upgradeCheckPromise = this.checkForUpgrade();
+        }
+        if (waitForResult) {
+            return this.#upgradeCheckPromise;
+        }
+        return Promise.race([
+            this.#upgradeCheckPromise,
+            new Promise((resolve) => setTimeout(() => resolve(undefined), VERSION_CHECK_TIMEOUT_MS)),
+        ]);
     }
     detectOs() {
         switch (process.platform) {
@@ -106,7 +114,10 @@ export default class DefaultUpgradeService {
     }
     async upgrade(osOverride, archOverride, installMethodOverride) {
         const oldVersion = this.#cliConfig.version;
-        const checkResult = await this.checkForUpgrade(osOverride, archOverride, installMethodOverride);
+        const hasOverride = osOverride !== undefined || archOverride !== undefined || installMethodOverride !== undefined;
+        const checkResult = hasOverride
+            ? await this.checkForUpgrade(osOverride, archOverride, installMethodOverride)
+            : await this.getUpgradeCheckResult(true);
         if (!checkResult) {
             return {
                 ok: false,
@@ -117,6 +128,9 @@ export default class DefaultUpgradeService {
         if (!this.#spawnService) {
             return { ok: false, oldVersion, error: new Error("SpawnService is not available") };
         }
+        if (checkResult.installMethod === InstallMethod.GITHUB_RELEASE && !this.#fetchService) {
+            return { ok: false, oldVersion, error: new Error("FetchService is not available") };
+        }
         try {
             switch (checkResult.installMethod) {
                 case InstallMethod.LINUX_SCRIPT:
@@ -145,20 +159,14 @@ export default class DefaultUpgradeService {
         if (!this.#spawnService || !this.#config.homebrew) {
             return false;
         }
-        const result = await withSpawnTimeout(this.#spawnService.spawn(["brew", "list", "--versions", this.#config.homebrew.formula], {
-            stdio: "wrapped",
-            longRunning: false,
-        }), { ok: false });
+        const result = await this.#spawnService.spawn(["brew", "list", "--versions", this.#config.homebrew.formula], { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS });
         return result.ok;
     }
     async #isWingetInstalled() {
         if (!this.#spawnService || !this.#config.winget) {
             return false;
         }
-        const result = await withSpawnTimeout(this.#spawnService.spawn(["winget", "list", "--id", this.#config.winget.packageId], {
-            stdio: "wrapped",
-            longRunning: false,
-        }), { ok: false });
+        const result = await this.#spawnService.spawn(["winget", "list", "--id", this.#config.winget.packageId], { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS });
         return result.ok;
     }
     #isLinuxScriptInstall() {
@@ -178,12 +186,12 @@ export default class DefaultUpgradeService {
         }
     }
     async #getLatestGithubReleaseVersion() {
-        if (!this.#config.githubRelease) {
+        if (!this.#config.githubRelease || !this.#fetchService) {
             return undefined;
         }
         const { owner, repo } = this.#config.githubRelease;
         try {
-            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/releases/latest`, { signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS) });
+            const response = await this.#fetchService.fetch(`https://api.github.com/repos/${owner}/${repo}/releases/latest`, { timeoutMs: VERSION_CHECK_TIMEOUT_MS });
             if (!response.ok) {
                 return undefined;
             }
@@ -196,7 +204,7 @@ export default class DefaultUpgradeService {
         }
     }
     async #getLatestHomebrewVersion() {
-        if (!this.#config.homebrew) {
+        if (!this.#config.homebrew || !this.#fetchService) {
             return undefined;
         }
         const { tap, formula } = this.#config.homebrew;
@@ -205,7 +213,7 @@ export default class DefaultUpgradeService {
             return undefined;
         }
         try {
-            const response = await fetch(`https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`, { signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS) });
+            const response = await this.#fetchService.fetch(`https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`, { timeoutMs: VERSION_CHECK_TIMEOUT_MS });
             if (!response.ok) {
                 return undefined;
             }
@@ -222,11 +230,12 @@ export default class DefaultUpgradeService {
             return undefined;
         }
         const lines = [];
-        const result = await withSpawnTimeout(this.#spawnService.spawn(["winget", "show", "--id", this.#config.winget.packageId], {
-            stdio: "wrapped",
+        const result = await this.#spawnService.spawn(["winget", "show", "--id", this.#config.winget.packageId], {
+            mode: "wrapped",
             longRunning: false,
+            timeoutMs: VERSION_CHECK_TIMEOUT_MS,
             onOutput: (line) => lines.push(line),
-        }), { ok: false });
+        });
         if (!result.ok) {
             return undefined;
         }
@@ -240,16 +249,20 @@ export default class DefaultUpgradeService {
     }
     async #upgradeViaLinuxScript() {
         const { scriptUrl } = this.#config.linuxScript;
-        const result = await this.#spawnService.spawn(["sh", "-c", `curl -fsSL ${scriptUrl} | sh`]);
+        const result = await this.#spawnService.spawn(["sh", "-c", `curl -fsSL ${scriptUrl} | sh`], {
+            mode: "ignore",
+        });
         if (!result.ok) {
-            throw new Error(`Install script failed: ${result.error?.message ?? `exit code ${result.exitCode}`}`);
+            throw new Error(`Install script failed: ${describeSpawnFailure(result)}`);
         }
     }
     async #upgradeViaHomebrew() {
         const { tap, formula } = this.#config.homebrew;
-        const result = await this.#spawnService.spawn(["brew", "upgrade", `${tap}/${formula}`]);
+        const result = await this.#spawnService.spawn(["brew", "upgrade", `${tap}/${formula}`], {
+            mode: "ignore",
+        });
         if (!result.ok) {
-            throw new Error(`brew upgrade failed: ${result.error?.message ?? `exit code ${result.exitCode}`}`);
+            throw new Error(`brew upgrade failed: ${describeSpawnFailure(result)}`);
         }
     }
     async #upgradeViaWinget() {
@@ -262,9 +275,9 @@ export default class DefaultUpgradeService {
             "--silent",
             "--accept-package-agreements",
             "--accept-source-agreements",
-        ]);
+        ], { mode: "ignore" });
         if (!result.ok) {
-            throw new Error(`winget upgrade failed: ${result.error?.message ?? `exit code ${result.exitCode}`}`);
+            throw new Error(`winget upgrade failed: ${describeSpawnFailure(result)}`);
         }
     }
     async #upgradeViaGithubRelease(os, arch) {
@@ -272,21 +285,13 @@ export default class DefaultUpgradeService {
         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}`;
-        // Downloading the release asset happens outside SpawnService (which enters long-running mode
-        // for its own subprocesses by default), so bracket it here to get the same cooperative
-        // Ctrl-C handling during what can be the slowest step of the upgrade.
-        this.#shutdownService?.enterLongRunningMode();
-        let archiveData;
-        try {
-            const response = await fetch(url);
-            if (!response.ok) {
-                throw new Error(`Failed to download release asset '${assetName}': HTTP ${response.status}`);
-            }
-            archiveData = await response.arrayBuffer();
-        }
-        finally {
-            this.#shutdownService?.leaveLongRunningMode();
+        // longRunning: true gets cooperative Ctrl-C handling during what can be the slowest step of
+        // the upgrade.
+        const response = await this.#fetchService.fetch(url, { longRunning: true });
+        if (!response.ok) {
+            throw new Error(`Failed to download release asset '${assetName}': HTTP ${response.status}`);
         }
+        const archiveData = await response.arrayBuffer();
         const tmpDir = await mkdtemp(join(tmpdir(), "upgrade-"));
         const archivePath = join(tmpDir, assetName);
         await Bun.write(archivePath, archiveData);
@@ -296,49 +301,31 @@ export default class DefaultUpgradeService {
                 "powershell",
                 "-Command",
                 `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpDir}' -Force`,
-            ]);
+            ], { mode: "ignore" });
             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,
-            ]);
+            const moveResult = await this.#spawnService.spawn(["cmd", "/c", "move", "/y", currentExecutable, oldPath], { mode: "ignore" });
             if (!moveResult.ok) {
                 throw new Error("Failed to move current executable aside");
             }
-            const copyResult = await this.#spawnService.spawn([
-                "cmd",
-                "/c",
-                "copy",
-                "/y",
-                extractedBinary,
-                currentExecutable,
-            ]);
+            const copyResult = await this.#spawnService.spawn(["cmd", "/c", "copy", "/y", extractedBinary, currentExecutable], { mode: "ignore" });
             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,
-            ]);
+            const extractResult = await this.#spawnService.spawn(["unzip", "-o", archivePath, "-d", tmpDir], {
+                mode: "ignore",
+            });
             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]);
+            await this.#spawnService.spawn(["chmod", "+x", currentExecutable], { mode: "ignore" });
         }
     }
 }

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

@@ -1 +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;AAczE,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;CAgH1D"}
+{"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;AAczE,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;CAsH1D"}

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

@@ -2,7 +2,7 @@ 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 { SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { FETCH_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";
@@ -29,16 +29,20 @@ export default class UpgradeServiceProvider {
     async initService(context) {
         const upgradeService = this.#upgradeService;
         const cliConfig = this.#cliConfig;
-        if (context.doesServiceExist(SPAWN_SERVICE_ID)) {
-            const spawnService = context.getServiceById(SPAWN_SERVICE_ID);
-            const shutdownService = context.doesServiceExist(SHUTDOWN_SERVICE_ID)
-                ? context.getServiceById(SHUTDOWN_SERVICE_ID)
-                : undefined;
-            upgradeService.setDependencies(spawnService, shutdownService);
-        }
-        else {
+        const spawnService = context.doesServiceExist(SPAWN_SERVICE_ID)
+            ? context.getServiceById(SPAWN_SERVICE_ID)
+            : undefined;
+        const fetchService = context.doesServiceExist(FETCH_SERVICE_ID)
+            ? context.getServiceById(FETCH_SERVICE_ID)
+            : undefined;
+        if (spawnService === undefined) {
             logger.debug(() => "SpawnService not available, upgrade install methods will be unavailable");
         }
+        if (fetchService === undefined) {
+            logger.debug(() => "FetchService not available, upgrade version checks will be unavailable");
+        }
+        upgradeService.setDependencies(spawnService, fetchService);
+        void upgradeService.getUpgradeCheckResult();
         if (!context.doesServiceExist(PROMPTER_SERVICE_ID)) {
             logger.debug(() => "PrompterService not available, skipping auto-upgrade");
             return;
@@ -101,7 +105,7 @@ export default class UpgradeServiceProvider {
     }
     async #checkAndUpgrade(context, upgradeService, cliConfig) {
         try {
-            const checkResult = await upgradeService.checkForUpgrade();
+            const checkResult = await upgradeService.getUpgradeCheckResult();
             if (!checkResult?.updateAvailable) {
                 return;
             }

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

@@ -1 +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"}
+{"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;CAyCtF"}

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

@@ -31,7 +31,9 @@ export class UpgradeSubCommand {
         const os = argumentValues.os;
         const arch = undefined;
         const installMethod = argumentValues["install-method"];
-        const checkResult = await this.#upgradeService.checkForUpgrade(os, arch, installMethod);
+        const checkResult = os === undefined && installMethod === undefined
+            ? await this.#upgradeService.getUpgradeCheckResult(true)
+            : 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;

package/index.ts

@@ -78,6 +78,11 @@ 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 { FETCH_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+export type { FetchOptions, FetchService } from "@flowscripter/dynamic-cli-framework-api";
+export { default as DefaultFetchService } from "./src/service/fetch/DefaultFetchService.ts";
+export { default as FetchServiceProvider } from "./src/service/fetch/FetchServiceProvider.ts";
+
 export { SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 export type {
   SpawnOptions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowscripter/dynamic-cli-framework",
-  "version": "2.3.3",
+  "version": "2.5.0",
   "description": "A framework for developing CLI applications which supports dynamic discovery and installation of new commands",
   "keywords": [
     "bun",
@@ -48,8 +48,8 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@flowscripter/dynamic-cli-framework-api": "^1.2.0",
-    "@flowscripter/dynamic-plugin-framework": "1.11.1",
+    "@flowscripter/dynamic-cli-framework-api": "^1.4.0",
+    "@flowscripter/dynamic-plugin-framework": "1.12.0",
     "emphasize": "^7.0.0",
     "fastest-levenshtein": "^1.0.16",
     "figlet": "^1.11.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 FetchServiceProvider from "../service/fetch/FetchServiceProvider.ts";
 import UpgradeServiceProvider from "../service/upgrade/UpgradeServiceProvider.ts";
 const logger = getLogger("BaseCLI");
 
@@ -72,6 +73,7 @@ const logger = getLogger("BaseCLI");
  *
  * * {@link ImagePrinterServiceProvider}
  * * {@link SpawnServiceProvider}
+ * * {@link FetchServiceProvider}
  * * {@link CompletionServiceProvider}
  * * {@link UpgradeServiceProvider}
  *
@@ -136,6 +138,7 @@ export default class BaseCLI implements CLI {
       completionServiceEnabled: false,
       imagePrinterServiceEnabled: false,
       spawnServiceEnabled: false,
+      fetchServiceEnabled: false,
       upgradeServiceEnabled: false,
       upgradeLocationsConfig: { supportedPlatforms: [] },
       validateAllCommands: false,
@@ -274,6 +277,10 @@ export default class BaseCLI implements CLI {
       this.addServiceProvider(new SpawnServiceProvider(58));
     }
 
+    if (this.#options.fetchServiceEnabled) {
+      this.addServiceProvider(new FetchServiceProvider(57));
+    }
+
     if (this.#options.completionServiceEnabled) {
       const completionService = new DefaultCompletionService();
       this.addServiceProvider(

package/src/cli/BaseCLIFeatureOptions.ts

@@ -9,6 +9,7 @@ export default interface BaseCLIFeatureOptions {
   readonly completionServiceEnabled?: boolean;
   readonly imagePrinterServiceEnabled?: boolean;
   readonly spawnServiceEnabled?: boolean;
+  readonly fetchServiceEnabled?: boolean;
   readonly upgradeServiceEnabled?: boolean;
   readonly upgradeLocationsConfig?: UpgradeLocationsConfig;
   readonly validateAllCommands?: boolean;

package/src/command/VersionCommand.ts

@@ -19,7 +19,7 @@ export default class VersionCommand implements GlobalCommand {
     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);
+      const result = await upgradeService.getUpgradeCheckResult().catch(() => undefined);
       if (result?.updateAvailable) {
         line += ` (${result.latestVersion} available, run '${context.cliConfig.name} upgrade')`;
       }

package/src/service/banner/BannerServiceProvider.ts

@@ -72,7 +72,7 @@ export default class BannerServiceProvider implements ServiceProvider {
     }
     if (context.doesServiceExist(UPGRADE_SERVICE_ID)) {
       const upgradeService = context.getServiceById(UPGRADE_SERVICE_ID) as UpgradeService;
-      const result = await upgradeService.checkForUpgrade().catch(() => undefined);
+      const result = await upgradeService.getUpgradeCheckResult().catch(() => undefined);
       if (result?.updateAvailable) {
         await printerService.info(
           `  ${printerService.secondary(

package/src/service/fetch/DefaultFetchService.ts

@@ -0,0 +1,55 @@
+import type {
+  FetchOptions,
+  FetchService,
+  ShutdownService,
+} from "@flowscripter/dynamic-cli-framework-api";
+import getLogger from "../../util/logger.ts";
+
+const logger = getLogger("DefaultFetchService");
+
+export default class DefaultFetchService implements FetchService {
+  #shutdownService: ShutdownService | undefined;
+
+  public setDependencies(shutdownService: ShutdownService): void {
+    this.#shutdownService = shutdownService;
+  }
+
+  public async fetch(input: string | URL, options: FetchOptions = {}): Promise<Response> {
+    if (this.#shutdownService === undefined) {
+      throw new Error("DefaultFetchService.fetch() called before setDependencies()");
+    }
+    const shutdownService = this.#shutdownService;
+    const { timeoutMs, longRunning = false, signal: callerSignal, ...requestInit } = options;
+
+    const controller = new AbortController();
+    const signals: AbortSignal[] = [controller.signal];
+    if (callerSignal) {
+      signals.push(callerSignal);
+    }
+    if (timeoutMs !== undefined) {
+      signals.push(AbortSignal.timeout(timeoutMs));
+    }
+    const signal = signals.length === 1 ? signals[0]! : AbortSignal.any(signals);
+
+    let settled = false;
+    if (longRunning) {
+      shutdownService.enterLongRunningMode();
+      shutdownService.addShutdownListener(async () => {
+        if (settled) {
+          return;
+        }
+        logger.debug(() => `Aborting fetch of '${input.toString()}' due to shutdown`);
+        controller.abort();
+      });
+    }
+
+    try {
+      return await fetch(input, { ...requestInit, signal });
+    } finally {
+      settled = true;
+      if (longRunning) {
+        shutdownService.leaveLongRunningMode();
+      }
+    }
+  }
+}

package/src/service/fetch/FetchServiceProvider.ts

@@ -0,0 +1,33 @@
+import type {
+  CLIConfig,
+  Context,
+  ServiceInfo,
+  ServiceProvider,
+  ShutdownService,
+} from "@flowscripter/dynamic-cli-framework-api";
+import { FETCH_SERVICE_ID, SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import DefaultFetchService from "./DefaultFetchService.ts";
+
+export default class FetchServiceProvider implements ServiceProvider {
+  readonly serviceId: string = FETCH_SERVICE_ID;
+  readonly servicePriority: number;
+  #fetchService: DefaultFetchService | undefined;
+
+  public constructor(servicePriority: number) {
+    this.servicePriority = servicePriority;
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    this.#fetchService = new DefaultFetchService();
+    return Promise.resolve({
+      service: this.#fetchService,
+      commands: [],
+    });
+  }
+
+  public initService(context: Context): Promise<void> {
+    const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
+    this.#fetchService!.setDependencies(shutdownService);
+    return Promise.resolve();
+  }
+}

package/src/service/plugin/DefaultPluginServiceProvider.ts

@@ -3,7 +3,10 @@ import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 import type { PrinterService, SpawnService } from "@flowscripter/dynamic-cli-framework-api";
 import { PRINTER_SERVICE_ID, SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import type { FetchService } from "@flowscripter/dynamic-cli-framework-api";
+import { FETCH_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type {
+  FetchCapable,
   MarketplacePluginManager,
   SpawnCapable,
 } from "@flowscripter/dynamic-plugin-framework";
@@ -13,6 +16,9 @@ import { PluginGroupCommand } from "./command/PluginGroupCommand.ts";
 import SpawnInterfaceAdapter, {
   type SpawnInterfaceAdapterOptions,
 } from "./SpawnInterfaceAdapter.ts";
+import FetchInterfaceAdapter, {
+  type FetchInterfaceAdapterOptions,
+} from "./FetchInterfaceAdapter.ts";
 import getLogger from "../../util/logger.ts";
 
 const logger = getLogger("DefaultPluginServiceProvider");
@@ -22,16 +28,19 @@ export default class DefaultPluginServiceProvider implements ServiceProvider {
   readonly servicePriority: number;
   readonly #pluginManager: MarketplacePluginManager;
   readonly #spawnInterfaceAdapterOptions: SpawnInterfaceAdapterOptions;
+  readonly #fetchInterfaceAdapterOptions: FetchInterfaceAdapterOptions;
   #pluginService: DefaultPluginService | undefined;
 
   constructor(
     pluginManager: MarketplacePluginManager,
     servicePriority = 50,
     spawnInterfaceAdapterOptions: SpawnInterfaceAdapterOptions = {},
+    fetchInterfaceAdapterOptions: FetchInterfaceAdapterOptions = {},
   ) {
     this.#pluginManager = pluginManager;
     this.servicePriority = servicePriority;
     this.#spawnInterfaceAdapterOptions = spawnInterfaceAdapterOptions;
+    this.#fetchInterfaceAdapterOptions = fetchInterfaceAdapterOptions;
   }
 
   async getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
@@ -45,21 +54,29 @@ export default class DefaultPluginServiceProvider implements ServiceProvider {
   initService(context: Context): Promise<void> {
     if (!context.doesServiceExist(SPAWN_SERVICE_ID)) {
       logger.debug("SpawnService not available, plugin manager will spawn processes directly");
-      return Promise.resolve();
-    }
-    if (!("setSpawn" in this.#pluginManager)) {
+    } else if (!("setSpawn" in this.#pluginManager)) {
       logger.debug("Plugin manager does not support SpawnCapable, skipping spawn injection");
-      return Promise.resolve();
+    } else {
+      const spawnService = context.getServiceById(SPAWN_SERVICE_ID) as SpawnService;
+      const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
+      const adapter = new SpawnInterfaceAdapter(
+        spawnService,
+        printerService,
+        this.#spawnInterfaceAdapterOptions,
+      );
+      (this.#pluginManager as unknown as SpawnCapable).setSpawn(adapter);
+    }
+
+    if (!context.doesServiceExist(FETCH_SERVICE_ID)) {
+      logger.debug("FetchService not available, plugin manager will fetch directly");
+    } else if (!("setFetch" in this.#pluginManager)) {
+      logger.debug("Plugin manager does not support FetchCapable, skipping fetch injection");
+    } else {
+      const fetchService = context.getServiceById(FETCH_SERVICE_ID) as FetchService;
+      const adapter = new FetchInterfaceAdapter(fetchService, this.#fetchInterfaceAdapterOptions);
+      (this.#pluginManager as unknown as FetchCapable).setFetch(adapter);
     }
 
-    const spawnService = context.getServiceById(SPAWN_SERVICE_ID) as SpawnService;
-    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
-    const adapter = new SpawnInterfaceAdapter(
-      spawnService,
-      printerService,
-      this.#spawnInterfaceAdapterOptions,
-    );
-    (this.#pluginManager as unknown as SpawnCapable).setSpawn(adapter);
     return Promise.resolve();
   }
 }

package/src/service/plugin/FetchInterfaceAdapter.ts

@@ -0,0 +1,28 @@
+import type { FetchService } from "@flowscripter/dynamic-cli-framework-api";
+import type { FetchInterface } from "@flowscripter/dynamic-plugin-framework";
+
+export interface FetchInterfaceAdapterOptions {
+  timeoutMs?: number;
+}
+
+/**
+ * Adapts a {@link FetchService} to dynamic-plugin-framework's {@link FetchInterface}, so plugin
+ * manager/repository fetches respect the host CLI's shutdown handling and default timeout.
+ */
+export default class FetchInterfaceAdapter implements FetchInterface {
+  readonly #fetchService: FetchService;
+  readonly #timeoutMs: number | undefined;
+
+  public constructor(fetchService: FetchService, options: FetchInterfaceAdapterOptions = {}) {
+    this.#fetchService = fetchService;
+    this.#timeoutMs = options.timeoutMs;
+  }
+
+  public async fetch(
+    input: string,
+    init?: RequestInit & { timeoutMs?: number },
+  ): Promise<Response> {
+    const { timeoutMs = this.#timeoutMs, ...requestInit } = init ?? {};
+    return this.#fetchService.fetch(input, { ...requestInit, timeoutMs });
+  }
+}