@flowscripter/dynamic-cli-framework 7.0.10 → 7.1.0

package/src/cli/BaseCLI.ts

@@ -57,9 +57,28 @@ import ImagePrinterServiceProvider from "../service/imagePrinter/ImagePrinterSer
 import SpawnServiceProvider from "../service/spawn/SpawnServiceProvider.ts";
 import FetchServiceProvider from "../service/fetch/FetchServiceProvider.ts";
 import UpgradeServiceProvider, {
+  createAutoUpgradeStartupTask,
   createUpgradeCheckStartupTask,
 } from "../service/upgrade/UpgradeServiceProvider.ts";
 import PluginServiceProvider from "../service/plugin/PluginServiceProvider.ts";
+import {
+  ARGUMENT_PROMPTER_SERVICE_PRIORITY,
+  AUTO_UPGRADE_STARTUP_TASK_PRIORITY,
+  COMPLETION_SERVICE_PRIORITY,
+  CONFIGURATION_SERVICE_PRIORITY,
+  FETCH_SERVICE_PRIORITY,
+  IMAGE_PRINTER_SERVICE_PRIORITY,
+  KEY_VALUE_SERVICE_PRIORITY,
+  PLUGIN_SERVICE_PRIORITY,
+  PRINTER_SERVICE_PRIORITY,
+  PROMPTER_SERVICE_PRIORITY,
+  SHUTDOWN_SERVICE_PRIORITY,
+  SPAWN_SERVICE_PRIORITY,
+  STARTUP_SERVICE_PRIORITY,
+  TABLE_GENERATOR_SERVICE_PRIORITY,
+  UPGRADE_CHECK_STARTUP_TASK_PRIORITY,
+  UPGRADE_SERVICE_PRIORITY,
+} from "../runtime/lifecycle/priorities.ts";
 const logger = getLogger("BaseCLI");
 
 /**
@@ -152,6 +171,7 @@ export default class BaseCLI implements CLI {
       fetchServiceEnabled: false,
       upgradeServiceEnabled: false,
       upgradeLocationsConfig: { supportedPlatforms: [] },
+      restartAfterAutoUpgrade: false,
       pluginServiceEnabled: false,
       pluginServiceRemoteConfig: { name: "", registryUrl: "", packageJsonNamespace: "" },
       pluginServiceLocalConfig: { nodeModulesPath: "", packageJsonNamespace: "" },
@@ -177,9 +197,7 @@ export default class BaseCLI implements CLI {
     // create a context
     this.#context = new DefaultContext(this.#cliConfig);
 
-    // priority 95 sits between shutdown (100) and configuration (90) - it has no ordering
-    // dependency on anything since its own initService() is a no-op.
-    this.#startupServiceProvider = new StartupServiceProvider(95);
+    this.#startupServiceProvider = new StartupServiceProvider(STARTUP_SERVICE_PRIORITY);
 
     this.#stdoutTerminal = stdoutTerminal;
     this.#printerService = new DefaultPrinterService(
@@ -251,10 +269,12 @@ export default class BaseCLI implements CLI {
     }
 
     // create and add core services
-    this.addServiceProvider(new ShutdownServiceProvider(100));
+    this.addServiceProvider(new ShutdownServiceProvider(SHUTDOWN_SERVICE_PRIORITY));
     this.addServiceProvider(this.#startupServiceProvider);
-    this.addServiceProvider(new PrinterServiceProvider(80, this.#printerService));
-    this.addServiceProvider(new TableGeneratorServiceProvider(70));
+    this.addServiceProvider(
+      new PrinterServiceProvider(PRINTER_SERVICE_PRIORITY, this.#printerService),
+    );
+    this.addServiceProvider(new TableGeneratorServiceProvider(TABLE_GENERATOR_SERVICE_PRIORITY));
 
     const canPrompt = this.#keyReader !== undefined && this.#stderrTerminal.isTty();
 
@@ -271,7 +291,9 @@ export default class BaseCLI implements CLI {
         this.#printerService,
       );
       prompterService.promptEnabled = this.#options.promptingEnabled;
-      this.addServiceProvider(new PrompterServiceProvider(75, prompterService));
+      this.addServiceProvider(
+        new PrompterServiceProvider(PROMPTER_SERVICE_PRIORITY, prompterService),
+      );
     } else {
       logger.debug(
         () =>
@@ -284,7 +306,12 @@ export default class BaseCLI implements CLI {
     if (this.#options.argumentPrompterServiceEnabled) {
       if (prompterService !== undefined) {
         const argumentPrompterService = new DefaultArgumentPrompterService(prompterService);
-        this.addServiceProvider(new ArgumentPrompterServiceProvider(65, argumentPrompterService));
+        this.addServiceProvider(
+          new ArgumentPrompterServiceProvider(
+            ARGUMENT_PROMPTER_SERVICE_PRIORITY,
+            argumentPrompterService,
+          ),
+        );
       } else {
         logger.debug(
           "Skipping ArgumentPrompterServiceProvider: argumentPrompterServiceEnabled is true but prompting is unavailable",
@@ -294,7 +321,9 @@ export default class BaseCLI implements CLI {
 
     if (this.#options.imagePrinterServiceEnabled) {
       if (this.#stdoutTerminal.isTty()) {
-        this.addServiceProvider(new ImagePrinterServiceProvider(55, this.#stdoutTerminal));
+        this.addServiceProvider(
+          new ImagePrinterServiceProvider(IMAGE_PRINTER_SERVICE_PRIORITY, this.#stdoutTerminal),
+        );
       } else {
         logger.debug(
           "Skipping ImagePrinterServiceProvider: imagePrinterServiceEnabled is true but stdout is not a TTY",
@@ -305,32 +334,39 @@ export default class BaseCLI implements CLI {
     // The plugin service routes package manager output through SpawnService so that it is
     // quoted, marked and cleared on success; enabling plugins therefore also enables spawning.
     if (this.#options.spawnServiceEnabled || this.#options.pluginServiceEnabled) {
-      this.addServiceProvider(new SpawnServiceProvider(58));
+      this.addServiceProvider(new SpawnServiceProvider(SPAWN_SERVICE_PRIORITY));
     }
 
     if (this.#options.fetchServiceEnabled) {
-      this.addServiceProvider(new FetchServiceProvider(57));
+      this.addServiceProvider(new FetchServiceProvider(FETCH_SERVICE_PRIORITY));
     }
 
     if (this.#options.completionServiceEnabled) {
       const completionService = new DefaultCompletionService();
       this.addServiceProvider(
-        new CompletionServiceProvider(5, completionService, this.#commandRegistry),
+        new CompletionServiceProvider(
+          COMPLETION_SERVICE_PRIORITY,
+          completionService,
+          this.#commandRegistry,
+        ),
       );
     }
 
     let upgradeServiceProvider: UpgradeServiceProvider | undefined;
     if (this.#options.upgradeServiceEnabled) {
-      // 56 runs after Spawn(58)/Fetch(57) - whose dependencies it needs
-      // but before the consumer-configured Banner/Plugin(50) priority band.
-      upgradeServiceProvider = new UpgradeServiceProvider(56, this.#options.upgradeLocationsConfig);
+      upgradeServiceProvider = new UpgradeServiceProvider(
+        UPGRADE_SERVICE_PRIORITY,
+        this.#options.upgradeLocationsConfig,
+        this.#options.restartAfterAutoUpgrade,
+      );
+      upgradeServiceProvider.setRestartArgs(args);
       this.addServiceProvider(upgradeServiceProvider);
     }
 
     if (this.#options.pluginServiceEnabled) {
       this.addServiceProvider(
         new PluginServiceProvider(
-          50,
+          PLUGIN_SERVICE_PRIORITY,
           this.#options.pluginServiceRemoteConfig,
           this.#options.pluginServiceLocalConfig,
           this.#commandRegistry,
@@ -340,16 +376,14 @@ export default class BaseCLI implements CLI {
     }
 
     const configurationServiceProvider = new ConfigurationServiceProvider(
-      90,
+      CONFIGURATION_SERVICE_PRIORITY,
       this.#options.envVarsSupportEnabled,
       this.#options.configFileSupportEnabled,
       this.#options.secretServiceEnabled,
     );
     this.addServiceProvider(configurationServiceProvider);
-    // priority 89 sits just below ConfigurationServiceProvider's 90 - its config-file read
-    // happens in its own initService(), before KeyValueServiceProvider's initService() runs.
     const keyValueServiceProvider = new KeyValueServiceProvider(
-      89,
+      KEY_VALUE_SERVICE_PRIORITY,
       configurationServiceProvider,
       this.#options.keyValueServiceEnabled,
       this.#options.secretServiceEnabled,
@@ -369,7 +403,15 @@ export default class BaseCLI implements CLI {
     }
 
     if (upgradeServiceProvider?.upgradeService) {
-      this.addStartupTask(createUpgradeCheckStartupTask(upgradeServiceProvider.upgradeService, 56));
+      this.addStartupTask(
+        createUpgradeCheckStartupTask(
+          upgradeServiceProvider.upgradeService,
+          UPGRADE_CHECK_STARTUP_TASK_PRIORITY,
+        ),
+      );
+      this.addStartupTask(
+        createAutoUpgradeStartupTask(upgradeServiceProvider, AUTO_UPGRADE_STARTUP_TASK_PRIORITY),
+      );
     }
 
     // directly-registered StartupTasks (e.g. the banner task) aren't backed by a ServiceProvider,
@@ -435,6 +477,10 @@ export default class BaseCLI implements CLI {
         defaultCommand,
         this.#startupServiceProvider.startupService,
       );
+      // a startup task ended the run, having already handled its outcome itself
+      if (runResult.exitRequested) {
+        return { runState: runResult.runState };
+      }
       // then handle the result...
       if (runResult.runState === RunState.NO_COMMAND) {
         // print usage

package/src/cli/BaseCLIFeatureOptions.ts

@@ -16,6 +16,11 @@ export default interface BaseCLIFeatureOptions {
   readonly fetchServiceEnabled?: boolean;
   readonly upgradeServiceEnabled?: boolean;
   readonly upgradeLocationsConfig?: UpgradeLocationsConfig;
+  /**
+   * When an automatic upgrade on startup succeeds, run the upgraded executable with the same
+   * arguments and end this run with its result, rather than continuing on the old version.
+   */
+  readonly restartAfterAutoUpgrade?: boolean;
   readonly pluginServiceEnabled?: boolean;
   readonly pluginServiceRemoteConfig?: NpmjsPluginRepositoryConfig;
   readonly pluginServiceLocalConfig?: NpmPluginRepositoryConfig;

