@expo-harmony/cli 55.0.26-harmony.8 → 55.0.26-harmony.9

package/src/cli.ts

@@ -1,245 +1,42 @@
-import path from 'node:path';
-
-import { parseBuildArgs } from './buildHap/options';
-import { parseDoctorArgs } from './doctor/options';
+import type { Command } from './command';
 import { HarmonyCliError } from './errors';
-import { parseExportEmbedArgs } from './exportEmbed/options';
-import { parseModulesArgs } from './modules/options';
-import { parsePrebuildArgs } from './prebuild/options';
-import { resolveProject } from './project';
-import { withHarmonyProjectLockAsync } from './projectLock';
-import { parseRunArgs } from './run/options';
-import { parseStartArgs } from './start/options';
-
-const Help = `Usage: expo-harmony <command> [project] [options]
-
-Commands:
-  start                 Start Expo Metro for Harmony development
-  prebuild              Generate the Harmony native project with Expo CNG
-  prebuild --clean      Safely recreate the managed Harmony directory
-  prebuild --check      Compare generated desired state without project writes
-  build                 Build a HAP without selecting or contacting a device
-  doctor                Validate config, versions, Metro, RNOH, SDK, and signing
-  modules list          List native module candidates and their discovery source
-  modules inspect       Resolve Harmony metadata (--package narrows the result)
-  modules verify        Validate module config, registration conflicts and safe paths
-  export:embed          Export validated Hermes bytecode, assets, and a source map
-  run                   Build, install, and launch the Harmony app
-
-Options:
-  --no-install          Skip dependency install (prebuild) or HAP install (run)
-  --npm|--yarn|--pnpm|--bun
-                        Select the package manager used by prebuild dependency install
-  --skip-dependency-update <packages>
-                        Preserve comma-separated dependency versions
-  --device <id-or-name> Select an HDC target or start a local emulator by name
-  --variant <mode>      Build debug or release (default: debug)
-  --no-bundler          Use an already-running Expo Metro server
-  --app-id <bundleName>
-                        Launch another installed app (requires --no-install when different)
-  --port <number>       Metro and device reverse port (default: 8081)
-  --sync                Re-run prebuild before building
-  --check               Validate an existing export without writing
-  --reset-cache         Reset Metro while exporting or starting
-  -c, --clear           Alias for --reset-cache (start)
-  -h, --help            Show this help
-`;
-
-type Invocation = { command: 'help' }
-  | { command: 'build'; parsed: ReturnType<typeof parseBuildArgs>; projectRoot: string }
-  | { command: 'doctor'; parsed: ReturnType<typeof parseDoctorArgs>; projectRoot: string }
-  | { command: 'export:embed'; parsed: ReturnType<typeof parseExportEmbedArgs>; projectRoot: string }
-  | { command: 'modules'; parsed: ReturnType<typeof parseModulesArgs>; projectRoot: string }
-  | { command: 'prebuild'; parsed: ReturnType<typeof parsePrebuildArgs>; projectRoot: string }
-  | { command: 'run'; parsed: ReturnType<typeof parseRunArgs>; projectRoot: string }
-  | { command: 'start'; parsed: ReturnType<typeof parseStartArgs>; projectRoot: string };
-
-function parseInvocation(argv: string[]): Invocation {
-  if (argv.length === 0 || (argv.length === 1 && ['--help', '-h'].includes(argv[0]))) {
-    return { command: 'help' };
-  }
-
-  const command = argv[0] as Exclude<Invocation['command'], 'help'>;
-  if (!['build', 'prebuild', 'doctor', 'export:embed', 'modules', 'run', 'start'].includes(command)) {
-    throw new HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unknown command: ${command}`, {
-      operation: 'parse-arguments',
-    });
-  }
-
-  const parsed = command === 'build'
-    ? parseBuildArgs(argv.slice(1))
-    : command === 'prebuild'
-      ? parsePrebuildArgs(argv.slice(1), { allowProject: true })
-      : command === 'doctor'
-        ? parseDoctorArgs(argv.slice(1))
-        : command === 'export:embed'
-          ? parseExportEmbedArgs(argv.slice(1))
-          : command === 'modules'
-            ? parseModulesArgs(argv.slice(1))
-            : command === 'start'
-              ? parseStartArgs(argv.slice(1))
-              : parseRunArgs(argv.slice(1));
-  if (parsed.help) return { command: 'help' };
-
-  const projectRoot = resolveProject(parsed.project ? path.resolve(parsed.project) : process.cwd());
-
-  return { command, parsed, projectRoot } as Invocation;
-}
-
-async function runAsync(
-  argv: string[] = process.argv.slice(2),
-  io: Pick<Console, 'error' | 'log' | 'warn'> = console
-): Promise<number> {
+import { Help } from './help';
+import type { Log } from './log';
+
+const commands: Record<string, () => Promise<{ command: Command }>> = {
+  'start': () => import('./start/index.js'),
+  'prebuild': () => import('./prebuild/index.js'),
+  'build': () => import('./buildHap/index.js'),
+  'doctor': () => import('./doctor/index.js'),
+  'modules': () => import('./modules/index.js'),
+  'export:embed': () => import('./exportEmbed/index.js'),
+  'run': () => import('./run/index.js'),
+};
+
+export async function runAsync(argv: string[] = process.argv.slice(2), io: Log = console): Promise<number> {
   process.env.EXPO_HARMONY = '1';
   process.env.EXPO_METRO_TARGET = 'harmony';
 
-  const invocation = parseInvocation(argv);
-  if (invocation.command === 'help') {
+  if (argv.length === 0 || (argv.length === 1 && ['--help', '-h'].includes(argv[0]))) {
     io.log(Help);
     return 0;
   }
 
-  if (invocation.command === 'start') {
-    const { startExpoMetroAsync } = await import('./run/metro.js');
-    const metro = await startExpoMetroAsync(invocation.projectRoot, {
-      ...invocation.parsed,
-      interactive: true,
-    });
-
-    try {
-      if (metro.owner === 'existing') {
-        io.log(`Expo Metro is already running on port ${metro.port}.`);
-        if (invocation.parsed.resetCache) {
-          io.warn('Stop the existing Metro server and run this command again to reset its cache.');
-        }
-      } else {
-        io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
-        await metro.waitAsync();
-      }
-
-      return 0;
-    } finally {
-      await metro.stop();
-    }
-  }
-
-  if (invocation.command === 'doctor') {
-    const { doctorAsync, formatDoctor } = await import('./doctor/doctor.js');
-    const result = await doctorAsync(invocation.projectRoot, { requireBuildTools: true });
-
-    io.log(formatDoctor(result));
-
-    return result.ok ? 0 : 1;
-  }
-
-  if (invocation.command === 'build') {
-    const { buildHarmonyAsync } = await import('./buildHap/build.js');
-    const result = await buildHarmonyAsync(invocation.projectRoot, {
-      ...invocation.parsed,
-      io,
-    });
-
-    io.log(`Built ${result.variant} HAP at ${result.hapPath}; no device actions were performed.`);
-
-    return 0;
-  }
-
-  if (invocation.command === 'export:embed') {
-    const { exportEmbedAsync } = await import('./exportEmbed/export.js');
-    const result = await exportEmbedAsync(invocation.projectRoot, invocation.parsed);
-
-    if (invocation.parsed.check) io.log('Harmony export bundle, assets, and source map are valid.');
-    else io.log(`Exported Hermes bytecode ${result.bundle.path} with ${result.assets.length} asset file(s).`);
-
-    return 0;
-  }
-
-  if (invocation.command === 'modules') {
-    const { formatModulesResult, runModulesCommandAsync } = await import('./modules/modules.js');
-    const result = await runModulesCommandAsync(invocation.projectRoot, invocation.parsed);
-
-    io.log(formatModulesResult(result));
-    return result.ok ? 0 : 1;
-  }
-
-  if (invocation.command === 'run') {
-    const { runHarmonySessionAsync } = await import('./run/run.js');
-
-    const session = await runHarmonySessionAsync(invocation.projectRoot, {
-      ...invocation.parsed,
-      interactiveBundler: true,
-      io,
-    });
-    const { result } = session;
-
-    io.log(`Launched ${result.bundleName} on ${result.device.id} (${result.variant}).`);
-    if (session.metro.owner === 'started') {
-      io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
-      await session.metro.waitAsync();
-    }
-
-    return 0;
+  const name = argv[0];
+  if (!Object.hasOwn(commands, name)) {
+    throw new HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unknown command: ${name}`, { operation: 'parse-arguments' });
   }
 
