@fnndsc/chili 3.2.5

package/dist/plugins/pluginGroupHandler.js

@@ -0,0 +1,90 @@
+/**
+ * @file Handler for the plugin context command group.
+ *
+ * @module
+ */
+import { BaseGroupHandler } from "../handlers/baseGroupHandler.js";
+import { options_toParams } from "../utils/cli.js";
+import { PluginContextController } from "../controllers/pluginContextController.js";
+import { pluginParameters_renderMan } from "../views/pluginParameters.js";
+class InitializationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InitializationError";
+    }
+}
+/**
+ * Handles commands related to groups of plugin contexts (computes, instances, parameters).
+ */
+export class PluginContextGroupHandler {
+    constructor(controller, assetName) {
+        this.baseGroupHandler = null;
+        this.controller = controller;
+        this.assetName = assetName;
+        // Cast ChRISEmbeddedResourceGroup to ChRISEmbeddedResourceGroup<unknown> safely.
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+    }
+    /**
+     * Factory method to create a new PluginContextGroupHandler instance.
+     *
+     * @param assetName - The type of plugin context to handle ('computesofplugin', 'instancesofplugin', 'parametersofplugin').
+     * @param id - Optional plugin ID. Defaults to current ChRIS plugin context.
+     * @returns A Promise resolving to a new PluginContextGroupHandler instance.
+     * @throws InitializationError if an unsupported asset type is provided.
+     */
+    static async handler_create(assetName, id) {
+        try {
+            const controller = await PluginContextController.controller_create(assetName, id);
+            return new PluginContextGroupHandler(controller, assetName);
+        }
+        catch (error) {
+            throw new InitializationError(`Failed to initialize PluginContextGroupHandler: ${error}`);
+        }
+    }
+    /**
+     * Lists plugin parameters in a "man page" style format.
+     * This is a specialized view for parameters that differs from the standard table view.
+     *
+     * @param options - CLI options for filtering.
+     */
+    async parameters_listMan(options) {
+        try {
+            // We access the asset directly from the controller
+            const asset = this.controller.chrisObject.asset;
+            if (!asset || typeof asset.resources_listAndFilterByOptions !== 'function') {
+                console.error("Underlying resource does not support listing.");
+                return;
+            }
+            const params = options_toParams(options);
+            const results = await asset.resources_listAndFilterByOptions(params);
+            if (results) {
+                pluginParameters_renderMan(results);
+            }
+            else {
+                console.log("No parameters found.");
+            }
+        }
+        catch (error) {
+            console.error(`Error listing parameters: ${error}`);
+        }
+    }
+    /**
+     * Lists available fields for the current plugin context resource.
+     */
+    async parameters_fieldsList() {
+        if (this.baseGroupHandler) {
+            await this.baseGroupHandler.resourceFields_list();
+        }
+    }
+    /**
+     * Sets up the Commander.js commands for plugin context group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginContextGroupCommand_setup(program) {
+        if (this.baseGroupHandler) {
+            this.baseGroupHandler.command_setup(program);
+        }
+        const fileGroupCommand = program.commands.find((cmd) => cmd.name() === this.assetName);
+    }
+}

package/dist/plugins/pluginHandler.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @file Manages command groups and member operations for ChRIS plugins.
+ *
+ * This module defines the `PluginGroupHandler` and `PluginMemberHandler` classes,
+ * which orchestrate CLI commands for lists of plugins and individual plugin operations.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { CLIoptions } from "../utils/cli.js";
+/**
+ * Handles commands related to groups of ChRIS plugins.
+ */
+export declare class PluginGroupHandler {
+    private baseGroupHandler;
+    private controller;
+    assetName: string;
+    constructor();
+    /**
+     * Displays an overview of the plugin system.
+     */
+    plugins_overview(): Promise<void>;
+    /**
+     * Lists plugin fields using the new command logic.
+     */
+    plugins_fields(): Promise<void>;
+    /**
+     * Deletes plugins using the new command logic.
+     * Supports batch deletion using ++ separator.
+     */
+    plugins_delete(searchable: string, options: CLIoptions): Promise<void>;
+    /**
+     * Adds a new plugin to ChRIS.
+     * @param image - The Docker image of the plugin.
+     * @param options - CLI options including public_repo and compute environments.
+     */
+    plugins_add(image: string, options: CLIoptions): Promise<void>;
+    /**
+     * Sets up the Commander.js commands for plugin group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginGroupCommand_setup(program: Command): void;
+}
+/**
+ * Handles commands related to individual ChRIS plugins.
+ */
+export declare class PluginMemberHandler {
+    private assetName;
+    private controller;
+    constructor();
+    /**
+     * Prints the content of a README file from a given repository URL.
+     * Attempts to fetch README.md or README.rst from 'master' or 'main' branches.
+     *
+     * @param repoUrl - The base URL of the plugin repository.
+     */
+    readme_print(repoUrl: string): Promise<void>;
+    /**
+     * Retrieves and displays the README for a specific plugin.
+     *
+     * @param pluginId - The ID of the plugin.
+     * @returns A Promise resolving to the documentation URL or null.
+     */
+    plugin_readme(pluginId: string): Promise<string | null>;
+    /**
+     * Retrieves a plugin ID based on search options.
+     *
+     * @param options - CLI options for searching for a plugin.
+     * @returns A Promise resolving to the plugin ID as a string, or null if not found.
+     */
+    pluginID_fromSearch(options: CLIoptions): Promise<string | null>;
+    /**
+     * Runs a plugin instance.
+     */
+    plugin_run(searchable: string, params: string): Promise<number | null>;
+    /**
+     * Resolves a search term to plugin IDs.
+     */
+    plugin_searchableToIDs(searchable: string): Promise<string[] | null>;
+    /**
+     * Sets up the Commander.js commands for individual plugin operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginCommand_setup(program: Command): void;
+}

package/dist/plugins/pluginHandler.js

@@ -0,0 +1,303 @@
+import { BaseGroupHandler } from "../handlers/baseGroupHandler.js";
+import { table_display } from "../screen/screen.js";
+import { PluginController } from "../controllers/pluginController.js";
+import { Context, chrisContext, errorStack, errorStack_getAllOfType, Searchable } from "@fnndsc/cumin";
+// import { plugins_fetchList, PluginListResult } from "../commands/plugins/list.js"; // No longer needed
+import { pluginFields_fetch } from "../commands/plugins/fields.js";
+import { plugins_searchByTerm, plugin_deleteById } from "../commands/plugins/delete.js";
+import { prompt_confirm } from "../utils/ui.js";
+import { plugin_add } from "../commands/plugins/add.js";
+import { pluginsOverview_display } from "../commands/plugins/overview.js";
+import { plugin_execute } from "../commands/plugin/run.js";
+import { pluginIds_resolve } from "../commands/plugin/search.js";
+import { pluginRun_render } from "../views/plugin.js"; // Still needed for pluginRun_render
+import chalk from "chalk";
+import { pluginReadme_render } from "../commands/plugin/readme.js";
+/**
+ * Handles commands related to groups of ChRIS plugins.
+ */
+export class PluginGroupHandler {
+    constructor() {
+        this.assetName = "plugins";
+        this.controller = PluginController.controller_create();
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+    }
+    /**
+     * Displays an overview of the plugin system.
+     */
+    async plugins_overview() {
+        await pluginsOverview_display();
+    }
+    // /**
+    //  * Lists plugins using the new command logic.
+    //  */
+    // async plugins_list(options: CLIoptions): Promise<void> {
+    //   try {
+    //     const { plugins, selectedFields } = await plugins_fetchList(options);
+    //     console.log(pluginList_render(plugins, selectedFields, { table: options.table, csv: options.csv }));
+    //   } catch (error: unknown) {
+    //     const msg = error instanceof Error ? error.message : String(error);
+    //     console.error(msg);
+    //   }
+    // }
+    /**
+     * Lists plugin fields using the new command logic.
+     */
+    async plugins_fields() {
+        try {
+            const fields = await pluginFields_fetch();
+            if (fields && fields.length > 0) {
+                table_display(fields, ["fields"]);
+            }
+            else {
+                console.log(`No resource fields found for ${this.assetName}.`);
+            }
+        }
+        catch (error) {
+            console.log(errorStack.stack_search(this.assetName)[0]);
+        }
+    }
+    /**
+     * Deletes plugins using the new command logic.
+     * Supports batch deletion using ++ separator.
+     */
+    async plugins_delete(searchable, options) {
+        const searchableObj = Searchable.from(searchable);
+        const searchables = searchableObj.toBatchSearchables();
+        for (const search of searchables) {
+            const items = await plugins_searchByTerm(search.raw);
+            if (items.length === 0) {
+                console.log(`No plugins found matching: ${search.raw}`);
+                continue;
+            }
+            for (const item of items) {
+                // Show item info - reusing table_display for single item details if possible, or simple log
+                console.log(`Preparing to delete Plugin: ID=${item.id}, Name=${item.name}, Version=${item.version}`);
+                if (!options.force) {
+                    const confirmed = await prompt_confirm(`Are you sure you want to delete plugin ${item.name} (ID: ${item.id})?`);
+                    if (!confirmed)
+                        continue;
+                }
+                const success = await plugin_deleteById(item.id);
+                if (success) {
+                    console.log(`Deleted plugin ${item.id}`);
+                }
+                else {
+                    console.error(`Failed to delete plugin ${item.id}`);
+                }
+            }
+        }
+    }
+    /**
+     * Adds a new plugin to ChRIS.
+     * @param image - The Docker image of the plugin.
+     * @param options - CLI options including public_repo and compute environments.
+     */
+    async plugins_add(image, options) {
+        await plugin_add(image, options);
+    }
+    /**
+     * Sets up the Commander.js commands for plugin group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginGroupCommand_setup(program) {
+        // Manually set up commands to use new logic for list, but keep base for others
+        const pluginsCommand = program
+            .command(this.assetName)
+            .description(`Interact with a group of ChRIS ${this.assetName}`);
+        // Use base list command generator and add plugin-specific options
+        const listCommand = this.baseGroupHandler.baseListCommand_create(async (options) => {
+            await this.baseGroupHandler.resources_list(options);
+        });
+        listCommand.option("-a, --all", "List all plugins (disable pagination)");
+        pluginsCommand.addCommand(listCommand);
+        pluginsCommand
+            .command("fieldslist")
+            .description(`list the ${this.assetName} resource fields`)
+            .action(async () => {
+            await this.plugins_fields();
+        });
+        pluginsCommand
+            .command("delete <searchable>")
+            .description(`delete target ${this.assetName} resolved from '++' separated <searchable>, i.e. "id:77++id:33"`)
+            .option("-f, --force", `force the deletion without prompting for user confirmation`)
+            .action(async (searchable, options) => {
+            await this.plugins_delete(searchable, options);
+        });
+        pluginsCommand
+            .command("overview")
+            .description("Get an overview of various plugin-group operations")
+            .action(async (pluginId, options) => {
+            await this.plugins_overview();
+        });
+        pluginsCommand
+            .command("add <image>")
+            .description("Add a new plugin to ChRIS from a Docker image")
+            .option("-r, --public_repo <url>", "Public repository URL of the plugin (e.g., https://github.com/FNNDSC/pl-dcm2niix)")
+            .option("-c, --compute <names>", "Comma-separated list of compute resource names to assign the plugin to")
+            .option("--store <url>", "URL of the peer store to search/import from")
+            .option("--adminUser <username>", "Admin username for registration")
+            .option("--adminPassword <password>", "Admin password for registration")
+            .action(async (image, options) => {
+            await this.plugins_add(image, options);
+        });
+    }
+}
+/**
+ * Handles commands related to individual ChRIS plugins.
+ */
+export class PluginMemberHandler {
+    constructor() {
+        this.assetName = "plugin";
+        this.controller = PluginController.controller_create();
+    }
+    /**
+     * Prints the content of a README file from a given repository URL.
+     * Attempts to fetch README.md or README.rst from 'master' or 'main' branches.
+     *
+     * @param repoUrl - The base URL of the plugin repository.
+     */
+    async readme_print(repoUrl) {
+        const content = await this.controller.readmeContent_fetch(repoUrl);
+        if (content) {
+            console.log(chalk.green.bold("\nREADME Content:"));
+            console.log(pluginReadme_render(content));
+        }
+        else {
+            console.log(chalk.red("README not found in the repository."));
+        }
+    }
+    /**
+     * Retrieves and displays the README for a specific plugin.
+     *
+     * @param pluginId - The ID of the plugin.
+     * @returns A Promise resolving to the documentation URL or null.
+     */
+    async plugin_readme(pluginId) {
+        try {
+            console.log(`Fetching info for plugin with ID: ${pluginId}`);
+            const documentation = await this.controller.documentationUrl_get(pluginId);
+            if (!documentation) {
+                return null;
+            }
+            console.log(documentation);
+            await this.readme_print(documentation);
+            return documentation;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Error fetching plugin info: ${error.message}`);
+            }
+            else {
+                console.error("An unknown error occurred while fetching plugin info");
+            }
+        }
+        return null;
+    }
+    /**
+     * Retrieves a plugin ID based on search options.
+     *
+     * @param options - CLI options for searching for a plugin.
+     * @returns A Promise resolving to the plugin ID as a string, or null if not found.
+     */
+    async pluginID_fromSearch(options) {
+        const pluginId = await this.controller.pluginID_fromSearch(options);
+        // Warning logic could be here if controller returns array, but controller returns single ID or null.
+        // Assuming single hit for simplicity based on previous refactor
+        return pluginId;
+    }
+    /**
+     * Runs a plugin instance.
+     */
+    async plugin_run(searchable, params) {
+        try {
+            const instance = await plugin_execute(searchable, params);
+            if (!instance) {
+                console.log(errorStack.messagesOfType_search("error", "plugin"));
+                return null;
+            }
+            console.log(pluginRun_render(instance));
+            return instance.id;
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            console.error(message);
+            return null;
+        }
+    }
+    /**
+     * Resolves a search term to plugin IDs.
+     */
+    async plugin_searchableToIDs(searchable) {
+        const hits = await pluginIds_resolve(searchable);
+        if (!hits) {
+            return null;
+        }
+        console.log(hits);
+        return hits;
+    }
+    /**
+     * Sets up the Commander.js commands for individual plugin operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginCommand_setup(program) {
+        const pluginCommand = program
+            .command(this.assetName)
+            .description(`Interact with a single ChRIS ${this.assetName}`);
+        if (pluginCommand) {
+            pluginCommand
+                .command("readme [pluginId]")
+                .description("Get the readme of a specific plugin")
+                .option("--search <searchString>", "Search for a plugin using a comma-separated key-value pair")
+                .action(async (pluginId, options) => {
+                let targetId;
+                if (pluginId === undefined) {
+                    if (options.search === undefined) {
+                        targetId = await chrisContext.current_get(Context.ChRISplugin); // Await and RPN change
+                    }
+                    else {
+                        targetId = await this.pluginID_fromSearch(options);
+                    }
+                }
+                else {
+                    targetId = pluginId;
+                }
+                if (targetId) {
+                    await this.plugin_readme(targetId);
+                }
+                else {
+                    const warnings = errorStack_getAllOfType('warning');
+                    if (warnings && warnings.length > 0) {
+                        warnings.forEach(warning => console.error(chalk.yellow(warning)));
+                    }
+                    else {
+                        console.error(chalk.red("Plugin not found."));
+                    }
+                }
+            });
+            pluginCommand
+                .command("run <searchable...>")
+                .description("Run a plugin in a given context")
+                .allowUnknownOption(true)
+                .action(async (args, command) => {
+                const searchable = args[0];
+                let pluginParams = "";
+                if (args.length > 0) {
+                    pluginParams = args.slice(1).join(" "); // Join with space
+                }
+                await this.plugin_run(searchable, pluginParams);
+            });
+            pluginCommand
+                .command("search <searchable>")
+                .description("Resolve a plugin searchable into an ID")
+                .action((searchable) => {
+                this.plugin_searchableToIDs(searchable);
+            });
+        }
+        else {
+            console.error(`Failed to find '${this.assetName}' command. The 'readme' subcommand was not added.`);
+        }
+    }
+}

package/dist/plugins/pluginMetaHandler.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Handler for the plugin-meta command group.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Handles commands related to groups of plugin metadata.
+ */
+export declare class PluginMetaGroupHandler {
+    private baseGroupHandler;
+    private controller;
+    assetName: string;
+    constructor();
+    /**
+     * Sets up the Commander.js commands for plugin metadata group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginMetaGroupCommand_setup(program: Command): void;
+}

package/dist/plugins/pluginMetaHandler.js

@@ -0,0 +1,27 @@
+/**
+ * @file Handler for the plugin-meta command group.
+ *
+ * @module
+ */
+import { BaseGroupHandler } from "../handlers/baseGroupHandler.js";
+import { PluginMetaController } from "../controllers/pluginMetaController.js";
+/**
+ * Handles commands related to groups of plugin metadata.
+ */
+export class PluginMetaGroupHandler {
+    constructor() {
+        this.assetName = "pluginMetas";
+        this.controller = PluginMetaController.controller_create();
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+    }
+    /**
+     * Sets up the Commander.js commands for plugin metadata group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    pluginMetaGroupCommand_setup(program) {
+        this.baseGroupHandler.command_setup(program);
+        // The 'readme' command has been moved to pluginHandler.ts for consolidation.
+        // This handler can be extended with other plugin metadata specific commands in the future.
+    }
+}