package/src/cli/DefaultRuntimeCLI.ts

@@ -72,7 +72,7 @@ export default class DefaultRuntimeCLI extends BaseCLI {
       stderrTerminal,
       new TtyStyler(colorLevel, supportsHyperlinks(process.stderr)),
       keyReader,
-      { promptingEnabled, ...options },
+      { promptingEnabled, restartAfterAutoUpgrade: true, ...options },
     );
   }
 

package/src/runtime/lifecycle/priorities.ts

@@ -0,0 +1,67 @@
+/**
+ * Priorities of the framework's built-in service providers, startup tasks and shutdown tasks.
+ * Higher values run earlier (see {@link sortByPriority}). Service provider priorities also order
+ * their `initService()` calls within the startup sequence: when a provider and a directly
+ * registered startup task share a priority, the provider runs first.
+ *
+ * Consumer service providers and startup tasks (e.g. the banner task) choose their own
+ * priorities relative to these.
+ */
+
+/** Shutdown service provider: first, so signal handling is in place before anything else. */
+export const SHUTDOWN_SERVICE_PRIORITY = 100;
+
+/** Startup service provider: no ordering dependency, as its `initService()` is a no-op. */
+export const STARTUP_SERVICE_PRIORITY = 95;
+
+/** Configuration service provider: reads the config file in its `initService()`. */
+export const CONFIGURATION_SERVICE_PRIORITY = 90;
+
+/** Key-value service provider: just below configuration, whose config-file read it depends on. */
+export const KEY_VALUE_SERVICE_PRIORITY = 89;
+
+/** Printer service provider. */
+export const PRINTER_SERVICE_PRIORITY = 80;
+
+/** Prompter service provider. */
+export const PROMPTER_SERVICE_PRIORITY = 75;
+
+/** Table generator service provider. */
+export const TABLE_GENERATOR_SERVICE_PRIORITY = 70;
+
+/** Argument prompter service provider: below the prompter it uses. */
+export const ARGUMENT_PROMPTER_SERVICE_PRIORITY = 65;
+
+/** Spawn service provider. */
+export const SPAWN_SERVICE_PRIORITY = 58;
+
+/** Fetch service provider. */
+export const FETCH_SERVICE_PRIORITY = 57;
+
+/** Upgrade service provider: below the spawn and fetch services it uses. */
+export const UPGRADE_SERVICE_PRIORITY = 56;
+
+/** Background startup task which refreshes the cached upgrade check result. */
+export const UPGRADE_CHECK_STARTUP_TASK_PRIORITY = 56;
+
+/** Image printer service provider. */
+export const IMAGE_PRINTER_SERVICE_PRIORITY = 55;
+
+/** Plugin service provider. */
+export const PLUGIN_SERVICE_PRIORITY = 50;
+
+/**
+ * Startup task which prompts to enable automatic upgrades and performs them. It runs below
+ * consumer startup tasks such as the banner (typically 45 or more) and above the completion
+ * prompt.
+ */
+export const AUTO_UPGRADE_STARTUP_TASK_PRIORITY = 10;
+
+/** Completion service provider, whose `initService()` prompts to enable shell completion. */
+export const COMPLETION_SERVICE_PRIORITY = 5;
+
+/** Shutdown tasks which clean up in-flight work (spinners, progress bars, spawns, fetches). */
+export const CLEANUP_SHUTDOWN_TASK_PRIORITY = 0;
+
+/** Shutdown task which flushes key-value data to the config file, after all other cleanup. */
+export const KEY_VALUE_FLUSH_SHUTDOWN_TASK_PRIORITY = -100;