-  const { check, clean, passthrough } = invocation.parsed;
+  const { command } = await commands[name]();
 
-  if (check && passthrough.length) {
-    throw new HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--check cannot be combined with mutating prebuild options.');
-  }
-
-  return withHarmonyProjectLockAsync(
-    invocation.projectRoot,
-    check ? 'prebuild-check' : 'prebuild',
-    async () => {
-      if (clean) {
-        const { assertSafeCleanTarget } = await import('./prebuild/clean.js');
-        await assertSafeCleanTarget(invocation.projectRoot);
-      }
-
-      const { doctorAsync, formatDoctor } = await import('./doctor/doctor.js');
-      const doctor = await doctorAsync(invocation.projectRoot, {
-        requireBuildTools: false,
-        validateGeneratedProject: !clean,
-        validateModules: false,
-      });
-      if (!doctor.ok) {
-        io.error(formatDoctor(doctor));
-        throw new HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', 'Harmony doctor found blocking errors.', {
-          operation: 'doctor',
-        });
-      }
-
-      for (const item of doctor.checks.filter(item => item.status === 'warn')) io.warn(`! ${item.message}`);
-
-      if (check) {
-        const { checkAsync } = await import('./prebuild/check.js');
-        const result = await checkAsync(invocation.projectRoot);
-
-        if (result.clean) io.log('Harmony CNG output is up to date.');
-        else for (const change of result.changes) io.log(`${change.type}: ${change.path}`);
-
-        return result.clean ? 0 : 2;
-      }
-
-      const { prebuildParsedAsync } = await import('./prebuild/prebuild.js');
-      await prebuildParsedAsync(invocation.projectRoot, passthrough);
-
-      return 0;
-    });
+  return command(argv.slice(1), io);
 }
 
