@guanghechen/commander 4.5.1 → 4.7.0

package/lib/cjs/{index.cjs → node.cjs}

@@ -1,28 +1,98 @@
 'use strict';
 
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var env = require('@guanghechen/env');
 var reporter = require('@guanghechen/reporter');
 var fs = require('node:fs');
-var path = require('node:path');
 
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
+const WINDOWS_DRIVE_ABSOLUTE_REGEX = /^[a-zA-Z]:[\\/]/;
+function isAbsolutePath(filepath) {
+    return (filepath.startsWith('/') ||
+        filepath.startsWith('\\\\') ||
+        WINDOWS_DRIVE_ABSOLUTE_REGEX.test(filepath));
+}
+function resolvePathFrom(base, fragment) {
+    const useWindowsStyle = WINDOWS_DRIVE_ABSOLUTE_REGEX.test(base);
+    const normalizedBase = base.replace(/\\/g, '/');
+    const normalizedFragment = fragment.replace(/\\/g, '/');
+    const source = isAbsolutePath(normalizedFragment)
+        ? normalizedFragment
+        : `${normalizedBase.replace(/\/$/, '')}/${normalizedFragment}`;
+    const prefix = useWindowsStyle ? source.slice(0, 2) : '';
+    const body = useWindowsStyle ? source.slice(2) : source;
+    const stack = [];
+    for (const token of body.split('/')) {
+        if (token === '' || token === '.') {
+            continue;
+        }
+        if (token === '..') {
+            if (stack.length > 0) {
+                stack.pop();
             }
-        });
+            continue;
+        }
+        stack.push(token);
+    }
+    if (useWindowsStyle) {
+        const resolved = `${prefix}/${stack.join('/')}`;
+        return resolved.endsWith('/') ? resolved.slice(0, -1) : resolved;
+    }
+    return `/${stack.join('/')}`;
+}
+function createUnsupportedFsError(operation) {
+    return new Error(`runtime does not support file-system operation: ${operation}`);
+}
+function getFallbackCwd() {
+    const proc = globalThis.process;
+    if (proc && typeof proc.cwd === 'function') {
+        return proc.cwd();
     }
-    n.default = e;
-    return Object.freeze(n);
+    return '/';
+}
+function createBrowserCommandRuntime() {
+    return {
+        cwd: () => getFallbackCwd(),
+        isAbsolute: filepath => isAbsolutePath(filepath),
+        resolve: (...paths) => {
+            if (paths.length === 0) {
+                return getFallbackCwd();
+            }
+            let resolved = getFallbackCwd();
+            for (const path of paths) {
+                if (path.length === 0) {
+                    continue;
+                }
+                resolved = resolvePathFrom(resolved, path);
+            }
+            return resolved;
+        },
+        readFile: async () => {
+            throw createUnsupportedFsError('readFile');
+        },
+        stat: async () => {
+            throw createUnsupportedFsError('stat');
+        },
+    };
+}
+
+let defaultRuntime = createBrowserCommandRuntime();
+function getDefaultCommandRuntime() {
+    return defaultRuntime;
+}
+function setDefaultCommandRuntime(runtime) {
+    defaultRuntime = runtime;
 }
 
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+function createNodeCommandRuntime() {
+    return {
+        cwd: () => process.cwd(),
+        isAbsolute: filepath => path.isAbsolute(filepath),
+        resolve: (...paths) => path.resolve(...paths),
+        readFile: filepath => promises.readFile(filepath, 'utf8'),
+        stat: filepath => promises.stat(filepath),
+    };
+}
 
 const TERMINAL_STYLE = {
     bold: '\x1b[1m',
@@ -36,22 +106,35 @@ function styleText(text, ...styles) {
     return `${styles.join('')}${text}${TERMINAL_STYLE.reset}`;
 }
 
+const BUILTIN_LOG_LEVELS = ['debug', 'info', 'hint', 'warn', 'error'];
+function resolveReporterLogLevel(raw) {
+    const normalized = raw.trim().toLowerCase();
+    return BUILTIN_LOG_LEVELS.find(level => level === normalized);
+}
+function setReporterLevel(ctx, level) {
+    const reporter = ctx.reporter;
+    reporter?.setLevel?.(level);
+}
+function setReporterFlight(ctx, flight) {
+    const reporter = ctx.reporter;
+    reporter?.setFlight?.(flight);
+}
 const logLevelOption = {
     long: 'logLevel',
     type: 'string',
     args: 'required',
     desc: 'Set log level',
     default: 'info',
-    choices: reporter.LOG_LEVELS,
+    choices: [...BUILTIN_LOG_LEVELS],
     coerce: (raw) => {
-        const level = reporter.resolveLogLevel(raw);
+        const level = resolveReporterLogLevel(raw);
         if (level === undefined) {
             throw new Error(`Invalid log level: ${raw}`);
         }
         return level;
     },
     apply: (value, ctx) => {
-        ctx.reporter.setLevel(value);
+        setReporterLevel(ctx, value);
     },
 };
 const logDateOption = {
@@ -61,7 +144,7 @@ const logDateOption = {
     desc: 'Enable log timestamp',
     default: true,
     apply: (value, ctx) => {
-        ctx.reporter.setFlight({ date: Boolean(value) });
+        setReporterFlight(ctx, { date: Boolean(value) });
     },
 };
 const logColorfulOption = {
@@ -71,7 +154,7 @@ const logColorfulOption = {
     desc: 'Enable colorful log output',
     default: true,
     apply: (value, ctx) => {
-        ctx.reporter.setFlight({ color: Boolean(value) });
+        setReporterFlight(ctx, { color: Boolean(value) });
     },
 };
 const silentOption = {
@@ -82,7 +165,7 @@ const silentOption = {
     default: false,
     apply: (value, ctx) => {
         if (value) {
-            ctx.reporter.setLevel('error');
+            setReporterLevel(ctx, 'error');
         }
     },
 };
@@ -103,6 +186,11 @@ class CommanderError extends Error {
 
 const LONG_OPTION_REGEX = /^--[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 const NEGATIVE_OPTION_REGEX = /^--no-[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const PRESET_OPTS_FLAG = '--preset-opts';
+const PRESET_ENVS_FLAG = '--preset-envs';
+const PRESET_ROOT_FLAG = '--preset-root';
+const DEFAULT_PRESET_OPTS_FILENAME = '.opt.local';
+const DEFAULT_PRESET_ENVS_FILENAME = '.env.local';
 function kebabToCamelCase(str) {
     return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
@@ -190,14 +278,12 @@ function tokenize(argv, commandPath) {
 }
 const BUILTIN_HELP_OPTION = {
     long: 'help',
-    short: 'h',
     type: 'boolean',
     args: 'none',
     desc: 'Show help information',
 };
 const BUILTIN_VERSION_OPTION = {
     long: 'version',
-    short: 'V',
     type: 'boolean',
     args: 'none',
     desc: 'Show version number',
@@ -211,6 +297,7 @@ const BUILTIN_COLOR_OPTION = {
 };
 function createBuiltinOptionState(enabled) {
     return {
+        version: enabled,
         color: enabled,
         logLevel: enabled,
         silent: enabled,
@@ -224,9 +311,6 @@ function isNoColorEnabled(envs) {
 function normalizeBuiltinConfig(builtin) {
     const resolved = {
         option: createBuiltinOptionState(true),
-        command: {
-            help: false,
-        },
     };
     if (builtin === undefined) {
         return resolved;
@@ -234,13 +318,11 @@ function normalizeBuiltinConfig(builtin) {
     if (builtin === true) {
         return {
             option: createBuiltinOptionState(true),
-            command: { help: true },
         };
     }
     if (builtin === false) {
         return {
             option: createBuiltinOptionState(false),
-            command: { help: false },
         };
     }
     if (builtin.option !== undefined) {
@@ -251,6 +333,8 @@ function normalizeBuiltinConfig(builtin) {
             resolved.option = createBuiltinOptionState(true);
         }
         else {
+            if (builtin.option.version !== undefined)
+                resolved.option.version = builtin.option.version;
             if (builtin.option.color !== undefined)
                 resolved.option.color = builtin.option.color;
             if (builtin.option.logLevel !== undefined) {
@@ -265,25 +349,17 @@ function normalizeBuiltinConfig(builtin) {
             }
         }
     }
-    if (builtin.command !== undefined) {
-        if (builtin.command === false) {
-            resolved.command = { help: false };
-        }
-        else if (builtin.command === true) {
-            resolved.command = { help: true };
-        }
-        else if (builtin.command.help !== undefined) {
-            resolved.command.help = builtin.command.help;
-        }
-    }
     return resolved;
 }
 class Command {
     #name;
     #desc;
     #version;
+    #builtinConfig;
     #builtin;
+    #presetConfig;
     #reporter;
+    #runtime;
     #parent;
     #options = [];
     #arguments = [];
@@ -295,8 +371,11 @@ class Command {
         this.#name = config.name ?? '';
         this.#desc = config.desc;
         this.#version = config.version;
+        this.#builtinConfig = config.builtin;
         this.#builtin = normalizeBuiltinConfig(config.builtin);
+        this.#presetConfig = config.preset;
         this.#reporter = config.reporter;
+        this.#runtime = config.runtime ?? getDefaultCommandRuntime();
     }
     get name() {
         return this.#name || undefined;
@@ -307,6 +386,12 @@ class Command {
     get version() {
         return this.#version;
     }
+    get builtin() {
+        return this.#builtinConfig;
+    }
+    get preset() {
+        return this.#presetConfig === undefined ? undefined : { ...this.#presetConfig };
+    }
     get parent() {
         return this.#parent;
     }
@@ -342,14 +427,17 @@ class Command {
         return this;
     }
     subcommand(name, cmd) {
-        if (this.#builtin.command.help && name === 'help') {
-            throw new CommanderError('ConfigurationError', '"help" is a reserved subcommand name when help subcommand is enabled', this.#getCommandPath());
+        if (name === 'help') {
+            throw new CommanderError('ConfigurationError', '"help" is a reserved subcommand name', this.#getCommandPath());
         }
         if (cmd.#parent && cmd.#parent !== this) {
             throw new CommanderError('ConfigurationError', `command "${cmd.#name}" already has a parent`, this.#getCommandPath());
         }
         const existing = this.#subcommandsList.find(e => e.command === cmd);
         if (existing) {
+            if (existing.aliases.includes(name)) {
+                return this;
+            }
             existing.aliases.push(name);
             this.#subcommandsMap.set(name, cmd);
         }
@@ -362,34 +450,37 @@ class Command {
         return this;
     }
     async run(params) {
-        const { argv, envs, reporter: reporter$1 } = params;
+        const { argv, envs, reporter } = params;
         try {
-            const processedArgv = this.#processHelpSubcommand(argv);
-            const routeResult = this.#route(processedArgv);
-            const { chain, remaining } = routeResult;
+            const routeResult = this.#route(argv);
+            const { chain } = routeResult;
             const leafCommand = chain[chain.length - 1];
-            const tokenizeResult = tokenize(remaining, leafCommand.#getCommandPath());
-            const { optionTokens, restArgs } = tokenizeResult;
-            const optionPolicyMap = this.#buildOptionPolicyMap(chain);
-            const leafPolicy = this.#mustGetOptionPolicy(optionPolicyMap, leafCommand);
-            if (leafPolicy.enableBuiltinHelp && this.#hasFlag(optionTokens, 'help', 'h')) {
-                const helpColor = leafCommand.#resolveHelpColorOption(optionTokens, envs, leafPolicy);
-                console.log(leafCommand.#formatHelpForDisplay({ color: helpColor }));
+            const ctx = this.#createContext({
+                chain,
+                cmds: routeResult.cmds,
+                envs,
+                reporter,
+            });
+            const controlScanResult = this.#controlScan(routeResult.remaining, leafCommand);
+            ctx.controls = controlScanResult.controls;
+            ctx.sources.user.argv = [...controlScanResult.remaining];
+            if (ctx.controls.help) {
+                const helpCommand = this.#resolveHelpCommand(leafCommand, controlScanResult.helpTarget);
+                const helpColor = helpCommand.#resolveHelpColorFromTailArgv(controlScanResult.remaining, ctx.envs);
+                console.log(helpCommand.#formatHelpForDisplay({ color: helpColor }));
                 return;
             }
-            if (leafPolicy.enableBuiltinVersion) {
-                if (this.#hasFlag(optionTokens, 'version', 'V')) {
-                    console.log(leafCommand.#version);
-                    return;
-                }
+            if (ctx.controls.version) {
+                console.log(leafCommand.#version);
+                return;
             }
+            const optionPolicyMap = this.#buildOptionPolicyMap(chain);
+            const presetResult = await this.#preset(controlScanResult.remaining, ctx, optionPolicyMap);
+            ctx.sources = presetResult.sources;
+            ctx.envs = presetResult.envs;
+            const tokenizeResult = tokenize(presetResult.tailArgv, leafCommand.#getCommandPath());
+            const { optionTokens, restArgs } = tokenizeResult;
             const resolveResult = this.#resolve(chain, optionTokens, optionPolicyMap);
-            const ctx = {
-                cmd: leafCommand,
-                envs,
-                reporter: reporter$1 ?? this.#reporter ?? new reporter.Reporter(),
-                argv,
-            };
             const parseResult = this.#parse(chain, resolveResult, optionPolicyMap, ctx, restArgs);
             const actionParams = {
                 ctx: parseResult.ctx,
@@ -401,7 +492,7 @@ class Command {
                 await leafCommand.#runAction(actionParams);
             }
             else if (leafCommand.#subcommandsList.length > 0) {
-                const helpColor = leafCommand.#resolveHelpColorOption(optionTokens, envs, leafPolicy);
+                const helpColor = leafCommand.#resolveHelpColorFromTailArgv(presetResult.tailArgv, ctx.envs);
                 console.log(leafCommand.#formatHelpForDisplay({ color: helpColor }));
             }
             else {
@@ -417,22 +508,27 @@ class Command {
             throw err;
         }
     }
-    parse(params) {
-        const { argv, envs, reporter: reporter$1 } = params;
-        const processedArgv = this.#processHelpSubcommand(argv);
-        const routeResult = this.#route(processedArgv);
-        const { chain, remaining } = routeResult;
+    async parse(params) {
+        const { argv, envs, reporter } = params;
+        const routeResult = this.#route(argv);
+        const { chain } = routeResult;
         const leafCommand = chain[chain.length - 1];
-        const tokenizeResult = tokenize(remaining, leafCommand.#getCommandPath());
-        const { optionTokens, restArgs } = tokenizeResult;
+        const ctx = this.#createContext({
+            chain,
+            cmds: routeResult.cmds,
+            envs,
+            reporter,
+        });
+        const controlScanResult = this.#controlScan(routeResult.remaining, leafCommand);
+        ctx.controls = controlScanResult.controls;
+        ctx.sources.user.argv = [...controlScanResult.remaining];
         const optionPolicyMap = this.#buildOptionPolicyMap(chain);
+        const presetResult = await this.#preset(controlScanResult.remaining, ctx, optionPolicyMap);
+        ctx.sources = presetResult.sources;
+        ctx.envs = presetResult.envs;
+        const tokenizeResult = tokenize(presetResult.tailArgv, leafCommand.#getCommandPath());
+        const { optionTokens, restArgs } = tokenizeResult;
         const resolveResult = this.#resolve(chain, optionTokens, optionPolicyMap);
-        const ctx = {
-            cmd: leafCommand,
-            envs,
-            reporter: reporter$1 ?? this.#reporter ?? new reporter.Reporter(),
-            argv,
-        };
         return this.#parse(chain, resolveResult, optionPolicyMap, ctx, restArgs);
     }
     formatHelp() {
@@ -450,7 +546,11 @@ class Command {
         return color && process.stdout.isTTY === true;
     }
     #buildHelpData() {
-        const allOptions = this.#resolveOptionPolicy().mergedOptions;
+        const parseOptions = this.#resolveOptionPolicy().mergedOptions;
+        const allOptions = [...parseOptions, BUILTIN_HELP_OPTION];
+        if (this.#supportsBuiltinVersion()) {
+            allOptions.push(BUILTIN_VERSION_OPTION);
+        }
         const commandPath = this.#getCommandPath();
         let usage = `Usage: ${commandPath}`;
         if (allOptions.length > 0)
@@ -484,7 +584,10 @@ class Command {
                 desc += ` [choices: ${opt.choices.join(', ')}]`;
             }
             options.push({ sig, desc });
-            if (opt.type === 'boolean' && opt.args === 'none') {
+            if (opt.type === 'boolean' &&
+                opt.args === 'none' &&
+                opt.long !== 'help' &&
+                opt.long !== 'version') {
                 options.push({
                     sig: `    --no-${kebabLong}`,
                     desc: `Negate --${kebabLong}`,
@@ -492,8 +595,7 @@ class Command {
             }
         }
         const commands = [];
-        const showHelpSubcommand = this.#builtin.command.help && this.#subcommandsList.length > 0;
-        if (showHelpSubcommand) {
+        if (this.#subcommandsList.length > 0) {
             commands.push({ name: 'help', desc: 'Show help for a command' });
         }
         for (const entry of this.#subcommandsList) {
@@ -616,50 +718,9 @@ class Command {
     #findSubcommandEntry(token) {
         return this.#subcommandsList.find(e => e.name === token || e.aliases.includes(token));
     }
-    #createUnknownSubcommandError(subcommand) {
-        const commandPath = this.#getCommandPath();
-        return new CommanderError('UnknownSubcommand', `unknown subcommand "${subcommand}" for command "${commandPath}"`, commandPath);
-    }
-    #processHelpSubcommand(argv) {
-        let current = this;
-        for (let i = 0; i < argv.length; ++i) {
-            const token = argv[i];
-            if (token.startsWith('-')) {
-                return argv;
-            }
-            if (token === 'help') {
-                if (!current.#builtin.command.help) {
-                    if (current.#subcommandsList.length > 0) {
-                        throw current.#createUnknownSubcommandError('help');
-                    }
-                    return argv;
-                }
-                if (current.#subcommandsList.length === 0) {
-                    return argv;
-                }
-                const target = argv[i + 1];
-                if (target === undefined) {
-                    return [...argv.slice(0, i), '--help'];
-                }
-                const targetEntry = current.#findSubcommandEntry(target);
-                if (targetEntry === undefined) {
-                    throw current.#createUnknownSubcommandError(target);
-                }
-                if (argv[i + 2] !== undefined) {
-                    throw new CommanderError('UnexpectedArgument', 'help subcommand accepts at most one subcommand argument', current.#getCommandPath());
-                }
-                return [...argv.slice(0, i), target, '--help'];
-            }
-            const entry = current.#findSubcommandEntry(token);
-            if (entry === undefined) {
-                return argv;
-            }
-            current = entry.command;
-        }
-        return argv;
-    }
     #route(argv) {
         const chain = [this];
+        const cmds = [];
         let current = this;
         let idx = 0;
         while (idx < argv.length) {
@@ -670,10 +731,382 @@ class Command {
             if (!entry)
                 break;
             current = entry.command;
+            cmds.push(token);
             chain.push(current);
             idx += 1;
         }
-        return { chain, remaining: argv.slice(idx) };
+        return { chain, remaining: argv.slice(idx), cmds };
+    }
+    #controlScan(tailArgv, leafCommand) {
+        const controls = { help: false, version: false };
+        const separatorIndex = tailArgv.indexOf('--');
+        const beforeSeparator = separatorIndex === -1 ? tailArgv : tailArgv.slice(0, separatorIndex);
+        const afterSeparator = separatorIndex === -1 ? [] : tailArgv.slice(separatorIndex + 1);
+        let helpTarget;
+        let scanStartIndex = 0;
+        if (beforeSeparator[0] === 'help') {
+            controls.help = true;
+            scanStartIndex = 1;
+            const candidate = beforeSeparator[1];
+            if (candidate !== undefined && !candidate.startsWith('-')) {
+                helpTarget = candidate;
+                scanStartIndex = 2;
+            }
+        }
+        const remainingBeforeSeparator = [];
+        for (let i = scanStartIndex; i < beforeSeparator.length; i += 1) {
+            const token = beforeSeparator[i];
+            if (token === '--help') {
+                controls.help = true;
+                continue;
+            }
+            if (token === '--version' && leafCommand.#supportsBuiltinVersion()) {
+                controls.version = true;
+                continue;
+            }
+            remainingBeforeSeparator.push(token);
+        }
+        const remaining = separatorIndex === -1
+            ? remainingBeforeSeparator
+            : [...remainingBeforeSeparator, '--', ...afterSeparator];
+        return {
+            controls,
+            remaining,
+            helpTarget,
+        };
+    }
+    #createContext(params) {
+        const { chain, cmds, envs, reporter: reporter$1 } = params;
+        const leafCommand = chain[chain.length - 1];
+        const envSnapshot = { ...envs };
+        return {
+            cmd: leafCommand,
+            chain,
+            envs: envSnapshot,
+            controls: { help: false, version: false },
+            sources: {
+                preset: {
+                    argv: [],
+                    envs: {},
+                },
+                user: {
+                    cmds: [...cmds],
+                    argv: [],
+                    envs: envSnapshot,
+                },
+            },
+            reporter: reporter$1 ?? this.#reporter ?? new reporter.Reporter(),
+        };
+    }
+    #resolveHelpCommand(leafCommand, helpTarget) {
+        if (helpTarget === undefined) {
+            return leafCommand;
+        }
+        const target = leafCommand.#findSubcommandEntry(helpTarget);
+        if (target === undefined) {
+            return leafCommand;
+        }
+        return target.command;
+    }
+    async #preset(controlTailArgv, ctx, optionPolicyMap) {
+        const commandPath = ctx.chain[ctx.chain.length - 1].#getCommandPath();
+        const separatorIndex = controlTailArgv.indexOf('--');
+        const beforeSeparator = separatorIndex === -1 ? controlTailArgv : controlTailArgv.slice(0, separatorIndex);
+        const afterSeparator = separatorIndex === -1 ? [] : controlTailArgv.slice(separatorIndex + 1);
+        const rootScanResult = this.#scanPresetRootDirectives(beforeSeparator, commandPath);
+        const commandPreset = this.#resolveCommandPresetFromChain(ctx.chain);
+        const presetRoot = await this.#resolveEffectivePresetRoot(rootScanResult.cliPresetRoots, commandPreset, commandPath);
+        const fileScanResult = this.#scanPresetFileDirectives(rootScanResult.cleanArgv, commandPath);
+        const cleanArgv = separatorIndex === -1
+            ? fileScanResult.cleanArgv
+            : [...fileScanResult.cleanArgv, '--', ...afterSeparator];
+        const presetOptsFiles = this.#resolvePresetFileSources({
+            cliFiles: fileScanResult.cliPresetOptsFiles,
+            commandPresetFile: this.#normalizeCommandPresetFile(commandPreset?.opt),
+            presetRoot,
+            defaultFilename: DEFAULT_PRESET_OPTS_FILENAME,
+        });
+        const presetEnvsFiles = this.#resolvePresetFileSources({
+            cliFiles: fileScanResult.cliPresetEnvsFiles,
+            commandPresetFile: this.#normalizeCommandPresetFile(commandPreset?.env),
+            presetRoot,
+            defaultFilename: DEFAULT_PRESET_ENVS_FILENAME,
+        });
+        const userSources = {
+            cmds: [...ctx.sources.user.cmds],
+            argv: [...cleanArgv],
+            envs: { ...ctx.sources.user.envs },
+        };
+        const presetArgv = [];
+        for (const file of presetOptsFiles) {
+            const content = await this.#readPresetFile(file, commandPath);
+            if (content === undefined) {
+                continue;
+            }
+            const tokens = this.#tokenizePresetOptions(content);
+            this.#validatePresetOptionTokens(tokens, file.displayPath, commandPath);
+            this.#assertPresetOptionFragments(tokens, file.displayPath, ctx.chain, optionPolicyMap);
+            presetArgv.push(...tokens);
+        }
+        const presetEnvs = {};
+        for (const file of presetEnvsFiles) {
+            const content = await this.#readPresetFile(file, commandPath);
+            if (content === undefined) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = env.parse(content);
+            }
+            catch (error) {
+                throw new CommanderError('ConfigurationError', `failed to parse preset envs file "${file.displayPath}": ${error.message}`, commandPath);
+            }
+            Object.assign(presetEnvs, parsed);
+        }
+        const sources = {
+            user: userSources,
+            preset: {
+                argv: presetArgv,
+                envs: presetEnvs,
+            },
+        };
+        const envs = { ...sources.user.envs, ...sources.preset.envs };
+        const tailArgv = [...sources.preset.argv, ...sources.user.argv];
+        return { tailArgv, envs, sources };
+    }
+    #resolveCommandPresetFromChain(chain) {
+        for (let index = chain.length - 1; index >= 0; index -= 1) {
+            const preset = chain[index].#presetConfig;
+            if (preset?.root !== undefined) {
+                return preset;
+            }
+        }
+        return undefined;
+    }
+    async #resolveEffectivePresetRoot(cliPresetRoots, commandPreset, commandPath) {
+        if (cliPresetRoots.length > 0) {
+            const root = cliPresetRoots[cliPresetRoots.length - 1];
+            return await this.#assertPresetRoot(root, PRESET_ROOT_FLAG, commandPath);
+        }
+        if (commandPreset?.root === undefined) {
+            return undefined;
+        }
+        return await this.#assertPresetRoot(commandPreset.root, 'command.preset.root', commandPath);
+    }
+    async #assertPresetRoot(root, sourceName, commandPath) {
+        if (!this.#runtime.isAbsolute(root)) {
+            throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" is not an absolute directory`, commandPath);
+        }
+        let stats;
+        try {
+            stats = await this.#runtime.stat(root);
+        }
+        catch (error) {
+            throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" cannot be accessed (${error.message})`, commandPath);
+        }
+        if (!stats.isDirectory()) {
+            throw new CommanderError('ConfigurationError', `invalid preset root from "${sourceName}": "${root}" is not a directory`, commandPath);
+        }
+        return root;
+    }
+    #normalizeCommandPresetFile(filepath) {
+        if (filepath === undefined) {
+            return undefined;
+        }
+        if (!this.#isValidPresetFileValue(filepath)) {
+            return undefined;
+        }
+        return filepath;
+    }
+    #resolvePresetFileSources(params) {
+        const { cliFiles, commandPresetFile, presetRoot, defaultFilename } = params;
+        if (cliFiles.length > 0) {
+            return cliFiles.map(filepath => ({
+                displayPath: filepath,
+                absolutePath: this.#resolvePresetFileAbsolutePath(filepath, presetRoot),
+                explicit: true,
+            }));
+        }
+        if (presetRoot === undefined) {
+            return [];
+        }
+        if (commandPresetFile !== undefined) {
+            return [
+                {
+                    displayPath: commandPresetFile,
+                    absolutePath: this.#resolvePresetFileAbsolutePath(commandPresetFile, presetRoot),
+                    explicit: true,
+                },
+            ];
+        }
+        const absolutePath = this.#runtime.resolve(presetRoot, defaultFilename);
+        return [
+            {
+                displayPath: absolutePath,
+                absolutePath,
+                explicit: false,
+            },
+        ];
+    }
+    #resolvePresetFileAbsolutePath(filepath, presetRoot) {
+        if (this.#runtime.isAbsolute(filepath)) {
+            return filepath;
+        }
+        if (presetRoot !== undefined) {
+            return this.#runtime.resolve(presetRoot, filepath);
+        }
+        return this.#runtime.resolve(this.#runtime.cwd(), filepath);
+    }
+    #assertPresetOptionFragments(tokens, filepath, chain, optionPolicyMap) {
+        if (tokens.length === 0) {
+            return;
+        }
+        const commandPath = chain[chain.length - 1].#getCommandPath();
+        try {
+            const { optionTokens, restArgs } = tokenize(tokens, commandPath);
+            void restArgs;
+            const { argTokens } = this.#resolve(chain, optionTokens, optionPolicyMap);
+            if (argTokens.length > 0) {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": token "${argTokens[0].original}" cannot be resolved as an option fragment`, commandPath);
+            }
+        }
+        catch (error) {
+            if (error instanceof CommanderError) {
+                if (error.kind === 'ConfigurationError') {
+                    throw error;
+                }
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": ${error.message}`, commandPath);
+            }
+            throw error;
+        }
+    }
+    #scanPresetRootDirectives(argv, commandPath) {
+        const cleanArgv = [];
+        const cliPresetRoots = [];
+        let index = 0;
+        while (index < argv.length) {
+            const token = argv[index];
+            if (token === PRESET_ROOT_FLAG) {
+                const value = argv[index + 1];
+                if (value === undefined || value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_ROOT_FLAG}"`, commandPath);
+                }
+                cliPresetRoots.push(value);
+                index += 2;
+                continue;
+            }
+            if (token.startsWith(`${PRESET_ROOT_FLAG}=`)) {
+                const value = token.slice(PRESET_ROOT_FLAG.length + 1);
+                if (value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_ROOT_FLAG}"`, commandPath);
+                }
+                cliPresetRoots.push(value);
+                index += 1;
+                continue;
+            }
+            cleanArgv.push(token);
+            index += 1;
+        }
+        return { cleanArgv, cliPresetRoots };
+    }
+    #scanPresetFileDirectives(argv, commandPath) {
+        const cleanArgv = [];
+        const cliPresetOptsFiles = [];
+        const cliPresetEnvsFiles = [];
+        const assertAndPush = (flag, value) => {
+            this.#assertPresetFileValue(value, flag, commandPath);
+            if (flag === PRESET_OPTS_FLAG) {
+                cliPresetOptsFiles.push(value);
+            }
+            else {
+                cliPresetEnvsFiles.push(value);
+            }
+        };
+        let index = 0;
+        while (index < argv.length) {
+            const token = argv[index];
+            if (token === PRESET_OPTS_FLAG || token === PRESET_ENVS_FLAG) {
+                const value = argv[index + 1];
+                if (value === undefined || value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${token}"`, commandPath);
+                }
+                assertAndPush(token, value);
+                index += 2;
+                continue;
+            }
+            if (token.startsWith(`${PRESET_OPTS_FLAG}=`)) {
+                const value = token.slice(PRESET_OPTS_FLAG.length + 1);
+                if (value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_OPTS_FLAG}"`, commandPath);
+                }
+                assertAndPush(PRESET_OPTS_FLAG, value);
+                index += 1;
+                continue;
+            }
+            if (token.startsWith(`${PRESET_ENVS_FLAG}=`)) {
+                const value = token.slice(PRESET_ENVS_FLAG.length + 1);
+                if (value.length === 0) {
+                    throw new CommanderError('ConfigurationError', `missing value for "${PRESET_ENVS_FLAG}"`, commandPath);
+                }
+                assertAndPush(PRESET_ENVS_FLAG, value);
+                index += 1;
+                continue;
+            }
+            cleanArgv.push(token);
+            index += 1;
+        }
+        return { cleanArgv, cliPresetOptsFiles, cliPresetEnvsFiles };
+    }
+    #isValidPresetFileValue(filepath) {
+        return filepath.length > 0 && !filepath.startsWith('..');
+    }
+    #assertPresetFileValue(filepath, directive, commandPath) {
+        if (this.#isValidPresetFileValue(filepath)) {
+            return;
+        }
+        throw new CommanderError('ConfigurationError', `invalid value for "${directive}": "${filepath}" (must be non-empty and must not start with "..")`, commandPath);
+    }
+    async #readPresetFile(file, commandPath) {
+        try {
+            return await this.#runtime.readFile(file.absolutePath);
+        }
+        catch (error) {
+            const ioError = error;
+            if (!file.explicit && ioError.code === 'ENOENT') {
+                return undefined;
+            }
+            throw new CommanderError('ConfigurationError', `failed to read preset file "${file.displayPath}": ${error.message}`, commandPath);
+        }
+    }
+    #tokenizePresetOptions(content) {
+        return content
+            .split(/\s+/)
+            .map(token => token.trim())
+            .filter(token => token.length > 0);
+    }
+    #validatePresetOptionTokens(tokens, filepath, commandPath) {
+        if (tokens.length === 0) {
+            return;
+        }
+        if (!tokens[0].startsWith('-')) {
+            throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": bare token "${tokens[0]}" cannot appear before any option token`, commandPath);
+        }
+        for (const token of tokens) {
+            if (token === '--') {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": "--" is not allowed`, commandPath);
+            }
+            if (token === 'help' || token === '--help' || token === '--version') {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": control token "${token}" is not allowed`, commandPath);
+            }
+            if (token === PRESET_ROOT_FLAG ||
+                token.startsWith(`${PRESET_ROOT_FLAG}=`) ||
+                token === PRESET_OPTS_FLAG ||
+                token.startsWith(`${PRESET_OPTS_FLAG}=`) ||
+                token === PRESET_ENVS_FLAG ||
+                token.startsWith(`${PRESET_ENVS_FLAG}=`)) {
+                throw new CommanderError('ConfigurationError', `invalid preset options in "${filepath}": preset directive "${token}" is not allowed`, commandPath);
+            }
+        }
     }
     #resolve(chain, tokens, optionPolicyMap) {
         const consumedTokens = new Map();
@@ -783,13 +1216,20 @@ class Command {
                 }
             }
         }
-        const mergedOpts = {};
-        for (const cmd of chain) {
-            Object.assign(mergedOpts, optsMap.get(cmd) ?? {});
+        const leafLocalOpts = {};
+        const leafParsedOpts = optsMap.get(leafCommand) ?? {};
+        for (const opt of leafCommand.#options) {
+            if (Object.prototype.hasOwnProperty.call(leafParsedOpts, opt.long)) {
+                leafLocalOpts[opt.long] = leafParsedOpts[opt.long];
+            }
         }
         const rawArgStrings = [...argTokens.map(t => t.original), ...restArgs];
         const { args, rawArgs } = leafCommand.#parseArguments(rawArgStrings);
-        return { ctx, opts: mergedOpts, args, rawArgs };
+        const parseCtx = {
+            ...ctx,
+            sources: this.#freezeInputSources(ctx.sources),
+        };
+        return { ctx: parseCtx, opts: leafLocalOpts, args, rawArgs };
     }
     #parseOptions(tokens, allOptions, envs) {
         const opts = {};
@@ -976,29 +1416,19 @@ class Command {
     #hasUserOption(long) {
         return this.#options.some(option => option.long === long);
     }
-    #canUseBuiltinVersion() {
-        return this.#version !== undefined;
+    #supportsBuiltinVersion() {
+        return this.#parent === undefined && this.#version !== undefined && this.#builtin.option.version;
     }
     #resolveOptionPolicy() {
         const optionMap = new Map();
         const hasUserColor = this.#hasUserOption('color');
-        const hasUserHelp = this.#hasUserOption('help');
-        const hasUserVersion = this.#hasUserOption('version');
         const hasUserLogLevel = this.#hasUserOption('logLevel');
         const hasUserSilent = this.#hasUserOption('silent');
         const hasUserLogDate = this.#hasUserOption('logDate');
         const hasUserLogColorful = this.#hasUserOption('logColorful');
-        const enableBuiltinHelp = !hasUserHelp;
-        const enableBuiltinVersion = !hasUserVersion && this.#canUseBuiltinVersion();
         if (this.#builtin.option.color && !hasUserColor) {
             optionMap.set('color', BUILTIN_COLOR_OPTION);
         }
-        if (enableBuiltinHelp) {
-            optionMap.set('help', BUILTIN_HELP_OPTION);
-        }
-        if (enableBuiltinVersion) {
-            optionMap.set('version', BUILTIN_VERSION_OPTION);
-        }
         if (this.#builtin.option.logLevel && !hasUserLogLevel) {
             optionMap.set('logLevel', logLevelOption);
         }
@@ -1016,8 +1446,6 @@ class Command {
         }
         return {
             mergedOptions: Array.from(optionMap.values()),
-            enableBuiltinHelp,
-            enableBuiltinVersion,
         };
     }
     #buildOptionPolicyMap(chain) {
@@ -1054,6 +1482,9 @@ class Command {
         }
     }
     #validateOptionConfig(opt) {
+        if (opt.long === 'help' || opt.long === 'version') {
+            throw new CommanderError('ConfigurationError', `option long name "${opt.long}" is reserved`, this.#getCommandPath());
+        }
         if (opt.type === 'boolean' && opt.args !== 'none') {
             throw new CommanderError('ConfigurationError', `boolean option "--${opt.long}" must have args: 'none'`, this.#getCommandPath());
         }
@@ -1134,22 +1565,27 @@ class Command {
             process.exit(1);
         }
     }
-    #resolveHelpColorOption(tokens, envs, policy = this.#resolveOptionPolicy()) {
+    #resolveHelpColorFromTailArgv(tailArgv, envs, policy = this.#resolveOptionPolicy()) {
         const colorOption = policy.mergedOptions.find(opt => opt.long === 'color');
         let color = !isNoColorEnabled(envs);
         if (!colorOption || colorOption.type !== 'boolean' || colorOption.args !== 'none') {
             return color;
         }
-        for (const token of tokens) {
-            if (token.type !== 'long' || token.name !== 'color') {
+        const separatorIndex = tailArgv.indexOf('--');
+        const scanTokens = separatorIndex === -1 ? tailArgv : tailArgv.slice(0, separatorIndex);
+        for (const token of scanTokens) {
+            if (token === '--color') {
+                color = true;
                 continue;
             }
-            const eqIdx = token.resolved.indexOf('=');
-            if (eqIdx === -1) {
-                color = true;
+            if (token === '--no-color') {
+                color = false;
                 continue;
             }
-            const value = token.resolved.slice(eqIdx + 1);
+            if (!token.startsWith('--color=')) {
+                continue;
+            }
+            const value = token.slice('--color='.length);
             if (value === 'true') {
                 color = true;
             }
@@ -1162,16 +1598,18 @@ class Command {
         }
         return color;
     }
-    #hasFlag(tokens, longName, shortName) {
-        for (const token of tokens) {
-            if (token.type === 'long' && token.name === longName) {
-                return true;
-            }
-            if (token.type === 'short' && token.name === shortName) {
-                return true;
-            }
-        }
-        return false;
+    #freezeInputSources(sources) {
+        return Object.freeze({
+            preset: Object.freeze({
+                argv: Object.freeze([...sources.preset.argv]),
+                envs: Object.freeze({ ...sources.preset.envs }),
+            }),
+            user: Object.freeze({
+                cmds: Object.freeze([...sources.user.cmds]),
+                argv: Object.freeze([...sources.user.argv]),
+                envs: Object.freeze({ ...sources.user.envs }),
+            }),
+        });
     }
     #getCommandPath() {
         const parts = [];
@@ -1340,9 +1778,12 @@ function camelToKebabCase(str) {
     return str.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
 }
 class CompletionCommand extends Command {
-    constructor(root, config) {
-        const paths = config.paths;
+    constructor(root, config = {}) {
         const programName = config.programName ?? root.name ?? 'program';
+        const paths = {
+            ...createDefaultCompletionPaths(programName),
+            ...config.paths,
+        };
         super({ desc: 'Generate shell completion script' });
         this.option({
             long: 'bash',
@@ -1404,11 +1845,11 @@ class CompletionCommand extends Command {
             if (writeOpt !== undefined) {
                 const filePath = typeof writeOpt === 'string' && writeOpt !== '' ? writeOpt : paths[shell];
                 const expandedPath = expandHome(filePath);
-                const dir = path__namespace.dirname(expandedPath);
-                if (!fs__namespace.existsSync(dir)) {
-                    fs__namespace.mkdirSync(dir, { recursive: true });
+                const dir = path.dirname(expandedPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
                 }
-                fs__namespace.writeFileSync(expandedPath, script, 'utf-8');
+                fs.writeFileSync(expandedPath, script, 'utf-8');
                 console.log(`Completion script written to: ${expandedPath}`);
             }
             else {
@@ -1417,6 +1858,13 @@ class CompletionCommand extends Command {
         });
     }
 }
+function createDefaultCompletionPaths(programName) {
+    return {
+        bash: `~/.local/share/bash-completion/completions/${programName}`,
+        fish: `~/.config/fish/completions/${programName}.fish`,
+        pwsh: '~/.config/powershell/Microsoft.PowerShell_profile.ps1',
+    };
+}
 function expandHome(filepath) {
     if (filepath.startsWith('~/') || filepath === '~') {
         const home = process.env['HOME'] || process.env['USERPROFILE'] || '';
@@ -1694,6 +2142,8 @@ class PwshCompletion {
     }
 }
 
+setDefaultCommandRuntime(createNodeCommandRuntime());
+
 exports.BashCompletion = BashCompletion;
 exports.Coerce = Coerce;
 exports.Command = Command;
@@ -1701,6 +2151,9 @@ exports.CommanderError = CommanderError;
 exports.CompletionCommand = CompletionCommand;
 exports.FishCompletion = FishCompletion;
 exports.PwshCompletion = PwshCompletion;
+exports.createBrowserCommandRuntime = createBrowserCommandRuntime;
+exports.createNodeCommandRuntime = createNodeCommandRuntime;
+exports.getDefaultCommandRuntime = getDefaultCommandRuntime;
 exports.isDomain = isDomain;
 exports.isIp = isIp;
 exports.isIpv4 = isIpv4;
@@ -1708,4 +2161,5 @@ exports.isIpv6 = isIpv6;
 exports.logColorfulOption = logColorfulOption;
 exports.logDateOption = logDateOption;
 exports.logLevelOption = logLevelOption;
+exports.setDefaultCommandRuntime = setDefaultCommandRuntime;
 exports.silentOption = silentOption;