package/src/runtime/runner.ts

@@ -36,6 +36,12 @@ import { sortByPriority } from "./lifecycle/PriorityTaskList.ts";
 
 const logger = getLogger("runner");
 
+/**
+ * The {@link RunResult} returned by {@link run}, with `exitRequested` set when a startup task ended
+ * the run early by returning an `exitRequest`.
+ */
+export type RunnerResult = RunResult & { readonly exitRequested?: true };
+
 /**
  * Wrap a {@link ServiceProvider}'s `initService()` call as a {@link StartupTask} so it can be
  * merged with directly-registered {@link StartupTask}s (e.g. the banner task) into a single
@@ -560,6 +566,8 @@ async function findAndExecuteDefaultNonModifierCommand(
  *    - Run the task: awaited before continuing if its mode is "blocking" (the default, and how
  *      every ServiceProvider's initService() behaves); fired without awaiting if "background"
  *      (errors logged, not propagated).
+ *    - Return immediately if a "blocking" task returned an exitRequest, using its runState and
+ *      skipping the remaining tasks and the command.
  * 2. Scan arguments for any GlobalModifierCommand clauses not provided by a StartupTask
  *    - For each discovered clause:
  *      - Set any argument defaults from ConfigurationServiceProvider
@@ -615,7 +623,7 @@ export async function run(
   context: Context,
   defaultCommand?: Command,
   startupService?: DefaultStartupService,
-): Promise<RunResult> {
+): Promise<RunnerResult> {
   if (defaultCommand && !isSubCommand(defaultCommand) && !isGlobalCommand(defaultCommand)) {
     throw new Error(
       "If a default command is provided, if must be a global command or sub-command!",
@@ -681,7 +689,14 @@ export async function run(
       : context;
 
     if ((task.mode ?? "blocking") === "blocking") {
-      await task.run(taskContext);
+      const outcome = await task.run(taskContext);
+      if (outcome?.exitRequest) {
+        logger.debug(
+          () =>
+            `Startup task '${task.id}' requested exit with run state ${outcome.exitRequest.runState}`,
+        );
+        return { runState: outcome.exitRequest.runState, exitRequested: true };
+      }
     } else {
       void task.run(taskContext).catch((error: unknown) => {
         logger.debug(() => `Background startup task '${task.id}' failed: ${error}`);

package/src/service/configuration/DefaultKeyValueService.ts

@@ -16,16 +16,37 @@ export default class DefaultKeyValueService implements KeyValueService {
   readonly #keyValueData: Map<string, ValueNode>;
   #dirty = false;
   readonly #secretService: DefaultSecretService | undefined;
+  readonly #flushToStorage: (() => Promise<void>) | undefined;
 
-  constructor(keyValueData: Map<string, ValueNode>, secretService?: DefaultSecretService) {
+  /**
+   * @param keyValueData the scope's data.
+   * @param secretService optional secret service for {@link Secret} values.
+   * @param flushToStorage optional callback which writes every scope's pending changes to storage
+   * and marks them clean, invoked by {@link flush}.
+   */
+  constructor(
+    keyValueData: Map<string, ValueNode>,
+    secretService?: DefaultSecretService,
+    flushToStorage?: () => Promise<void>,
+  ) {
     this.#keyValueData = keyValueData;
     this.#secretService = secretService;
+    this.#flushToStorage = flushToStorage;
   }
 
   public isDirty(): boolean {
     return this.#dirty;
   }
 
