@fnndsc/chili 3.2.5 → 3.4.0

package/dist/index.js

@@ -2,62 +2,18 @@
 /**
  * @file Command-line entry point for the chili (ChILI) CLI.
  *
- * @module
- */
-/**
- * Suppress DEP0169 warning from axios/proxy-from-env dependency.
- *
- * This warning originates from the `proxy-from-env` package (version 1.1.0)
- * used by axios for proxy configuration. The package uses the legacy `url.parse()`
- * API which is deprecated in favor of the WHATWG URL API.
+ * This is a thin wrapper: all command wiring and execution live in {@link run}
+ * (./run.js) so the same logic can be driven in-process by a host such as chell
+ * without spawning a separate `node` subprocess. This file only adds the
+ * bin-only concerns — shell completion and fatal-exit handling.
  *
- * Why we suppress it:
- * - It's a transitive dependency (axios → proxy-from-env) we don't control
- * - proxy-from-env 1.1.0 is the latest version and hasn't been updated
- * - According to the warning: "CVEs are not issued for url.parse() vulnerabilities"
- * - The warning doesn't affect functionality, only console output
- * - This is a well-known issue in the Node.js ecosystem
- *
- * This can be removed once:
- * - proxy-from-env migrates to WHATWG URL API, OR
- * - axios replaces proxy-from-env with an alternative
- *
- * Tracking: https://github.com/Rob--W/proxy-from-env/issues/51
+ * @module
  */
-const originalEmitWarning = process.emitWarning;
-process.emitWarning = function (warning, ...args) {
-    // Suppress only the specific DEP0169 warning
-    if (typeof warning === 'string' &&
-        (warning.includes('DEP0169') || warning.includes('url.parse()'))) {
-        return;
-    }
-    // Allow all other warnings through
-    return originalEmitWarning.call(process, warning, ...args);
-};
-import { Command } from "commander";
-import figlet from "figlet";
 import omelette from "omelette";
-import { connectCommand_setup } from "./connect/connectHandler.js";
-import { FeedGroupHandler, FeedMemberHandler } from "./feeds/feedHandler.js";
-import { PluginGroupHandler, PluginMemberHandler, } from "./plugins/pluginHandler.js";
-import { PluginMetaGroupHandler } from "./plugins/pluginMetaHandler.js";
-import { PluginContextGroupHandler } from "./plugins/pluginGroupHandler.js";
-import { inodeCommand_setup } from "./filesystem/inodeCommand.js";
-import { contextCommand_setup } from "./context/contextCommand.js";
-import { pathCommand_setup } from "./path/pathCommand.js";
-import { fileBrowserCommand_setup } from "./filesystem/filesystemHandler.js";
-import { manCommand_setup } from "./man/man.js";
-import { chefsCommand_setup } from "./chefs/chefs.js";
-import { PACSServerGroupHandler } from "./pacs/pacsServerHandler.js";
-import { PACSQueryGroupHandler } from "./pacs/pacsQueryHandler.js";
-import { PACSRetrieveGroupHandler } from "./pacs/pacsRetrieveHandler.js";
-import { chrisConnection_init, NodeStorageProvider, errorStack_getAllOfType } from "@fnndsc/cumin";
-import { FileGroupHandler } from "./filesystem/fileGroupHandler.js";
-const program = new Command();
-program.version("1.0.1").description("A CLI for ChRIS");
+import { run } from "./run.js";
 /**
- * Sets up command completion for the ChILI CLI using omelette.
- * This provides auto-completion suggestions in the shell.
+ * Sets up shell command completion for the standalone chili CLI using omelette.
+ * This is a bin-only concern; in-process hosts provide their own completion.
  */
 function commandCompletion_setup() {
     const completion = omelette(`chili|chili`);
@@ -95,7 +51,6 @@ function commandCompletion_setup() {
     });
     completion.on("man.doc", ({ reply }) => {
         console.log("Autocomplete triggered for man doc command");
-        // We'll implement actual topic retrieval here later
         reply([]);
     });
     completion.init();
