@lakutata/entrypoint 3.0.0-beta.0

package/dist/cjs/adapter/commander/CommanderCLIEntrypoint.d.ts

@@ -0,0 +1,192 @@
+import { Command } from 'commander';
+import { type Module } from '@lakutata/core';
+import type { EntrypointAdapter } from '../../channel/EntrypointAdapter.js';
+import type { MiddlewareDefinition } from '../../lib/Middleware.js';
+import { CLIContext } from '../../context/CLIContext.js';
+/**
+ * The JSON schema of a property of the input of an action
+ */
+export type PropertySchema = {
+    type?: string | string[];
+    enum?: unknown[];
+    items?: PropertySchema;
+    default?: unknown;
+    description?: string;
+    format?: string;
+    [key: string]: unknown;
+};
+/**
+ * A text of the help or of the prompts of {@link commanderCLIEntrypoint}, given to its `translate` function.
+ */
+export type CLIText = {
+    /**
+     * The key identifying the text: `description` (the program), `commands.<command>.description`,
+     * `commands.<command>.options.<property>`, `commands.<command>.arguments.<name>` (a nested command's words are joined
+     * with dots: `package.exe`), the help titles and labels (`help.usage`, `help.options`, `help.commands`,
+     * `help.default`, `help.choices`…), the prompt messages (`prompt.json`).
+     */
+    key: string;
+    /**
+     * The English text, with its `{name}` placeholders.
+     */
+    text: string;
+    /**
+     * The values of the text's `{name}` placeholders, by name.
+     */
+    params?: Record<string, string>;
+};
+/**
+ * Translate a text of the help or of the prompts into the user's language: return the translated text, its `{name}`
+ * placeholders filled from `params`.
+ */
+export type CLITranslate = (text: CLIText) => string;
+/**
+ * The options of {@link commanderCLIEntrypoint}.
+ */
+export type CommanderCLIEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several CLI adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The program name shown in the help.
+     * @default the name of the script run, without its extension
+     */
+    bin?: string;
+    /**
+     * The program description shown in the help.
+     */
+    description?: string;
+    /**
+     * The descriptions of the command groups, by group name: the first words of the nested commands (`'package'` for
+     * the command `'package exe <file>'`), whose help (`tool package --help`) lists their commands.
+     */
+    groups?: Record<string, string>;
+    /**
+     * The program version; adds the `-V, --version` option.
+     */
+    version?: string;
+    /**
+     * The command-line arguments to parse, without the node executable and the script.
+     * @default process.argv.slice(2)
+     */
+    argv?: string[];
+    /**
+     * Prompt for the missing required options (it needs the optional package `@inquirer/prompts`): `'auto'` when both
+     * stdin and stdout are terminals, `true` always, `false` never. While prompting is on, the required options are not
+     * enforced by the parser; without `@inquirer/prompts` installed, prompting is off (the parser requires them).
+     * @default 'auto'
+     */
+    interactive?: boolean | 'auto';
+    /**
+     * The input stream of the prompts.
+     * @default process.stdin
+     */
+    stdin?: NodeJS.ReadableStream;
+    /**
+     * The output stream of the results, the help and the prompts.
+     * @default process.stdout
+     */
+    stdout?: NodeJS.WritableStream;
+    /**
+     * The output stream of the errors.
+     * @default process.stderr
+     */
+    stderr?: NodeJS.WritableStream;
+    /**
+     * Turn an action's result into the text or bytes written to stdout; `undefined` writes nothing.
+     * @default a string as is (with a final newline), bytes as is, `null` and `undefined` as nothing, any other value as
+     * indented JSON (the bigints as strings)
+     */
+    format?: (result: unknown) => string | Uint8Array | undefined;
+    /**
+     * What happens when no argument is given: `'help'` writes the help and ends with the code 1, `'ignore'` runs no
+     * command and leaves the application running (an application also serving other channels).
+     * @default 'help'
+     */
+    noCommand?: 'help' | 'ignore';
+    /**
+     * What happens once the command ended, with its exit code (0 on success, 1 on failure, the parser's code for a
+     * usage error): `'application'` exits the application with the code, `'process'` only sets `process.exitCode`,
+     * `'none'` does nothing, or a function receiving the code.
+     * @default 'application'
+     */
+    exit?: 'application' | 'process' | 'none' | ((code: number) => void | Promise<void>);
+    /**
+     * Customize the commander program (hooks, global options, additional commands) after the action commands are
+     * added and before the arguments are parsed.
+     */
+    configure?: (program: Command) => void | Promise<void>;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+    /**
+     * Translate the texts of the help and of the prompts (the program, command, argument and option descriptions, the
+     * help titles) into the user's language: given the entrypoint's module when the arguments are parsed, it returns the
+     * translating function (`commanderTranslator` of `lakutata/com/i18n` returns the one of an i18n component). The
+     * command and option names are never translated.
+     * @default the English texts
+     */
+    translate?: (module: Module) => CLITranslate | Promise<CLITranslate>;
+};
+/**
+ * Create the CLI adapter of an entrypoint, parsing the command-line arguments with commander: each CLI action
+ * (`@CLIAction`) becomes a command, and the properties of its input DTO become its options. It needs the optional peer
+ * dependency `commander` (and `@inquirer/prompts` for the interactive prompts).
+ *
+ * A property becomes a kebab-case option (`deviceId` → `--device-id <value>`), parsed by its type: a number, `true` or
+ * `false`, a JSON object, an array (`--tags <values...>`), a boolean as a flag (with a `--no-<name>` negation when it
+ * defaults to `true`); the enums, the defaults and the descriptions appear in the help. The command text may declare
+ * positional arguments, given to the properties of their names (`'copy <files...> [target]'`), and its leading words
+ * before the last one name its groups (`'package exe <file>'` is the command `exe` of the group `package`).
+ *
+ * The command runs once the application has launched (all its objects, its bootstrap and the other adapters are
+ * ready). Its result is written to stdout (see `format`; an `EventsResult` writes each event's data, a `FileResult`
+ * the file's bytes); a failure writes `error: <message>` to stderr and ends with the code 1. Then the application exits
+ * with the command's code (see `exit`). When the entrypoint stops first, a command not started yet does not run, and
+ * the prompts and the event streams end.
+ * @param options The adapter options; by default it parses `process.argv`, prompts in a terminal, and exits the
+ * application once the command ended.
+ * @returns The adapter, to give to the `cli` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application, DTO} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {CLIAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {commanderCLIEntrypoint} from 'lakutata/adapter/commander'
+ *
+ * class GreetDTO extends DTO {
+ *     @Expect(DTO.String().required().description('The name to greet'))
+ *     public name!: string
+ *
+ *     @Expect(DTO.Number().integer().optional().default(1).description('How many times'))
+ *     public times?: number
+ *
+ *     @Expect(DTO.Boolean().optional().default(false))
+ *     public loud?: boolean
+ * }
+ *
+ * class GreetController extends Controller {
+ *     //tool greet Ada --times 2 --loud
+ *     @CLIAction('greet <name>', GreetDTO)
+ *     public async greet(input: GreetDTO): Promise<string> {
+ *         const text: string = `Hello, ${input.name}`
+ *         return (input.loud ? text.toUpperCase() : text).repeat(input.times ?? 1)
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'tool.app',
+ *     name: 'Tool',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [GreetController],
+ *             cli: commanderCLIEntrypoint({bin: 'tool', description: 'A greeting tool', version: '1.0.0'})
+ *         })
+ *     }
+ * })
+ * ```
+ */
+export declare function commanderCLIEntrypoint(options?: CommanderCLIEntrypointOptions): EntrypointAdapter<CLIContext>;

