@automattic/vip 3.25.1 → 3.25.2-dev.0

package/AGENTS.md

@@ -72,6 +72,12 @@ Guide for future agents working on this codebase. Focus on traps, cross-cutting
 - `prepare` runs `npm run clean && npm run build`; npm package bins point to `dist/**`. Always rebuild before publishing so dist matches src.
 - `helpers/prepublishOnly.js` enforces branch `trunk` for `npm publish --tag latest` and optionally reruns `npm test`. Release flows expect a clean node version that satisfies `engines.node`.
 
+## Standalone SEA Packaging
+
+- Canonical runbook for standalone executable build/signing is in `docs/SEA-BUILD-SIGNING.md`. Use it for macOS, Linux, Windows native, and WSL-mediated Windows builds.
+- SEA builds are Node 22 only (enforced in `helpers/build-sea.js`); always verify `node -v` before `npm run build:sea`.
+- The executable is self-contained for Node runtime + JS deps, but `dev-env` commands still require host Docker/Compose availability.
+
 ## Common Pitfalls Checklist
 
 - Running CLI without a token opens a browser (`open`) and waits for interactive input—pass `--help` or set `WPVIP_DEPLOY_TOKEN` in automation.

package/CLAUDE.md

@@ -1,3 +1,4 @@
 # CLAUDE
 
 For guidance on working in this repo, traps, and migration notes, see `AGENTS.md`.
+For standalone SEA build/signing by platform, see `docs/SEA-BUILD-SIGNING.md`.

package/dist/bin/vip-dev-env-exec.js

