@flowscripter/dynamic-cli-framework 3.0.1 → 4.0.0

package/src/service/configuration/DefaultKeyValueService.ts

@@ -1,9 +1,14 @@
-import type { KeyValueService } from "@flowscripter/dynamic-cli-framework-api";
-import { SECRET_SENTINEL_PREFIX } from "@flowscripter/dynamic-cli-framework-api";
+import type {
+  ValueNode,
+  KeyValueService,
+  SettableValueNode,
+} from "@flowscripter/dynamic-cli-framework-api";
+import { Secret, SECRET_SENTINEL_PREFIX } from "@flowscripter/dynamic-cli-framework-api";
 import type DefaultSecretService from "./DefaultSecretService.ts";
+import resolveSecrets from "./resolveSecrets.ts";
 
 export default class DefaultKeyValueService implements KeyValueService {
-  #keyValueData: Map<string, string> | undefined;
+  #keyValueData: Map<string, ValueNode> | undefined;
   #dirty = false;
   readonly #secretService: DefaultSecretService | undefined;
 
@@ -11,7 +16,7 @@ export default class DefaultKeyValueService implements KeyValueService {
     this.#secretService = secretService;
   }
 
-  public setKeyValueData(keyValueData: Map<string, string>) {
+  public setKeyValueData(keyValueData: Map<string, ValueNode>) {
     if (this.#keyValueData) {
       throw new Error("Attempt to overwrite key-value data, it should be cleared first");
     }
@@ -28,7 +33,7 @@ export default class DefaultKeyValueService implements KeyValueService {
     return this.#dirty;
   }
 
-  public async getKey(key: string): Promise<string> {
+  public async get<T extends ValueNode = ValueNode>(key: string): Promise<T> {
     if (this.#keyValueData === undefined) {
       throw new Error("Attempt to access undefined key-value data");
     }
@@ -37,56 +42,105 @@ export default class DefaultKeyValueService implements KeyValueService {
       throw new Error("Attempt to access unknown key");
     }
 
-    if (value.startsWith(SECRET_SENTINEL_PREFIX)) {
+    const resolveSecret = async (bunSecretName: string): Promise<unknown> => {
       if (!this.#secretService) {
         throw new Error("Secret sentinel found but no secret service is available");
       }
-      const bunSecretName = value.slice(SECRET_SENTINEL_PREFIX.length);
       const secretValue = await this.#secretService.getSecret(bunSecretName);
       if (secretValue === null) {
         throw new Error(`Secret not found in OS secret store for key: '${key}'`);
       }
-      return secretValue;
-    }
+      try {
+        return JSON.parse(secretValue);
+      } catch {
+        return secretValue;
+      }
+    };
 
-    return value;
+    return resolveSecrets(value, resolveSecret) as Promise<T>;
   }
 
-  public hasKey(key: string): Promise<boolean> {
+  public has(key: string): Promise<boolean> {
     if (this.#keyValueData === undefined) {
       return Promise.reject(new Error("Attempt to access undefined key-value data"));
     }
     return Promise.resolve(this.#keyValueData.has(key));
   }
 
-  public async setKey(key: string, value: string, isSecret = false): Promise<void> {
+  public async set(key: string, value: SettableValueNode): Promise<void> {
     if (this.#keyValueData === undefined) {
       throw new Error("Attempt to access undefined key-value data");
     }
-    if (isSecret) {
+    this.#keyValueData.set(key, await this.#storeSecrets(key, value, []));
+    this.#dirty = true;
+  }
+
+  async #storeSecrets(
+    key: string,
+    value: SettableValueNode,
+    path: Array<string>,
+  ): Promise<ValueNode> {
+    if (value instanceof Secret) {
       if (!this.#secretService) {
         throw new Error("Attempt to set a secret but no secret service is available");
       }
-      const bunSecretName = await this.#secretService.setSecret(key, value);
-      this.#keyValueData.set(key, SECRET_SENTINEL_PREFIX + bunSecretName);
-    } else {
-      this.#keyValueData.set(key, value);
+      const secretName = [key, ...path].join("_");
+      const bunSecretName = await this.#secretService.setSecret(
+        secretName,
+        JSON.stringify(value.value),
+      );
+      return SECRET_SENTINEL_PREFIX + bunSecretName;
     }
-    this.#dirty = true;
+    if (Array.isArray(value)) {
+      const result: Array<ValueNode> = [];
+      for (let i = 0; i < value.length; i += 1) {
+        result.push(await this.#storeSecrets(key, value[i]!, [...path, String(i)]));
+      }
+      return result as ValueNode;
+    }
+    if (typeof value === "object" && value !== null) {
+      const result: Record<string, ValueNode> = {};
+      for (const [propertyName, propertyValue] of Object.entries(value)) {
+        result[propertyName] = await this.#storeSecrets(key, propertyValue, [
+          ...path,
+          propertyName,
+        ]);
+      }
+      return result as ValueNode;
+    }
+    return value;
   }
 
-  public async deleteKey(key: string): Promise<void> {
+  public async delete(key: string): Promise<void> {
     if (this.#keyValueData === undefined) {
       throw new Error("Attempt to access undefined key-value data");
     }
     const value = this.#keyValueData.get(key);
-    if (value !== undefined && value.startsWith(SECRET_SENTINEL_PREFIX)) {
+    if (value !== undefined) {
+      await this.#deleteSecrets(value);
+    }
+    this.#keyValueData.delete(key);
+    this.#dirty = true;
+  }
+
+  async #deleteSecrets(value: ValueNode): Promise<void> {
+    if (typeof value === "string" && value.startsWith(SECRET_SENTINEL_PREFIX)) {
       if (this.#secretService) {
         const bunSecretName = value.slice(SECRET_SENTINEL_PREFIX.length);
         await this.#secretService.deleteSecret(bunSecretName);
       }
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        await this.#deleteSecrets(item);
+      }
+      return;
+    }
+    if (typeof value === "object" && value !== null) {
+      for (const propertyValue of Object.values(value)) {
+        await this.#deleteSecrets(propertyValue as ValueNode);
+      }
     }
-    this.#keyValueData.delete(key);
-    this.#dirty = true;
   }
 }

package/src/service/configuration/resolveSecrets.ts

@@ -0,0 +1,35 @@
+import { SECRET_SENTINEL_PREFIX } from "@flowscripter/dynamic-cli-framework-api";
+
+/**
+ * Recursively walk the provided value and resolve any string leaf - at any depth - which starts
+ * with {@link SECRET_SENTINEL_PREFIX}, via the provided resolver callback.
+ *
+ * @param value the value to walk (a JSON-serializable value or a `PopulatedValues` /
+ *   `PopulatedValueType` tree).
+ * @param resolveSecret callback used to resolve a sentinel-prefixed string (with the prefix
+ *   stripped) to its actual value. Should throw if the secret cannot be found.
+ */
+export default async function resolveSecrets<T>(
+  value: T,
+  resolveSecret: (sentinelValue: string) => Promise<unknown>,
+): Promise<T> {
+  if (typeof value === "string" && value.startsWith(SECRET_SENTINEL_PREFIX)) {
+    const bunSecretName = value.slice(SECRET_SENTINEL_PREFIX.length);
+    return (await resolveSecret(bunSecretName)) as unknown as T;
+  }
+  if (typeof value === "object" && value !== null) {
+    if (Array.isArray(value)) {
+      const resolved = [];
+      for (const item of value) {
+        resolved.push(await resolveSecrets(item, resolveSecret));
+      }
+      return resolved as unknown as T;
+    }
+    const resolved: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(value)) {
+      resolved[key] = await resolveSecrets(val, resolveSecret);
+    }
+    return resolved as unknown as T;
+  }
+  return value;
+}

package/src/service/plugin/DefaultPluginService.ts

@@ -1,15 +1,53 @@
 import type { PluginService } from "@flowscripter/dynamic-cli-framework-api";
+import type { KeyValueService } from "@flowscripter/dynamic-cli-framework-api";
 import type {
   MarketplacePluginManager,
   SearchQuery,
   VersionedPluginDescriptor,
+  NpmjsPluginRepositoryConfig,
+  NpmPluginRepositoryConfig,
+} from "@flowscripter/dynamic-plugin-framework";
+import {
+  NpmPluginManager,
+  NpmjsPluginRepository,
+  NpmPluginRepository,
 } from "@flowscripter/dynamic-plugin-framework";
 
 export default class DefaultPluginService implements PluginService {
-  readonly #pluginManager: MarketplacePluginManager;
+  readonly #defaultRemoteConfig: NpmjsPluginRepositoryConfig;
+  readonly #defaultLocalConfig: NpmPluginRepositoryConfig;
+  #pluginManager: MarketplacePluginManager;
+
+  constructor(remoteConfig: NpmjsPluginRepositoryConfig, localConfig: NpmPluginRepositoryConfig) {
+    this.#defaultRemoteConfig = remoteConfig;
+    this.#defaultLocalConfig = localConfig;
+    this.#pluginManager = new NpmPluginManager(
+      [new NpmjsPluginRepository(remoteConfig)],
+      new NpmPluginRepository(localConfig),
+    );
+  }
+
+  get pluginManager(): MarketplacePluginManager {
+    return this.#pluginManager;
+  }
 
-  constructor(pluginManager: MarketplacePluginManager) {
-    this.#pluginManager = pluginManager;
+  async applyKeyValueOverrides(keyValueService: KeyValueService): Promise<void> {
+    let remotesConfig: NpmjsPluginRepositoryConfig[] = [this.#defaultRemoteConfig];
+    if (await keyValueService.has("remotes-config")) {
+      remotesConfig = (await keyValueService.get(
+        "remotes-config",
+      )) as unknown as NpmjsPluginRepositoryConfig[];
+    }
+    let localConfig: NpmPluginRepositoryConfig = this.#defaultLocalConfig;
+    if (await keyValueService.has("local-config")) {
+      localConfig = (await keyValueService.get(
+        "local-config",
+      )) as unknown as NpmPluginRepositoryConfig;
+    }
+    this.#pluginManager = new NpmPluginManager(
+      remotesConfig.map((config) => new NpmjsPluginRepository(config)),
+      new NpmPluginRepository(localConfig),
+    );
   }
 
   search(query: Readonly<SearchQuery>): AsyncIterable<Readonly<VersionedPluginDescriptor>> {

package/src/service/plugin/PluginServiceProvider.ts

@@ -0,0 +1,142 @@
+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 { 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 { KEY_VALUE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import type { KeyValueService } from "@flowscripter/dynamic-cli-framework-api";
+import { DYNAMIC_CLI_FRAMEWORK_COMMAND_FACTORY_EXTENSION_POINT } from "@flowscripter/dynamic-cli-framework-api";
+import { DYNAMIC_CLI_FRAMEWORK_SERVICE_PROVIDER_FACTORY_EXTENSION_POINT } from "@flowscripter/dynamic-cli-framework-api";
+import type { CommandFactory } from "@flowscripter/dynamic-cli-framework-api";
+import type { ServiceProviderFactory } from "@flowscripter/dynamic-cli-framework-api";
+import type {
+  FetchCapable,
+  NpmjsPluginRepositoryConfig,
+  NpmPluginRepositoryConfig,
+  SpawnCapable,
+} from "@flowscripter/dynamic-plugin-framework";
+import { PLUGIN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import DefaultPluginService from "./DefaultPluginService.ts";
+import { PluginGroupCommand } from "./command/PluginGroupCommand.ts";
+import SpawnInterfaceAdapter, {
+  type SpawnInterfaceAdapterOptions,
+} from "./SpawnInterfaceAdapter.ts";
+import FetchInterfaceAdapter, {
+  type FetchInterfaceAdapterOptions,
+} from "./FetchInterfaceAdapter.ts";
+import DefaultCommandRegistry from "../../runtime/registry/DefaultCommandRegistry.ts";
+import DefaultServiceProviderRegistry from "../../runtime/registry/DefaultServiceProviderRegistry.ts";
+import type DefaultContext from "../../runtime/DefaultContext.ts";
+import getLogger from "../../util/logger.ts";
+
+const logger = getLogger("PluginServiceProvider");
+
+export default class PluginServiceProvider implements ServiceProvider {
+  readonly serviceId = PLUGIN_SERVICE_ID;
+  readonly servicePriority: number;
+  readonly #remoteConfig: NpmjsPluginRepositoryConfig;
+  readonly #localConfig: NpmPluginRepositoryConfig;
+  readonly #commandRegistry: DefaultCommandRegistry;
+  readonly #serviceProviderRegistry: DefaultServiceProviderRegistry;
+  readonly #spawnInterfaceAdapterOptions: SpawnInterfaceAdapterOptions;
+  readonly #fetchInterfaceAdapterOptions: FetchInterfaceAdapterOptions;
+  #pluginService: DefaultPluginService | undefined;
+  #cliConfig: CLIConfig | undefined;
+
+  constructor(
+    servicePriority: number,
+    remoteConfig: NpmjsPluginRepositoryConfig,
+    localConfig: NpmPluginRepositoryConfig,
+    commandRegistry: DefaultCommandRegistry,
+    serviceProviderRegistry: DefaultServiceProviderRegistry,
+    spawnInterfaceAdapterOptions: SpawnInterfaceAdapterOptions = {},
+    fetchInterfaceAdapterOptions: FetchInterfaceAdapterOptions = {},
+  ) {
+    this.servicePriority = servicePriority;
+    this.#remoteConfig = remoteConfig;
+    this.#localConfig = localConfig;
+    this.#commandRegistry = commandRegistry;
+    this.#serviceProviderRegistry = serviceProviderRegistry;
+    this.#spawnInterfaceAdapterOptions = spawnInterfaceAdapterOptions;
+    this.#fetchInterfaceAdapterOptions = fetchInterfaceAdapterOptions;
+  }
+
+  async getServiceInfo(cliConfig: CLIConfig): Promise<ServiceInfo> {
+    this.#cliConfig = cliConfig;
+    this.#pluginService = new DefaultPluginService(this.#remoteConfig, this.#localConfig);
+    return {
+      service: this.#pluginService,
+      commands: [new PluginGroupCommand()],
+    };
+  }
+
+  async initService(context: Context): Promise<void> {
+    const pluginService = this.#pluginService!;
+
+    if (context.doesServiceExist(KEY_VALUE_SERVICE_ID)) {
+      const keyValueService = context.getServiceById(KEY_VALUE_SERVICE_ID) as KeyValueService;
+      await pluginService.applyKeyValueOverrides(keyValueService);
+    }
+
+    const pluginManager = pluginService.pluginManager;
+
+    if (!context.doesServiceExist(SPAWN_SERVICE_ID)) {
+      logger.debug("SpawnService not available, plugin manager will spawn processes directly");
+    } else if (!("setSpawn" in pluginManager)) {
+      logger.debug("Plugin manager does not support SpawnCapable, skipping spawn injection");
+    } 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,
+      );
+      (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 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);
+      (pluginManager as unknown as FetchCapable).setFetch(adapter);
+    }
+
+    await pluginManager.registerExtensions(DYNAMIC_CLI_FRAMEWORK_COMMAND_FACTORY_EXTENSION_POINT);
+    await pluginManager.registerExtensions(
+      DYNAMIC_CLI_FRAMEWORK_SERVICE_PROVIDER_FACTORY_EXTENSION_POINT,
+    );
+
+    const commandFactoryExtensions = await pluginManager.getRegisteredExtensions(
+      DYNAMIC_CLI_FRAMEWORK_COMMAND_FACTORY_EXTENSION_POINT,
+    );
+    for (const ext of commandFactoryExtensions) {
+      const factory = (await pluginManager.instantiate(ext.extensionHandle)) as CommandFactory;
+      for (const command of factory.getCommands()) {
+        this.#commandRegistry.addCommand(command);
+      }
+    }
+
+    const spFactoryExtensions = await pluginManager.getRegisteredExtensions(
+      DYNAMIC_CLI_FRAMEWORK_SERVICE_PROVIDER_FACTORY_EXTENSION_POINT,
+    );
+    for (const ext of spFactoryExtensions) {
+      const factory = (await pluginManager.instantiate(
+        ext.extensionHandle,
+      )) as ServiceProviderFactory;
+      for (const sp of factory.getServiceProviders()) {
+        const info = await sp.getServiceInfo(this.#cliConfig!);
+        if (info.service) {
+          (context as DefaultContext).addServiceInstance(sp.serviceId, info.service);
+        }
+        info.commands.forEach((cmd) => this.#commandRegistry.addCommand(cmd, sp.serviceId));
+        this.#serviceProviderRegistry.addServiceProvider(sp);
+      }
+    }
+  }
+}

package/src/service/upgrade/DefaultUpgradeService.ts

@@ -23,7 +23,9 @@ import getLogger from "../../util/logger.ts";
 const logger = getLogger("DefaultUpgradeService");
 
 // checkForUpgrade() runs opportunistically on every CLI invocation (via BannerServiceProvider),
-// so its version-check network/spawn calls must never be allowed to stall CLI startup.
+// so that opportunistic call is raced against this timeout so it never stalls CLI startup.
+// A deliberate caller (waitForResult=true, e.g. the `upgrade` command) awaits checkForUpgrade()
+// directly with no timeout, so its underlying network/spawn calls are never artificially cut off.
 export const VERSION_CHECK_TIMEOUT_MS = 250;
 
 function describeSpawnFailure(result: Extract<SpawnResult, { ok: false }>): string {
@@ -61,10 +63,11 @@ export default class DefaultUpgradeService implements UpgradeService {
   public getUpgradeCheckResult(waitForResult = false): Promise<UpgradeCheckResult | undefined> {
     if (!this.#upgradeCheckPromise) {
       // Only cache a successful result. An `undefined` result can come from a transient
-      // failure (e.g. the opportunistic startup check's fetch exceeding
-      // VERSION_CHECK_TIMEOUT_MS) - caching that would permanently deny a later, deliberate
-      // caller (e.g. the `upgrade` command explicitly waiting via waitForResult=true) any
-      // chance of a fresh attempt for the rest of this process's lifetime.
+      // failure (e.g. the opportunistic startup check racing past VERSION_CHECK_TIMEOUT_MS
+      // before checkForUpgrade() itself resolves) - caching that would permanently deny a
+      // later, deliberate caller (e.g. the `upgrade` command explicitly waiting via
+      // waitForResult=true) any chance of a fresh attempt for the rest of this process's
+      // lifetime.
       this.#upgradeCheckPromise = this.checkForUpgrade().then((result) => {
         if (result === undefined) {
           this.#upgradeCheckPromise = undefined;
@@ -220,7 +223,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     }
     const result = await this.#spawnService.spawn(
       ["brew", "list", "--versions", this.#config.homebrew.formula],
-      { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
+      { mode: "ignore", longRunning: false },
     );
     return result.ok;
   }
@@ -231,7 +234,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     }
     const result = await this.#spawnService.spawn(
       ["winget", "list", "--id", this.#config.winget.packageId],
-      { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
+      { mode: "ignore", longRunning: false },
     );
     return result.ok;
   }
@@ -262,7 +265,6 @@ export default class DefaultUpgradeService implements UpgradeService {
     try {
       const response = await this.#fetchService.fetch(
         `https://api.github.com/repos/${owner}/${repo}/releases/latest`,
-        { timeoutMs: VERSION_CHECK_TIMEOUT_MS },
       );
       if (!response.ok) {
         return undefined;
@@ -287,7 +289,6 @@ export default class DefaultUpgradeService implements UpgradeService {
     try {
       const response = await this.#fetchService.fetch(
         `https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`,
-        { timeoutMs: VERSION_CHECK_TIMEOUT_MS },
       );
       if (!response.ok) {
         return undefined;
@@ -310,7 +311,6 @@ export default class DefaultUpgradeService implements UpgradeService {
       {
         mode: "wrapped",
         longRunning: false,
-        timeoutMs: VERSION_CHECK_TIMEOUT_MS,
         onOutput: (line) => lines.push(line),
       },
     );

package/src/service/upgrade/UpgradeServiceProvider.ts

@@ -71,8 +71,8 @@ export default class UpgradeServiceProvider implements ServiceProvider {
 
     const keyValueService = context.getServiceById(KEY_VALUE_SERVICE_ID) as KeyValueService;
 
-    if (await keyValueService.hasKey("upgrade-status")) {
-      const status = await keyValueService.getKey("upgrade-status");
+    if (await keyValueService.has("upgrade-status")) {
+      const status = await keyValueService.get("upgrade-status");
       if (status === "declined") {
         logger.debug(() => "Auto-upgrade previously declined, skipping");
         return;
@@ -120,11 +120,11 @@ export default class UpgradeServiceProvider implements ServiceProvider {
     }
 
     if (enableResult.value !== true) {
-      await keyValueService.setKey("upgrade-status", "declined");
+      await keyValueService.set("upgrade-status", "declined");
       return;
     }
 
-    await keyValueService.setKey("upgrade-status", "enabled");
+    await keyValueService.set("upgrade-status", "enabled");
     await this.#checkAndUpgrade(context, upgradeService, cliConfig);
   }
 

package/dist/src/cli/DynamicPluginRuntimeCLI.d.ts

@@ -1,20 +0,0 @@
-import type { MarketplacePluginManager } from "@flowscripter/dynamic-plugin-framework";
-import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
-import type BaseCLIFeatureOptions from "./BaseCLIFeatureOptions.ts";
-import type { RunResult } from "@flowscripter/dynamic-cli-framework-api";
-import DefaultRuntimeCLI from "./DefaultRuntimeCLI.ts";
-/**
- * Extension of {@link DefaultRuntimeCLI} that discovers and loads installed plugins before running.
- *
- * On each invocation of {@link run}, all locally installed plugins are discovered via the
- * {@link MarketplacePluginManager}. Commands provided by {@link CommandFactory} extensions and
- * service providers provided by {@link ServiceProviderFactory} extensions are registered before
- * the runner starts, so they participate in the full initialization lifecycle.
- */
-export default class DynamicPluginRuntimeCLI extends DefaultRuntimeCLI {
-    #private;
-    constructor(cliConfig: CLIConfig, pluginManager: MarketplacePluginManager, options?: BaseCLIFeatureOptions);
-    run(): Promise<RunResult>;
-    loadPlugins(): Promise<void>;
-}
-//# sourceMappingURL=DynamicPluginRuntimeCLI.d.ts.map

package/dist/src/cli/DynamicPluginRuntimeCLI.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DynamicPluginRuntimeCLI.d.ts","sourceRoot":"","sources":["../../../src/cli/DynamicPluginRuntimeCLI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,iBAAiB,MAAM,wBAAwB,CAAC;AAQvD;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAwB,SAAQ,iBAAiB;;gBAIlE,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,wBAAwB,EACvC,OAAO,CAAC,EAAE,qBAAqB;IAOlB,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC;IAUlC,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;CAgCnC"}

package/dist/src/cli/DynamicPluginRuntimeCLI.js

@@ -1,50 +0,0 @@
-import { RunState } from "@flowscripter/dynamic-cli-framework-api";
-import DefaultRuntimeCLI from "./DefaultRuntimeCLI.js";
-import DefaultPluginServiceProvider from "../service/plugin/DefaultPluginServiceProvider.js";
-import { DYNAMIC_CLI_FRAMEWORK_COMMAND_FACTORY_EXTENSION_POINT } from "@flowscripter/dynamic-cli-framework-api";
-import { DYNAMIC_CLI_FRAMEWORK_SERVICE_PROVIDER_FACTORY_EXTENSION_POINT } from "@flowscripter/dynamic-cli-framework-api";
-import process from "node:process";
-/**
- * Extension of {@link DefaultRuntimeCLI} that discovers and loads installed plugins before running.
- *
- * On each invocation of {@link run}, all locally installed plugins are discovered via the
- * {@link MarketplacePluginManager}. Commands provided by {@link CommandFactory} extensions and
- * service providers provided by {@link ServiceProviderFactory} extensions are registered before
- * the runner starts, so they participate in the full initialization lifecycle.
- */
-export default class DynamicPluginRuntimeCLI extends DefaultRuntimeCLI {
-    #pluginManager;
-    constructor(cliConfig, pluginManager, options) {
-        super(cliConfig, options);
-        this.#pluginManager = pluginManager;
-        this.addServiceProvider(new DefaultPluginServiceProvider(pluginManager));
-    }
-    async run() {
-        try {
-            await this.loadPlugins();
-        }
-        catch (err) {
-            console.error(err);
-            process.exit(RunState.RUNTIME_ERROR);
-        }
-        return super.run();
-    }
-    async loadPlugins() {
-        await this.#pluginManager.registerExtensions(DYNAMIC_CLI_FRAMEWORK_COMMAND_FACTORY_EXTENSION_POINT);
-        await this.#pluginManager.registerExtensions(DYNAMIC_CLI_FRAMEWORK_SERVICE_PROVIDER_FACTORY_EXTENSION_POINT);
-        const commandFactoryExtensions = await this.#pluginManager.getRegisteredExtensions(DYNAMIC_CLI_FRAMEWORK_COMMAND_FACTORY_EXTENSION_POINT);
-        for (const ext of commandFactoryExtensions) {
-            const factory = (await this.#pluginManager.instantiate(ext.extensionHandle));
-            for (const command of factory.getCommands()) {
-                this.addCommand(command);
-            }
-        }
-        const spFactoryExtensions = await this.#pluginManager.getRegisteredExtensions(DYNAMIC_CLI_FRAMEWORK_SERVICE_PROVIDER_FACTORY_EXTENSION_POINT);
-        for (const ext of spFactoryExtensions) {
-            const factory = (await this.#pluginManager.instantiate(ext.extensionHandle));
-            for (const sp of factory.getServiceProviders()) {
-                this.addServiceProvider(sp);
-            }
-        }
-    }
-}

package/dist/src/service/plugin/DefaultPluginServiceProvider.d.ts

@@ -1,15 +0,0 @@
-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 { MarketplacePluginManager } from "@flowscripter/dynamic-plugin-framework";
-import { type SpawnInterfaceAdapterOptions } from "./SpawnInterfaceAdapter.ts";
-import { type FetchInterfaceAdapterOptions } from "./FetchInterfaceAdapter.ts";
-export default class DefaultPluginServiceProvider implements ServiceProvider {
-    #private;
-    readonly serviceId = "PLUGIN_SERVICE";
-    readonly servicePriority: number;
-    constructor(pluginManager: MarketplacePluginManager, servicePriority?: number, spawnInterfaceAdapterOptions?: SpawnInterfaceAdapterOptions, fetchInterfaceAdapterOptions?: FetchInterfaceAdapterOptions);
-    getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo>;
-    initService(context: Context): Promise<void>;
-}
-//# sourceMappingURL=DefaultPluginServiceProvider.d.ts.map

package/dist/src/service/plugin/DefaultPluginServiceProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DefaultPluginServiceProvider.d.ts","sourceRoot":"","sources":["../../../../src/service/plugin/DefaultPluginServiceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKzE,OAAO,KAAK,EAEV,wBAAwB,EAEzB,MAAM,wCAAwC,CAAC;AAIhD,OAA8B,EAC5B,KAAK,4BAA4B,EAClC,MAAM,4BAA4B,CAAC;AACpC,OAA8B,EAC5B,KAAK,4BAA4B,EAClC,MAAM,4BAA4B,CAAC;AAKpC,MAAM,CAAC,OAAO,OAAO,4BAA6B,YAAW,eAAe;;IAC1E,QAAQ,CAAC,SAAS,oBAAqB;IACvC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;gBAO/B,aAAa,EAAE,wBAAwB,EACvC,eAAe,SAAK,EACpB,4BAA4B,GAAE,4BAAiC,EAC/D,4BAA4B,GAAE,4BAAiC;IAQ3D,cAAc,CAAC,UAAU,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IAQjE,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CA4B7C"}

package/dist/src/service/plugin/DefaultPluginServiceProvider.js

@@ -1,56 +0,0 @@
-import { PRINTER_SERVICE_ID, SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
-import { FETCH_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
-import { PLUGIN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
-import DefaultPluginService from "./DefaultPluginService.js";
-import { PluginGroupCommand } from "./command/PluginGroupCommand.js";
-import SpawnInterfaceAdapter, {} from "./SpawnInterfaceAdapter.js";
-import FetchInterfaceAdapter, {} from "./FetchInterfaceAdapter.js";
-import getLogger from "../../util/logger.js";
-const logger = getLogger("DefaultPluginServiceProvider");
-export default class DefaultPluginServiceProvider {
-    serviceId = PLUGIN_SERVICE_ID;
-    servicePriority;
-    #pluginManager;
-    #spawnInterfaceAdapterOptions;
-    #fetchInterfaceAdapterOptions;
-    #pluginService;
-    constructor(pluginManager, servicePriority = 50, spawnInterfaceAdapterOptions = {}, fetchInterfaceAdapterOptions = {}) {
-        this.#pluginManager = pluginManager;
-        this.servicePriority = servicePriority;
-        this.#spawnInterfaceAdapterOptions = spawnInterfaceAdapterOptions;
-        this.#fetchInterfaceAdapterOptions = fetchInterfaceAdapterOptions;
-    }
-    async getServiceInfo(_cliConfig) {
-        this.#pluginService = new DefaultPluginService(this.#pluginManager);
-        return {
-            service: this.#pluginService,
-            commands: [new PluginGroupCommand()],
-        };
-    }
-    initService(context) {
-        if (!context.doesServiceExist(SPAWN_SERVICE_ID)) {
-            logger.debug("SpawnService not available, plugin manager will spawn processes directly");
-        }
-        else if (!("setSpawn" in this.#pluginManager)) {
-            logger.debug("Plugin manager does not support SpawnCapable, skipping spawn injection");
-        }
-        else {
-            const spawnService = context.getServiceById(SPAWN_SERVICE_ID);
-            const printerService = context.getServiceById(PRINTER_SERVICE_ID);
-            const adapter = new SpawnInterfaceAdapter(spawnService, printerService, this.#spawnInterfaceAdapterOptions);
-            this.#pluginManager.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);
-            const adapter = new FetchInterfaceAdapter(fetchService, this.#fetchInterfaceAdapterOptions);
-            this.#pluginManager.setFetch(adapter);
-        }
-        return Promise.resolve();
-    }
-}