@fnndsc/chili 3.2.5

package/dist/commands/fs/rm.js

@@ -0,0 +1,108 @@
+/**
+ * @file Implements the core logic for the `rm` command in the ChRIS CLI.
+ *
+ * This module provides functionality to delete files, directories, and links
+ * from the ChRIS file system. It determines the type of the target and calls
+ * the appropriate delete function.
+ *
+ * @module
+ */
+import { files_listAll } from "@fnndsc/salsa";
+import { files_delete as salsaFiles_delete } from "@fnndsc/salsa";
+import { path_resolveChrisFs } from "../../utils/cli.js";
+/**
+ * Finds a file/dir/link by path and returns its type and ID.
+ *
+ * @param targetPath - The resolved path to search for.
+ * @returns An object with type, id, and name, or null if not found.
+ */
+async function pathInfo_find(targetPath) {
+    const parts = targetPath.split('/').filter((p) => p);
+    const basename = parts.pop() || '';
+    const parentPath = '/' + parts.join('/');
+    const fetchOpts = { limit: 1000, offset: 0 };
+    // Search in all three asset types within the parent directory
+    const [dirs, files, links] = await Promise.all([
+        files_listAll(fetchOpts, 'dirs', parentPath),
+        files_listAll(fetchOpts, 'files', parentPath),
+        files_listAll(fetchOpts, 'links', parentPath)
+    ]);
+    // Helper to extract name from raw object
+    const extractName = (raw) => {
+        let name = raw.fname || raw.path || "";
+        if (name.includes('/')) {
+            name = name.split('/').pop() || name;
+        }
+        return name;
+    };
+    if (dirs && dirs.tableData) {
+        for (const d of dirs.tableData) {
+            if (extractName(d) === basename && d.id) {
+                return { type: 'dir', id: Number(d.id), name: basename };
+            }
+        }
+    }
+    if (files && files.tableData) {
+        for (const f of files.tableData) {
+            if (extractName(f) === basename && f.id) {
+                return { type: 'file', id: Number(f.id), name: basename };
+            }
+        }
+    }
+    if (links && links.tableData) {
+        for (const l of links.tableData) {
+            if (extractName(l) === basename && l.id) {
+                return { type: 'link', id: Number(l.id), name: basename };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Core logic for the 'rm' command.
+ *
+ * @param targetPath - The path to delete.
+ * @param options - Options including recursive and force flags.
+ * @returns A Promise resolving to RmResult.
+ */
+export async function files_rm(targetPath, options = {}) {
+    try {
+        const resolvedPath = await path_resolveChrisFs(targetPath, {});
+        const info = await pathInfo_find(resolvedPath);
+        if (!info) {
+            return {
+                success: false,
+                path: resolvedPath,
+                type: null,
+                error: `No such file or directory: ${resolvedPath}`
+            };
+        }
+        // Check if it's a directory and recursive flag is not set
+        if (info.type === 'dir' && !options.recursive) {
+            return {
+                success: false,
+                path: resolvedPath,
+                type: info.type,
+                error: `Cannot remove directory '${resolvedPath}': is a directory (use -r for recursive delete)`
+            };
+        }
+        // Delete the resource
+        const assetName = info.type === 'dir' ? 'dirs' : info.type === 'link' ? 'links' : 'files';
+        const deleted = await salsaFiles_delete(info.id, assetName);
+        return {
+            success: deleted,
+            path: resolvedPath,
+            type: info.type,
+            error: deleted ? undefined : `Failed to delete ${info.type}: ${resolvedPath}`
+        };
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            path: targetPath,
+            type: null,
+            error: errorMsg
+        };
+    }
+}

package/dist/commands/fs/touch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Options for the touch command.
+ */
+export interface TouchOptions {
+    withContents?: string;
+    withContentsFromFile?: string;
+}
+/**
+ * Core logic for the 'touch' command.
+ * This function does not perform any console output.
+ *
+ * @param filePath - The full or relative ChRIS path for the new file.
+ * @param options - Optional parameters for content injection.
+ * @returns A Promise resolving to true on success, false on failure.
+ */
+export declare function files_touch(filePath: string, options?: TouchOptions): Promise<boolean>;

package/dist/commands/fs/touch.js

@@ -0,0 +1,62 @@
+/**
+ * @file Implements the core logic for the `touch` command in the ChRIS CLI.
+ *
+ * This module provides functionality to create empty files or files with content
+ * within the ChRIS file system. It interacts with the `@fnndsc/salsa` library.
+ *
+ * @module
+ */
+import fs from 'fs';
+import { files_touch as salsaFiles_touch } from "@fnndsc/salsa";
+import { path_resolveChrisFs } from "../../utils/cli.js";
+import { errorStack, Ok, Err } from "@fnndsc/cumin";
+/**
+ * Reads content from a local file with proper error handling.
+ *
+ * @param localFilePath - Path to the local file on the host system.
+ * @returns Result<string> containing file contents or error.
+ */
+function fileContents_read(localFilePath) {
+    try {
+        if (!fs.existsSync(localFilePath)) {
+            errorStack.stack_push("error", `Local file not found: ${localFilePath}`);
+            return Err();
+        }
+        const content = fs.readFileSync(localFilePath, 'utf-8');
+        return Ok(content);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        errorStack.stack_push("error", `Failed to read local file ${localFilePath}: ${msg}`);
+        return Err();
+    }
+}
+/**
+ * Core logic for the 'touch' command.
+ * This function does not perform any console output.
+ *
+ * @param filePath - The full or relative ChRIS path for the new file.
+ * @param options - Optional parameters for content injection.
+ * @returns A Promise resolving to true on success, false on failure.
+ */
+export async function files_touch(filePath, options = {}) {
+    const resolvedPath = await path_resolveChrisFs(filePath, {});
+    // Determine content to write
+    let content;
+    if (options.withContentsFromFile) {
+        const result = fileContents_read(options.withContentsFromFile);
+        if (!result.ok) {
+            return false;
+        }
+        content = result.value;
+    }
+    else if (options.withContents !== undefined) {
+        content = options.withContents;
+    }
+    if (content !== undefined) {
+        return await salsaFiles_touch(resolvedPath, content);
+    }
+    else {
+        return await salsaFiles_touch(resolvedPath);
+    }
+}

package/dist/commands/fs/upload.d.ts

@@ -0,0 +1,55 @@
+/**
+ * File information for upload tracking.
+ */
+export interface UploadFileInfo {
+    hostPath: string;
+    chrisPath: string;
+    size: number;
+}
+/**
+ * Upload summary statistics.
+ */
+export interface UploadSummary {
+    startTime: number;
+    endTime: number;
+    totalFiles: number;
+    transferredCount: number;
+    failedCount: number;
+    transferSize: number;
+    duration: number;
+    speed: number;
+    actualTargetPath: string;
+}
+/**
+ * Formats bytes into human-readable format.
+ * @param bytes - Number of bytes.
+ * @returns Formatted string (e.g., "1.23 MB").
+ */
+export declare function bytes_format(bytes: number): string;
+/**
+ * Formats seconds into a human-friendly ETA string.
+ * @param seconds - Remaining seconds.
+ */
+export declare function eta_format(seconds: number | null): string;
+/**
+ * Formats a bytes-per-second rate into human-readable string.
+ * @param rateBytesPerSec - Rate in bytes per second.
+ */
+export declare function rate_format(rateBytesPerSec: number): string;
+/**
+ * Uploads files with a progress bar display.
+ * @param localPath - Local path (file or directory).
+ * @param remotePath - Remote ChRIS path.
+ * @returns Promise<UploadSummary> with upload statistics.
+ */
+export declare function files_uploadWithProgress(localPath: string, remotePath: string, options?: {
+    force?: boolean;
+}): Promise<UploadSummary>;
+/**
+ * Uploads a local file or directory to ChRIS.
+ *
+ * @param localPath - Local path.
+ * @param remotePath - Remote ChRIS path.
+ * @returns Promise<boolean> true if successful.
+ */
+export declare function files_upload(localPath: string, remotePath: string): Promise<boolean>;

package/dist/commands/fs/upload.js

@@ -0,0 +1,221 @@
+/**
+ * @file Upload command implementation.
+ * @module
+ */
+import { files_uploadPath } from "@fnndsc/salsa";
+import { chrisIO } from "@fnndsc/cumin";
+import { path_resolveChrisFs } from "../../utils/cli.js";
+import fs from "fs";
+import path from "path";
+import cliProgress from "cli-progress";
+import chalk from "chalk";
+import { prompt_confirmOrThrow } from "../../utils/input_format.js";
+/**
+ * Formats bytes into human-readable format.
+ * @param bytes - Number of bytes.
+ * @returns Formatted string (e.g., "1.23 MB").
+ */
+export function bytes_format(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+/**
+ * Formats seconds into a human-friendly ETA string.
+ * @param seconds - Remaining seconds.
+ */
+export function eta_format(seconds) {
+    if (seconds === null || !Number.isFinite(seconds) || seconds < 0)
+        return "--";
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    const hrs = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    if (hrs > 0) {
+        return `${hrs}h ${mins}m ${secs}s`;
+    }
+    return `${mins}m ${secs}s`;
+}
+/**
+ * Formats a bytes-per-second rate into human-readable string.
+ * @param rateBytesPerSec - Rate in bytes per second.
+ */
+export function rate_format(rateBytesPerSec) {
+    if (!Number.isFinite(rateBytesPerSec) || rateBytesPerSec <= 0)
+        return "--";
+    return `${bytes_format(rateBytesPerSec)}/s`;
+}
+/**
+ * Recursively scans a local directory to get all files for upload.
+ * @param localPath - The local filesystem path.
+ * @param remotePath - The target ChRIS path.
+ * @returns Array of UploadFileInfo objects.
+ */
+async function localFiles_scan(localPath, remotePath) {
+    const files = [];
+    async function walkDir(currentLocal, currentRemote) {
+        const entries = await fs.promises.readdir(currentLocal, { withFileTypes: true });
+        for (const entry of entries) {
+            const localFilePath = path.join(currentLocal, entry.name);
+            const remoteFilePath = currentRemote.endsWith('/')
+                ? currentRemote + entry.name
+                : currentRemote + '/' + entry.name;
+            if (entry.isDirectory()) {
+                await walkDir(localFilePath, remoteFilePath);
+            }
+            else {
+                const stats = await fs.promises.stat(localFilePath);
+                files.push({
+                    hostPath: localFilePath,
+                    chrisPath: remoteFilePath,
+                    size: stats.size,
+                });
+            }
+        }
+    }
+    const stats = await fs.promises.stat(localPath);
+    if (stats.isDirectory()) {
+        // Preserve directory basename in remote path (Unix cp semantics)
+        const basename = path.basename(localPath);
+        const targetDir = remotePath.endsWith('/')
+            ? remotePath + basename
+            : remotePath + '/' + basename;
+        await walkDir(localPath, targetDir);
+    }
+    else {
+        // Single file upload
+        const filename = path.basename(localPath);
+        const targetPath = remotePath.endsWith('/')
+            ? remotePath + filename
+            : remotePath + '/' + filename;
+        files.push({
+            hostPath: localPath,
+            chrisPath: targetPath,
+            size: stats.size,
+        });
+    }
+    return files;
+}
+/**
+ * Uploads files with a progress bar display.
+ * @param localPath - Local path (file or directory).
+ * @param remotePath - Remote ChRIS path.
+ * @returns Promise<UploadSummary> with upload statistics.
+ */
+export async function files_uploadWithProgress(localPath, remotePath, options = {}) {
+    const resolvedRemote = await path_resolveChrisFs(remotePath, {});
+    // Scan files
+    console.log(chalk.cyan("Scanning files to upload..."));
+    const fileList = await localFiles_scan(localPath, resolvedRemote);
+    const totalSize = fileList.reduce((sum, f) => sum + f.size, 0);
+    // Determine actual target path (where files will be uploaded)
+    const stats = await fs.promises.stat(localPath);
+    let actualTarget = resolvedRemote;
+    if (stats.isDirectory()) {
+        const basename = path.basename(localPath);
+        actualTarget = resolvedRemote.endsWith('/')
+            ? resolvedRemote + basename
+            : resolvedRemote + '/' + basename;
+    }
+    // Detect existing target and require confirmation unless force is set
+    if (!options.force) {
+        try {
+            const client = await chrisIO.client_get();
+            if (client) {
+                const folderList = await client.getFileBrowserFolders({ path: actualTarget });
+                const items = await folderList.getItems();
+                if (items && items.length > 0) {
+                    await prompt_confirmOrThrow(`Target '${actualTarget}' already exists in ChRIS. Merge/overwrite? (y/N)`);
+                }
+            }
+        }
+        catch {
+            // If listing fails (path absent or error), continue.
+        }
+    }
+    else {
+        // Force mode: if target exists and is a directory, no prompt. If it's a file and we're uploading a single file, proceed.
+    }
+    const showProgress = !!process.stdout.isTTY;
+    const progressBar = showProgress
+        ? new cliProgress.SingleBar({
+            format: "Transferring [{bar}] {percentage}% | ETA: {etaHuman} | Rate: {rate} | {value}/{total} files | {bytes}/{totalBytes}",
+        }, cliProgress.Presets.shades_classic)
+        : null;
+    if (progressBar) {
+        progressBar.start(fileList.length, 0, {
+            bytes: "0 B",
+            totalBytes: bytes_format(totalSize),
+            etaHuman: "--",
+            rate: "--",
+        });
+    }
+    // Upload files
+    const summary = {
+        startTime: Date.now(),
+        endTime: 0,
+        totalFiles: fileList.length,
+        transferredCount: 0,
+        failedCount: 0,
+        transferSize: 0,
+        duration: 0,
+        speed: 0,
+        actualTargetPath: actualTarget,
+    };
+    for (const [index, file] of fileList.entries()) {
+        try {
+            const fileContent = await fs.promises.readFile(file.hostPath);
+            const fileBlob = new Blob([fileContent]);
+            // Split chrisPath into dir and filename for the new API
+            const lastSlash = file.chrisPath.lastIndexOf('/');
+            const dir = file.chrisPath.substring(0, lastSlash) || '/';
+            const filename = file.chrisPath.substring(lastSlash + 1);
+            const uploadResult = await chrisIO.file_upload(fileBlob, dir, filename);
+            if (uploadResult) {
+                summary.transferredCount++;
+                summary.transferSize += fileContent.length;
+            }
+            else {
+                summary.failedCount++;
+                console.log(chalk.yellow(`Failed to upload: ${file.hostPath}`));
+            }
+        }
+        catch (error) {
+            summary.failedCount++;
+            console.log(chalk.red(`Error uploading ${file.hostPath}: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        const elapsedSeconds = Math.max(1e-6, (Date.now() - summary.startTime) / 1000);
+        const rateCurrent = summary.transferSize > 0 ? summary.transferSize / elapsedSeconds : 0;
+        const remainingBytes = Math.max(0, totalSize - summary.transferSize);
+        const etaSeconds = rateCurrent > 0 ? remainingBytes / rateCurrent : null;
+        if (progressBar) {
+            progressBar.update(index + 1, {
+                bytes: bytes_format(summary.transferSize),
+                etaHuman: eta_format(etaSeconds),
+                rate: rate_format(rateCurrent),
+            });
+        }
+    }
+    if (progressBar) {
+        progressBar.stop();
+    }
+    summary.endTime = Date.now();
+    summary.duration = (summary.endTime - summary.startTime) / 1000; // seconds
+    summary.speed = summary.transferSize / summary.duration; // bytes per second
+    return summary;
+}
+/**
+ * Uploads a local file or directory to ChRIS.
+ *
+ * @param localPath - Local path.
+ * @param remotePath - Remote ChRIS path.
+ * @returns Promise<boolean> true if successful.
+ */
+export async function files_upload(localPath, remotePath) {
+    const resolvedRemote = await path_resolveChrisFs(remotePath, {});
+    return await files_uploadPath(localPath, resolvedRemote);
+}

package/dist/commands/groups/fields.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the available group field names.
+ *
+ * @returns The group field names, or null on failure.
+ */
+export declare function groupFields_fetch(): Promise<string[] | null>;

package/dist/commands/groups/fields.js

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

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

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

package/dist/commands/groups/list.js

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

package/dist/commands/man/doc.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Options for rendering a man page.
+ */
+export interface ManPageOptions {
+    topic: string;
+    browser?: boolean;
+    style: "figlet" | "ascii";
+    width?: number;
+}
+/**
+ * Displays a documentation page for a specific topic.
+ *
+ * @param options - Options defining the topic, output format (browser vs console), and style.
+ * @returns A Promise resolving to `void`.
+ */
+export declare function manPage_display(options: ManPageOptions): Promise<void>;

package/dist/commands/man/doc.js

@@ -0,0 +1,32 @@
+/**
+ * @file Implements the logic for displaying documentation topics.
+ *
+ * This module provides functionality to render and display documentation
+ * pages either in the terminal or a browser.
+ *
+ * @module
+ */
+import fs from "fs";
+import path from "path";
+import { projectDir_get, browser_open, asciidoc_render } from "../../man/renderer.js";
+/**
+ * Displays a documentation page for a specific topic.
+ *
+ * @param options - Options defining the topic, output format (browser vs console), and style.
+ * @returns A Promise resolving to `void`.
+ */
+export async function manPage_display(options) {
+    const docDir = path.join(projectDir_get(), "doc");
+    const docPath = path.join(docDir, `${options.topic}.adoc`);
+    if (!fs.existsSync(docPath)) {
+        console.error(`Documentation for '${options.topic}' not found.`);
+        return;
+    }
+    if (options.browser) {
+        browser_open(docPath);
+    }
+    else {
+        const content = fs.readFileSync(docPath, "utf-8");
+        console.log(await asciidoc_render(content, options.style, options.width));
+    }
+}

package/dist/commands/man/topics.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Lists the available documentation topics.
+ *
+ * @returns A Promise resolving to an array of topic strings (filenames without extension).
+ */
+export declare function topics_list(): Promise<string[]>;

package/dist/commands/man/topics.js

@@ -0,0 +1,27 @@
+/**
+ * @file Implements the logic for listing available documentation topics.
+ *
+ * This module scans the documentation directory and returns a list
+ * of available topics (Asciidoc files).
+ *
+ * @module
+ */
+import fs from "fs";
+import path from "path";
+import { projectDir_get } from "../../man/renderer.js";
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faBook } from "@fortawesome/free-solid-svg-icons";
+/**
+ * Lists the available documentation topics.
+ *
+ * @returns A Promise resolving to an array of topic strings (filenames without extension).
+ */
+export async function topics_list() {
+    const docDir = path.join(projectDir_get(), "doc");
+    library.add(faBook);
+    const bookIcon = "";
+    const files = fs.readdirSync(docDir);
+    const adocFiles = files.filter((file) => path.extname(file) === ".adoc");
+    const formattedOutput = adocFiles.map((file) => `${bookIcon} ${path.basename(file, ".adoc")}`);
+    return formattedOutput;
+}

package/dist/commands/pipeline/fields.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the available pipeline field names.
+ *
+ * @returns The pipeline field names, or null on failure.
+ */
+export declare function pipelineFields_fetch(): Promise<string[] | null>;

package/dist/commands/pipeline/fields.js

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

package/dist/commands/pipeline/run.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file Pipeline run command — creates a workflow from a registered pipeline.
+ * @module
+ */
+import { Result } from "@fnndsc/cumin";
+import { WorkflowResult } from "@fnndsc/salsa";
+/**
+ * Runs a pipeline by name or ID, attaching it to the current plugin context node
+ * or an explicitly supplied previous instance ID.
+ *
+ * @param nameOrId - Pipeline name or numeric ID.
+ * @param options - Optional compute override and explicit previous instance ID.
+ * @returns Result containing workflow ID and created plugin instance IDs.
+ */
+export declare function pipeline_execute(nameOrId: string, options?: {
+    compute?: string;
+    previousInstId?: number;
+}): Promise<Result<WorkflowResult>>;