@@ -104,136 +59,15 @@ function commandCompletion_setup() {
     }
 }
 /**
- * Initializes and sets up all command handlers for the ChILI CLI.
- *
- * @param program - The Commander.js program instance.
- */
-async function handlers_initialize() {
-    // const client = await chrisConnection.client_get(); 
-    // We don't enforce connection here to allow --help to work. 
-    // Commands will fail individually if not connected.
-    fileBrowserCommand_setup(program);
-    contextCommand_setup(program);
-    pathCommand_setup(program);
-    manCommand_setup(program);
-    chefsCommand_setup(program);
-    const pacsServerHandler = new PACSServerGroupHandler();
-    pacsServerHandler.pacsServerCommand_setup(program);
-    const pacsQueryHandler = new PACSQueryGroupHandler();
-    pacsQueryHandler.pacsQueryCommand_setup(program);
-    const pacsRetrieveHandler = new PACSRetrieveGroupHandler();
-    pacsRetrieveHandler.pacsRetrieveCommand_setup(program);
-    await inodeCommand_setup(program);
-    const pluginGroupHandler = new PluginGroupHandler();
-    pluginGroupHandler.pluginGroupCommand_setup(program);
-    const pluginMetaGroupHandler = new PluginMetaGroupHandler();
-    pluginMetaGroupHandler.pluginMetaGroupCommand_setup(program);
-    const feedGroupHandler = new FeedGroupHandler();
-    feedGroupHandler.feedGroupCommand_setup(program);
-    const feedMemberHandler = new FeedMemberHandler();
-    feedMemberHandler.feedCommand_setup(program);
-    const pluginMemberHandler = new PluginMemberHandler();
-    pluginMemberHandler.pluginCommand_setup(program);
-    try {
-        const filesGroupHandler = await FileGroupHandler.handler_create("files");
-        filesGroupHandler.fileGroupCommand_setup(program);
-        const linksGroupHandler = await FileGroupHandler.handler_create("links");
-        linksGroupHandler.fileGroupCommand_setup(program);
-        const dirsGroupHandler = await FileGroupHandler.handler_create("dirs");
-        dirsGroupHandler.fileGroupCommand_setup(program);
-    }
-    catch (e) {
-        const err = e instanceof Error ? e.message : String(e);
-        const errors = errorStack_getAllOfType("error");
-        const warnings = errorStack_getAllOfType("warning");
-        console.log(`Note: File group commands (files, dirs, links) are unavailable. Reason: ${err}`);
-        if (errors.length > 0) {
-            console.log("Errors:");
-            errors.forEach(msg => console.log(`  - ${msg}`));
-        }
-        if (warnings.length > 0) {
-            console.log("Warnings:");
-            warnings.forEach(msg => console.log(`  - ${msg}`));
-        }
-    }
-    try {
-        const computesOfPluginHandler = await PluginContextGroupHandler.handler_create("computesofplugin");
-        computesOfPluginHandler.pluginContextGroupCommand_setup(program);
-        const pluginInstancesHandler = await PluginContextGroupHandler.handler_create("instancesofplugin");
-        pluginInstancesHandler.pluginContextGroupCommand_setup(program);
-        const pluginParametersHandler = await PluginContextGroupHandler.handler_create("parametersofplugin");
-        pluginParametersHandler.pluginContextGroupCommand_setup(program);
-    }
-    catch (e) {
-        const err = e instanceof Error ? e.message : String(e);
-        const errors = errorStack_getAllOfType("error");
-        const warnings = errorStack_getAllOfType("warning");
-        console.log(`Note: Plugin context commands are unavailable. Reason: ${err}`);
-        if (errors.length > 0) {
-            console.log("Errors:");
-            errors.forEach(msg => console.log(`  - ${msg}`));
-        }
-        if (warnings.length > 0) {
-            console.log("Warnings:");
-            warnings.forEach(msg => console.log(`  - ${msg}`));
-        }
-    }
-    commandCompletion_setup();
-}
-/**
- * Parses the command line arguments to extract context information.
- *
- * @param args - The command line arguments array (process.argv).
- * @returns A tuple containing the context string (if found) and the remaining arguments.
- */
-function context_parse(args) {
-    // Find the first argument that looks like a context string (contains "=" but doesn't start with "-")
-    for (let i = 2; i < args.length; i++) {
-        const arg = args[i];
-        if (arg.includes("=") && !arg.startsWith("-")) {
-            const context = arg;
-            // Reconstruct args without the context string
-            const newArgs = [...args.slice(0, i), ...args.slice(i + 1)];
-            return [context, newArgs];
-        }
-    }
-    return [undefined, args];
-}
-/**
- * Main function to run the ChILI CLI.
- * Handles initialization, context parsing, and command execution.
+ * Bin entry: register shell completion, then run the requested chili command.
  */
 async function main() {
-    const nodeStorageProvider = new NodeStorageProvider();
-    const connection = await chrisConnection_init(nodeStorageProvider);
-    const [context, newArgs] = context_parse(process.argv);
-    if (context) {
-        const contextSetSuccess = await connection.context_set(context);
-        if (!contextSetSuccess) {
-            console.error("Failed to set context. Exiting.");
-            process.exit(1);
-        }
-        process.argv = newArgs;
-    }
-    program
-        .name("chili")
-        .description("ChILI handles Intelligent Line Interactions")
-        .option("-v, --verbose", "enable verbose output")
-        .option("-c, --config <path>", "path to config file")
-        .option("-s, --nosplash", "disable splash screen");
-    connectCommand_setup(program);
-    await handlers_initialize(); // Call handlers_initialize here
-    program.parseOptions(process.argv);
-    const options = program.opts();
-    if (!options.nosplash) {
-        console.log(figlet.textSync("ChILI"));
-        console.log("ChILI handles Intelligent Line Interactions");
-    }
-    program.parse(process.argv);
+    commandCompletion_setup();
+    await run(process.argv.slice(2));
 }
 main().catch((error) => {
     console.error("An error occurred:", error);
     process.exit(1);
 });
