@automattic/vip 3.25.3-dev.0 → 4.0.1

package/dist/lib/cli/command.js

@@ -4,14 +4,18 @@ exports.__esModule = true;
 exports.containsAppEnvArgument = containsAppEnvArgument;
 exports.default = _default;
 exports.getEnvIdentifier = getEnvIdentifier;
-var _args = _interopRequireDefault(require("args"));
 var _chalk = _interopRequireDefault(require("chalk"));
+var _commander = require("commander");
 var _debug = _interopRequireDefault(require("debug"));
 var _enquirer = require("enquirer");
 var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+var _nodeChild_process = require("node:child_process");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
+var _nodePath = _interopRequireDefault(require("node:path"));
 var _envAlias = require("./envAlias");
 var exit = _interopRequireWildcard(require("./exit"));
 var _format = require("./format");
+var _internalBinLoader = require("./internal-bin-loader");
 var _prompt = require("./prompt");
 var _package = _interopRequireDefault(require("../../../package.json"));
 var _api = _interopRequireDefault(require("../../lib/api"));
@@ -37,15 +41,233 @@ process.on('uncaughtException', uncaughtError);
 process.on('unhandledRejection', uncaughtError);
 let _opts = {};
 let alreadyConfirmedDebugAttachment = false;
+const RESERVED_AUTO_SHORT_ALIASES = new Set(['h', 'v', 'd']);
+function normalizeUsage(program, usage) {
+  if (!usage) {
+    return;
+  }
+  const [rootCommand, ...rest] = usage.trim().split(/\s+/);
+  if (rootCommand) {
+    program.name(rootCommand);
+  }
+  if (rest.length) {
+    const usageString = rest.join(' ');
+    program.usage(usageString.includes('[options]') ? usageString : `${usageString} [options]`);
+  }
+}
+function createOptionDefinition(name, description, defaultValue, parseFn, usedShortNames) {
+  const isArray = Array.isArray(name);
+  const shortName = isArray ? name[0] : null;
+  const longName = isArray ? name[1] : name;
+  const normalizedLongName = String(longName).trim().replace(/^--?/, '');
+  const explicitShortName = shortName ? String(shortName).trim().replace(/^-/, '') : null;
+  let normalizedShortName = explicitShortName;
+  if (!normalizedShortName) {
+    const autoShortName = normalizedLongName.charAt(0);
+    const canUseAutoShortName = autoShortName && !RESERVED_AUTO_SHORT_ALIASES.has(autoShortName) && !usedShortNames.has(autoShortName);
+    if (canUseAutoShortName) {
+      normalizedShortName = autoShortName;
+    }
+  }
+  if (normalizedShortName) {
+    usedShortNames.add(normalizedShortName);
+  }
+  const isBooleanOption = typeof defaultValue === 'boolean';
+  const usesOptionalValue = !isBooleanOption;
+  const parseOptionValue = value => {
+    if (parseFn) {
+      return parseFn(value);
+    }
+    return value;
+  };
+  let parser;
+  if (usesOptionalValue) {
+    parser = (value, previousValue) => {
+      const parsedValue = parseOptionValue(value);
+      if (previousValue === undefined) {
+        return parsedValue;
+      }
+      if (Array.isArray(previousValue)) {
+        return [...previousValue, parsedValue];
+      }
+      return [previousValue, parsedValue];
+    };
+  }
+  let flags = `--${normalizedLongName}`;
+  if (usesOptionalValue) {
+    flags += ' [value]';
+  }
+  if (normalizedShortName) {
+    flags = `-${normalizedShortName}, ${flags}`;
+  }
+  return {
+    flags,
+    description,
+    defaultValue,
+    parser
+  };
+}
+function isOptionToken(arg) {
+  return arg !== '-' && arg.startsWith('-');
+}
+class CommanderArgsCompat {
+  constructor(opts) {
+    this.details = {
+      commands: []
+    };
+    this.sub = [];
+    this.examplesList = [];
+    this.usedShortNames = new Set();
+    this._opts = opts;
+    this.program = new _commander.Command();
+    this.program.allowUnknownOption(true);
+    this.program.allowExcessArguments(true);
+    this.program.helpOption(false);
+    normalizeUsage(this.program, this._opts.usage);
+  }
+  option(name, description, defaultValue, parseFn) {
+    const definition = createOptionDefinition(name, description, defaultValue, parseFn, this.usedShortNames);
+    const {
+      flags,
+      parser
+    } = definition;
+    if (parser && defaultValue !== undefined) {
+      this.program.option(flags, description, parser, defaultValue);
+    } else if (parser) {
+      this.program.option(flags, description, parser);
+    } else if (defaultValue !== undefined) {
+      this.program.option(flags, description, defaultValue);
+    } else {
+      this.program.option(flags, description);
+    }
+    return this;
+  }
+  command(name, description = '') {
+    this.details.commands.push({
+      usage: name,
+      description
+    });
+    return this;
+  }
+  example(usage, description) {
+    this.examplesList.push({
+      usage,
+      description
+    });
+    return this;
+  }
+  examples(examples = []) {
+    for (const example of examples) {
+      this.example(example.usage, example.description);
+    }
+    return this;
+  }
+  showVersion() {
+    console.log(_package.default.version);
+    process.exit(0);
+  }
+  showHelp() {
+    const lines = [this.program.helpInformation().trimEnd()];
+    if (this.details.commands.length) {
+      lines.push('');
+      lines.push('Commands:');
+      for (const entry of this.details.commands) {
+        const commandName = entry.usage.padEnd(26, ' ');
+        lines.push(`  ${commandName}${entry.description}`);
+      }
+    }
+    if (this.examplesList.length) {
+      lines.push('');
+      lines.push('Examples:');
+      for (const example of this.examplesList) {
+        lines.push(`  - ${example.description}`);
+        lines.push(`    $ ${example.usage}`);
+      }
+    }
+    console.log(lines.join('\n'));
+    process.exit(0);
+  }
+  isDefined(value, key) {
+    if (key !== 'commands') {
+      return false;
+    }
+    return this.details.commands.some(entry => entry.usage === value);
+  }
+  parse(argv) {
+    this.program.parse(argv, {
+      from: 'node'
+    });
+    this.sub = this.program.args.slice();
+    return this.program.opts();
+  }
+  findSubcommand(argv) {
+    const dashDashIndex = argv.indexOf('--', 2);
+    const searchEnd = dashDashIndex === -1 ? argv.length : dashDashIndex;
+    for (let index = 2; index < searchEnd; index++) {
+      const arg = argv[index];
+      if (this.isDefined(arg, 'commands')) {
+        return {
+          index,
+          name: arg
+        };
+      }
+      if (!isOptionToken(arg)) {
+        return null;
+      }
+      const nextArg = argv[index + 1];
+      const optionHasInlineValue = arg.includes('=');
+      const nextArgCouldBeOptionValue = nextArg && !isOptionToken(nextArg) && !this.isDefined(nextArg, 'commands');
+      if (!optionHasInlineValue && nextArgCouldBeOptionValue) {
+        index++;
+      }
+    }
+    return null;
+  }
+  async executeSubcommand(argv, parsedAlias, subcommand) {
+    const currentScript = argv[1];
+    const subcommandName = subcommand.name;
+    const extension = _nodePath.default.extname(currentScript);
+    const baseScriptPath = extension ? currentScript.slice(0, -extension.length) : currentScript;
+    const childScriptPath = extension ? `${baseScriptPath}-${subcommandName}${extension}` : `${baseScriptPath}-${subcommandName}`;
+    const aliasFromRawArgv = argv.slice(2).find(arg => (0, _envAlias.isAlias)(arg));
+    let childArgs = [...parsedAlias.argv.slice(2, subcommand.index), ...parsedAlias.argv.slice(subcommand.index + 1)];
+    if (aliasFromRawArgv) {
+      childArgs = [aliasFromRawArgv, ...childArgs];
+    }
+    let runResult;
+    if (_nodeFs.default.existsSync(childScriptPath)) {
+      runResult = (0, _nodeChild_process.spawnSync)(process.execPath, [childScriptPath, ...childArgs], {
+        stdio: 'inherit',
+        env: process.env
+      });
+    } else {
+      const fallbackCommand = `${_nodePath.default.basename(baseScriptPath)}-${subcommandName}`;
+      if (process.env.VIP_CLI_SEA_MODE === '1' && (0, _internalBinLoader.hasInternalBin)(fallbackCommand)) {
+        process.argv = [process.argv[0], process.argv[1], ...childArgs];
+        const loaded = await (0, _internalBinLoader.loadInternalBin)(fallbackCommand);
+        if (!loaded) {
+          throw new Error(`Unable to load SEA subcommand "${fallbackCommand}"`);
+        }
+        return;
+      }
+      runResult = (0, _nodeChild_process.spawnSync)(fallbackCommand, childArgs, {
+        stdio: 'inherit',
+        env: process.env,
+        shell: process.platform === 'win32'
+      });
+    }
+    if (runResult.error) {
+      throw runResult.error;
+    }
+    process.exit(runResult.status ?? 1);
+  }
+}
 
 /**
  * @param {string[]} argv
  */
 // eslint-disable-next-line complexity
