@flowscripter/dynamic-cli-framework 2.3.3 → 2.5.0

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,
     });
 
@@ -55,8 +55,11 @@ export default class SpawnInterfaceAdapter implements SpawnInterface {
     this.#printerService.endMark();
     await this.#printerService.clearMarked(this.#markMinimumDisplayTimeMs);
 
-    return result.ok
-      ? { ok: true, exitCode: result.exitCode }
+    if (result.ok) {
+      return { ok: true, exitCode: result.exitCode };
+    }
+    return "timedOut" in result
+      ? { ok: false, error: new Error("Command timed out") }
       : { ok: false, exitCode: result.exitCode, error: result.error };
   }
 }

package/src/service/spawn/DefaultSpawnService.ts

@@ -41,6 +41,22 @@ export default class DefaultSpawnService implements SpawnService {
     this.#shutdownService = shutdownService;
   }
 
+  async #terminate(
+    proc: ReturnType<typeof Bun.spawn>,
+    command: ReadonlyArray<string>,
+  ): Promise<void> {
+    logger.debug(() => `Sending SIGTERM to spawned command '${command.join(" ")}'`);
+    proc.kill("SIGTERM");
+    const exitedInTime = await Promise.race([
+      proc.exited.then(() => true),
+      new Promise<boolean>((resolve) => setTimeout(() => resolve(false), SHUTDOWN_GRACE_PERIOD_MS)),
+    ]);
+    if (!exitedInTime) {
+      logger.debug(() => `Sending SIGKILL to spawned command '${command.join(" ")}'`);
+      proc.kill("SIGKILL");
+    }
+  }
+
   async #pipeLines(
     stream: ReadableStream<Uint8Array> | number | undefined,
     streamName: "stdout" | "stderr",
@@ -79,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();
     }
@@ -91,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}`);
@@ -110,25 +126,38 @@ export default class DefaultSpawnService implements SpawnService {
       if (settled) {
         return;
       }
-      logger.debug(() => `Sending SIGTERM to spawned command '${command.join(" ")}'`);
-      proc.kill("SIGTERM");
-      await Promise.race([
-        proc.exited.then(() => {}),
-        new Promise<void>((resolve) => setTimeout(resolve, SHUTDOWN_GRACE_PERIOD_MS)),
-      ]);
-      if (!settled) {
-        logger.debug(() => `Sending SIGKILL to spawned command '${command.join(" ")}'`);
-        proc.kill("SIGKILL");
-      }
+      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);
     }
 
     try {
+      if (options.timeoutMs === undefined) {
+        const exitCode = await proc.exited;
+        settled = true;
+        return exitCode === 0 ? { ok: true, exitCode } : { ok: false, exitCode };
+      }
+
+      let timeoutHandle: ReturnType<typeof setTimeout>;
+      const timedOut = await Promise.race([
+        proc.exited.then(() => false),
+        new Promise<boolean>((resolve) => {
+          timeoutHandle = setTimeout(() => resolve(true), options.timeoutMs);
+        }),
+      ]);
+      clearTimeout(timeoutHandle!);
+
+      if (timedOut) {
+        logger.debug(() => `Command '${command.join(" ")}' timed out after ${options.timeoutMs}ms`);
+        await this.#terminate(proc, command);
+        settled = true;
+        return { ok: false, timedOut: true };
+      }
+
       const exitCode = await proc.exited;
       settled = true;
       return exitCode === 0 ? { ok: true, exitCode } : { ok: false, exitCode };

package/src/service/upgrade/DefaultUpgradeService.ts

@@ -4,7 +4,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type {
   CLIConfig,
-  ShutdownService,
+  FetchService,
+  SpawnResult,
   SpawnService,
   UpgradeCheckResult,
   UpgradeResult,
@@ -22,18 +23,13 @@ import getLogger from "../../util/logger.ts";
 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<T>(spawnPromise: Promise<T>, fallback: T): Promise<T> {
-  return Promise.race([
-    spawnPromise,
-    new Promise<T>((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: Extract<SpawnResult, { ok: false }>): string {
+  return "timedOut" in result
+    ? "timed out"
+    : (result.error?.message ?? `exit code ${result.exitCode}`);
 }
 
 const OS_LABELS: Record<SupportedOs, string> = {
@@ -44,7 +40,8 @@ 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;
 
@@ -53,9 +50,27 @@ 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> {
+    if (!this.#upgradeCheckPromise) {
+      this.#upgradeCheckPromise = this.checkForUpgrade();
+    }
+    if (waitForResult) {
+      return this.#upgradeCheckPromise;
+    }
+    return Promise.race([
+      this.#upgradeCheckPromise,
+      new Promise<undefined>((resolve) =>
+        setTimeout(() => resolve(undefined), VERSION_CHECK_TIMEOUT_MS),
+      ),
+    ]);
   }
 
   public detectOs(): SupportedOs | undefined {
@@ -143,7 +158,11 @@ export default class DefaultUpgradeService implements UpgradeService {
     installMethodOverride?: InstallMethod,
   ): Promise<UpgradeResult> {
     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,
@@ -154,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) {
@@ -186,12 +208,9 @@ export default class DefaultUpgradeService implements UpgradeService {
     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 } as const,
+    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;
   }
@@ -200,12 +219,9 @@ export default class DefaultUpgradeService implements UpgradeService {
     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 } as const,
+    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;
   }
@@ -229,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;
@@ -250,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;
@@ -259,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;
@@ -279,13 +295,14 @@ export default class DefaultUpgradeService implements UpgradeService {
       return undefined;
     }
     const lines: string[] = [];
-    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 } as const,
+      },
     );
     if (!result.ok) {
       return undefined;
@@ -301,39 +318,40 @@ 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: ${result.error?.message ?? `exit code ${result.exitCode}`}`,
-      );
+      throw new Error(`Install script failed: ${describeSpawnFailure(result)}`);
     }
   }
 
   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: ${result.error?.message ?? `exit code ${result.exitCode}`}`,
-      );
+      throw new Error(`brew upgrade failed: ${describeSpawnFailure(result)}`);
     }
   }
 
   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: ${result.error?.message ?? `exit code ${result.exitCode}`}`,
-      );
+      throw new Error(`winget upgrade failed: ${describeSpawnFailure(result)}`);
     }
   }
 
@@ -344,20 +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 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: 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);
@@ -366,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,21 @@ 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();
 
     if (!context.doesServiceExist(PROMPTER_SERVICE_ID)) {
       logger.debug(() => "PrompterService not available, skipping auto-upgrade");
@@ -128,7 +134,7 @@ export default class UpgradeServiceProvider implements ServiceProvider {
     cliConfig: CLIConfig,
   ): Promise<void> {
     try {
-      const checkResult = await upgradeService.checkForUpgrade();
+      const checkResult = await upgradeService.getUpgradeCheckResult();
       if (!checkResult?.updateAvailable) {
         return;
       }

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

@@ -52,7 +52,10 @@ export class UpgradeSubCommand implements SubCommand {
     const arch = undefined as SupportedArch | undefined;
     const installMethod = argumentValues["install-method"] as InstallMethod | undefined;
 
-    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`,