+  public markClean(): void {
+    this.#dirty = false;
+  }
+
+  public async flush(): Promise<void> {
+    await this.#flushToStorage?.();
+    this.#dirty = false;
+  }
+
   public async get<T extends ValueNode = ValueNode>(key: string): Promise<T> {
     const value = this.#keyValueData.get(key);
     if (value === undefined) {

package/src/service/configuration/KeyValueServiceProvider.ts

@@ -12,6 +12,7 @@ import DefaultSecretService from "./DefaultSecretService.ts";
 import type ConfigurationServiceProvider from "./ConfigurationServiceProvider.ts";
 import type { KeyValueServiceScopeType } from "./ConfigurationServiceProvider.ts";
 import type DefaultContext from "../../runtime/DefaultContext.ts";
+import { KEY_VALUE_FLUSH_SHUTDOWN_TASK_PRIORITY } from "../../runtime/lifecycle/priorities.ts";
 
 /**
  * Registered under {@link KEY_VALUE_SERVICE_ID} in the plain, undecorated {@link Context} purely
@@ -37,6 +38,10 @@ class UnreachableKeyValueService implements KeyValueService {
     return Promise.reject(new Error(UnreachableKeyValueService.#message));
   }
 
+  flush(): Promise<void> {
+    return Promise.reject(new Error(UnreachableKeyValueService.#message));
+  }
+
   static readonly #message =
     "KeyValueService accessed without a resolved scope - this should be unreachable";
 }
@@ -188,7 +193,9 @@ export default class KeyValueServiceProvider implements ServiceProvider {
     const secretService = this.secretServiceEnabled
       ? new DefaultSecretService(this.#cliConfigName!, `${scopeType}_${scopeKey}`)
       : undefined;
-    const scopedService = new DefaultKeyValueService(keyValueData, secretService);
+    const scopedService = new DefaultKeyValueService(keyValueData, secretService, () =>
+      this.#flushDirtyScopes(),
+    );
     scopedServices.set(scopeKey, scopedService);
     return scopedService;
   }
@@ -229,15 +236,21 @@ export default class KeyValueServiceProvider implements ServiceProvider {
 
   /**
    * Flush every scoped KeyValueService's data to the configuration file, if any of them report
-   * themselves dirty. Registered as a low-priority ShutdownTask (see {@link initService}) so it
-   * runs once, after other shutdown cleanup, regardless of how long any scope was written to.
+   * themselves dirty, then mark them all clean. Registered as a low-priority ShutdownTask (see
+   * {@link initService}) so it runs once, after other shutdown cleanup, regardless of how long any
+   * scope was written to. Also backs {@link KeyValueService.flush} for every scope.
    */
   async #flushDirtyScopes(): Promise<void> {
-    const anyDirty = [
+    const scopedServices = [
       ...this.#commandScopedKeyValueServices.values(),
       ...this.#serviceScopedKeyValueServices.values(),
-    ].some((service) => service.isDirty());
-    await this.#configurationServiceProvider.flushIfDirty(anyDirty);
+    ];
+    await this.#configurationServiceProvider.flushIfDirty(
+      scopedServices.some((service) => service.isDirty()),
+    );
+    for (const service of scopedServices) {
+      service.markClean();
+    }
   }
 
   public async initService(context: Context): Promise<void> {
@@ -245,9 +258,7 @@ export default class KeyValueServiceProvider implements ServiceProvider {
       const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
       shutdownService.registerTask({
         id: `${KEY_VALUE_SERVICE_ID}-flush`,
-        // low priority - shutdown tasks run in descending priority order, so this runs after
-        // other shutdown cleanup (which defaults to priority 0).
-        priority: -100,
+        priority: KEY_VALUE_FLUSH_SHUTDOWN_TASK_PRIORITY,
         run: () => this.#flushDirtyScopes(),
       });
     }

package/src/service/fetch/DefaultFetchService.ts

@@ -6,6 +6,7 @@ import type {
 } from "@flowscripter/dynamic-cli-framework-api";
 import { SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.ts";
+import { CLEANUP_SHUTDOWN_TASK_PRIORITY } from "../../runtime/lifecycle/priorities.ts";
 
 const logger = getLogger("DefaultFetchService");
 
@@ -38,7 +39,7 @@ export default class DefaultFetchService implements FetchService {
       shutdownService.enterLongRunningMode();
       shutdownService.registerTask({
         id: `fetch:${input.toString()}`,
-        priority: 0,
+        priority: CLEANUP_SHUTDOWN_TASK_PRIORITY,
         run: async () => {
           if (settled) {
             return;

package/src/service/printer/PrinterServiceProvider.ts

@@ -9,6 +9,7 @@ import NoHyperlinksCommand from "./command/NoHyperlinksCommand.ts";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 import type { ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
 import { SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { CLEANUP_SHUTDOWN_TASK_PRIORITY } from "../../runtime/lifecycle/priorities.ts";
 
 /**
  * Provides a {@link PrinterService}.
@@ -45,7 +46,7 @@ export default class PrinterServiceProvider implements ServiceProvider {
     const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
     shutdownService.registerTask({
       id: PRINTER_SERVICE_ID,
-      priority: 0,
+      priority: CLEANUP_SHUTDOWN_TASK_PRIORITY,
       run: async () => {
         await this.printerService.hideSpinner();
         await this.printerService.hideAllProgressBars();

package/src/service/shutdown/ShutdownServiceProvider.ts

@@ -2,7 +2,7 @@ import process from "node:process";
 import type { ServiceInfo, ServiceProvider } from "@flowscripter/dynamic-cli-framework-api";
 import DefaultShutdownService from "./DefaultShutdownService.ts";
 import type { ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
-import { SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { RunState, SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.ts";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
@@ -37,7 +37,7 @@ export default class ShutdownServiceProvider implements ServiceProvider {
     shutdownState.interruptCount++;
     if (!shutdownState.longRunningMode || shutdownState.interruptCount >= 3) {
       ShutdownServiceProvider.shutdown().then(() => {
-        process.exit(130);
+        process.exit(RunState.INTERRUPTED);
       });
     } else {
       shutdownState.shutdownRequested = true;
@@ -46,7 +46,7 @@ export default class ShutdownServiceProvider implements ServiceProvider {
 
   static onTerminate(): void {
     ShutdownServiceProvider.shutdown().then(() => {
-      process.exit(143);
+      process.exit(RunState.TERMINATED);
     });
   }
 

package/src/service/spawn/DefaultSpawnService.ts

@@ -9,6 +9,7 @@ import type {
 } from "@flowscripter/dynamic-cli-framework-api";
 import { PRINTER_SERVICE_ID, SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.ts";
+import { CLEANUP_SHUTDOWN_TASK_PRIORITY } from "../../runtime/lifecycle/priorities.ts";
 
 const logger = getLogger("DefaultSpawnService");
 
@@ -107,6 +108,7 @@ export default class DefaultSpawnService implements SpawnService {
     try {
       proc = Bun.spawn(resolveForPlatform(command), {
         cwd: options.cwd,
+        env: options.env === undefined ? undefined : { ...process.env, ...options.env },
         stdin: mode === "inherit" ? "inherit" : "ignore",
         stdout: mode === "wrapped" ? "pipe" : mode === "ignore" ? "ignore" : "inherit",
         stderr: mode === "wrapped" ? "pipe" : mode === "ignore" ? "ignore" : "inherit",
@@ -124,7 +126,7 @@ export default class DefaultSpawnService implements SpawnService {
 
     shutdownService.registerTask({
       id: `spawn:${command.join(" ")}`,
-      priority: 0,
+      priority: CLEANUP_SHUTDOWN_TASK_PRIORITY,
       run: async () => {
         if (settled) {
           return;