@flowscripter/dynamic-cli-framework 6.0.1 → 7.0.0

package/src/service/configuration/KeyValueServiceProvider.ts

@@ -0,0 +1,246 @@
+import type { ServiceInfo, ServiceProvider } from "@flowscripter/dynamic-cli-framework-api";
+import type { Context } from "@flowscripter/dynamic-cli-framework-api";
+import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
+import type {
+  KeyValueService,
+  ShutdownService,
+  ValueNode,
+} from "@flowscripter/dynamic-cli-framework-api";
+import { KEY_VALUE_SERVICE_ID, SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import DefaultKeyValueService from "./DefaultKeyValueService.ts";
+import DefaultSecretService from "./DefaultSecretService.ts";
+import type ConfigurationServiceProvider from "./ConfigurationServiceProvider.ts";
+import type { KeyValueServiceScopeType } from "./ConfigurationServiceProvider.ts";
+
+/**
+ * Registered under {@link KEY_VALUE_SERVICE_ID} in the plain, undecorated {@link Context} purely
+ * so {@link Context.doesServiceExist} reports correctly - every real access goes through a
+ * per-scope instance from {@link KeyValueServiceProvider.getScopedKeyValueService}, applied
+ * via a per-call decorated {@link Context} (see `runner.ts`). Reaching any of these methods
+ * directly means that decoration was somehow bypassed.
+ */
+class UnreachableKeyValueService implements KeyValueService {
+  get<T extends ValueNode>(): Promise<T> {
+    return Promise.reject(new Error(UnreachableKeyValueService.#message));
+  }
+
+  has(): Promise<boolean> {
+    return Promise.reject(new Error(UnreachableKeyValueService.#message));
+  }
+
+  set(): Promise<void> {
+    return Promise.reject(new Error(UnreachableKeyValueService.#message));
+  }
+
+  delete(): Promise<void> {
+    return Promise.reject(new Error(UnreachableKeyValueService.#message));
+  }
+
+  static readonly #message =
+    "KeyValueService accessed without a resolved scope - this should be unreachable";
+}
+
+/**
+ * Provides a generic, per-scope key-value store for commands and services ({@link KeyValueService}).
+ *
+ * The underlying data is read from/written to the same configuration file managed by
+ * {@link ConfigurationServiceProvider} - see {@link ConfigurationServiceProvider.getKeyValueData} and
+ * {@link ConfigurationServiceProvider.flushIfDirty}, reached via a direct constructor reference wired
+ * up by `BaseCLI` (never via {@link Context}, since that would expose config-file read/write access
+ * more broadly than intended).
+ *
+ * Its `serviceId` is {@link KEY_VALUE_SERVICE_ID} and its {@link ServiceInfo.service} is a
+ * placeholder ({@link UnreachableKeyValueService}) - real access always goes through a per-consumer
+ * decorated {@link Context} from {@link getContextForScope}, applied by `runner.ts`.
+ *
+ * Any node within a value passed to {@link KeyValueService.set} can be wrapped in {@link Secret} -
+ * at any depth - to have that node, and only that node, stored as an OS-native secret. When a node
+ * is wrapped in {@link Secret}, its value (of any shape) is JSON-serialized and stored as a single
+ * OS-native secret via Bun.secrets, with a sentinel value of the format `__SECRET__:<bun_secret_name>`
+ * substituted in its place in the structure that gets stored in the config file. Everything else in
+ * the value is stored as plain (unencrypted) config data. The sentinel prefix `__SECRET__:` is
+ * reserved and must not be used for regular key-value data.
+ *
+ * Independently of how a value was written, {@link KeyValueService.get} recursively resolves any
+ * string leaf - at any depth within the retrieved value - which starts with the sentinel prefix,
+ * via the OS secret store. This means a secret reference may also be hand-embedded (nested
+ * arbitrarily deep) directly within a plain, non-secret value in the config file.
+ *
+ * Secret support requires `secretServiceEnabled=true` in the constructor (which also requires
+ * `keyValueServiceEnabled=true` on the {@link ConfigurationServiceProvider} to have config enabled).
+ *
+ * As an example of the underlying config file structure:
+ * ```
+ * {
+ *    "defaults": {
+ *        ...
+ *    },
+ *    "key-values": {
+ *        "commands": {
+ *            "command1": {
+ *               "foo1": "bar1",
+ *               "foo2": "__SECRET__:command_command1_foo2",
+ *               "foo3": {
+ *                   "nested": ["a", "__SECRET__:command_command1_foo3_nested"]
+ *               }
+ *            },
+ *            "command2": {
+ *                "foo1": "bar3"
+ *            }
+ *        },
+ *        "services": {
+ *            "service-id-1": {
+ *                "foo1": "bar"
+ *            }
+ *        }
+ *    }
+ * }
+ * ```
+ */
+export default class KeyValueServiceProvider implements ServiceProvider {
+  readonly serviceId: string = KEY_VALUE_SERVICE_ID;
+  readonly servicePriority: number;
+
+  readonly #configurationServiceProvider: ConfigurationServiceProvider;
+
+  public readonly keyValueServiceEnabled: boolean;
+  public readonly secretServiceEnabled: boolean;
+
+  // per-scope KeyValueService instances, created on first request and cached thereafter - each is
+  // bound permanently to one scope's Map (and one scope-prefixed DefaultSecretService), never
+  // re-pointed. See getScopedKeyValueService().
+  readonly #commandScopedKeyValueServices = new Map<string, DefaultKeyValueService>();
+  readonly #serviceScopedKeyValueServices = new Map<string, DefaultKeyValueService>();
+
+  // used to construct scoped DefaultSecretService instances on demand.
+  #cliConfigName: string | undefined;
+
+  /**
+   * Create an instance of the service provider with the specified details.
+   *
+   * @param servicePriority the priority of the service.
+   * @param configurationServiceProvider the {@link ConfigurationServiceProvider} whose config file
+   * backs this provider's data - an internal wiring reference, never exposed further.
+   * @param keyValueServiceEnabled optionally provide a {@link KeyValueService} implementation: `configurationServiceProvider.configEnabled` must be true in this case
+   * @param secretServiceEnabled optionally enable OS-native secret storage via Bun.secrets: `configurationServiceProvider.configEnabled` must be true in this case
+   */
+  public constructor(
+    servicePriority: number,
+    configurationServiceProvider: ConfigurationServiceProvider,
+    keyValueServiceEnabled = false,
+    secretServiceEnabled = false,
+  ) {
+    if (!configurationServiceProvider.configEnabled && keyValueServiceEnabled) {
+      throw new Error("configEnabled must be true if keyValueServiceEnabled is true");
+    }
+    if (!configurationServiceProvider.configEnabled && secretServiceEnabled) {
+      throw new Error("configEnabled must be true if secretServiceEnabled is true");
+    }
+    this.servicePriority = servicePriority;
+    this.#configurationServiceProvider = configurationServiceProvider;
+    this.keyValueServiceEnabled = keyValueServiceEnabled;
+    this.secretServiceEnabled = secretServiceEnabled;
+  }
+
+  public getServiceInfo(cliConfig: CLIConfig): Promise<ServiceInfo> {
+    this.#cliConfigName = cliConfig.name;
+    return Promise.resolve({
+      // this is a placeholder - see UnreachableKeyValueService - unless neither is enabled
+      service:
+        this.keyValueServiceEnabled || this.secretServiceEnabled
+          ? new UnreachableKeyValueService()
+          : undefined,
+      commands: [],
+    });
+  }
+
+  /**
+   * Return the {@link KeyValueService} bound to the given scope, creating (and caching) it on
+   * first request. The returned instance is permanently bound to that scope's data and secret
+   * prefix - it is never re-pointed, so it may be held and used for as long as its owning
+   * command/service/task is alive without racing any other scope's window.
+   *
+   * @param scopeType whether `scopeKey` is a command name or a service/task ID.
+   * @param scopeKey the command name or service/task ID to scope the key-value data to.
+   *
+   * @throws {Error} if neither `keyValueServiceEnabled` nor `secretServiceEnabled` is set.
+   */
+  public getScopedKeyValueService(
+    scopeType: KeyValueServiceScopeType,
+    scopeKey: string,
+  ): KeyValueService {
+    if (!this.keyValueServiceEnabled && !this.secretServiceEnabled) {
+      throw new Error(`Attempt to use KeyValueService/SecretService which is not enabled`);
+    }
+
+    const scopedServices =
+      scopeType === "command"
+        ? this.#commandScopedKeyValueServices
+        : this.#serviceScopedKeyValueServices;
+    const cached = scopedServices.get(scopeKey);
+    if (cached) {
+      return cached;
+    }
+
+    const keyValueData = this.#configurationServiceProvider.getKeyValueData(scopeType, scopeKey);
+
+    const secretService = this.secretServiceEnabled
+      ? new DefaultSecretService(this.#cliConfigName!, `${scopeType}_${scopeKey}`)
+      : undefined;
+    const scopedService = new DefaultKeyValueService(keyValueData, secretService);
+    scopedServices.set(scopeKey, scopedService);
+    return scopedService;
+  }
+
+  /**
+   * Return a {@link Context} which delegates every lookup to `context` unchanged, except
+   * `getServiceById(KEY_VALUE_SERVICE_ID)`, which resolves to the scope-bound instance from
+   * {@link getScopedKeyValueService} for the given scope. Used by `runner.ts` to give each
+   * command/service/task a KeyValueService isolated to its own scope, invisibly at the call site.
+   *
+   * Returns `context` itself, unchanged, if neither `keyValueServiceEnabled` nor
+   * `secretServiceEnabled` is set.
+   */
+  public getContextForScope(
+    context: Context,
+    scopeType: KeyValueServiceScopeType,
+    scopeKey: string,
+  ): Context {
+    if (!this.keyValueServiceEnabled && !this.secretServiceEnabled) {
+      return context;
+    }
+    const scopedKeyValueService = this.getScopedKeyValueService(scopeType, scopeKey);
+    return {
+      cliConfig: context.cliConfig,
+      getServiceById: (id: string): unknown =>
+        id === KEY_VALUE_SERVICE_ID ? scopedKeyValueService : context.getServiceById(id),
+      doesServiceExist: (id: string): boolean => context.doesServiceExist(id),
+    };
+  }
+
+  /**
+   * 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.
+   */
+  async #flushDirtyScopes(): Promise<void> {
+    const anyDirty = [
+      ...this.#commandScopedKeyValueServices.values(),
+      ...this.#serviceScopedKeyValueServices.values(),
+    ].some((service) => service.isDirty());
+    await this.#configurationServiceProvider.flushIfDirty(anyDirty);
+  }
+
+  public async initService(context: Context): Promise<void> {
+    if (this.keyValueServiceEnabled || this.secretServiceEnabled) {
+      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,
+        run: () => this.#flushDirtyScopes(),
+      });
+    }
+  }
+}

package/src/service/configuration/command/ConfigCommand.ts

@@ -2,10 +2,14 @@ import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type ConfigurationServiceProvider from "../ConfigurationServiceProvider.ts";
+import {
+  CONFIGURATION_SERVICE_ID,
+  type ConfigurationService,
+} from "@flowscripter/dynamic-cli-framework-api";
 
 /**
- * Command allowing the specification of the configuration file location used by the {@link ConfigurationServiceProvider}.
+ * Command allowing the specification of the configuration file location used by
+ * {@link ConfigurationServiceProvider}.
  */
 export default class ConfigCommand implements GlobalModifierCommand {
   readonly name = "config";
@@ -17,20 +21,17 @@ export default class ConfigCommand implements GlobalModifierCommand {
   };
   readonly executePriority: number;
 
-  readonly #configurationServiceProvider: ConfigurationServiceProvider;
-
-  public constructor(
-    configurationServiceProvider: ConfigurationServiceProvider,
-    executePriority: number,
-  ) {
-    this.#configurationServiceProvider = configurationServiceProvider;
+  public constructor(executePriority: number) {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
+  public execute(context: Context, argumentValue: SingleValueType): Promise<void> {
     const configLocation = argumentValue as string;
 
-    this.#configurationServiceProvider.setConfigLocation(configLocation);
+    const configurationService = context.getServiceById(
+      CONFIGURATION_SERVICE_ID,
+    ) as ConfigurationService;
+    configurationService.setConfigLocation(configLocation);
 
     return Promise.resolve();
   }

package/src/service/configuration/command/DumpConfigCommand.ts

@@ -1,22 +1,26 @@
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
-import type ConfigurationServiceProvider from "../ConfigurationServiceProvider.ts";
 import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
 import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { SyntaxHighlighterService } from "@flowscripter/dynamic-cli-framework-api";
 import { SYNTAX_HIGHLIGHTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 
 /**
- * Command which dumps the configuration loaded by the {@link ConfigurationServiceProvider}.
+ * Command which dumps the configuration loaded by {@link ConfigurationServiceProvider}.
+ *
+ * Takes a direct reference to {@link ConfigurationServiceProvider.getConfigString}, wired by the
+ * provider that constructs this command, rather than looking it up via {@link Context} -
+ * deliberately, since a full config dump is not something every command/task should be able to
+ * reach through a general lookup (see {@link ConfigurationService}'s doc comment).
  */
 export default class DumpConfigCommand implements GlobalCommand {
   readonly name = "dump-config";
   readonly description = "Dump configuration values";
 
-  readonly #configurationServiceProvider: ConfigurationServiceProvider;
+  readonly #getConfigString: () => string;
 
-  public constructor(configurationServiceProvider: ConfigurationServiceProvider) {
-    this.#configurationServiceProvider = configurationServiceProvider;
+  public constructor(getConfigString: () => string) {
+    this.#getConfigString = getConfigString;
   }
 
   public async execute(context: Context): Promise<void> {
@@ -26,10 +30,7 @@ export default class DumpConfigCommand implements GlobalCommand {
     ) as SyntaxHighlighterService;
 
     await printerService.print(
-      `${syntaxHighlighterService.highlight(
-        this.#configurationServiceProvider.getConfigString(),
-        "json",
-      )}\n`,
+      `${syntaxHighlighterService.highlight(this.#getConfigString(), "json")}\n`,
     );
   }
 }

package/src/service/fetch/DefaultFetchService.ts

@@ -1,24 +1,26 @@
 import type {
+  Context,
   FetchOptions,
   FetchService,
   ShutdownService,
 } from "@flowscripter/dynamic-cli-framework-api";
+import { SHUTDOWN_SERVICE_ID } 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;
+  #context: Context | undefined;
 
-  public setDependencies(shutdownService: ShutdownService): void {
-    this.#shutdownService = shutdownService;
+  public setContext(context: Context): void {
+    this.#context = context;
   }
 
   public async fetch(input: string | URL, options: FetchOptions = {}): Promise<Response> {
-    if (this.#shutdownService === undefined) {
-      throw new Error("DefaultFetchService.fetch() called before setDependencies()");
+    if (this.#context === undefined) {
+      throw new Error("DefaultFetchService.fetch() called before setContext()");
     }
-    const shutdownService = this.#shutdownService;
+    const shutdownService = this.#context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
     const { timeoutMs, longRunning = false, signal: callerSignal, ...requestInit } = options;
 
     const controller = new AbortController();
@@ -34,12 +36,16 @@ export default class DefaultFetchService implements FetchService {
     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();
+      shutdownService.registerTask({
+        id: `fetch:${input.toString()}`,
+        priority: 0,
+        run: async () => {
+          if (settled) {
+            return;
+          }
+          logger.debug(() => `Aborting fetch of '${input.toString()}' due to shutdown`);
+          controller.abort();
+        },
       });
     }
 

package/src/service/fetch/FetchServiceProvider.ts

@@ -3,9 +3,8 @@ import type {
   Context,
   ServiceInfo,
   ServiceProvider,
-  ShutdownService,
 } from "@flowscripter/dynamic-cli-framework-api";
-import { FETCH_SERVICE_ID, SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { FETCH_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import DefaultFetchService from "./DefaultFetchService.ts";
 
 export default class FetchServiceProvider implements ServiceProvider {
@@ -26,8 +25,7 @@ export default class FetchServiceProvider implements ServiceProvider {
   }
 
   public initService(context: Context): Promise<void> {
-    const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
-    this.#fetchService!.setDependencies(shutdownService);
+    this.#fetchService!.setContext(context);
     return Promise.resolve();
   }
 }

package/src/service/printer/PrinterServiceProvider.ts

@@ -33,19 +33,23 @@ export default class PrinterServiceProvider implements ServiceProvider {
     return Promise.resolve({
       service: this.printerService,
       commands: [
-        new NoHyperlinksCommand(this, this.servicePriority + 3),
-        new DarkModeCommand(this, this.servicePriority + 2),
-        new NoColorCommand(this, this.servicePriority + 1),
-        new LogLevelCommand(this, this.servicePriority),
+        new NoHyperlinksCommand(this.servicePriority + 3),
+        new DarkModeCommand(this.servicePriority + 2),
+        new NoColorCommand(this.servicePriority + 1),
+        new LogLevelCommand(this.servicePriority),
       ],
     });
   }
 
   initService(context: Context): Promise<void> {
     const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
-    shutdownService.addShutdownListener(async () => {
-      await this.printerService.hideSpinner();
-      await this.printerService.hideAllProgressBars();
+    shutdownService.registerTask({
+      id: PRINTER_SERVICE_ID,
+      priority: 0,
+      run: async () => {
+        await this.printerService.hideSpinner();
+        await this.printerService.hideAllProgressBars();
+      },
     });
 
     return Promise.resolve();

package/src/service/printer/command/DarkModeCommand.ts

@@ -2,10 +2,11 @@ import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
+import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 
 /**
- * Command allowing the specification of dark/light mode for {@link PrinterServiceProvider}.
+ * Command allowing the specification of dark/light mode for the {@link PrinterService}.
  */
 export default class DarkModeCommand implements GlobalModifierCommand {
   readonly name = "dark-mode";
@@ -18,15 +19,13 @@ export default class DarkModeCommand implements GlobalModifierCommand {
   };
   readonly executePriority: number;
 
-  readonly #printerServiceProvider: PrinterServiceProvider;
-
-  public constructor(printerServiceProvider: PrinterServiceProvider, executePriority: number) {
-    this.#printerServiceProvider = printerServiceProvider;
+  public constructor(executePriority: number) {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
-    this.#printerServiceProvider.printerService!.darkMode = argumentValue as boolean;
+  public execute(context: Context, argumentValue: SingleValueType): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
+    printerService.darkMode = argumentValue as boolean;
 
     return Promise.resolve();
   }

package/src/service/printer/command/LogLevelCommand.ts

@@ -2,11 +2,12 @@ import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-
 import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
+import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import { Level } from "@flowscripter/dynamic-cli-framework-api";
 
 /**
- * Command allowing the setting of the log level for {@link PrinterServiceProvider}.
+ * Command allowing the setting of the log level for the {@link PrinterService}.
  */
 export default class LogLevelCommand implements GlobalModifierCommand {
   readonly name = "log-level";
@@ -21,28 +22,26 @@ export default class LogLevelCommand implements GlobalModifierCommand {
   };
   readonly executePriority: number;
 
-  readonly #printerServiceProvider: PrinterServiceProvider;
-
-  public constructor(printerServiceProvider: PrinterServiceProvider, executePriority: number) {
-    this.#printerServiceProvider = printerServiceProvider;
+  public constructor(executePriority: number) {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
+  public execute(context: Context, argumentValue: SingleValueType): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
     const logLevel = argumentValue as string;
 
     switch (logLevel.toUpperCase()) {
       case "DEBUG":
-        this.#printerServiceProvider.printerService!.setLevel(Level.DEBUG);
+        printerService.setLevel(Level.DEBUG);
         break;
       case "INFO":
-        this.#printerServiceProvider.printerService!.setLevel(Level.INFO);
+        printerService.setLevel(Level.INFO);
         break;
       case "WARN":
-        this.#printerServiceProvider.printerService!.setLevel(Level.WARN);
+        printerService.setLevel(Level.WARN);
         break;
       case "ERROR":
-        this.#printerServiceProvider.printerService!.setLevel(Level.ERROR);
+        printerService.setLevel(Level.ERROR);
         break;
     }
 

package/src/service/printer/command/NoColorCommand.ts

@@ -2,10 +2,11 @@ import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
+import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 
 /**
- * Command allowing the disabling of color for {@link PrinterServiceProvider}.
+ * Command allowing the disabling of color for the {@link PrinterService}.
  */
 export default class NoColorCommand implements GlobalModifierCommand {
   readonly name = "no-color";
@@ -18,15 +19,13 @@ export default class NoColorCommand implements GlobalModifierCommand {
   };
   readonly executePriority: number;
 
-  readonly #printerServiceProvider: PrinterServiceProvider;
-
-  public constructor(printerServiceProvider: PrinterServiceProvider, executePriority: number) {
-    this.#printerServiceProvider = printerServiceProvider;
+  public constructor(executePriority: number) {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
-    this.#printerServiceProvider.printerService!.colorEnabled = !argumentValue as boolean;
+  public execute(context: Context, argumentValue: SingleValueType): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
+    printerService.colorEnabled = !argumentValue as boolean;
 
     return Promise.resolve();
   }

package/src/service/printer/command/NoHyperlinksCommand.ts

@@ -2,7 +2,8 @@ import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
+import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 
 export default class NoHyperlinksCommand implements GlobalModifierCommand {
   readonly name = "no-hyperlinks";
@@ -15,15 +16,13 @@ export default class NoHyperlinksCommand implements GlobalModifierCommand {
   };
   readonly executePriority: number;
 
-  readonly #printerServiceProvider: PrinterServiceProvider;
-
-  public constructor(printerServiceProvider: PrinterServiceProvider, executePriority: number) {
-    this.#printerServiceProvider = printerServiceProvider;
+  public constructor(executePriority: number) {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
-    this.#printerServiceProvider.printerService!.hyperlinksEnabled = !argumentValue as boolean;
+  public execute(context: Context, argumentValue: SingleValueType): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
+    printerService.hyperlinksEnabled = !argumentValue as boolean;
 
     return Promise.resolve();
   }

package/src/service/prompter/PrompterServiceProvider.ts

@@ -18,7 +18,7 @@ export default class PrompterServiceProvider implements ServiceProvider {
   public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.prompterService,
-      commands: [new NoPromptCommand(this, this.servicePriority)],
+      commands: [new NoPromptCommand(this.servicePriority)],
     });
   }
 

package/src/service/prompter/command/NoPromptCommand.ts

@@ -2,7 +2,8 @@ import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type PrompterServiceProvider from "../PrompterServiceProvider.ts";
+import type { PrompterService } from "@flowscripter/dynamic-cli-framework-api";
+import { PROMPTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 
 export default class NoPromptCommand implements GlobalModifierCommand {
   readonly name = "no-prompt";
@@ -15,15 +16,13 @@ export default class NoPromptCommand implements GlobalModifierCommand {
   };
   readonly executePriority: number;
 
-  readonly #prompterServiceProvider: PrompterServiceProvider;
-
-  public constructor(prompterServiceProvider: PrompterServiceProvider, executePriority: number) {
-    this.#prompterServiceProvider = prompterServiceProvider;
+  public constructor(executePriority: number) {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
-    this.#prompterServiceProvider.prompterService.promptEnabled = !(argumentValue as boolean);
+  public execute(context: Context, argumentValue: SingleValueType): Promise<void> {
+    const prompterService = context.getServiceById(PROMPTER_SERVICE_ID) as PrompterService;
+    prompterService.promptEnabled = !(argumentValue as boolean);
 
     return Promise.resolve();
   }

package/src/service/shutdown/DefaultShutdownService.ts

@@ -1,11 +1,12 @@
-import type { ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
+import type { ShutdownService, ShutdownTask } from "@flowscripter/dynamic-cli-framework-api";
+import PriorityTaskList from "../../runtime/lifecycle/PriorityTaskList.ts";
 import { shutdownState } from "./ShutdownState.ts";
 
 export default class DefaultShutdownService implements ShutdownService {
-  static readonly callbacks: Array<() => Promise<void>> = [];
+  static readonly taskList = new PriorityTaskList<ShutdownTask>();
 
-  addShutdownListener(callback: () => Promise<void>): void {
-    DefaultShutdownService.callbacks.push(callback);
+  registerTask(task: ShutdownTask): void {
+    DefaultShutdownService.taskList.add(task);
   }
 
   enterLongRunningMode(): void {