@fnndsc/chili 3.2.5

package/dist/commands/workflows/fields.js

@@ -0,0 +1,13 @@
+/**
+ * @file Fetches available fields for workflow resources.
+ * @module
+ */
+import { workflowFields_get } from '@fnndsc/salsa';
+/**
+ * Fetches the available workflow field names.
+ *
+ * @returns The workflow field names, or null on failure.
+ */
+export async function workflowFields_fetch() {
+    return await workflowFields_get();
+}

package/dist/commands/workflows/list.d.ts

@@ -0,0 +1,16 @@
+import { CLIoptions } from '../../utils/cli.js';
+/**
+ * Result of listing workflows (table data plus selected fields).
+ */
+export interface WorkflowListResult {
+    workflows: Record<string, unknown>[];
+    selectedFields: string[];
+    totalCount?: number;
+}
+/**
+ * Fetches a list of workflows.
+ *
+ * @param options - List and filter options.
+ * @returns The workflows list result.
+ */
+export declare function workflows_fetchList(options: CLIoptions): Promise<WorkflowListResult>;

package/dist/commands/workflows/list.js

@@ -0,0 +1,26 @@
+/**
+ * @file Implements listing ChRIS workflows.
+ * @module
+ */
+import { workflows_list as salsaWorkflows_list, workflows_listAll as salsaWorkflows_listAll } from '@fnndsc/salsa';
+import { options_toParams } from '../../utils/cli.js';
+import { list_applySort } from '../../utils/sort.js';
+/**
+ * Fetches a list of workflows.
+ *
+ * @param options - List and filter options.
+ * @returns The workflows list result.
+ */
+export async function workflows_fetchList(options) {
+    const params = options_toParams(options);
+    const result = options.all
+        ? await salsaWorkflows_listAll(params)
+        : await salsaWorkflows_list(params);
+    if (result && result.tableData) {
+        let workflows = result.tableData;
+        if (options.sort)
+            workflows = list_applySort(workflows, options.sort, options.reverse);
+        return { workflows, selectedFields: result.selectedFields || [], totalCount: result.totalCount };
+    }
+    return { workflows: [], selectedFields: [] };
+}

package/dist/config/colorConfig.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Interface for color style configuration.
+ */
+export interface ColorStyle {
+    color: string;
+    bold?: boolean;
+    dim?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    inverse?: boolean;
+    strikethrough?: boolean;
+}
+/**
+ * Interface for icon configuration.
+ */
+export interface IconConfig {
+    enabled: boolean;
+    dir: string;
+    file: string;
+    link: string;
+    plugin: string;
+    pipeline: string;
+    vfs: string;
+}
+/**
+ * Interface for the complete color configuration.
+ */
+export interface ColorConfig {
+    icons?: IconConfig;
+    fileTypes: {
+        dir: ColorStyle;
+        file: ColorStyle;
+        link: ColorStyle;
+        plugin: ColorStyle;
+        pipeline: ColorStyle;
+        vfs: ColorStyle;
+    };
+    specialPaths: {
+        [path: string]: ColorStyle;
+    };
+}
+/**
+ * Gets the colorized text for a file system item based on its type.
+ *
+ * @param name - The name of the item.
+ * @param type - The type of the item ('dir', 'file', 'link', 'plugin', 'vfs').
+ * @param fullPath - Optional full path for special path handling.
+ * @returns The colorized name with optional icon prefix.
+ */
+export declare function fileSystemItem_colorize(name: string, type: 'dir' | 'file' | 'link' | 'plugin' | 'pipeline' | 'vfs' | 'job', fullPath?: string): string;
+/**
+ * Gets the color configuration.
+ *
+ * @returns The current color configuration.
+ */
+export declare function colorConfig_get(): ColorConfig;

package/dist/config/colorConfig.js