package/dist/cjs/adapter/commander/CommanderCLIEntrypoint.js

@@ -0,0 +1,439 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commanderCLIEntrypoint = commanderCLIEntrypoint;
+const commander_1 = require("commander");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const ApplicationOf_js_1 = require("../../lib/ApplicationOf.js");
+const CLIContext_js_1 = require("../../context/CLIContext.js");
+const BuiltinChannels_js_1 = require("../../channel/BuiltinChannels.js");
+const Result_js_1 = require("../../lib/Result.js");
+const Prompt_js_1 = require("./Prompt.js");
+const Width_js_1 = require("./Width.js");
+/**
+ * The English texts, their arguments filled
+ * @param text
+ */
+function english(text) {
+    return text.text.replace(/\{(\w+)\}/g, (all, name) => text.params?.[name] ?? all);
+}
+/**
+ * The keys of the titles of the help of commander
+ */
+const TITLES = {
+    'Usage:': 'help.usage',
+    'Arguments:': 'help.arguments',
+    'Options:': 'help.options',
+    'Commands:': 'help.commands',
+    'Global Options:': 'help.globalOptions'
+};
+/**
+ * The type of a property, without null
+ * @param schema
+ */
+function typeOf(schema) {
+    const types = [].concat(schema.type ?? []).filter((type) => type !== 'null');
+    if (types.length)
+        return types[0];
+    if (schema.enum?.length)
+        return typeof schema.enum[0];
+    return undefined;
+}
+/**
+ * The kebab case of a property name (deviceId → device-id)
+ * @param name
+ */
+function kebabCase(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/_/g, '-').toLowerCase();
+}
+/**
+ * Parse a value of an option by its schema
+ * @param schema
+ * @param value
+ */
+function parseValue(schema, value) {
+    let parsed;
+    switch (typeOf(schema)) {
+        case 'integer':
+        case 'number': {
+            parsed = Number(value);
+            if (value.trim() === '' || Number.isNaN(parsed))
+                throw new commander_1.InvalidArgumentError('Not a number.');
+            break;
+        }
+        case 'boolean': {
+            if (!['true', 'false'].includes(value))
+                throw new commander_1.InvalidArgumentError('Not a boolean.');
+            parsed = value === 'true';
+            break;
+        }
+        case 'object': {
+            try {
+                parsed = JSON.parse(value);
+            }
+            catch {
+                throw new commander_1.InvalidArgumentError('Not a JSON object.');
+            }
+            break;
+        }
+        default:
+            parsed = value;
+    }
+    if (schema.enum && !schema.enum.includes(parsed))
+        throw new commander_1.InvalidArgumentError(`Allowed choices are ${schema.enum.map((choice) => JSON.stringify(choice)).join(', ')}.`);
+    return parsed;
+}
+/**
+ * The option of a property
+ * @param property
+ * @param schema
+ * @param mandatory
+ * @param say the text of the help in the language of the user
+ * @param command the name of the command
+ */
+function propertyOption(property, schema, mandatory, say, command) {
+    const flag = `--${kebabCase(property)}`;
+    //A boolean or a value (DTO.Alternatives(DTO.Boolean(), …)): a flag taking an optional value
+    const alternatives = Array.isArray(schema.anyOf) ? schema.anyOf : [];
+    const valued = alternatives.some((alternative) => typeOf(alternative) === 'boolean')
+        ? alternatives.find((alternative) => typeOf(alternative) !== 'boolean')
+        : undefined;
+    const hints = [];
+    const choices = schema.enum ?? schema.items?.enum ?? valued?.enum;
+    if (choices)
+        hints.push(say('help.choices', 'choices: {choices}', { choices: choices.map((choice) => JSON.stringify(choice)).join(', ') }));
+    if (schema.default !== undefined)
+        hints.push(say('help.default', 'default: {value}', { value: JSON.stringify(schema.default) }));
+    const text = schema.description ? say(`commands.${command}.options.${property}`, schema.description) : '';
+    //The hints after the description, " (default: 1)"
+    const description = hints.length ? `${text}${say('help.hints', ' ({hints})', { hints: hints.join(say('help.separator', ', ')) })}`.trim() : text;
+    //--flag gives true, --flag <value> the value
+    if (valued)
+        return [new commander_1.Option(`${flag} [value]`, description).argParser((value) => parseValue(valued, value))];
+    const type = typeOf(schema);
+    if (type === 'boolean') {
+        const options = [new commander_1.Option(flag, description)];
+        //A flag on by default is turned off by its negation
+        if (schema.default === true)
+            options.push(new commander_1.Option(`--no-${kebabCase(property)}`, say('help.negate', 'Turn off {flag}', { flag: flag })));
+        return options;
+    }
+    const option = type === 'array'
+        ? new commander_1.Option(`${flag} <values...>`, description).argParser((value, previous) => [...(Array.isArray(previous) ? previous : []), parseValue(schema.items ?? {}, value)])
+        : new commander_1.Option(`${flag} <${type === 'object' ? 'json' : 'value'}>`, description).argParser((value) => parseValue(schema, value));
+    return [option.makeOptionMandatory(mandatory)];
+}
+/**
+ * The default format of a result
+ * @param result
+ */
+function defaultFormat(result) {
+    if (result === undefined || result === null)
+        return undefined;
+    if (typeof result === 'string')
+        return result.endsWith('\n') ? result : `${result}\n`;
+    if (result instanceof Uint8Array)
+        return result;
+    return `${JSON.stringify(result, (key, value) => typeof value === 'bigint' ? value.toString() : value, 2)}\n`;
+}
+/**
+ * The message of an error
+ * @param error
+ */
+function errorMessage(error) {
+    if (error && typeof error === 'object') {
+        const { errMsg, message } = error;
+        if (typeof errMsg === 'string' && errMsg)
+            return errMsg;
+        if (typeof message === 'string' && message)
+            return message;
+    }
+    return String(error);
+}
+/**
+ * Create the CLI adapter of an entrypoint, parsing the command-line arguments with commander: each CLI action
+ * (`@CLIAction`) becomes a command, and the properties of its input DTO become its options. It needs the optional peer
+ * dependency `commander` (and `@inquirer/prompts` for the interactive prompts).
+ *
+ * A property becomes a kebab-case option (`deviceId` → `--device-id <value>`), parsed by its type: a number, `true` or
+ * `false`, a JSON object, an array (`--tags <values...>`), a boolean as a flag (with a `--no-<name>` negation when it
+ * defaults to `true`); the enums, the defaults and the descriptions appear in the help. The command text may declare
+ * positional arguments, given to the properties of their names (`'copy <files...> [target]'`), and its leading words
+ * before the last one name its groups (`'package exe <file>'` is the command `exe` of the group `package`).
+ *
+ * The command runs once the application has launched (all its objects, its bootstrap and the other adapters are
+ * ready). Its result is written to stdout (see `format`; an `EventsResult` writes each event's data, a `FileResult`
+ * the file's bytes); a failure writes `error: <message>` to stderr and ends with the code 1. Then the application exits
+ * with the command's code (see `exit`). When the entrypoint stops first, a command not started yet does not run, and
+ * the prompts and the event streams end.
+ * @param options The adapter options; by default it parses `process.argv`, prompts in a terminal, and exits the
+ * application once the command ended.
+ * @returns The adapter, to give to the `cli` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application, DTO} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {CLIAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {commanderCLIEntrypoint} from 'lakutata/adapter/commander'
+ *
+ * class GreetDTO extends DTO {
+ *     @Expect(DTO.String().required().description('The name to greet'))
+ *     public name!: string
+ *
+ *     @Expect(DTO.Number().integer().optional().default(1).description('How many times'))
+ *     public times?: number
+ *
+ *     @Expect(DTO.Boolean().optional().default(false))
+ *     public loud?: boolean
+ * }
+ *
+ * class GreetController extends Controller {
+ *     //tool greet Ada --times 2 --loud
+ *     @CLIAction('greet <name>', GreetDTO)
+ *     public async greet(input: GreetDTO): Promise<string> {
+ *         const text: string = `Hello, ${input.name}`
+ *         return (input.loud ? text.toUpperCase() : text).repeat(input.times ?? 1)
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'tool.app',
+ *     name: 'Tool',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [GreetController],
+ *             cli: commanderCLIEntrypoint({bin: 'tool', description: 'A greeting tool', version: '1.0.0'})
+ *         })
+ *     }
+ * })
+ * ```
+ */
+function commanderCLIEntrypoint(options = {}) {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const stdin = options.stdin ?? process.stdin;
+    const format = options.format ?? defaultFormat;
+    //Aborts the prompts and the event streams when the adapter stops
+    const stopController = new AbortController();
+    const write = (output) => {
+        if (output !== undefined && output.length)
+            stdout.write(output);
+    };
+    /**
+     * Write the result of an action
+     * @param result
+     */
+    const output = async (result) => {
+        if (result instanceof Result_js_1.EventsResult) {
+            return await result.producer((data) => {
+                if (!stopController.signal.aborted)
+                    write(format(data));
+            }, stopController.signal);
+        }
+        if (result instanceof Result_js_1.FileResult) {
+            const source = result.source;
+            if (Buffer.isBuffer(source))
+                return write(source);
+            const stream = typeof source === 'string' ? (0, node_fs_1.createReadStream)(node_path_1.default.resolve(source)) : source;
+            return await new Promise((resolve, reject) => {
+                stream.once('error', reject).once('end', resolve).pipe(stdout, { end: false });
+            });
+        }
+        write(format(result instanceof Result_js_1.StatusResult ? result.data : result));
+    };
+    /**
+     * Whether the missing options are prompted: the prompts installed (else the parser requires the options)
+     */
+    const interactive = async () => {
+        if (options.interactive === false)
+            return false;
+        if (options.interactive !== true && !(stdin.isTTY && stdout.isTTY))
+            return false;
+        return !!(await (0, Prompt_js_1.loadPrompts)());
+    };
+    /**
+     * Run a command
+     * @param runtime
+     * @param action
+     * @param data
+     * @param prompting
+     * @param describe the description of a property in the language of the user
+     * @param say the text of the prompts in the language of the user
+     */
+    const execute = async (runtime, action, data, prompting, describe, say) => {
+        try {
+            if (prompting)
+                await (0, Prompt_js_1.prompt)(action, data, { input: stdin, output: stdout, signal: stopController.signal }, describe, say);
+            const context = new CLIContext_js_1.CLIContext({ command: action.address.command, data: data });
+            await output(await runtime.dispatchTo(action, context));
+            return 0;
+        }
+        catch (error) {
+            stderr.write(`error: ${errorMessage(error)}\n`);
+            return 1;
+        }
+    };
+    /**
+     * Parse the arguments and run the command
+     * @param runtime
+     */
+    const run = async (runtime) => {
+        const argv = options.argv ?? process.argv.slice(2);
+        if (!argv.length && options.noCommand === 'ignore')
+            return undefined;
+        const prompting = await interactive();
+        //The texts of the help and of the prompts in the language of the user
+        const translate = options.translate ? await options.translate(runtime.module) : english;
+        const say = (key, text, params) => translate({ key: key, text: text, params: params });
+        const program = new commander_1.Command(options.bin ?? node_path_1.default.basename(process.argv[1] ?? 'cli', node_path_1.default.extname(process.argv[1] ?? '')))
+            .exitOverride()
+            .configureOutput({
+            writeOut: (text) => stdout.write(text),
+            writeErr: (text) => stderr.write(text)
+        });
+        if (options.translate) {
+            //Inherited by the commands created next
+            program
+                .configureHelp({
+                styleTitle: (title) => TITLES[title] ? say(TITLES[title], title) : title,
+                //The widths of the wide characters (Chinese, Japanese, Korean), their lines wrapped between them
+                displayWidth: Width_js_1.displayWidth,
+                boxWrap: (text, width) => (0, Width_js_1.boxWrap)(text, width)
+            })
+                .helpOption('-h, --help', say('help.helpOption', 'display help for command'));
+            if (runtime.actions.length)
+                program.helpCommand('help [command]', say('help.helpCommand', 'display help for command'));
+        }
+        if (options.description)
+            program.description(say('description', options.description));
+        /**
+         * A group of commands, its help listing them
+         * @param parent
+         * @param group its name
+         * @param names the names of its groups and its own
+         */
+        const commandGroup = (parent, group, names) => {
+            const created = parent.command(group);
+            const description = options.groups?.[names.join(' ')];
+            if (description)
+                created.description(say(`commands.${names.join('.')}.description`, description));
+            if (options.translate)
+                created.helpCommand('help [command]', say('help.helpCommand', 'display help for command'));
+            return created;
+        };
+        if (options.version)
+            program.version(options.version, '-V, --version', say('help.versionOption', 'output the version number'));
+        let code = 0;
+        for (const action of runtime.actions) {
+            const schema = action.jsonSchema;
+            const required = new Set(schema.required ?? []);
+            //The command may declare positional arguments ("run <script>", "copy <files...> [target]"), given to the properties of their names;
+            //its words before them but the last are its groups ("package exe <file>": the command exe of the group package)
+            const words = action.address.command.trim().split(/\s+/);
+            const first = words.findIndex((word) => /^[<[]/.test(word));
+            const names = first < 0 ? words : words.slice(0, first);
+            let parent = program;
+            names.slice(0, -1).forEach((group, index) => {
+                parent = parent.commands.find((existing) => existing.name() === group) ?? commandGroup(parent, group, names.slice(0, index + 1));
+            });
+            const command = parent.command([names.at(-1), ...words.slice(names.length)].join(' ')).allowExcessArguments(false);
+            //The key of its texts: the names of its groups and its own
+            const name = names.join('.');
+            command.description(action.description ? say(`commands.${name}.description`, action.description) : action.name);
+            const positional = command.registeredArguments.map((argument) => argument.name());
+            //The description of a property: the one of its argument or of its option
+            const describe = (property) => {
+                const text = schema.properties?.[property]?.description;
+                return text ? say(`commands.${name}.${positional.includes(property) ? 'arguments' : 'options'}.${property}`, text) : undefined;
+            };
+            for (const argument of command.registeredArguments) {
+                const propertySchema = schema.properties?.[argument.name()];
+                if (!propertySchema)
+                    continue;
+                if (propertySchema.description)
+                    argument.description = describe(argument.name());
+                if (argument.variadic) {
+                    argument.argParser((value, previous) => [...(Array.isArray(previous) ? previous : []), parseValue(propertySchema.items ?? {}, value)]);
+                }
+                else {
+                    argument.argParser((value) => parseValue(propertySchema, value));
+                }
+            }
+            //The properties by the attribute names of their options
+            const properties = new Map();
+            for (const [property, propertySchema] of Object.entries(schema.properties ?? {})) {
+                if (positional.includes(property))
+                    continue;
+                const mandatory = !prompting && required.has(property) && propertySchema.default === undefined;
+                for (const option of propertyOption(property, propertySchema, mandatory, say, name)) {
+                    command.addOption(option);
+                    properties.set(option.attributeName(), property);
+                }
+            }
+            command.action(async () => {
+                const data = {};
+                positional.forEach((name, index) => {
+                    const value = command.processedArgs[index];
+                    if (value !== undefined)
+                        data[name] = value;
+                });
+                for (const [attribute, value] of Object.entries(command.opts())) {
+                    if (value !== undefined && properties.has(attribute))
+                        data[properties.get(attribute)] = value;
+                }
+                code = await execute(runtime, action, data, prompting, describe, say);
+            });
+        }
+        await options.configure?.(program);
+        try {
+            await program.parseAsync(argv, { from: 'user' });
+        }
+        catch (error) {
+            if (error instanceof commander_1.CommanderError)
+                return error.exitCode;
+            throw error;
+        }
+        return code;
+    };
+    /**
+     * End with the code of the command
+     * @param runtime
+     * @param code
+     */
+    const exit = async (runtime, code) => {
+        const mode = options.exit ?? 'application';
+        if (typeof mode === 'function')
+            return await mode(code);
+        if (mode === 'none')
+            return;
+        const application = mode === 'application' ? (0, ApplicationOf_js_1.applicationOf)(runtime.module) : undefined;
+        if (application)
+            return application.exit(code);
+        process.exitCode = code;
+    };
+    return {
+        channel: 'cli',
+        definition: BuiltinChannels_js_1.CLIChannel,
+        name: options.name,
+        middlewares: options.middlewares,
+        start: (runtime) => {
+            //The command runs once the application launched: every object, the bootstrap and the other adapters are ready
+            runtime.ready
+                .then(() => stopController.signal.aborted ? undefined : run(runtime))
+                .catch((error) => {
+                stderr.write(`error: ${errorMessage(error)}\n`);
+                return 1;
+            })
+                .then((code) => code === undefined || stopController.signal.aborted ? undefined : exit(runtime, code))
+                .catch((error) => stderr.write(`error: ${errorMessage(error)}\n`));
+        },
+        stop: () => {
+            //A command not started yet is not run, the prompts and the event streams are ended
+            stopController.abort();
+        }
+    };
+}

package/dist/cjs/adapter/commander/Prompt.d.ts

@@ -0,0 +1,22 @@
+import type { ChannelActionInfo } from '../../channel/EntrypointAdapter.js';
+/**
+ * The streams of the prompts
+ */
+export type PromptStreams = {
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+    signal: AbortSignal;
+};
+/**
+ * Load the prompts
+ */
+export declare function loadPrompts(): Promise<any>;
+/**
+ * Prompt for the required properties missing from the input of an action, when @inquirer/prompts is installed
+ * @param action
+ * @param data
+ * @param streams
+ * @param describe the description of a property in the language of the user
+ * @param say the text of the prompts in the language of the user
+ */
+export declare function prompt(action: ChannelActionInfo, data: Record<string, unknown>, streams: PromptStreams, describe?: (property: string) => string | undefined, say?: (key: string, text: string) => string): Promise<void>;