@flowscripter/dynamic-cli-framework 2.4.0 → 2.5.0

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,19 @@ 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");

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.4.0",
+  "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.3.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/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 });
+  }
+}

package/src/service/plugin/SpawnInterfaceAdapter.ts

@@ -45,7 +45,7 @@ export default class SpawnInterfaceAdapter implements SpawnInterface {
 
     const result = await this.#spawnService.spawn(command, {
       cwd: options.cwd,
-      stdio: "wrapped",
+      mode: "wrapped",
       onOutput,
     });
 

package/src/service/spawn/DefaultSpawnService.ts

@@ -95,10 +95,10 @@ export default class DefaultSpawnService implements SpawnService {
     }
     const printerService = this.#printerService;
     const shutdownService = this.#shutdownService;
-    const stdio = options.stdio ?? "inherit";
+    const mode = options.mode ?? "inherit";
     const longRunning = options.longRunning ?? true;
 
-    if (stdio === "inherit") {
+    if (mode === "inherit") {
       await printerService.hideSpinner();
       await printerService.hideAllProgressBars();
     }
@@ -107,9 +107,9 @@ export default class DefaultSpawnService implements SpawnService {
     try {
       proc = Bun.spawn(resolveForPlatform(command), {
         cwd: options.cwd,
-        stdin: stdio === "wrapped" ? "ignore" : "inherit",
-        stdout: stdio === "wrapped" ? "pipe" : "inherit",
-        stderr: stdio === "wrapped" ? "pipe" : "inherit",
+        stdin: mode === "inherit" ? "inherit" : "ignore",
+        stdout: mode === "wrapped" ? "pipe" : mode === "ignore" ? "ignore" : "inherit",
+        stderr: mode === "wrapped" ? "pipe" : mode === "ignore" ? "ignore" : "inherit",
       });
     } catch (error) {
       logger.debug(() => `Failed to launch command '${command.join(" ")}': ${error}`);
@@ -129,7 +129,7 @@ export default class DefaultSpawnService implements SpawnService {
       await this.#terminate(proc, command);
     });
 
-    if (stdio === "wrapped" && options.onOutput) {
+    if (mode === "wrapped" && options.onOutput) {
       const onOutput = options.onOutput;
       void this.#pipeLines(proc.stdout, "stdout", onOutput);
       void this.#pipeLines(proc.stderr, "stderr", onOutput);

package/src/service/upgrade/DefaultUpgradeService.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type {
   CLIConfig,
-  ShutdownService,
+  FetchService,
   SpawnResult,
   SpawnService,
   UpgradeCheckResult,
@@ -40,7 +40,7 @@ const OS_LABELS: Record<SupportedOs, string> = {
 
 export default class DefaultUpgradeService implements UpgradeService {
   #spawnService: SpawnService | undefined;
-  #shutdownService: ShutdownService | undefined;
+  #fetchService: FetchService | undefined;
   #upgradeCheckPromise: Promise<UpgradeCheckResult | undefined> | undefined;
   readonly #config: UpgradeLocationsConfig;
   readonly #cliConfig: CLIConfig;
@@ -50,9 +50,12 @@ export default class DefaultUpgradeService implements UpgradeService {
     this.#cliConfig = cliConfig;
   }
 
-  public setDependencies(spawnService: SpawnService, shutdownService?: ShutdownService): void {
+  public setDependencies(
+    spawnService: SpawnService | undefined,
+    fetchService: FetchService | undefined,
+  ): void {
     this.#spawnService = spawnService;
-    this.#shutdownService = shutdownService;
+    this.#fetchService = fetchService;
   }
 
   public getUpgradeCheckResult(waitForResult = false): Promise<UpgradeCheckResult | undefined> {
@@ -170,6 +173,9 @@ export default class DefaultUpgradeService implements UpgradeService {
     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) {
@@ -204,7 +210,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     }
     const result = await this.#spawnService.spawn(
       ["brew", "list", "--versions", this.#config.homebrew.formula],
-      { stdio: "wrapped", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
+      { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
     );
     return result.ok;
   }
@@ -215,7 +221,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     }
     const result = await this.#spawnService.spawn(
       ["winget", "list", "--id", this.#config.winget.packageId],
-      { stdio: "wrapped", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
+      { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
     );
     return result.ok;
   }
@@ -239,14 +245,14 @@ export default class DefaultUpgradeService implements UpgradeService {
   }
 
   async #getLatestGithubReleaseVersion(): Promise<string | undefined> {
-    if (!this.#config.githubRelease) {
+    if (!this.#config.githubRelease || !this.#fetchService) {
       return undefined;
     }
     const { owner, repo } = this.#config.githubRelease;
     try {
-      const response = await fetch(
+      const response = await this.#fetchService.fetch(
         `https://api.github.com/repos/${owner}/${repo}/releases/latest`,
-        { signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS) },
+        { timeoutMs: VERSION_CHECK_TIMEOUT_MS },
       );
       if (!response.ok) {
         return undefined;
@@ -260,7 +266,7 @@ export default class DefaultUpgradeService implements UpgradeService {
   }
 
   async #getLatestHomebrewVersion(): Promise<string | undefined> {
-    if (!this.#config.homebrew) {
+    if (!this.#config.homebrew || !this.#fetchService) {
       return undefined;
     }
     const { tap, formula } = this.#config.homebrew;
@@ -269,9 +275,9 @@ export default class DefaultUpgradeService implements UpgradeService {
       return undefined;
     }
     try {
-      const response = await fetch(
+      const response = await this.#fetchService.fetch(
         `https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`,
-        { signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS) },
+        { timeoutMs: VERSION_CHECK_TIMEOUT_MS },
       );
       if (!response.ok) {
         return undefined;
@@ -292,7 +298,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     const result = await this.#spawnService.spawn(
       ["winget", "show", "--id", this.#config.winget.packageId],
       {
-        stdio: "wrapped",
+        mode: "wrapped",
         longRunning: false,
         timeoutMs: VERSION_CHECK_TIMEOUT_MS,
         onOutput: (line) => lines.push(line),
@@ -312,7 +318,9 @@ export default class DefaultUpgradeService implements UpgradeService {
 
   async #upgradeViaLinuxScript(): Promise<void> {
     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: ${describeSpawnFailure(result)}`);
     }
@@ -320,7 +328,9 @@ export default class DefaultUpgradeService implements UpgradeService {
 
   async #upgradeViaHomebrew(): Promise<void> {
     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: ${describeSpawnFailure(result)}`);
     }
@@ -328,15 +338,18 @@ export default class DefaultUpgradeService implements UpgradeService {
 
   async #upgradeViaWinget(): Promise<void> {
     const { packageId } = this.#config.winget!;
-    const result = await this.#spawnService!.spawn([
-      "winget",
-      "upgrade",
-      "--id",
-      packageId,
-      "--silent",
-      "--accept-package-agreements",
-      "--accept-source-agreements",
-    ]);
+    const result = await this.#spawnService!.spawn(
+      [
+        "winget",
+        "upgrade",
+        "--id",
+        packageId,
+        "--silent",
+        "--accept-package-agreements",
+        "--accept-source-agreements",
+      ],
+      { mode: "ignore" },
+    );
     if (!result.ok) {
       throw new Error(`winget upgrade failed: ${describeSpawnFailure(result)}`);
     }
@@ -349,19 +362,13 @@ export default class DefaultUpgradeService implements UpgradeService {
     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 but enter long-running mode to get cooperative
-    // Ctrl-C handling during what can be the slowest step of the upgrade.
-    this.#shutdownService?.enterLongRunningMode();
-    let archiveData: ArrayBuffer;
-    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);
@@ -370,52 +377,46 @@ export default class DefaultUpgradeService implements UpgradeService {
     const currentExecutable = process.execPath;
 
     if (os === SupportedOs.WINDOWS) {
-      const extractResult = await this.#spawnService!.spawn([
-        "powershell",
-        "-Command",
-        `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpDir}' -Force`,
-      ]);
+      const extractResult = await this.#spawnService!.spawn(
+        [
+          "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/src/service/upgrade/UpgradeServiceProvider.ts

@@ -8,8 +8,8 @@ import { KEY_VALUE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { KeyValueService } from "@flowscripter/dynamic-cli-framework-api";
 import { SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { SpawnService } from "@flowscripter/dynamic-cli-framework-api";
-import { SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
-import type { ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
+import { FETCH_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import type { FetchService } from "@flowscripter/dynamic-cli-framework-api";
 import { Icon, PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
 import DefaultUpgradeService from "./DefaultUpgradeService.ts";
@@ -44,15 +44,19 @@ export default class UpgradeServiceProvider implements ServiceProvider {
     const upgradeService = this.#upgradeService!;
     const cliConfig = this.#cliConfig!;
 
-    if (context.doesServiceExist(SPAWN_SERVICE_ID)) {
-      const spawnService = context.getServiceById(SPAWN_SERVICE_ID) as SpawnService;
-      const shutdownService = context.doesServiceExist(SHUTDOWN_SERVICE_ID)
-        ? (context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService)
-        : undefined;
-      upgradeService.setDependencies(spawnService, shutdownService);
-    } else {
+    const spawnService = context.doesServiceExist(SPAWN_SERVICE_ID)
+      ? (context.getServiceById(SPAWN_SERVICE_ID) as SpawnService)
+      : undefined;
+    const fetchService = context.doesServiceExist(FETCH_SERVICE_ID)
+      ? (context.getServiceById(FETCH_SERVICE_ID) as FetchService)
+      : 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();