@@ -0,0 +1,161 @@
+/**
+ * @file Color Configuration Loader
+ *
+ * Loads and manages color scheme configuration for file system types
+ * from the colors.yml configuration file.
+ *
+ * @module
+ */
+import yaml from 'js-yaml';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+let cachedConfig = null;
+/**
+ * Loads the color configuration from colors.yml.
+ *
+ * @returns The parsed color configuration.
+ */
+function colorConfig_load() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    // Use import.meta.url for ESM (chili is built as ESM)
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const configPath = path.resolve(__dirname, '../../config/colors.yml');
+    try {
+        const fileContents = fs.readFileSync(configPath, 'utf8');
+        cachedConfig = yaml.load(fileContents);
+        return cachedConfig;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Warning: Could not load color config: ${msg}`);
+        return {
+            icons: {
+                enabled: true,
+                dir: '\uF07C',
+                file: '\uF15B',
+                link: '\uF0C1',
+                plugin: '\uF013',
+                pipeline: '\uF013',
+                vfs: '\uF0C8'
+            },
+            fileTypes: {
+                dir: { color: 'cyan', bold: true },
+                file: { color: 'white', bold: false },
+                link: { color: 'magenta', bold: false },
+                plugin: { color: 'green', bold: true },
+                pipeline: { color: 'magenta', bold: true },
+                vfs: { color: 'cyanBright', bold: true }
+            },
+            specialPaths: {
+                '/bin': { color: 'cyan', bold: true },
+                '~': { color: 'blue', bold: false }
+            }
+        };
+    }
+}
+/**
+ * Applies color style to text using chalk.
+ *
+ * @param text - The text to colorize.
+ * @param style - The color style configuration.
+ * @returns The colorized text.
+ */
+function colorStyle_apply(text, style) {
+    let styledText = text;
+    // Apply color
+    if (style.color && typeof chalk[style.color] === 'function') {
+        const colorFn = chalk[style.color];
+        styledText = colorFn(styledText);
+    }
+    // Apply modifiers
+    if (style.bold)
+        styledText = chalk.bold(styledText);
+    if (style.dim)
+        styledText = chalk.dim(styledText);
+    if (style.italic)
+        styledText = chalk.italic(styledText);
+    if (style.underline)
+        styledText = chalk.underline(styledText);
+    if (style.inverse)
+        styledText = chalk.inverse(styledText);
+    if (style.strikethrough)
+        styledText = chalk.strikethrough(styledText);
+    return styledText;
+}
+/**
+ * Gets the colorized text for a file system item based on its type.
+ *
+ * @param name - The name of the item.
+ * @param type - The type of the item ('dir', 'file', 'link', 'plugin', 'vfs').
+ * @param fullPath - Optional full path for special path handling.
+ * @returns The colorized name with optional icon prefix.
+ */
+export function fileSystemItem_colorize(name, type, fullPath) {
+    const config = colorConfig_load();
+    let icon = '';
+    if (config.icons && config.icons.enabled) {
+        const iconKey = type in config.icons ? type : 'file';
+        icon = config.icons[iconKey] + ' ';
+    }
+    if (fullPath && config.specialPaths[fullPath]) {
+        const styled = colorStyle_apply(name, config.specialPaths[fullPath]);
+        return icon ? colorStyle_apply(icon, config.specialPaths[fullPath]) + styled : styled;
+    }
+    // Fallback: check if the name itself is a special path key
+    if (config.specialPaths[name]) {
+        const styled = colorStyle_apply(name, config.specialPaths[name]);
+        return icon ? colorStyle_apply(icon, config.specialPaths[name]) + styled : styled;
+    }
+    // Fallback: check if /name is a special path key
+    if (config.specialPaths[`/${name}`]) {
+        const styled = colorStyle_apply(name, config.specialPaths[`/${name}`]);
+        return icon ? colorStyle_apply(icon, config.specialPaths[`/${name}`]) + styled : styled;
+    }
+    // Special handling for plugins with versions: color version part differently
+    if (type === 'plugin' && name.includes('-v')) {
+        const lastVIndex = name.lastIndexOf('-v');
+        const pluginName = name.substring(0, lastVIndex);
+        const version = name.substring(lastVIndex);
+        // Plugin name in bold green, version in dim green
+        const nameStyled = chalk.green.bold(pluginName);
+        const versionStyled = chalk.green.dim(version);
+        const iconStyled = icon ? chalk.green.bold(icon) : '';
+        return iconStyled + nameStyled + versionStyled;
+    }
+    // Special handling for plugins without versions (builtins in /usr/bin): bright green
+    if (type === 'plugin' && !name.includes('-v')) {
+        const styled = chalk.greenBright.bold(name);
+        const iconStyled = icon ? chalk.greenBright.bold(icon) : '';
+        return iconStyled + styled;
+    }
+    // Pipeline: bold magenta
+    if (type === 'pipeline') {
+        const styled = chalk.magenta.bold(name);
+        const iconStyled = icon ? chalk.magenta.bold(icon) : '';
+        return iconStyled + styled;
+    }
+    // Job (proc instance / feed dir): cyan bold like a directory — it IS navigable
+    if (type === 'job') {
+        const styled = chalk.cyan.bold(name);
+        const iconStyled = icon ? chalk.cyan.bold(icon) : '';
+        return iconStyled + styled;
+    }
+    // Apply file type styling
+    const style = config.fileTypes[type] ?? config.fileTypes.file;
+    const styled = colorStyle_apply(name, style);
+    const iconStyled = icon ? colorStyle_apply(icon, style) : '';
+    return iconStyled + styled;
+}
+/**
+ * Gets the color configuration.
+ *
+ * @returns The current color configuration.
+ */
+export function colorConfig_get() {
+    return colorConfig_load();
+}

package/dist/connect/connectHandler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Implements the setup for connection-related CLI commands.
+ *
+ * This module provides the `connectCommand_setup` function which configures
+ * the `connect` and `logout` commands in the main CLI program.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Sets up the 'connect' and 'logout' commands for the CLI program.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export declare function connectCommand_setup(program: Command): void;

package/dist/connect/connectHandler.js

@@ -0,0 +1,48 @@
+import { connect_login } from "../commands/connect/login.js";
+import { connect_logout } from "../commands/connect/logout.js";
+import { login_render, logout_render } from "../views/connect.js";
+import chalk from "chalk";
+/**
+ * Sets up the 'connect' and 'logout' commands for the CLI program.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export function connectCommand_setup(program) {
+    program
+        .command("connect <url>")
+        .description("Connect to a ChRIS CUBE instance")
+        .option("-u, --user <user>", "username")
+        .option("-p, --password <password>", "password")
+        .action(async (url, options) => {
+        const user = options.user || 'unknown';
+        const connectOptions = {
+            url,
+            user: options.user || '',
+            password: options.password || '',
+            debug: false,
+        };
+        try {
+            const success = await connect_login(connectOptions);
+            console.log(login_render(success, url, user));
+        }
+        catch (error) {
+            console.log(login_render(false, url, user));
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`Error: ${msg}`));
+        }
+    });
+    program
+        .command("logout")
+        .description("Log out from ChRIS")
+        .action(async () => {
+        try {
+            await connect_logout();
+            console.log(logout_render(true));
+        }
+        catch (error) {
+            console.log(logout_render(false));
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`Error: ${msg}`));
+        }
+    });
+}

package/dist/context/contextCommand.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file Commander setup for the `context` command group.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Sets up the 'context' command for the CLI program, allowing users to
+ * get and set various ChRIS context parameters.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export declare function contextCommand_setup(program: Command): Promise<void>;

package/dist/context/contextCommand.js

@@ -0,0 +1,193 @@
+/**
+ * @file Commander setup for the `context` command group.
+ *
+ * @module
+ */
+import { errorStack, } from "@fnndsc/cumin";
+import { context_getFull, context_getSingle, context_set as salsa_context_set } from "@fnndsc/salsa";
+import chalk from "chalk";
+// import Table from "cli-table3";
+import { screen, border_draw, table_display } from "../screen/screen.js";
+/**
+ * Retrieves and formats ChRIS context information based on CLI options.
+ *
+ * @param options - CLI options for context retrieval.
+ * @returns A formatted string of context information.
+ */
+async function context_get(options) {
+    const results = [];
+    if (options.all) {
+        return context_displayFull(options);
+    }
+    else {
+        return context_displaySingle(options);
+    }
+}
+/**
+ * Retrieves and displays the full ChRIS context, including all users and their URLs.
+ *
+ * @param options - CLI options (currently only `all` is used to trigger this function).
+ * @returns An empty string, as output is directly to console via `displayTable`.
+ */
+function context_displayFull(options) {
+    const fullContext = context_getFull();
+    const currentUser = fullContext.currentUser;
+    const currentURL = fullContext.currentURL;
+    Object.entries(fullContext.users).forEach(([user, userContext]) => {
+        const tableData = Object.entries(userContext.urls).map(([url, urlContext]) => ({
+            URL: url,
+            Folder: urlContext.folder || "Not set",
+            Feed: urlContext.feed || "Not set",
+            Plugin: urlContext.plugin || "Not set",
+            PACS: urlContext.pacsserver || "Not set",
+            Token: urlContext.token ? "Set" : "Not set",
+        }));
+        // Apply highlighting
+        tableData.forEach((row) => {
+            if (row.URL === currentURL && user === currentUser) {
+                Object.keys(row).forEach((key) => {
+                    row[key] = chalk.cyan(row[key]);
+                });
+            }
+        });
+        table_display(tableData, ["URL", "Folder", "Feed", "Plugin", "PACS", "Token"], {
+            title: {
+                title: `User: ${user}`,
+                justification: "center",
+            },
+        });
+    });
+    return "";
+}
+/**
+ * Retrieves and displays a single ChRIS context (current context).
+ *
+ * @param options - CLI options for context retrieval (e.g., --full, --ChRISurl).
+ * @returns A formatted string of context information, or an empty string if output handled by `screen.table_output`.
+ */
+async function context_displaySingle(options) {
+    const singleContext = await context_getSingle();
+    if (options.full) {
+        const tableData = [
+            {
+                Context: "ChRIS URL",
+                Value: singleContext.URL || "Not set",
+            },
+            {
+                Context: "ChRIS User",
+                Value: singleContext.user || "Not set",
+            },
+            {
+                Context: "ChRIS Folder",
+                Value: singleContext.folder || "Not set",
+            },
+            {
+                Context: "ChRIS Feed",
+                Value: singleContext.feed || "Not set",
+            },
+            {
+                Context: "ChRIS Plugin",
+                Value: singleContext.plugin || "Not set",
+            },
+            {
+                Context: "PACS Server",
+                Value: singleContext.pacsserver || "Not set",
+            },
+        ];
+        console.log(screen.table_output(tableData, {
+            head: ["Context", "Value"],
+            columns: [
+                { color: "yellow", justification: "right" },
+                { color: "cyan", justification: "left" },
+            ],
+            title: {
+                title: "ChRIS Context",
+                justification: "center",
+            },
+        }));
+        return ""; // screen.table directly outputs to console, so we return an empty string
+    }
+    else {
+        const results = [];
+        if (options.ChRISurl) {
+            results.push(`ChRIS URL: ${singleContext.URL || "Not set"}`);
+        }
+        if (options.ChRISuser) {
+            results.push(`ChRIS User: ${singleContext.user || "Not set"}`);
+        }
+        if (options.ChRISfolder) {
+            results.push(`ChRIS Folder: ${singleContext.folder || "Not set"}`);
+        }
+        if (options.ChRISfeed) {
+            results.push(`ChRIS Feed: ${singleContext.feed || "Not set"}`);
+        }
+        if (options.ChRISplugin) {
+            results.push(`ChRIS Plugin: ${singleContext.plugin || "Not set"}`);
+        }
+        if (options.pacsserver) {
+            results.push(`PACS Server: ${singleContext.pacsserver || "Not set"}`);
+        }
+        if (results.length === 0) {
+            results.push("No specific context requested. Use --ChRISurl, --ChRISuser, --ChRISfolder, --ChRISfeed, --pacsserver, or --full");
+        }
+        return results.join("\n");
+    }
+}
+/**
+ * Sets various ChRIS context parameters based on CLI options.
+ *
+ * @param options - CLI options for setting context.
+ * @returns A formatted string summarizing the context changes.
+ */
+async function context_set(options) {
+    const result = await salsa_context_set(options);
+    if (!result.ok) {
+        const errors = errorStack.allOfType_get('error');
+        border_draw(chalk.red(`ERROR: ${errors.join('\n')}`));
+        return "";
+    }
+    if (result.value.length === 0) {
+        return "No context value was set. Use --ChRISurl, --ChRISuser, --ChRISFolder, --ChRISfeed, or --ChRISPlugin";
+    }
+    return result.value.join("\n");
+}
+/**
+ * Sets up the 'context' command for the CLI program, allowing users to
+ * get and set various ChRIS context parameters.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export async function contextCommand_setup(program) {
+    const contextCommand = program
+        .command("context")
+        .description("Manipulate the ChRIS context");
+    contextCommand
+        .command("get")
+        .description("get information about the current context")
+        .option("--ChRISurl", "get the ChRIS URL for this context")
+        .option("--ChRISuser", "get the ChRIS user for this context")
+        .option("--ChRISfolder", "get the current ChRIS Folder context")
+        .option("--ChRISfeed", "get the current ChRIS Feed context")
+        .option("--ChRISplugin", "get the current ChRIS Plugin (or instance) context")
+        .option("--pacsserver", "get the current PACS server context")
+        .option("--full", "get full current context")
+        .option("--all", "get all contexts for current session")
+        .action(async (options) => {
+        const result = await context_get(options);
+        console.log(result);
+    });
+    contextCommand
+        .command("set")
+        .description("set values for the ChRIS context")
+        .option("--ChRISurl <url>", "set the ChRIS URL for this context")
+        .option("--ChRISuser <user>", "set the ChRIS user for this context")
+        .option("--ChRISfolder <folder>", "set the current ChRIS Folder context")
+        .option("--ChRISfeed <feedID>", "set the current ChRIS Feed context")
+        .option("--ChRISplugin <pluginID>", "set the current ChRIS Plugin (or instance) context")
+        .option("--pacsserver <pacsserver>", "set the current PACS server context")
+        .action(async (options) => {
+        const result = await context_set(options);
+        if (result.length)
+            border_draw(result);
+    });
+}

package/dist/controllers/baseController.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Base controller: shared resource listing and presentation logic.
+ *
+ * @module
+ */
+import { FilteredResourceData, ChRISPluginGroup, ChRISFeedGroup, ChRISEmbeddedResourceGroup, ResourcesByFields } from "@fnndsc/cumin";
+import { CLIoptions } from "../utils/cli.js";
+/**
+ * Base controller for managing ChRIS resources.
+ * Encapsulates business logic for fetching, filtering, and deleting resources.
+ * UI-agnostic.
+ */
+export declare class BaseController {
+    chrisObject: ChRISPluginGroup | ChRISFeedGroup | ChRISEmbeddedResourceGroup<unknown>;
+    constructor(chrisObject: ChRISPluginGroup | ChRISFeedGroup | ChRISEmbeddedResourceGroup<unknown>);
+    /**
+     * Fetches and filters resources based on provided options.
+     *
+     * @param options - CLI options for filtering and pagination.
+     * @returns A Promise resolving to FilteredResourceData or null if no resources found.
+     */
+    resources_get(options: CLIoptions): Promise<FilteredResourceData | null>;
+    /**
+     * Fetches the available fields for the resource type.
+     *
+     * @returns A Promise resolving to ResourcesByFields or null.
+     */
+    resourceFields_get(): Promise<ResourcesByFields | null>;
+    /**
+     * Deletes a resource by its ID.
+     *
+     * @param id - The ID of the resource to delete.
+     * @returns A Promise resolving to true if successful, false otherwise.
+     */
+    resource_delete(id: number): Promise<boolean>;
+    /**
+     * Resolves search terms to a list of resource IDs.
+     *
+     * @param options - CLI options containing search terms.
+     * @returns A Promise resolving to an array of IDs or null.
+     */
+    resourceIDs_resolve(options: CLIoptions): Promise<number[] | null>;
+}

package/dist/controllers/baseController.js

@@ -0,0 +1,67 @@
+/**
+ * @file Base controller: shared resource listing and presentation logic.
+ *
+ * @module
+ */
+import { record_extract, listParams_fromOptions } from "@fnndsc/cumin";
+/**
+ * Base controller for managing ChRIS resources.
+ * Encapsulates business logic for fetching, filtering, and deleting resources.
+ * UI-agnostic.
+ */
+export class BaseController {
+    constructor(chrisObject) {
+        this.chrisObject = chrisObject;
+    }
+    /**
+     * Fetches and filters resources based on provided options.
+     *
+     * @param options - CLI options for filtering and pagination.
+     * @returns A Promise resolving to FilteredResourceData or null if no resources found.
+     */
+    async resources_get(options) {
+        try {
+            const params = listParams_fromOptions(options);
+            const results = await this.chrisObject.asset.resources_listAndFilterByOptions(params);
+            return results;
+        }
+        catch (error) {
+            // Error handling is delegated to the caller or logged to errorStack
+            // For now, we let the errorStack mechanisms in cumin handle internal logging
+            // but we might want to bubble up specific errors.
+            return null;
+        }
+    }
+    /**
+     * Fetches the available fields for the resource type.
+     *
+     * @returns A Promise resolving to ResourcesByFields or null.
+     */
+    async resourceFields_get() {
+        return await this.chrisObject.asset.resourceFields_get();
+    }
+    /**
+     * Deletes a resource by its ID.
+     *
+     * @param id - The ID of the resource to delete.
+     * @returns A Promise resolving to true if successful, false otherwise.
+     */
+    async resource_delete(id) {
+        return await this.chrisObject.asset.resourceItem_delete(id);
+    }
+    /**
+     * Resolves search terms to a list of resource IDs.
+     *
+     * @param options - CLI options containing search terms.
+     * @returns A Promise resolving to an array of IDs or null.
+     */
+    async resourceIDs_resolve(options) {
+        const params = listParams_fromOptions(options);
+        const searchResults = await this.chrisObject.asset.resources_listAndFilterByOptions(params);
+        if (!searchResults) {
+            return null;
+        }
+        const queryHits = record_extract(searchResults.tableData, "id");
+        return queryHits.hits;
+    }
+}