@@ -10,6 +10,23 @@ var _userError = _interopRequireDefault(require("../lib/user-error"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const exampleUsage = 'vip dev-env exec';
 const usage = 'vip dev-env exec';
+const ENV_UP_CHECK_ATTEMPTS = 5;
+const ENV_UP_CHECK_DELAY_MS = 1500;
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function waitForEnvironmentReadiness(lando, slug) {
+  const instancePath = (0, _devEnvironmentCore.getEnvironmentPath)(slug);
+  return pollEnvironmentReadiness(lando, instancePath, 1);
+}
+async function pollEnvironmentReadiness(lando, instancePath, attempt) {
+  if (await (0, _devEnvironmentLando.isEnvUp)(lando, instancePath)) {
+    return true;
+  }
+  if (attempt >= ENV_UP_CHECK_ATTEMPTS) {
+    return false;
+  }
+  await sleep(ENV_UP_CHECK_DELAY_MS);
+  return pollEnvironmentReadiness(lando, instancePath, attempt + 1);
+}
 const examples = [{
   usage: `${exampleUsage} --slug=example-site -- wp post list`,
   description: 'Run a WP-CLI command against a local environment named "example-site".\n' + '      * A double dash ("--") must separate the arguments of "vip" from those of the "wp" command.'
@@ -46,7 +63,7 @@ const examples = [{
       arg = process.argv.slice(argSplitterIx + 1);
     }
     if (!opt.force) {
-      const isUp = await (0, _devEnvironmentLando.isEnvUp)(lando, (0, _devEnvironmentCore.getEnvironmentPath)(slug));
+      const isUp = await waitForEnvironmentReadiness(lando, slug);
       if (!isUp) {
         throw new _userError.default('A WP-CLI command can only be executed on a running local environment.');
       }

package/dist/bin/vip-import.js

@@ -4,6 +4,6 @@
 var _command = _interopRequireDefault(require("../lib/cli/command"));
 var _tracker = require("../lib/tracker");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _command.default)().command('sql', 'Import a SQL database file to an environment.').command('validate-sql', 'Validate a local SQL database file prior to import.').command('validate-files', 'Validate the directory structure and contents of a local media file directory prior to archiving and uploading it to a publicly accessible URL.').command('media', 'Import media files to an environment from an archived file located at a publicly accessible URL.').example('vip @example-app.develop import sql example-file.sql', 'Import the local SQL database file "example-file.sql" to the develop environment.').example('vip @example-app.production import media https://www.example.com/uploads.tar.gz', 'Import an archived file from a publicly accessible URL to the production environment.').argv(process.argv, async () => {
+(0, _command.default)().command('sql', 'Import a SQL database file to an environment.').command('validate-sql', 'Validate a local SQL database file prior to import.').command('validate-files', 'Validate that the directory structure and contents of a local media file directory can be successfully imported.').command('media', 'Import media files to a production environment from an archived file at a local path or a publicly accessible remote URL.').example('vip @example-app.develop import sql example-file.sql', 'Import the local SQL database file "example-file.sql" to the develop environment.').example('vip @example-app.production import media https://www.example.com/uploads.tar.gz', 'Import an archived file from a publicly accessible URL to the production environment.').argv(process.argv, async () => {
   await (0, _tracker.trackEvent)('vip_import_command_execute');
 });

package/dist/bin/vip-sea.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+
+var _seaDispatch = require("../lib/cli/sea-dispatch");
+var _seaRuntime = require("../lib/cli/sea-runtime");
+const run = async () => {
+  if ((0, _seaDispatch.isSeaRuntime)()) {
+    process.env.VIP_CLI_SEA_MODE = '1';
+    await (0, _seaRuntime.prepareSeaRuntimeFilesystem)();
+    const resolution = (0, _seaDispatch.resolveInternalBinFromArgv)(process.argv);
+    if (resolution.bin !== 'vip') {
+      process.env.VIP_CLI_TARGET_BIN = resolution.bin;
+      process.env.VIP_CLI_TARGET_START = String(resolution.start);
+      process.env.VIP_CLI_TARGET_LENGTH = String(resolution.length);
+    }
+  }
+  await import('./vip.js');
+};
+void run();

package/dist/bin/vip.js

@@ -7,6 +7,8 @@ var _debug = _interopRequireDefault(require("debug"));
 var _enquirer = require("enquirer");
 var _command = _interopRequireWildcard(require("../lib/cli/command"));
 var _config = _interopRequireDefault(require("../lib/cli/config"));
+var _internalBinLoader = require("../lib/cli/internal-bin-loader");
+var _seaDispatch = require("../lib/cli/sea-dispatch");
 var _token = _interopRequireDefault(require("../lib/token"));
 var _tracker = require("../lib/tracker");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
@@ -20,10 +22,28 @@ if (_config.default && _config.default.environment !== 'production') {
 // Config
 const tokenURL = 'https://dashboard.wpvip.com/me/cli/token';
 const customDeployToken = process.env.WPVIP_DEPLOY_TOKEN;
+async function maybeExecuteSeaTargetCommand() {
+  const targetBin = process.env.VIP_CLI_TARGET_BIN;
+  if (!(0, _seaDispatch.isSeaRuntime)() || !targetBin || targetBin === 'vip') {
+    return false;
+  }
+  const start = Number(process.env.VIP_CLI_TARGET_START ?? '0');
+  const length = Number(process.env.VIP_CLI_TARGET_LENGTH ?? '0');
+  const resolution = {
+    start: Number.isInteger(start) ? start : 0,
+    length: Number.isInteger(length) ? length : 0
+  };
+  process.argv = (0, _seaDispatch.rewriteArgvForInternalBin)(process.argv, resolution);
+  const loaded = await (0, _internalBinLoader.loadInternalBin)(targetBin);
+  if (!loaded) {
+    throw new Error(`Unable to load SEA command target "${targetBin}"`);
+  }
+  return true;
+}
 const runCmd = async function () {
   const cmd = (0, _command.default)();
   cmd.command('logout', 'Log out the current authenticated VIP-CLI user.').command('app', 'Interact with applications that the current authenticated VIP-CLI user has permission to access.').command('backup', 'Generate a backup of an environment.').command('cache', 'Manage page cache for an environment.').command('config', 'Manage environment configurations.').command('dev-env', 'Create and manage VIP Local Development Environments.').command('export', 'Export a copy of data associated with an environment.').command('import', 'Import media or SQL database files to an environment.').command('logs', 'Retrieve Runtime Logs from an environment.').command('search-replace', 'Search for a string in a local SQL file and replace it with a new string.').command('slowlogs', 'Retrieve MySQL slow query logs from an environment.').command('db', "Access an environment's database.").command('sync', 'Sync the database from production to a non-production environment.').command('whoami', 'Retrieve details about the current authenticated VIP-CLI user.').command('wp', 'Execute a WP-CLI command against an environment.');
-  cmd.argv(process.argv);
+  await cmd.argv(process.argv);
 };
 
 /**
@@ -34,7 +54,89 @@ const runCmd = async function () {
 function doesArgvHaveAtLeastOneParam(argv, params) {
   return argv.some(arg => params.includes(arg));
 }
+async function runLoginFlow() {
+  console.log();
+  console.log('   _    __ ________         ________    ____');
+  console.log('  | |  / //  _/ __        / ____/ /   /  _/');
+  console.log('  | | / / / // /_/ /______/ /   / /    / /  ');
+  console.log('  | |/ /_/ // ____//_____/ /___/ /____/ /   ');
+  console.log('  |___//___/_/           ____/_____/___/   ');
+  console.log();
+  console.log('  VIP-CLI is your tool for interacting with and managing your VIP applications.');
+  console.log();
+  console.log('  Authenticate your installation of VIP-CLI with your Personal Access Token. This URL will be opened in your web browser automatically so that you can retrieve your token: ' + tokenURL);
+  console.log();
+  await (0, _tracker.trackEvent)('login_command_execute');
+  const answer = await (0, _enquirer.prompt)({
+    type: 'confirm',
+    name: 'continue',
+    message: 'Ready to authenticate?'
+  });
+  if (!answer.continue) {
+    await (0, _tracker.trackEvent)('login_command_browser_cancelled');
+    return null;
+  }
+  const {
+    default: open
+  } = await import('open');
+  open(tokenURL, {
+    wait: false
+  });
+  await (0, _tracker.trackEvent)('login_command_browser_opened');
+  const {
+    token: tokenInput
+  } = await (0, _enquirer.prompt)({
+    type: 'password',
+    name: 'token',
+    message: 'Access Token:'
+  });
+  let token;
+  try {
+    token = new _token.default(tokenInput);
+  } catch (err) {
+    console.log('The token provided is malformed. Please check the token and try again.');
+    await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+      error: err.message
+    });
+    return null;
+  }
+  if (token.expired()) {
+    console.log('The token provided is expired. Please log in again to refresh the token.');
+    await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+      error: 'expired'
+    });
+    return null;
+  }
+  if (!token.valid()) {
+    console.log('The provided token is not valid. Please log in again to refresh the token.');
+    await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+      error: 'invalid'
+    });
+    return null;
+  }
+  try {
+    await _token.default.set(token.raw);
+  } catch (err) {
+    await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+      error: err.message
+    });
+    throw err;
+  }
+
+  // De-anonymize user for tracking
+  await (0, _tracker.aliasUser)(token.id);
+  await (0, _tracker.trackEvent)('login_command_token_submit_success');
+  return token;
+}
 const rootCmd = async function () {
+  if ((0, _seaDispatch.isSeaRuntime)() && !process.env.VIP_CLI_TARGET_BIN) {
+    const resolution = (0, _seaDispatch.resolveInternalBinFromArgv)(process.argv);
+    if (resolution.bin !== 'vip') {
+      process.env.VIP_CLI_TARGET_BIN = resolution.bin;
+      process.env.VIP_CLI_TARGET_START = String(resolution.start);
+      process.env.VIP_CLI_TARGET_LENGTH = String(resolution.length);
+    }
+  }
   let token = await _token.default.get();
   const isHelpCommand = doesArgvHaveAtLeastOneParam(process.argv, ['help', '-h', '--help']);
   const isVersionCommand = doesArgvHaveAtLeastOneParam(process.argv, ['-v', '--version']);
@@ -44,82 +146,22 @@ const rootCmd = async function () {
   const isCustomDeployCmdWithKey = doesArgvHaveAtLeastOneParam(process.argv, ['deploy']) && Boolean(customDeployToken);
   debug('Argv:', process.argv);
   if (!isLoginCommand && (isLogoutCommand || isHelpCommand || isVersionCommand || isDevEnvCommandWithoutEnv || token?.valid() || isCustomDeployCmdWithKey)) {
-    await runCmd();
-  } else {
-    console.log();
-    console.log('   _    __ ________         ________    ____');
-    console.log('  | |  / //  _/ __        / ____/ /   /  _/');
-    console.log('  | | / / / // /_/ /______/ /   / /    / /  ');
-    console.log('  | |/ /_/ // ____//_____/ /___/ /____/ /   ');
-    console.log('  |___//___/_/           ____/_____/___/   ');
-    console.log();
-    console.log('  VIP-CLI is your tool for interacting with and managing your VIP applications.');
-    console.log();
-    console.log('  Authenticate your installation of VIP-CLI with your Personal Access Token. This URL will be opened in your web browser automatically so that you can retrieve your token: ' + tokenURL);
-    console.log();
-    await (0, _tracker.trackEvent)('login_command_execute');
-    const answer = await (0, _enquirer.prompt)({
-      type: 'confirm',
-      name: 'continue',
-      message: 'Ready to authenticate?'
-    });
-    if (!answer.continue) {
-      await (0, _tracker.trackEvent)('login_command_browser_cancelled');
-      return;
-    }
-    const {
-      default: open
-    } = await import('open');
-    open(tokenURL, {
-      wait: false
-    });
-    await (0, _tracker.trackEvent)('login_command_browser_opened');
-    const {
-      token: tokenInput
-    } = await (0, _enquirer.prompt)({
-      type: 'password',
-      name: 'token',
-      message: 'Access Token:'
-    });
-    try {
-      token = new _token.default(tokenInput);
-    } catch (err) {
-      console.log('The token provided is malformed. Please check the token and try again.');
-      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
-        error: err.message
-      });
+    if (await maybeExecuteSeaTargetCommand()) {
       return;
     }
-    if (token.expired()) {
-      console.log('The token provided is expired. Please log in again to refresh the token.');
-      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
-        error: 'expired'
-      });
-      return;
-    }
-    if (!token.valid()) {
-      console.log('The provided token is not valid. Please log in again to refresh the token.');
-      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
-        error: 'invalid'
-      });
+    await runCmd();
+  } else {
+    token = await runLoginFlow();
+    if (!token) {
       return;
     }
-    try {
-      await _token.default.set(token.raw);
-    } catch (err) {
-      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
-        error: err.message
-      });
-      throw err;
-    }
-
-    // De-anonymize user for tracking
-    await (0, _tracker.aliasUser)(token.id);
-    await (0, _tracker.trackEvent)('login_command_token_submit_success');
     if (isLoginCommand) {
       console.log('You are now logged in - see `vip -h` for a list of available commands.');
       process.exit();
     }
+    if (await maybeExecuteSeaTargetCommand()) {
+      return;
+    }
     await runCmd();
   }
 };

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,209 @@ 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
+  };
+}
+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();
+  }
+  async executeSubcommand(argv, parsedAlias, subcommand) {
+    const currentScript = argv[1];
+    const extension = _nodePath.default.extname(currentScript);
+    const baseScriptPath = extension ? currentScript.slice(0, -extension.length) : currentScript;
+    const childScriptPath = extension ? `${baseScriptPath}-${subcommand}${extension}` : `${baseScriptPath}-${subcommand}`;
+    const aliasFromRawArgv = argv.slice(2).find(arg => (0, _envAlias.isAlias)(arg));
+    const subcommandIndex = parsedAlias.argv.findIndex((arg, index) => {
+      return index > 1 && arg === subcommand;
+    });
+    let childArgs = subcommandIndex > -1 ? parsedAlias.argv.slice(subcommandIndex + 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)}-${subcommand}`;
+      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 +253,13 @@ _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
+  if (this.isDefined(this.sub[0], 'commands')) {
+    await this.executeSubcommand(argv, parsedAlias, this.sub[0]);
+    return {};
+  }
   if (_opts.format && !options.format) {
     options.format = 'table';
   }
@@ -105,12 +291,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 +302,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 +322,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 +538,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 +611,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 +706,7 @@ function validateOpts(opts) {
 }
 
 /**
- * @returns {args}
+ * @returns {CommanderArgsCompat}
  */
 function _default(opts) {
   _opts = {
@@ -550,24 +720,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;