-_args.default.argv = async function (argv, cb) {
-  if (process.platform !== 'win32' && argv[1]?.endsWith('.js')) {
-    argv[1] = argv[1].slice(0, -3);
-  }
+CommanderArgsCompat.prototype.argv = async function (argv, cb) {
   if (process.execArgv.includes('--inspect') && !alreadyConfirmedDebugAttachment) {
     await (0, _enquirer.prompt)({
       type: 'confirm',
@@ -55,25 +277,14 @@ _args.default.argv = async function (argv, cb) {
     alreadyConfirmedDebugAttachment = true;
   }
   const parsedAlias = (0, _envAlias.parseEnvAliasFromArgv)(argv);
+  const options = this.parse(parsedAlias.argv);
 
-  // A usage option allows us to override the default usage text, which isn't
-  // accurate for subcommands. By default, it will display something like (note
-  // the hyphen):
-  //   Usage: vip command-subcommand [options]
-  //
-  // We can pass "vip command subcommand" to the name param for more accurate
-  // usage text:
-  //   Usage: vip command subcommand [options]
-  //
-  // It also allows us to represent required args in usage text:
-  //   Usage: vip command subcommand <arg1> <arg2> [options]
-  const name = _opts.usage || null;
-  const options = this.parse(parsedAlias.argv, {
-    help: false,
-    name,
-    version: false,
-    debug: false
-  });
+  // If there's a sub-command, run that instead
+  const dispatchSubcommand = this.findSubcommand(parsedAlias.argv);
+  if (dispatchSubcommand) {
+    await this.executeSubcommand(argv, parsedAlias, dispatchSubcommand);
+    return {};
+  }
   if (_opts.format && !options.format) {
     options.format = 'table';
   }
@@ -105,12 +316,7 @@ _args.default.argv = async function (argv, cb) {
     });
     exit.withError(error);
   }
-
-  // If there's a sub-command, run that instead
-  if (this.isDefined(this.sub[0], 'commands')) {
-    return {};
-  }
-  if (process.env.NODE_ENV !== 'test') {
+  if (process.env.NODE_ENV !== 'test' && process.env.VIP_CLI_SEA_MODE !== '1') {
     const {
       default: updateNotifier
     } = await import('update-notifier');
@@ -121,18 +327,7 @@ _args.default.argv = async function (argv, cb) {
       isGlobal: true
     });
   }
-
-  // `help` and `version` are always defined as subcommands
-  const customCommands = this.details.commands.filter(command => {
-    switch (command.usage) {
-      case 'help':
-      case 'version':
-      case 'debug':
-        return false;
-      default:
-        return true;
-    }
-  });
+  const customCommands = this.details.commands;
 
   // Show help if no args passed
   if (Boolean(customCommands.length) && !this.sub.length) {
@@ -152,7 +347,7 @@ _args.default.argv = async function (argv, cb) {
 
   // Show help if subcommand is invalid
   const subCommands = this.details.commands.map(cmd => cmd.usage);
-  if (!_opts.wildcardCommand && this.sub[_opts.requiredArgs] && 0 > subCommands.indexOf(this.sub[_opts.requiredArgs])) {
+  if (!_opts.wildcardCommand && this.sub[_opts.requiredArgs] && subCommands.length && 0 > subCommands.indexOf(this.sub[_opts.requiredArgs])) {
     const subcommand = this.sub.join(' ');
     await (0, _tracker.trackEvent)('command_validation_error', {
       error: `Invalid subcommand: ${subcommand}`
@@ -368,7 +563,7 @@ _args.default.argv = async function (argv, cb) {
               value: `${_chalk.default.cyan(launched)}`
             });
           }
-          if (this.sub) {
+          if (this.sub.length) {
             info.push({
               key: 'SQL File',
               value: `${_chalk.default.blueBright(this.sub)}`
@@ -441,7 +636,7 @@ _args.default.argv = async function (argv, cb) {
         }
       case 'import-media':
         {
-          const isUrl = this.sub && (String(this.sub).startsWith('http://') || String(this.sub).startsWith('https://'));
+          const isUrl = this.sub.length && (String(this.sub).startsWith('http://') || String(this.sub).startsWith('https://'));
           const archiveLabel = isUrl ? 'Archive URL' : 'Archive Path';
           info.push({
             key: archiveLabel,
@@ -536,7 +731,7 @@ function validateOpts(opts) {
 }
 
 /**
- * @returns {args}
+ * @returns {CommanderArgsCompat}
  */
 function _default(opts) {
   _opts = {
@@ -550,24 +745,25 @@ function _default(opts) {
     wildcardCommand: false,
     ...opts
   };
+  const args = new CommanderArgsCompat(_opts);
   if (_opts.appContext || _opts.requireConfirm) {
-    _args.default.option('app', 'Target an application. Accepts a string value for the application name or an integer for the application ID.');
+    args.option('app', 'Target an application. Accepts a string value for the application name or an integer for the application ID.');
   }
   if (_opts.envContext || _opts.childEnvContext) {
-    _args.default.option('env', 'Target an environment. Accepts a string value for the environment type.');
+    args.option('env', 'Target an environment. Accepts a string value for the environment type.');
   }
   if (_opts.requireConfirm) {
-    _args.default.option('force', 'Skip confirmation.', false);
+    args.option('force', 'Skip confirmation.', false);
   }
   if (_opts.format) {
-    _args.default.option('format', 'Render output in a particular format. Accepts “table“ (default), “csv“, and “json“.');
+    args.option('format', 'Render output in a particular format. Accepts “table“ (default), “csv“, and “json“.');
   }
 
   // Add help and version to all subcommands
-  _args.default.option('help', 'Retrieve a description, examples, and available options for a (sub)command.');
-  _args.default.option('version', 'Retrieve the version number of VIP-CLI currently installed on the local machine.');
-  _args.default.option('debug', 'Generate verbose output during command execution to help identify or fix errors or bugs.');
-  return _args.default;
+  args.option(['h', 'help'], 'Retrieve a description, examples, and available options for a (sub)command.', false);
+  args.option(['v', 'version'], 'Retrieve the version number of VIP-CLI currently installed on the local machine.', false);
+  args.option(['d', 'debug'], 'Generate verbose output during command execution to help identify or fix errors or bugs.');
+  return args;
 }
 function getEnvIdentifier(env) {
   let identifier = env.type;

package/dist/lib/cli/config.js

@@ -4,8 +4,9 @@ exports.__esModule = true;
 exports.default = void 0;
 exports.loadConfigFile = loadConfigFile;
 var _debug = _interopRequireDefault(require("debug"));
-var _nodeFs = require("node:fs");
+var _nodeFs = _interopRequireDefault(require("node:fs"));
 var _nodePath = _interopRequireDefault(require("node:path"));
+var _configPublish = _interopRequireDefault(require("../../../config/config.publish.json"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // I don't like using synchronous versions, but until we migrate to ESM, we have to.
 
@@ -14,26 +15,33 @@ function loadConfigFile() {
   const paths = [
   // Get `local` config first; this will only exist in dev as it's npmignore-d.
   _nodePath.default.join(__dirname, '../../../config/config.local.json'), _nodePath.default.join(__dirname, '../../../config/config.publish.json')];
+  let hasNonEnoentError = false;
   for (const filePath of paths) {
     try {
-      const data = (0, _nodeFs.readFileSync)(filePath, 'utf-8');
+      const data = _nodeFs.default.readFileSync(filePath, 'utf-8');
       debug(`Found config file at ${filePath}`);
       return JSON.parse(data);
     } catch (err) {
-      if (!(err instanceof Error) || !('code' in err) || err.code !== 'ENOENT') {
+      const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+      if (!isEnoent) {
+        hasNonEnoentError = true;
         debug(`Error reading config file at ${filePath}:`, err);
       }
     }
   }
+
+  // SEA builds can miss on-disk config files, so use the bundled publish config only for ENOENT.
+  if (!hasNonEnoentError) {
+    return _configPublish.default;
+  }
   return null;
 }
 const configFromFile = loadConfigFile();
 if (null === configFromFile) {
-  // This should not happen because `config/config.publish.json` is always present.
   console.error('FATAL ERROR: Could not find a valid configuration file');
   process.exit(1);
 }
 
-// Without this, TypeScript will export `configFromFile` as `Config | null`
+// Without this, TypeScript will export `configFromFile` as `Config | null`.
 const exportedConfig = configFromFile;
 var _default = exports.default = exportedConfig;

package/dist/lib/cli/exit.js

@@ -4,6 +4,7 @@ exports.__esModule = true;
 exports.withError = withError;
 var _chalk = _interopRequireDefault(require("chalk"));
 var _debug = _interopRequireDefault(require("debug"));
+var _runtimeMode = require("./runtime-mode");
 var _env = _interopRequireDefault(require("../../lib/env"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function withError(message) {
@@ -13,7 +14,7 @@ function withError(message) {
   // Debug ouput is printed below error output both for information
   // hierarchy and to make it more likely that the user copies it to their
   // clipboard when dragging across output.
-  console.log(`${_chalk.default.yellow('Debug: ')} VIP-CLI v${_env.default.app.version}, Node ${_env.default.node.version}, ${_env.default.os.name} ${_env.default.os.version} ${_env.default.os.arch}`);
+  console.log(`${_chalk.default.yellow('Debug: ')} VIP-CLI v${_env.default.app.version}, Node ${_env.default.node.version}, ${_env.default.os.name} ${_env.default.os.version} ${_env.default.os.arch}, Runtime ${(0, _runtimeMode.getRuntimeModeLabel)()}`);
   if (_debug.default.names.length > 0 && message instanceof Error) {
     console.error(_chalk.default.yellow('Debug: '), message);
   }

package/dist/lib/cli/internal-bin-loader.js

@@ -0,0 +1,81 @@
+"use strict";
+
+exports.__esModule = true;
+exports.hasInternalBin = hasInternalBin;
+exports.internalBinNames = void 0;
+exports.loadInternalBin = loadInternalBin;
+const internalBinLoaders = {
+  vip: () => import('../../bin/vip'),
+  'vip-app': () => import('../../bin/vip-app'),
+  'vip-app-deploy': () => import('../../bin/vip-app-deploy'),
+  'vip-app-deploy-validate': () => import('../../bin/vip-app-deploy-validate'),
+  'vip-app-list': () => import('../../bin/vip-app-list'),
+  'vip-backup': () => import('../../bin/vip-backup'),
+  'vip-backup-db': () => import('../../bin/vip-backup-db'),
+  'vip-cache': () => import('../../bin/vip-cache'),
+  'vip-cache-purge-url': () => import('../../bin/vip-cache-purge-url'),
+  'vip-config': () => import('../../bin/vip-config'),
+  'vip-config-envvar': () => import('../../bin/vip-config-envvar'),
+  'vip-config-envvar-delete': () => import('../../bin/vip-config-envvar-delete'),
+  'vip-config-envvar-get': () => import('../../bin/vip-config-envvar-get'),
+  'vip-config-envvar-get-all': () => import('../../bin/vip-config-envvar-get-all'),
+  'vip-config-envvar-list': () => import('../../bin/vip-config-envvar-list'),
+  'vip-config-envvar-set': () => import('../../bin/vip-config-envvar-set'),
+  'vip-config-software': () => import('../../bin/vip-config-software'),
+  'vip-config-software-get': () => import('../../bin/vip-config-software-get'),
+  'vip-config-software-update': () => import('../../bin/vip-config-software-update'),
+  'vip-db': () => import('../../bin/vip-db'),
+  'vip-db-phpmyadmin': () => import('../../bin/vip-db-phpmyadmin'),
+  'vip-dev-env': () => import('../../bin/vip-dev-env'),
+  'vip-dev-env-create': () => import('../../bin/vip-dev-env-create'),
+  'vip-dev-env-destroy': () => import('../../bin/vip-dev-env-destroy'),
+  'vip-dev-env-envvar': () => import('../../bin/vip-dev-env-envvar'),
+  'vip-dev-env-envvar-delete': () => import('../../bin/vip-dev-env-envvar-delete'),
+  'vip-dev-env-envvar-get': () => import('../../bin/vip-dev-env-envvar-get'),
+  'vip-dev-env-envvar-get-all': () => import('../../bin/vip-dev-env-envvar-get-all'),
+  'vip-dev-env-envvar-list': () => import('../../bin/vip-dev-env-envvar-list'),
+  'vip-dev-env-envvar-set': () => import('../../bin/vip-dev-env-envvar-set'),
+  'vip-dev-env-exec': () => import('../../bin/vip-dev-env-exec'),
+  'vip-dev-env-import': () => import('../../bin/vip-dev-env-import'),
+  'vip-dev-env-import-media': () => import('../../bin/vip-dev-env-import-media'),
+  'vip-dev-env-import-sql': () => import('../../bin/vip-dev-env-import-sql'),
+  'vip-dev-env-info': () => import('../../bin/vip-dev-env-info'),
+  'vip-dev-env-list': () => import('../../bin/vip-dev-env-list'),
+  'vip-dev-env-logs': () => import('../../bin/vip-dev-env-logs'),
+  'vip-dev-env-purge': () => import('../../bin/vip-dev-env-purge'),
+  'vip-dev-env-shell': () => import('../../bin/vip-dev-env-shell'),
+  'vip-dev-env-start': () => import('../../bin/vip-dev-env-start'),
+  'vip-dev-env-stop': () => import('../../bin/vip-dev-env-stop'),
+  'vip-dev-env-sync': () => import('../../bin/vip-dev-env-sync'),
+  'vip-dev-env-sync-sql': () => import('../../bin/vip-dev-env-sync-sql'),
+  'vip-dev-env-update': () => import('../../bin/vip-dev-env-update'),
+  'vip-export': () => import('../../bin/vip-export'),
+  'vip-export-sql': () => import('../../bin/vip-export-sql'),
+  'vip-import': () => import('../../bin/vip-import'),
+  'vip-import-media': () => import('../../bin/vip-import-media'),
+  'vip-import-media-abort': () => import('../../bin/vip-import-media-abort'),
+  'vip-import-media-status': () => import('../../bin/vip-import-media-status'),
+  'vip-import-sql': () => import('../../bin/vip-import-sql'),
+  'vip-import-sql-status': () => import('../../bin/vip-import-sql-status'),
+  'vip-import-validate-files': () => import('../../bin/vip-import-validate-files'),
+  'vip-import-validate-sql': () => import('../../bin/vip-import-validate-sql'),
+  'vip-logout': () => import('../../bin/vip-logout'),
+  'vip-logs': () => import('../../bin/vip-logs'),
+  'vip-search-replace': () => import('../../bin/vip-search-replace'),
+  'vip-slowlogs': () => import('../../bin/vip-slowlogs'),
+  'vip-sync': () => import('../../bin/vip-sync'),
+  'vip-whoami': () => import('../../bin/vip-whoami'),
+  'vip-wp': () => import('../../bin/vip-wp')
+};
+const internalBinNames = exports.internalBinNames = Object.freeze(Object.keys(internalBinLoaders));
+async function loadInternalBin(binName) {
+  const loader = internalBinLoaders[binName];
+  if (!loader) {
+    return false;
+  }
+  await loader();
+  return true;
+}
+function hasInternalBin(binName) {
+  return Object.hasOwn(internalBinLoaders, binName);
+}

package/dist/lib/cli/runtime-mode.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getRuntimeModeLabel = getRuntimeModeLabel;
+exports.isStandaloneExecutableRuntime = isStandaloneExecutableRuntime;
+var _nodeModule = require("node:module");
+const runtimeRequire = (0, _nodeModule.createRequire)(__filename);
+function isStandaloneExecutableRuntime() {
+  if (process.env.VIP_CLI_SEA_MODE === '1') {
+    return true;
+  }
+  try {
+    const sea = runtimeRequire('node:sea');
+    return Boolean(sea?.isSea?.());
+  } catch {
+    return false;
+  }
+}
+function getRuntimeModeLabel() {
+  return isStandaloneExecutableRuntime() ? 'standalone-sea' : 'node-script';
+}

package/dist/lib/cli/sea-dispatch.js

@@ -0,0 +1,88 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isSeaRuntime = isSeaRuntime;
+exports.resolveInternalBinFromArgv = resolveInternalBinFromArgv;
+exports.rewriteArgvForInternalBin = rewriteArgvForInternalBin;
+var _envAlias = require("./envAlias");
+var _internalBinLoader = require("./internal-bin-loader");
+const internalBinSet = new Set(_internalBinLoader.internalBinNames);
+
+/**
+ * Resolve the best matching internal bin for a command argv.
+ *
+ * @param {string[]} argv process.argv style array
+ * @returns {{ bin: string, start: number, length: number }}
+ */
+function resolveInternalBinFromArgv(argv) {
+  const args = argv.slice(2);
+  const dashDashIndex = args.indexOf('--');
+  const commandBoundary = dashDashIndex > -1 ? dashDashIndex : args.length;
+  let best = {
+    bin: 'vip',
+    start: 0,
+    length: 0
+  };
+  for (let start = 0; start < commandBoundary; start++) {
+    const firstToken = args[start];
+    if (!firstToken || firstToken.startsWith('-') || (0, _envAlias.isAlias)(firstToken)) {
+      continue;
+    }
+    const commandParts = [];
+    for (let index = start; index < commandBoundary; index++) {
+      const token = args[index];
+      if (!token || token.startsWith('-') || (0, _envAlias.isAlias)(token)) {
+        break;
+      }
+      commandParts.push(token);
+      const candidateBin = `vip-${commandParts.join('-')}`;
+      if (internalBinSet.has(candidateBin)) {
+        const isLongerMatch = commandParts.length > best.length;
+        const isEarlierEqualMatch = commandParts.length === best.length && commandParts.length > 0 && start < best.start;
+        if (isLongerMatch || isEarlierEqualMatch) {
+          best = {
+            bin: candidateBin,
+            start,
+            length: commandParts.length
+          };
+        }
+      }
+    }
+  }
+  return best;
+}
+
+/**
+ * Rewrites argv so the resolved command segment is removed and the target bin
+ * can parse its native flags/args shape.
+ *
+ * @param {string[]} argv process.argv style array
+ * @param {{ start: number, length: number }} resolution command resolution
+ * @returns {string[]} rewritten argv
+ */
+function rewriteArgvForInternalBin(argv, resolution) {
+  const args = argv.slice(2);
+  const start = resolution.start ?? 0;
+  const length = resolution.length ?? 0;
+  if (length <= 0) {
+    return argv.slice(0);
+  }
+  const rewrittenArgs = args.slice(0, start).concat(args.slice(start + length));
+  return [argv[0], argv[1], ...rewrittenArgs];
+}
+
+/**
+ * @returns {boolean}
+ */
+function isSeaRuntime() {
+  try {
+    const runtimeRequire = typeof module !== 'undefined' && module?.require ? module.require.bind(module) : null;
+    if (!runtimeRequire) {
+      return false;
+    }
+    const sea = runtimeRequire('node:sea');
+    return Boolean(sea?.isSea?.());
+  } catch {
+    return false;
+  }
+}