@fnndsc/chili 3.2.5

package/dist/feeds/feedHandler.js

@@ -0,0 +1,203 @@
+import { BaseGroupHandler } from "../handlers/baseGroupHandler.js";
+import { errorStack } from "@fnndsc/cumin"; // Import errorStack
+import { table_display } from "../screen/screen.js";
+import { FeedController } from "../controllers/feedController.js";
+import chalk from "chalk";
+import { feedFields_fetch } from "../commands/feeds/fields.js";
+import { feed_shareById } from "../commands/feeds/share.js";
+import { feeds_searchByTerm, feed_deleteById } from "../commands/feeds/delete.js";
+import { prompt_confirm } from "../utils/ui.js";
+import { feed_create as feed_create_command } from "../commands/feed/create.js"; // Original name
+import { feedCreate_render } from "../views/feed.js"; // Still needed for feedCreate_render
+// import { FeedListResult } from "../commands/feeds/list.js"; // No longer needed
+/**
+ * Handles commands related to groups of ChRIS feeds.
+ */
+export class FeedGroupHandler {
+    constructor() {
+        this.assetName = "feeds";
+        this.controller = FeedController.controller_create();
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+    }
+    // /**
+    //  * Lists feeds using the new command logic.
+    //  */
+    // async feeds_list(options: CLIoptions): Promise<void> {
+    //   try {
+    //     const { feeds, selectedFields }: FeedListResult = await feeds_fetchList(options);
+    //     console.log(feedList_render(feeds, selectedFields, { table: options.table, csv: options.csv }));
+    //   } catch (error: unknown) {
+    //     const msg = error instanceof Error ? error.message : String(error);
+    //     console.error(chalk.red(`Error listing feeds: ${msg}`));
+    //   }
+    // }
+    /**
+     * Lists feed fields using the new command logic.
+     */
+    async feeds_fields() {
+        try {
+            const fields = await feedFields_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]);
+        }
+    }
+    /**
+     * Shares feeds matching a search term.
+     *
+     * @param searchable - The search term to find feeds.
+     * @param options - Sharing options (e.g. is_public).
+     */
+    async feeds_share(searchable, options) {
+        const searchParts = searchable.split("++").map((part) => part.trim());
+        for (const searchPart of searchParts) {
+            const feedIds = await this.baseGroupHandler.IDs_getFromSearch({ search: searchPart });
+            if (!feedIds || feedIds.length === 0) {
+                console.log(`No feeds found matching: ${searchPart}`);
+                continue;
+            }
+            for (const feedId of feedIds) {
+                console.log(`Sharing feed ID: ${feedId}...`);
+                const shareOptions = { is_public: options.is_public === true };
+                const success = await feed_shareById(Number(feedId), shareOptions);
+                if (success) {
+                    console.log(`Feed ID ${feedId} shared successfully.`);
+                }
+                else {
+                    console.error(`Failed to share feed ID ${feedId}.`);
+                }
+            }
+        }
+    }
+    /**
+     * Deletes feeds using the new command logic.
+     * @param searchable - A string resolving to feed IDs.
+     * @param options - CLI options, including --force.
+     */
+    async feeds_delete(searchable, options) {
+        const searchParts = searchable.split("++").map((part) => part.trim());
+        for (const searchPart of searchParts) {
+            const items = await feeds_searchByTerm(searchPart);
+            if (items.length === 0) {
+                console.log(`No feeds found matching: ${searchPart}`);
+                continue;
+            }
+            for (const item of items) {
+                console.log(`Preparing to delete Feed: ID=${item.id}, Name=${item.name}`);
+                if (!options.force) {
+                    const confirmed = await prompt_confirm(`Are you sure you want to delete feed ${item.name} (ID: ${item.id})?`);
+                    if (!confirmed)
+                        continue;
+                }
+                const id = typeof item.id === "number" ? item.id : Number(item.id);
+                const success = await feed_deleteById(id);
+                if (success) {
+                    console.log(`Deleted feed ${item.id}`);
+                }
+                else {
+                    console.error(`Failed to delete feed ${item.id}`);
+                }
+            }
+        }
+    }
+    /**
+     * Sets up the Commander.js commands for feed group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    feedGroupCommand_setup(program) {
+        const feedGroupCommand = program
+            .command(this.assetName)
+            .description(`Interact with a group of ChRIS ${this.assetName}`);
+        const listCommand = this.baseGroupHandler.baseListCommand_create(async (options) => {
+            await this.baseGroupHandler.resources_list(options);
+        });
+        feedGroupCommand.addCommand(listCommand);
+        feedGroupCommand
+            .command("fieldslist")
+            .description(`list the ${this.assetName} resource fields`)
+            .action(async () => {
+            await this.feeds_fields();
+        });
+        feedGroupCommand
+            .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.feeds_delete(searchable, options);
+        });
+        feedGroupCommand
+            .command("share <searchable>")
+            .description("share a (group of) feed(s)")
+            .option("-i, --is_public", "Make the feed public or unpublic (default: public)")
+            .option("-f, --force", "force operation (do not ask for user confirmation)")
+            .action(async (searchable, options) => {
+            await this.feeds_share(searchable, options);
+        });
+    }
+}
+/**
+ * Handles commands related to individual ChRIS feeds.
+ */
+export class FeedMemberHandler {
+    constructor() {
+        this.assetName = "feed";
+        this.controller = FeedController.controller_create();
+    }
+    /**
+     * Creates a new ChRIS feed based on CLI options.
+     *
+     * @param options - CLI options for feed creation.
+     * @returns A Promise resolving to the created Feed object, or null on failure.
+     */
+    async feed_create(options) {
+        try {
+            const feed = await feed_create_command(options);
+            if (feed) {
+                console.log(feedCreate_render(feed));
+                return feed;
+            }
+            console.error(chalk.red("Feed creation returned null result."));
+            const errors = errorStack.allOfType_get('error'); // Keep error reporting
+            if (errors.length > 0) {
+                console.error(chalk.red('Errors:'));
+                errors.forEach(e => console.error(chalk.red(`  - ${e}`)));
+            }
+            return null;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`Error: ${message}`));
+            return null;
+        }
+    }
+    /**
+     * Sets up the Commander.js commands for individual feed operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    feedCommand_setup(program) {
+        const feedCommand = program
+            .command(this.assetName)
+            .description(`Interact with a single ChRIS ${this.assetName}`);
+        if (feedCommand) {
+            feedCommand
+                .command("create")
+                .description("Create a new feed")
+                .option("-p, --params <FeedParams>", "comma separated list of feed parameters ('title', 'cpu_limit', etc.)")
+                .option("-d, --dirs <ChRISpath>", "a (comma separated) path inside the ChRIS FS containing data for the root node")
+                .action(async (options) => {
+                await this.feed_create(options);
+            });
+        }
+        else {
+            console.error(`Failed to find '${this.assetName}' command. The 'new' subcommand was not added.`);
+        }
+    }
+}

package/dist/filesystem/fileGroupHandler.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @file Manages command groups and member operations for ChRIS files.
+ *
+ * This module defines the `FileGroupHandler` and `FileMemberHandler` classes,
+ * which orchestrate CLI commands for lists of files and individual file operations.
+ * It integrates various command modules to provide a cohesive interface.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { CLIoptions } from "../utils/cli.js";
+/**
+ * Handles commands related to groups of ChRIS files, links, or directories.
+ */
+export declare class FileGroupHandler {
+    private baseGroupHandler;
+    private controller;
+    readonly assetName: string;
+    private constructor();
+    /**
+     * Factory method to create a new FileGroupHandler instance.
+     *
+     * @param assetName - The type of asset to handle ('files', 'links', 'dirs').
+     * @param path - Optional path within ChRIS FS. Defaults to current ChRIS folder context.
+     * @returns A Promise resolving to a new FileGroupHandler instance.
+     */
+    static handler_create(assetName: string, path?: string): Promise<FileGroupHandler>;
+    /**
+     * Removes duplicate column headers from FilteredResourceData results.
+     * Copied from BaseGroupHandler to support local listing logic.
+     */
+    private columns_removeDuplicates;
+    /**
+     * Lists files, links, or directories using the new command logic.
+     */
+    files_list(options: CLIoptions, path?: string): Promise<void>;
+    /**
+     * Lists file fields using the new command logic.
+     */
+    files_fields(): Promise<void>;
+    /**
+     * Deletes files using the new command logic.
+     */
+    files_delete(searchable: string, options: CLIoptions): Promise<void>;
+    /**
+     * Handles sharing of ChRIS files.
+     *
+     * @param options - CLI options for sharing files.
+     */
+    files_share(options: CLIoptions): Promise<void>;
+    /**
+     * Sets up the Commander.js commands for file group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    fileGroupCommand_setup(program: Command): void;
+}
+/**
+ * Handles commands related to individual ChRIS files.
+ */
+export declare class FileMemberHandler {
+    private baseGroupHandler;
+    private controller;
+    assetName: string;
+    private constructor();
+    /**
+     * Factory method to create a new FileMemberHandler instance.
+     *
+     * @param path - The path to the individual file.
+     * @returns A Promise resolving to a new FileMemberHandler instance.
+     */
+    static handler_create(path: string): Promise<FileMemberHandler>;
+    /**
+     * Creates a new file in ChRIS with specified content.
+     *
+     * @param fileIdentifier - The primary argument for the file (name or path).
+     * @param options - CLI options including `--content`, `--from-file`, `--path`, `--name`.
+     */
+    file_create(fileIdentifier: string | undefined, options: CLIoptions): Promise<void>;
+    /**
+     * Sets up the Commander.js commands for individual file operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    fileMemberCommand_setup(program: Command): void;
+    /**
+     * Displays the content of the file.
+     *
+     * @param options - CLI options for viewing the file.
+     */
+    file_cat(options: CLIoptions): Promise<void>;
+}

package/dist/filesystem/fileGroupHandler.js

@@ -0,0 +1,318 @@
+import chalk from "chalk";
+import { BaseGroupHandler } from "../handlers/baseGroupHandler.js";
+import { path_resolveChrisFs } from "../utils/cli.js";
+import { FileController } from "../controllers/fileController.js";
+import { files_create } from "../commands/fs/create.js";
+import { errorStack } from "@fnndsc/cumin";
+import { table_display } from "../screen/screen.js";
+import { files_fetchList } from "../commands/files/list.js";
+import { fileFields_fetch } from "../commands/files/fields.js";
+import { files_searchByTerm, files_deleteById } from "../commands/files/delete.js";
+import { prompt_confirm } from "../utils/ui.js";
+import { files_viewContent } from "../commands/file/view.js";
+import { fileList_render } from "../views/file.js";
+/**
+ * Handles commands related to groups of ChRIS files, links, or directories.
+ */
+export class FileGroupHandler {
+    constructor(controller, assetName) {
+        this.controller = controller;
+        this.assetName = assetName;
+        // baseGroupHandler will be used for fieldslist, delete, share until those are refactored
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+    }
+    /**
+     * Factory method to create a new FileGroupHandler instance.
+     *
+     * @param assetName - The type of asset to handle ('files', 'links', 'dirs').
+     * @param path - Optional path within ChRIS FS. Defaults to current ChRIS folder context.
+     * @returns A Promise resolving to a new FileGroupHandler instance.
+     */
+    static async handler_create(assetName, path) {
+        try {
+            const controller = await FileController.handler_create(assetName, path);
+            if (controller === null) {
+                throw new Error(`Failed to create FileController for asset type: ${assetName}`);
+            }
+            return new FileGroupHandler(controller, assetName);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize FileGroupHandler for ${assetName}: ${errorMessage}`);
+        }
+    }
+    /**
+     * Removes duplicate column headers from FilteredResourceData results.
+     * Copied from BaseGroupHandler to support local listing logic.
+     */
+    columns_removeDuplicates(results) {
+        const uniqueHeaders = Array.from(new Set(results.selectedFields));
+        const uniqueTableData = results.tableData.map((row) => uniqueHeaders.reduce((acc, header) => {
+            if (typeof header === "string" && header in row) {
+                acc[header] = row[header];
+            }
+            return acc;
+        }, {}));
+        return {
+            ...results,
+            selectedFields: uniqueHeaders,
+            tableData: uniqueTableData,
+        };
+    }
+    /**
+     * Lists files, links, or directories using the new command logic.
+     */
+    async files_list(options, path) {
+        try {
+            const results = await files_fetchList(options, this.assetName, path);
+            if (!results) {
+                console.error(`No ${this.assetName} resources found. Perhaps check your current context?`);
+                return;
+            }
+            if (results.tableData.length === 0) {
+                console.log(`No ${this.assetName} found matching the criteria.`);
+            }
+            else {
+                const uniqueResults = this.columns_removeDuplicates(results);
+                // cumin returns dynamic table rows (Record<string, unknown>[]);
+                // narrow to the FileResource view model at this boundary.
+                console.log(fileList_render(uniqueResults.tableData, uniqueResults.selectedFields, { table: options.table, csv: options.csv }));
+            }
+        }
+        catch (error) {
+            const errors = errorStack.stack_search(this.assetName);
+            if (errors.length > 0) {
+                console.log(errors[0]);
+            }
+            else {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error(`Error: ${msg}`);
+                const errObj = error;
+                if (msg.includes("Internal server error") || (errObj && errObj.response && errObj.response.status === 500)) {
+                    console.error(chalk.yellow("\nHint: This indicates a problem on the ChRIS server (CUBE)."));
+                    console.error(chalk.yellow("      Please contact your system administrator or check the CUBE logs."));
+                    console.error(chalk.yellow("      To see full debug output, run the command again with CHILI_DEBUG=true:"));
+                    console.error(chalk.yellow("      CHILI_DEBUG=true chili ..."));
+                }
+            }
+        }
+    }
+    /**
+     * Lists file fields using the new command logic.
+     */
+    async files_fields() {
+        try {
+            const fields = await fileFields_fetch(this.assetName);
+            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 files using the new command logic.
+     */
+    async files_delete(searchable, options) {
+        const searchParts = searchable.split("++").map((part) => part.trim());
+        for (const searchPart of searchParts) {
+            const items = await files_searchByTerm(searchPart, this.assetName);
+            if (items.length === 0) {
+                console.log(`No ${this.assetName} found matching: ${searchPart}`);
+                continue;
+            }
+            for (const item of items) {
+                const displayName = item.fname || item.path || item.id;
+                if (!item.id) {
+                    console.error(`Cannot delete item without ID. Details: ${JSON.stringify(item)}`);
+                    continue;
+                }
+                console.log(`Preparing to delete ${this.assetName}: ID=${item.id}, Name=${displayName}`);
+                if (!options.force) {
+                    const confirmed = await prompt_confirm(`Are you sure you want to delete ${this.assetName} ${displayName} (ID: ${item.id})?`);
+                    if (!confirmed)
+                        continue;
+                }
+                const success = await files_deleteById(item.id, this.assetName);
+                if (success) {
+                    console.log(`Deleted ${this.assetName} ${item.id}`);
+                }
+                else {
+                    console.error(`Failed to delete ${this.assetName} ${item.id}`);
+                }
+            }
+        }
+    }
+    /**
+     * Handles sharing of ChRIS files.
+     *
+     * @param options - CLI options for sharing files.
+     */
+    async files_share(options) {
+        try {
+            console.log(`Sharing ${this.assetName} from ${this.controller.path_get}...`);
+            if (options.force) {
+                console.log("Force sharing enabled");
+            }
+            await this.controller.files_share(options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Error sharing ${this.assetName}: ${error.message}`);
+            }
+            else {
+                console.error(`An unknown error occurred while sharing the ${this.assetName}`);
+            }
+        }
+    }
+    /**
+     * Sets up the Commander.js commands for file group operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    fileGroupCommand_setup(program) {
+        const fileGroupCommand = program
+            .command(this.assetName)
+            .description(`Interact with a group of ChRIS ${this.assetName}`);
+        const listCommand = this.baseGroupHandler.baseListCommand_create(async (options) => {
+            await this.files_list(options);
+        });
+        // Add path argument and override action to handle it properly
+        listCommand.argument('[path]', 'Optional path to list');
+        listCommand.action(async (path, options) => {
+            await this.files_list(options, path);
+        });
+        fileGroupCommand.addCommand(listCommand);
+        fileGroupCommand
+            .command("fieldslist")
+            .description(`list the ${this.assetName} resource fields`)
+            .action(async () => {
+            await this.files_fields();
+        });
+        fileGroupCommand
+            .command("delete <searchable>")
+            .description(`delete target ${this.assetName} resolved from '++' separated <searchable>, i.e. "id:77++id:33"`)
+            .option("-f, --force", "force sharing (do not ask for user confirmation)")
+            .action(async (searchable, options) => {
+            await this.files_delete(searchable, options);
+        });
+        fileGroupCommand
+            .command("share")
+            .description(`share a (group of) ${this.assetName}`)
+            .option("-f, --force", "force sharing (do not ask for user confirmation)")
+            .action(async (options) => {
+            // Still delegates to baseGroupHandler for now
+            await this.files_share(options);
+        });
+    }
+}
+/**
+ * Handles commands related to individual ChRIS files.
+ */
+export class FileMemberHandler {
+    constructor(controller) {
+        this.assetName = "file";
+        this.controller = controller;
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, this.controller.chrisObject);
+    }
+    /**
+     * Factory method to create a new FileMemberHandler instance.
+     *
+     * @param path - The path to the individual file.
+     * @returns A Promise resolving to a new FileMemberHandler instance.
+     */
+    static async handler_create(path) {
+        try {
+            const controller = await FileController.member_create(path);
+            if (controller === null) {
+                throw new Error(`Failed to create FileController for path: ${path}`);
+            }
+            return new FileMemberHandler(controller);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize FileMemberHandler for path ${path}: ${errorMessage}`);
+        }
+    }
+    /**
+     * Creates a new file in ChRIS with specified content.
+     *
+     * @param fileIdentifier - The primary argument for the file (name or path).
+     * @param options - CLI options including `--content`, `--from-file`, `--path`, `--name`.
+     */
+    async file_create(fileIdentifier, options) {
+        try {
+            // files_create now throws on error
+            const success = await files_create(fileIdentifier, options);
+            if (success) {
+                const resolvedChRISPath = await path_resolveChrisFs(fileIdentifier, options);
+                console.log(`File created successfully at: ${resolvedChRISPath}`);
+            }
+            // If success is false, files_create would have thrown an error which is caught below.
+        }
+        catch (error) {
+            // Log the error from files_create
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(message);
+        }
+    }
+    /**
+     * Sets up the Commander.js commands for individual file operations.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    fileMemberCommand_setup(program) {
+        const fileCommand = program
+            .command(this.assetName)
+            .description(`Interact with a single ChRIS ${this.assetName}`);
+        const existingCommand = program.commands.find(cmd => cmd.name() === this.assetName);
+        const commandToUse = existingCommand || fileCommand;
+        commandToUse
+            .command("create [fileIdentifier]")
+            .description("Create a new file in ChRIS with optional content")
+            .option("-c, --content <text>", "Inline content for the new file")
+            .option("-f, --from-file <localPath>", "Path to a local file to upload as content")
+            .option("-p, --path <path>", "Base ChRIS directory for the file (overrides current context if relative)")
+            .option("-n, --name <name>", "Explicit filename (useful when fileIdentifier is a path or omitted)")
+            .action(async (fileIdentifier, options) => {
+            await this.file_create(fileIdentifier, options);
+        });
+        // TODO: Add cat/view command here
+        // Note: The original file_cat was present but not hooked up in setup? 
+        // Wait, looking at previous file, file_cat existed but wasn't in fileMemberCommand_setup?
+        // Ah, I should add it.
+        commandToUse
+            .command("cat")
+            .description("View the content of the file")
+            .action(async (options) => {
+            await this.file_cat(options);
+        });
+        console.log("FileMemberHandler commands set up successfully");
+    }
+    /**
+     * Displays the content of the file.
+     *
+     * @param options - CLI options for viewing the file.
+     */
+    async file_cat(options) {
+        try {
+            const path = this.controller.path_get;
+            console.log(`Viewing file at ${path}`);
+            const content = await files_viewContent(path);
+            if (content !== null) {
+                console.log(content);
+            }
+            else {
+                console.error("Failed to view file content (empty or error).");
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error viewing file: ${message}`);
+        }
+    }
+}

package/dist/filesystem/filesystemHandler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Commander setup for the ChRIS file-browser command group.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Sets up the 'fobj' command for interacting with ChRIS filesystem objects.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export declare function fileBrowserCommand_setup(program: Command): Promise<void>;