-// Export utilities for use by other packages (e.g., chell)
-export { logical_toPhysical } from './utils/cli.js';
+// Re-export library utilities for consumers that import the package root.
+export { logical_toPhysical } from "./utils/cli.js";

package/dist/man/renderer.d.ts

@@ -23,4 +23,4 @@ export declare function asciidoc_render(content: string, style: "figlet" | "asci
  *
  * @param filePath - The path to the file to open.
  */
-export declare function browser_open(filePath: string): void;
+export declare function browser_open(filePath: string): Promise<void>;

package/dist/man/renderer.js

@@ -6,7 +6,7 @@
 import fs from "fs";
 import path from "path";
 import chalk from "chalk";
-import asciidoctor from "asciidoctor";
+import { convert as adoc_convert } from "asciidoctor";
 import { exec } from "child_process";
 import os from "os";
 const headingStyles = [
@@ -63,9 +63,8 @@ export function projectDir_get() {
  * @param content - The AsciiDoc content string.
  * @returns The converted HTML string.
  */
-function adoc_htmlConvert(content) {
-    const ascii = asciidoctor();
-    let result = ascii.convert(content, {
+async function adoc_htmlConvert(content) {
+    let result = await adoc_convert(content, {
         standalone: false,
         attributes: {
             showtitle: "",
@@ -107,7 +106,7 @@ function text_wrap(text, width) {
  * @returns A Promise resolving to the formatted string.
  */
 export async function asciidoc_render(content, style, width) {
-    let result = adoc_htmlConvert(content);
+    let result = await adoc_htmlConvert(content);
     function ASCII_create(text, style) {
         const transformedText = style.textTransform(text);
         return style.color(transformedText);
@@ -159,12 +158,11 @@ export async function asciidoc_render(content, style, width) {
  *
  * @param filePath - The path to the file to open.
  */
-export function browser_open(filePath) {
-    const ascii = asciidoctor();
+export async function browser_open(filePath) {
     const tempHtmlPath = path.join(os.tmpdir(), path.basename(filePath).replace(".adoc", ".html"));
     try {
         const content = fs.readFileSync(filePath, "utf-8");
-        const html = ascii.convert(content, {
+        const html = await adoc_convert(content, {
             safe: "safe",
             standalone: true,
             attributes: { showtitle: true },

package/dist/path/pathCommand.js

@@ -13,7 +13,7 @@ import { table_display, border_draw } from "../screen/screen.js";
 import { options_toParams } from "../utils/cli.js";
 import archy from "archy";
 import open from "open";
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import os from "os";
 import { files_downloadWithProgress } from "../commands/fs/download.js";
 /**
@@ -160,10 +160,13 @@ async function mermaid_renderServerSide(mermaidDefinition, outputFile) {
     const tempDir = os.tmpdir();
     const inputFile = path.join(tempDir, "input.mmd");
     fs.writeFileSync(inputFile, mermaidDefinition);
+    // Pass args as an array (execFile, no shell) so a user-supplied --save path
+    // cannot inject shell commands. Requires `mmdc` (@mermaid-js/mermaid-cli),
+    // which is fetched on demand via npx and is not a hard dependency.
     return new Promise((resolve, reject) => {
-        exec(`npx mmdc -i ${inputFile} -o ${outputFile}`, (error, stdout, stderr) => {
+        execFile("npx", ["mmdc", "-i", inputFile, "-o", outputFile], (error) => {
             if (error) {
-                console.error(`exec error: ${error}`);
+                console.error(`Mermaid render failed. Ensure @mermaid-js/mermaid-cli is available (npx mmdc): ${error.message}`);
                 reject(error);
                 return;
             }

package/dist/plugins/pluginGroupHandler.d.ts

@@ -5,6 +5,7 @@
  */
 import { Command } from "commander";
 import { CLIoptions } from "../utils/cli.js";
+import { type CommandEnvelope } from "@fnndsc/cumin";
 /**
  * Handles commands related to groups of plugin contexts (computes, instances, parameters).
  */
@@ -33,6 +34,23 @@ export declare class PluginContextGroupHandler {
      * Lists available fields for the current plugin context resource.
      */
     parameters_fieldsList(): Promise<void>;
+    /**
+     * Renders plugin parameters in "man page" style as an envelope.
+     *
+     * Sans-I/O counterpart to {@link parameters_listMan}.
+     *
+     * @param options - CLI options for filtering.
+     * @returns An envelope carrying the rendered parameters or an error.
+     */
+    parameters_listManRender(options: CLIoptions): Promise<CommandEnvelope>;
+    /**
+     * Renders available fields for the current plugin context resource as an envelope.
+     *
+     * Sans-I/O counterpart to {@link parameters_fieldsList}.
+     *
+     * @returns An envelope carrying the field listing.
+     */
+    parameters_fieldsRender(): Promise<CommandEnvelope>;
     /**
      * Sets up the Commander.js commands for plugin context group operations.
      *

package/dist/plugins/pluginGroupHandler.js

@@ -6,7 +6,8 @@
 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";
+import { pluginParameters_renderMan, pluginParameters_manRender } from "../views/pluginParameters.js";
+import { envelope_ok, envelope_error } from "@fnndsc/cumin";
 class InitializationError extends Error {
     constructor(message) {
         super(message);
@@ -76,6 +77,44 @@ export class PluginContextGroupHandler {
             await this.baseGroupHandler.resourceFields_list();
         }
     }
+    /**
+     * Renders plugin parameters in "man page" style as an envelope.
+     *
+     * Sans-I/O counterpart to {@link parameters_listMan}.
+     *
+     * @param options - CLI options for filtering.
+     * @returns An envelope carrying the rendered parameters or an error.
+     */
+    async parameters_listManRender(options) {
+        try {
+            const asset = this.controller.chrisObject.asset;
+            if (!asset || typeof asset.resources_listAndFilterByOptions !== 'function') {
+                return envelope_error('', undefined, "Underlying resource does not support listing.\n");
+            }
+            const params = options_toParams(options);
+            const results = await asset.resources_listAndFilterByOptions(params);
+            if (results) {
+                return envelope_ok(`${pluginParameters_manRender(results)}\n`);
+            }
+            return envelope_ok("No parameters found.\n");
+        }
+        catch (error) {
+            return envelope_error('', undefined, `Error listing parameters: ${error}\n`);
+        }
+    }
+    /**
+     * Renders available fields for the current plugin context resource as an envelope.
+     *
+     * Sans-I/O counterpart to {@link parameters_fieldsList}.
+     *
+     * @returns An envelope carrying the field listing.
+     */
+    async parameters_fieldsRender() {
+        if (this.baseGroupHandler) {
+            return this.baseGroupHandler.resourceFields_render();
+        }
+        return envelope_ok('');
+    }
     /**
      * Sets up the Commander.js commands for plugin context group operations.
      *

package/dist/run.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file In-process library entry for the chili (ChILI) CLI.
+ *
+ * Exposes {@link run}, which builds a fresh Commander program and executes a
+ * single chili command, returning when it completes. Unlike the bin entry
+ * (`index.ts`), importing this module has no side effect of running the CLI and
+ * never calls `process.exit`, so a host process such as chell can drive chili
+ * in-process instead of spawning a separate `node` subprocess.
+ *
+ * @module
+ */
+/**
+ * Executes a single chili command in the current process.
+ *
+ * Builds a fresh Commander program (so repeated calls do not share parser
+ * state), wires all command handlers, and parses the supplied arguments. Help,
+ * version and usage errors are handled gracefully (Commander's message is
+ * already written) instead of terminating the process; genuine errors thrown by
+ * a command action propagate to the caller.
+ *
+ * @param argv - The chili arguments, e.g. `["feeds", "list", "-s"]` (without
+ *   the leading `node`/script entries).
+ */
+export declare function run(argv: string[]): Promise<void>;

package/dist/run.js

@@ -0,0 +1,192 @@
+/**
+ * @file In-process library entry for the chili (ChILI) CLI.
+ *
+ * Exposes {@link run}, which builds a fresh Commander program and executes a
+ * single chili command, returning when it completes. Unlike the bin entry
+ * (`index.ts`), importing this module has no side effect of running the CLI and
+ * never calls `process.exit`, so a host process such as chell can drive chili
+ * in-process instead of spawning a separate `node` subprocess.
+ *
+ * @module
+ */
+import { Command, CommanderError } from "commander";
+import figlet from "figlet";
+import { connectCommand_setup } from "./connect/connectHandler.js";
+import { FeedGroupHandler, FeedMemberHandler } from "./feeds/feedHandler.js";
+import { PluginGroupHandler, PluginMemberHandler, } from "./plugins/pluginHandler.js";
+import { PluginMetaGroupHandler } from "./plugins/pluginMetaHandler.js";
+import { PluginContextGroupHandler } from "./plugins/pluginGroupHandler.js";
+import { inodeCommand_setup } from "./filesystem/inodeCommand.js";
+import { contextCommand_setup } from "./context/contextCommand.js";
+import { pathCommand_setup } from "./path/pathCommand.js";
+import { fileBrowserCommand_setup } from "./filesystem/filesystemHandler.js";
+import { manCommand_setup } from "./man/man.js";
+import { chefsCommand_setup } from "./chefs/chefs.js";
+import { PACSServerGroupHandler } from "./pacs/pacsServerHandler.js";
+import { PACSQueryGroupHandler } from "./pacs/pacsQueryHandler.js";
+import { PACSRetrieveGroupHandler } from "./pacs/pacsRetrieveHandler.js";
+import { chrisConnection_init, NodeStorageProvider, errorStack_getAllOfType, } from "@fnndsc/cumin";
+import { FileGroupHandler } from "./filesystem/fileGroupHandler.js";
+/**
+ * Suppress the DEP0169 (`url.parse()`) warning emitted transitively by
+ * axios -> proxy-from-env, which we do not control. Installed once at import.
+ * See the tracking note in the original bin entry for context.
+ */
+const originalEmitWarning = process.emitWarning;
+process.emitWarning = function (warning, ...args) {
+    if (typeof warning === "string" &&
+        (warning.includes("DEP0169") || warning.includes("url.parse()"))) {
+        return;
+    }
+    return originalEmitWarning.call(process, warning, ...args);
+};
+/**
+ * Registers every chili command handler on the supplied program. The handler
+ * setup functions are program-parameterised, so a fresh program can be wired on
+ * each call without sharing Commander state across invocations.
+ *
+ * @param program - The Commander program to register commands on.
+ */
+async function handlers_initialize(program) {
+    // Connection is intentionally not enforced here so that `--help` works; each
+    // command fails individually if it needs a connection that is not present.
+    fileBrowserCommand_setup(program);
+    contextCommand_setup(program);
+    pathCommand_setup(program);
+    manCommand_setup(program);
+    chefsCommand_setup(program);
+    const pacsServerHandler = new PACSServerGroupHandler();
+    pacsServerHandler.pacsServerCommand_setup(program);
+    const pacsQueryHandler = new PACSQueryGroupHandler();
+    pacsQueryHandler.pacsQueryCommand_setup(program);
+    const pacsRetrieveHandler = new PACSRetrieveGroupHandler();
+    pacsRetrieveHandler.pacsRetrieveCommand_setup(program);
+    await inodeCommand_setup(program);
+    const pluginGroupHandler = new PluginGroupHandler();
+    pluginGroupHandler.pluginGroupCommand_setup(program);
+    const pluginMetaGroupHandler = new PluginMetaGroupHandler();
+    pluginMetaGroupHandler.pluginMetaGroupCommand_setup(program);
+    const feedGroupHandler = new FeedGroupHandler();
+    feedGroupHandler.feedGroupCommand_setup(program);
+    const feedMemberHandler = new FeedMemberHandler();
+    feedMemberHandler.feedCommand_setup(program);
+    const pluginMemberHandler = new PluginMemberHandler();
+    pluginMemberHandler.pluginCommand_setup(program);
+    try {
+        const filesGroupHandler = await FileGroupHandler.handler_create("files");
+        filesGroupHandler.fileGroupCommand_setup(program);
+        const linksGroupHandler = await FileGroupHandler.handler_create("links");
+        linksGroupHandler.fileGroupCommand_setup(program);
+        const dirsGroupHandler = await FileGroupHandler.handler_create("dirs");
+        dirsGroupHandler.fileGroupCommand_setup(program);
+    }
+    catch (e) {
+        const err = e instanceof Error ? e.message : String(e);
+        const errors = errorStack_getAllOfType("error");
+        const warnings = errorStack_getAllOfType("warning");
+        console.log(`Note: File group commands (files, dirs, links) are unavailable. Reason: ${err}`);
+        if (errors.length > 0) {
+            console.log("Errors:");
+            errors.forEach((msg) => console.log(`  - ${msg}`));
+        }
+        if (warnings.length > 0) {
+            console.log("Warnings:");
+            warnings.forEach((msg) => console.log(`  - ${msg}`));
+        }
+    }
+    try {
+        const computesOfPluginHandler = await PluginContextGroupHandler.handler_create("computesofplugin");
+        computesOfPluginHandler.pluginContextGroupCommand_setup(program);
+        const pluginInstancesHandler = await PluginContextGroupHandler.handler_create("instancesofplugin");
+        pluginInstancesHandler.pluginContextGroupCommand_setup(program);
+        const pluginParametersHandler = await PluginContextGroupHandler.handler_create("parametersofplugin");
+        pluginParametersHandler.pluginContextGroupCommand_setup(program);
+    }
+    catch (e) {
+        const err = e instanceof Error ? e.message : String(e);
+        const errors = errorStack_getAllOfType("error");
+        const warnings = errorStack_getAllOfType("warning");
+        console.log(`Note: Plugin context commands are unavailable. Reason: ${err}`);
+        if (errors.length > 0) {
+            console.log("Errors:");
+            errors.forEach((msg) => console.log(`  - ${msg}`));
+        }
+        if (warnings.length > 0) {
+            console.log("Warnings:");
+            warnings.forEach((msg) => console.log(`  - ${msg}`));
+        }
+    }
+}
+/**
+ * Extracts a leading `key=value` context string from an argv array.
+ *
+ * @param args - An argv array shaped like `process.argv` (exec, script, ...).
+ * @returns A tuple of the context string (if any) and argv with it removed.
+ */
+function context_parse(args) {
+    for (let i = 2; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.includes("=") && !arg.startsWith("-")) {
+            const context = arg;
+            const newArgs = [...args.slice(0, i), ...args.slice(i + 1)];
+            return [context, newArgs];
+        }
+    }
+    return [undefined, args];
+}
+/**
+ * Executes a single chili command in the current process.
+ *
+ * Builds a fresh Commander program (so repeated calls do not share parser
+ * state), wires all command handlers, and parses the supplied arguments. Help,
+ * version and usage errors are handled gracefully (Commander's message is
+ * already written) instead of terminating the process; genuine errors thrown by
+ * a command action propagate to the caller.
+ *
+ * @param argv - The chili arguments, e.g. `["feeds", "list", "-s"]` (without
+ *   the leading `node`/script entries).
+ */
+export async function run(argv) {
+    const nodeStorageProvider = new NodeStorageProvider();
+    const connection = await chrisConnection_init(nodeStorageProvider);
+    // Commander's default parsing expects argv[0]/argv[1] to be exec/script.
+    let fullArgv = ["node", "chili", ...argv];
+    const [context, newArgs] = context_parse(fullArgv);
+    if (context) {
+        const contextSetSuccess = await connection.context_set(context);
+        if (!contextSetSuccess) {
+            console.error("Failed to set context.");
+            return;
+        }
+        fullArgv = newArgs;
+    }
+    const program = new Command();
+    program
+        .name("chili")
+        .description("ChILI handles Intelligent Line Interactions")
+        .version("1.0.1")
+        .option("-v, --verbose", "enable verbose output")
+        .option("-c, --config <path>", "path to config file")
+        .option("-s, --nosplash", "disable splash screen")
+        .exitOverride();
+    connectCommand_setup(program);
+    await handlers_initialize(program);
+    program.parseOptions(fullArgv);
+    const options = program.opts();
+    if (!options.nosplash) {
+        console.log(figlet.textSync("ChILI"));
+        console.log("ChILI handles Intelligent Line Interactions");
+    }
+    try {
+        await program.parseAsync(fullArgv);
+    }
+    catch (err) {
+        // Under exitOverride, --help/--version/usage errors throw a CommanderError
+        // whose message Commander has already written. Swallow these so the host
+        // (e.g. a chell REPL) is not torn down; rethrow anything else.
+        if (err instanceof CommanderError) {
+            return;
+        }
+        throw err;
+    }
+}

package/dist/screen/screen.d.ts

@@ -75,6 +75,19 @@ export declare function border_draw(text: string, borders?: Borders): string;
  * @param options - Optional table display options.
  * @returns The `TableContent` object or null on error.
  */
+/**
+ * Renders a table to a string, the string form of {@link table_display}.
+ *
+ * Envelope-returning callers use this to return their output rather than
+ * printing it; table_display remains the printing form for callers not yet
+ * converted. Returns an empty string when there is no table to render.
+ *
+ * @param tableData - The rows to render.
+ * @param headers - Column headers.
+ * @param options - Table formatting options.
+ * @returns The rendered table (with a trailing newline), or an empty string.
+ */
+export declare function table_render(tableData: TableDataRow[] | string[][] | string[], headers: string[] | string, options?: TableOptions): string;
 export declare function table_display(tableData: TableDataRow[] | string[][] | string[], headers: string[] | string, options?: TableOptions): TableContent | null;
 /**
  * Provides screen utilities for logging and table output.