-async function main(argv = process.argv.slice(2)) {
+export async function mainAsync(argv: string[] = process.argv.slice(2)): Promise<void> {
   try {
-    const code = await runAsync(argv);
-
-    process.exitCode = code;
+    process.exitCode = await runAsync(argv);
   } catch (error) {
-    const code = error.code || 'ERR_HARMONY_UNKNOWN';
-
-    console.error(`[${code}] ${error.message}`);
-
+    console.error(`[${error.code || 'ERR_HARMONY_UNKNOWN'}] ${error.message}`);
     process.exitCode = error.exitCode || 1;
   }
 }
-
-export { main, runAsync };

package/src/command.ts

@@ -0,0 +1,24 @@
+import path from 'node:path';
+
+import { Help } from './help';
+import type { Log } from './log';
+import { resolveProject } from './project';
+
+export type Command = (argv: string[], io: Log) => Promise<number>;
+
+export function parseCommandArgs<T extends { help: boolean; project?: string }>(
+  parse: (argv: string[]) => T,
+  argv: string[],
+  io: Log
+): { options: T; projectRoot: string } | null {
+  const options = parse(argv);
+  if (options.help) {
+    io.log(Help);
+    return null;
+  }
+
+  return {
+    options,
+    projectRoot: resolveProject(options.project ? path.resolve(options.project) : process.cwd()),
+  };
+}

package/src/doctor/doctor.ts

@@ -5,17 +5,14 @@ import path from 'node:path';
 import { getConfig } from '@expo/config';
 import { normalizeHarmonyConfig } from '@expo-harmony/config-plugins';
 import { verifyModulesAsync } from '@expo-harmony/expo-modules-autolinking';
-import { isRnohAutolinkingDisabled } from '@expo-harmony/prebuild-config/native-project';
-import { validateHarmonySigningConfigFile } from '@expo-harmony/prebuild-config/signing';
+import { isRnohAutolinkingDisabled, validateHarmonySigningConfigFile } from '@expo-harmony/prebuild-config/internal';
 
 import { spawnAsync } from '../process';
 import { withHarmonyProjectLockAsync } from '../projectLock';
-import {
-  resolveHarmonyBuildPlanIfPresentAsync,
-  resolveHarmonyToolchain,
-  type HarmonyTool,
-} from '../tools';
+import { resolveHarmonyBuildPlanIfPresentAsync } from '../native/project';
+import { resolveHarmonyToolchain, type HarmonyTool } from '../native/toolchain';
 import { RequiredProjectPackages } from '../upstream';
+import { isBareHarmonyProject } from '../native/bare';
 
 export interface DoctorCheck {
   details?: unknown;
@@ -37,22 +34,23 @@ interface DoctorOptions {
   validateModules?: boolean;
 }
 
-function hasPlugin(plugins, packageName) {
-  return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === packageName);
+function hasPlugin(plugins, name) {
+  return (plugins || []).some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === name);
 }
 
 function check(id: string, status: DoctorCheck['status'], message: string, details?: unknown): DoctorCheck {
   return { id, status, message, ...(details ? { details } : {}) };
 }
 
-function canResolvePackage(projectRoot, packageName) {
-  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+function canResolvePackage(root, name) {
+  const require = createRequire(path.join(root, 'package.json'));
+
   try {
-    projectRequire.resolve(`${packageName}/package.json`);
+    require.resolve(`${name}/package.json`);
     return true;
   } catch {
     try {
-      projectRequire.resolve(packageName);
+      require.resolve(name);
       return true;
     } catch {
       return false;
@@ -60,20 +58,20 @@ function canResolvePackage(projectRoot, packageName) {
   }
 }
 
-async function validateMetroConfigAsync(projectRoot) {
-  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
-  let metroConfig;
+async function validateMetroConfigAsync(root) {
+  const require = createRequire(path.join(root, 'package.json'));
+  let metro;
 
   try {
-    metroConfig = projectRequire('metro-config');
+    metro = require('metro-config');
   } catch (cause) {
     throw new Error('Cannot load the project-local metro-config package.', { cause });
   }
 
-  if (typeof metroConfig.resolveConfig !== 'function') {
+  if (typeof metro.resolveConfig !== 'function') {
     const version = (() => {
       try {
-        return projectRequire('metro-config/package.json').version;
+        return require('metro-config/package.json').version;
       } catch {
         return 'unknown';
       }
@@ -82,15 +80,15 @@ async function validateMetroConfigAsync(projectRoot) {
     throw new Error(`metro-config ${version} does not expose resolveConfig().`);
   }
 
-  const hadMetroTarget = Object.hasOwn(process.env, 'EXPO_METRO_TARGET');
-  const previousMetroTarget = process.env.EXPO_METRO_TARGET;
+  const present = Object.hasOwn(process.env, 'EXPO_METRO_TARGET');
+  const previous = process.env.EXPO_METRO_TARGET;
   let resolved;
 
   try {
     process.env.EXPO_METRO_TARGET = 'harmony';
-    resolved = await metroConfig.resolveConfig(undefined, projectRoot);
+    resolved = await metro.resolveConfig(undefined, root);
   } finally {
-    if (hadMetroTarget) process.env.EXPO_METRO_TARGET = previousMetroTarget;
+    if (present) process.env.EXPO_METRO_TARGET = previous;
     else delete process.env.EXPO_METRO_TARGET;
   }
 
@@ -105,33 +103,40 @@ async function validateMetroConfigAsync(projectRoot) {
   }
 }
 
-async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions = {}): Promise<DoctorResult> {
+async function doctorUnlockedAsync(root: string, options: DoctorOptions = {}): Promise<DoctorResult> {
   const checks: DoctorCheck[] = [];
-  const unavailableToolStatus = options.requireBuildTools ? 'error' : 'warn';
+  const unavailable = options.requireBuildTools ? 'error' : 'warn';
   let config;
+  const bare = isBareHarmonyProject(root);
 
   try {
-    config = getConfig(projectRoot, {
-      isModdedConfig: true,
-      skipSDKVersionRequirement: true,
-    }).exp;
-    normalizeHarmonyConfig(config);
-    checks.push(check('app-config', 'pass', 'Harmony app config is valid.'));
+    if (bare) {
+      const plan = await resolveHarmonyBuildPlanIfPresentAsync(root);
+      checks.push(check('native-config', 'pass', `Bare Harmony project: ${plan.bundleName} / ${plan.moduleName}. Native files own the configuration.`));
+    } else {
+      config = getConfig(root, {
+        isModdedConfig: true,
+        skipSDKVersionRequirement: true,
+      }).exp;
+      normalizeHarmonyConfig(config);
+      checks.push(check('app-config', 'pass', 'Harmony app config is valid.'));
+    }
   } catch (error) {
-    checks.push(check('app-config', 'error', error.message, { code: error.code || 'ERR_HARMONY_CONFIG_INVALID' }));
+    checks.push(check(bare ? 'native-config' : 'app-config', 'error', error.message, { code: error.code || 'ERR_HARMONY_CONFIG_INVALID' }));
   }
 
   if (config) {
     checks.push(hasPlugin(config.plugins, '@expo-harmony/prebuild-config')
       ? check('config-plugin', 'pass', '@expo-harmony/prebuild-config is registered.')
       : check('config-plugin', 'error', 'Add @expo-harmony/prebuild-config to expo.plugins.'));
+
     const harmony = (config as typeof config & {
       harmony?: { signingConfigFile?: string };
     }).harmony;
 
     if (harmony?.signingConfigFile) {
       try {
-        const signing = await validateHarmonySigningConfigFile(projectRoot, harmony.signingConfigFile);
+        const signing = await validateHarmonySigningConfigFile(root, harmony.signingConfigFile);
         checks.push(check('signing', 'pass', `Harmony signing config ${signing.name} is valid.`));
       } catch (error) {
         checks.push(check('signing', 'error', error.message, { code: error.code || 'ERR_HARMONY_SIGNING_INVALID' }));
@@ -142,23 +147,23 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
   }
 
   try {
-    await validateMetroConfigAsync(projectRoot);
+    await validateMetroConfigAsync(root);
     checks.push(check('metro', 'pass', 'The resolved Metro config enables Harmony.'));
   } catch (error) {
     checks.push(check('metro', 'error', `Cannot load a Harmony-enabled Metro config: ${error.message}`, { code: error.code || 'ERR_HARMONY_METRO_CONFIG' }));
   }
 
-  for (const packageName of RequiredProjectPackages) {
-    if (canResolvePackage(projectRoot, packageName)) {
-      checks.push(check(`package:${packageName}`, 'pass', `${packageName} is resolvable.`));
+  for (const name of RequiredProjectPackages) {
+    if (canResolvePackage(root, name)) {
+      checks.push(check(`package:${name}`, 'pass', `${name} is resolvable.`));
     } else {
-      checks.push(check(`package:${packageName}`, 'error', `${packageName} is not resolvable from the app.`));
+      checks.push(check(`package:${name}`, 'error', `${name} is not resolvable from the app.`));
     }
   }
 
   if (options.validateModules !== false) {
     try {
-      const result = await verifyModulesAsync({ platform: 'harmony', projectRoot });
+      const result = await verifyModulesAsync({ platform: 'harmony', projectRoot: root });
       const errors = result.diagnostics.filter(item => item.severity === 'error');
       const warnings = result.diagnostics.filter(item => item.severity === 'warning');
 
@@ -190,54 +195,55 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
   }
 
   const toolchain = resolveHarmonyToolchain();
-  let sdkCheck;
+  let sdk;
 
   if (toolchain.sdkHome) {
-    sdkCheck = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
+    sdk = check('harmony-sdk', 'pass', `Complete Harmony SDK root was resolved at ${toolchain.sdkHome}.`);
   } else {
-    sdkCheck = check('harmony-sdk', unavailableToolStatus, 'No complete Harmony SDK root with HMS and OpenHarmony components was found; generation works but HAP build cannot be verified.');
+    sdk = check('harmony-sdk', unavailable, 'No complete Harmony SDK root with HMS and OpenHarmony components was found; generation works but HAP build cannot be verified.');
   }
 
-  checks.push(sdkCheck);
+  checks.push(sdk);
 
   const tools: Array<[string, HarmonyTool, string[], DoctorCheck['status']]> = [
-    ['ohpm', toolchain.ohpm, ['--version'], unavailableToolStatus],
-    ['hvigor-command', toolchain.hvigor, ['--version'], unavailableToolStatus],
+    ['ohpm', toolchain.ohpm, ['--version'], unavailable],
+    ['hvigor-command', toolchain.hvigor, ['--version'], unavailable],
   ];
   if (options.requireDeviceTools !== false) {
-    tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailableToolStatus]);
+    tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailable]);
   }
-  for (const [id, tool, versionArgs, unavailableStatus] of tools) {
+
+  for (const [id, tool, args, status] of tools) {
     const command = [tool.command, ...tool.args].map(value => JSON.stringify(value)).join(' ');
 
     try {
-      const result = await spawnAsync(tool.command, [...tool.args, ...versionArgs], {
+      const result = await spawnAsync(tool.command, [...tool.args, ...args], {
         capture: true,
-        cwd: projectRoot,
+        cwd: root,
         operation: `doctor-${id}`,
         timeoutMs: 10_000,
       });
 
       checks.push(result.code === 0 && !result.timedOut
         ? check(id, 'pass', `${command} is available through ${tool.source}.`)
-        : check(id, unavailableStatus, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
+        : check(id, status, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
     } catch {
-      checks.push(check(id, unavailableStatus, `${command} is unavailable; generation remains available.`));
+      checks.push(check(id, status, `${command} is unavailable; generation remains available.`));
     }
   }
 
   if (options.validateGeneratedProject !== false) {
     try {
-      const plan = await resolveHarmonyBuildPlanIfPresentAsync(projectRoot);
+      const plan = await resolveHarmonyBuildPlanIfPresentAsync(root);
       if (plan && fs.existsSync(plan.harmonyRoot)) {
         if (!fs.existsSync(plan.projectFiles.rootHvigor)
           || !fs.existsSync(plan.projectFiles.moduleHvigor)) {
-          checks.push(check('hvigor', 'error', 'Generated root and module Hvigor files are required.'));
+          checks.push(check('hvigor', 'error', 'Root and module Hvigor files are required.'));
         } else {
           const content = await fs.promises.readFile(plan.projectFiles.moduleHvigor, 'utf8');
           checks.push(isRnohAutolinkingDisabled(content)
             ? check('hvigor-autolinking', 'pass', 'RNOH duplicate autolinking is disabled.')
-            : check('hvigor-autolinking', 'error', 'The generated module Hvigor file must disable RNOH autolinking.'));
+            : check('hvigor-autolinking', 'error', 'The module Hvigor file must disable duplicate RNOH autolinking.'));
         }
       }
     } catch (error) {
@@ -248,16 +254,12 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
   return {
     checks,
     ok: checks.every(item => item.status !== 'error'),
-    projectRoot,
+    projectRoot: root,
   };
 }
 
-async function doctorAsync(projectRoot: string, options: DoctorOptions = {}): Promise<DoctorResult> {
-  return withHarmonyProjectLockAsync(
-    projectRoot,
-    'doctor',
-    () => doctorUnlockedAsync(projectRoot, options)
-  );
+async function doctorAsync(root: string, options: DoctorOptions = {}): Promise<DoctorResult> {
+  return withHarmonyProjectLockAsync(root, 'doctor', () => doctorUnlockedAsync(root, options));
 }
 
 function formatDoctor(result: DoctorResult): string {

package/src/doctor/index.ts

@@ -0,0 +1,16 @@
+import { parseCommandArgs, type Command } from '../command';
+import { parseDoctorArgs } from './options';
+
+export const command: Command = async (argv, io) => {
+  const args = parseCommandArgs(parseDoctorArgs, argv, io);
+  if (!args) return 0;
+
+  const { projectRoot: root } = args;
+  const { doctorAsync, formatDoctor } = await import('./doctor.js');
+
+  const result = await doctorAsync(root, { requireBuildTools: true });
+
+  io.log(formatDoctor(result));
+
+  return result.ok ? 0 : 1;
+};