@expo-harmony/cli 55.0.26-harmony.4 → 55.0.26-harmony.6

package/build/run/run.js

@@ -43,7 +43,10 @@ async function runHarmonyUnlockedAsync(projectRoot, options = {}) {
         variant: options.variant || 'debug',
     };
     const steps = {};
-    await (0, common_1.ensureGeneratedProjectAsync)(projectRoot, normalizedOptions, steps);
+    await (0, common_1.ensureGeneratedProjectAsync)(projectRoot, {
+        ...normalizedOptions,
+        skipGeneratedProjectCheck: true,
+    }, steps);
     const plan = await (0, common_1.timed)(steps, 'buildPlan', () => (0, tools_1.resolveHarmonyBuildPlanAsync)(projectRoot, { buildMode: normalizedOptions.variant }));
     const identity = resolveRunIdentity(plan, normalizedOptions);
     const toolchain = (0, tools_1.resolveHarmonyToolchain)();
@@ -80,6 +83,7 @@ async function runHarmonyUnlockedAsync(projectRoot, options = {}) {
         const buildEnv = {
             ...process.env,
             EXPO_HARMONY_NODE: process.env.EXPO_HARMONY_NODE || process.execPath,
+            EXPO_METRO_TARGET: 'harmony',
             HERMES_V1_ENABLED: 'true',
             ...(normalizedOptions.variant === 'release' ? { EXPO_HARMONY_BUNDLE_PREBUILT: '1' } : {}),
             ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME

package/build/tools.js

@@ -10,6 +10,7 @@ exports.resolveHarmonyEmulator = resolveHarmonyEmulator;
 exports.resolveHarmonyToolchain = resolveHarmonyToolchain;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const tool_command_1 = require("@expo-harmony/expo-modules-autolinking/tool-command");
 const build_descriptor_1 = require("@expo-harmony/prebuild-config/build-descriptor");
 const check_1 = require("@expo-harmony/prebuild-config/check");
 const errors_1 = require("./errors");
@@ -99,38 +100,35 @@ function resolveHarmonyToolchain() {
     const layouts = sdkHome ? devEcoLayouts(sdkHome) : [];
     let ohpm;
     if (env.HARMONY_OHPM) {
-        ohpm = { args: [], command: env.HARMONY_OHPM, source: 'override' };
+        ohpm = { ...(0, tool_command_1.resolveHarmonyCommand)('ohpm', [], env), source: 'override' };
     }
     else {
-        const devEcoOhpm = existingFile(layouts.map(layout => node_path_1.default.join(layout.toolsRoot, 'ohpm', 'bin', platform === 'win32' ? 'ohpm.bat' : 'ohpm')));
-        ohpm = devEcoOhpm
-            ? { args: [], command: devEcoOhpm, source: 'deveco' }
-            : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
+        const entry = layouts.map(layout => ({
+            node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_OHPM_NODE || env.HARMONY_NODE }),
+            script: node_path_1.default.join(layout.toolsRoot, 'ohpm', 'bin', 'pm-cli.js'),
+        })).find(candidate => candidate.node && node_fs_1.default.existsSync(candidate.script));
+        const command = existingFile(layouts.map(layout => node_path_1.default.join(layout.toolsRoot, 'ohpm', 'bin', platform === 'win32' ? 'ohpm.bat' : 'ohpm')));
+        ohpm = entry
+            ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
+            : command
+                ? { args: [], command, source: 'deveco' }
+                : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
     }
     let hvigor;
     if (env.HARMONY_HVIGORW) {
-        if (/\.(?:c|m)?js$/iu.test(env.HARMONY_HVIGORW)) {
-            hvigor = {
-                args: [env.HARMONY_HVIGORW],
-                command: env.HARMONY_NODE || process.execPath,
-                source: 'override',
-            };
-        }
-        else {
-            hvigor = { args: [], command: env.HARMONY_HVIGORW, source: 'override' };
-        }
+        hvigor = { ...(0, tool_command_1.resolveHarmonyCommand)('hvigorw', [], env), source: 'override' };
     }
     else {
-        const devEcoHvigor = layouts.map(layout => ({
-            layout,
-            node: devEcoNode(layout, platform, env),
+        const entry = layouts.map(layout => ({
+            node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_HVIGOR_NODE || env.HARMONY_NODE }),
             script: node_path_1.default.join(layout.toolsRoot, 'hvigor', 'bin', 'hvigorw.js'),
         })).find(candidate => candidate.node && node_fs_1.default.existsSync(candidate.script));
-        hvigor = devEcoHvigor
-            ? { args: [devEcoHvigor.script], command: devEcoHvigor.node.command, source: 'deveco' }
+        hvigor = entry
+            ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
             : { args: [], command: platform === 'win32' ? 'hvigorw.bat' : 'hvigorw', source: 'path' };
     }
     const toolsRoot = layouts.find(layout => (hvigor.args[0]?.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)
+        || ohpm.args[0]?.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)
         || ohpm.command.startsWith(`${layout.toolsRoot}${node_path_1.default.sep}`)))?.toolsRoot || null;
     let hdc;
     if (env.HARMONY_HDC) {
@@ -151,10 +149,14 @@ function resolveHarmonyToolchain() {
 function createHarmonyToolchainEnv(toolchain = resolveHarmonyToolchain()) {
     return {
         ...process.env,
-        HARMONY_OHPM: toolchain.ohpm.command,
-        // A script-based Hvigor invocation must retain both its script and Node executable.
+        HARMONY_OHPM: toolchain.ohpm.args[0] || toolchain.ohpm.command,
+        HARMONY_OHPM_NODE: toolchain.ohpm.args.length > 0 ? toolchain.ohpm.command : undefined,
+        // Script-based tools must retain both their script and Node executable.
         HARMONY_HVIGORW: toolchain.hvigor.args[0] || toolchain.hvigor.command,
-        ...(toolchain.hvigor.args.length > 0 ? { HARMONY_NODE: toolchain.hvigor.command } : {}),
+        HARMONY_HVIGOR_NODE: toolchain.hvigor.args.length > 0 ? toolchain.hvigor.command : undefined,
+        ...(toolchain.hvigor.args.length > 0
+            ? { HARMONY_NODE: toolchain.hvigor.command }
+            : toolchain.ohpm.args.length > 0 ? { HARMONY_NODE: toolchain.ohpm.command } : {}),
         ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
             ? { DEVECO_SDK_HOME: toolchain.sdkHome }
             : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo-harmony/cli",
-  "version": "55.0.26-harmony.4",
+  "version": "55.0.26-harmony.6",
   "keywords": [
     "react-native",
     "expo",
@@ -37,8 +37,8 @@
   },
   "dependencies": {
     "@expo-harmony/config-plugins": "55.0.10-harmony.2",
-    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.2",
-    "@expo-harmony/prebuild-config": "55.0.0-harmony.3",
+    "@expo-harmony/expo-modules-autolinking": "55.0.25-harmony.3",
+    "@expo-harmony/prebuild-config": "55.0.0-harmony.5",
     "@expo/config": "55.0.17",
     "cross-spawn": "^7.0.6",
     "json5": "2.2.3"

package/src/buildHap/common.ts

@@ -10,7 +10,7 @@ import { resolveHarmonyBuildPlanIfPresentAsync } from '../tools';
 interface HarmonyBuildPipelineOptions {
   io?: Pick<Console, 'error' | 'log' | 'warn'>;
   requireDeviceTools?: boolean;
-  /** @internal The caller already completed an isolated prebuild check. */
+  /** @internal Reuse the native project without an isolated drift check. */
   skipGeneratedProjectCheck?: boolean;
   sync: boolean;
   variant: 'debug' | 'release';

package/src/doctor/doctor.ts

@@ -208,6 +208,8 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
     tools.unshift(['hdc', toolchain.hdc, ['-v'], unavailableToolStatus]);
   }
   for (const [id, tool, versionArgs, unavailableStatus] of tools) {
+    const command = [tool.command, ...tool.args].map(value => JSON.stringify(value)).join(' ');
+
     try {
       const result = await spawnAsync(tool.command, [...tool.args, ...versionArgs], {
         capture: true,
@@ -215,11 +217,12 @@ async function doctorUnlockedAsync(projectRoot: string, options: DoctorOptions =
         operation: `doctor-${id}`,
         timeoutMs: 10_000,
       });
+
       checks.push(result.code === 0 && !result.timedOut
-        ? check(id, 'pass', `${tool.command} is available through ${tool.source}.`)
-        : check(id, unavailableStatus, `${tool.command} is unavailable or unhealthy; HAP build cannot be verified.`));
+        ? check(id, 'pass', `${command} is available through ${tool.source}.`)
+        : check(id, unavailableStatus, `${command} is unavailable or unhealthy; HAP build cannot be verified.`));
     } catch {
-      checks.push(check(id, unavailableStatus, `${tool.command} is unavailable; generation remains available.`));
+      checks.push(check(id, unavailableStatus, `${command} is unavailable; generation remains available.`));
     }
   }
 

package/src/prebuild/check.ts

@@ -40,7 +40,28 @@ function mirrorRoot(temp, project) {
   return path.join(temp, 'filesystem', volume, ...segments);
 }
 
-async function linkModulesAsync(source, target) {
+async function linkModuleEntryAsync(
+  source: string,
+  target: string,
+  entry: fs.Dirent
+) {
+  const directory = entry.isSymbolicLink()
+    ? (await fs.promises.stat(source)).isDirectory()
+    : entry.isDirectory();
+
+  if (process.platform === 'win32' && !directory) {
+    await fs.promises.copyFile(source, target);
+    return;
+  }
+
+  await fs.promises.symlink(
+    path.resolve(source),
+    target,
+    directory ? process.platform === 'win32' ? 'junction' : 'dir' : 'file'
+  );
+}
+
+async function linkModulesAsync(source: string, target: string) {
   await fs.promises.mkdir(target, { recursive: true });
 
   for (const entry of await fs.promises.readdir(source, { withFileTypes: true })) {
@@ -49,25 +70,18 @@ async function linkModulesAsync(source, target) {
 
     if (entry.name.startsWith('@') && entry.isDirectory() && !entry.isSymbolicLink()) {
       await fs.promises.mkdir(to);
+
       for (const child of await fs.promises.readdir(from, { withFileTypes: true })) {
-        await fs.promises.symlink(
+        await linkModuleEntryAsync(
           path.join(from, child.name),
           path.join(to, child.name),
-          process.platform === 'win32' && (child.isDirectory() || child.isSymbolicLink())
-            ? 'junction'
-            : child.isDirectory() ? 'dir' : 'file'
+          child
         );
       }
       continue;
     }
 
-    await fs.promises.symlink(
-      from,
-      to,
-      process.platform === 'win32' && (entry.isDirectory() || entry.isSymbolicLink())
-        ? 'junction'
-        : entry.isDirectory() ? 'dir' : 'file'
-    );
+    await linkModuleEntryAsync(from, to, entry);
   }
 }
 
@@ -126,8 +140,8 @@ async function copyAsync(
   // Keep a real node_modules directory in the isolated project and link its
   // entries. Dependency scanners then retain the isolated lexical package path
   // (including scoped packages) instead of collapsing the entire node_modules
-  // root to the source project's realpath. The packages remain read-only and
-  // are never copied or modified by --check.
+  // root to the source project's realpath. Package directories stay linked;
+  // Windows copies loose files to avoid requiring file-symlink privileges.
   await linkModulesAsync(modules, path.join(target, 'node_modules'));
   await stageAsync(project, target, temp);
 }

package/src/process.ts

@@ -1,4 +1,5 @@
 import spawn from 'cross-spawn';
+import { terminateProcess } from '@expo-harmony/expo-modules-autolinking/tool-command';
 
 import { HarmonyCliError } from './errors';
 
@@ -76,8 +77,15 @@ function formatDiagnostics(result: Pick<ProcessResult, 'stderr' | 'stdout'>, lim
 
 function spawnAsync(command: string, args: string[], options: ProcessOptions = {}): Promise<ProcessResult> {
   return new Promise<ProcessResult>((resolve, reject) => {
+    if (options.signal?.aborted) {
+      throw new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot run ${command}: operation aborted.`, {
+        cause: options.signal.reason,
+        operation: options.operation || 'spawn',
+      });
+    }
+
     const piped = Boolean(options.capture || options.onStdout || options.onStderr);
-    const outputLimit = options.outputLimit || DefaultOutputLimit;
+    const limit = options.outputLimit || DefaultOutputLimit;
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: options.env || process.env,
@@ -86,11 +94,12 @@ function spawnAsync(command: string, args: string[], options: ProcessOptions = {
       windowsHide: true,
     });
 
-    const stdout = new BoundedCapture(outputLimit);
-    const stderr = new BoundedCapture(outputLimit);
+    const stdout = new BoundedCapture(limit);
+    const stderr = new BoundedCapture(limit);
     let timedOut = false;
     let settled = false;
-    let forceKillTimer: NodeJS.Timeout | null = null;
+    let escalation: NodeJS.Timeout | null = null;
+    let stopping: Promise<void> | undefined;
 
     if (piped) {
       child.stdout.on('data', (chunk) => {
@@ -103,72 +112,96 @@ function spawnAsync(command: string, args: string[], options: ProcessOptions = {
       });
     }
 
-    const stopChild = (signal: NodeJS.Signals = 'SIGTERM') => {
-      child.kill(signal);
-      if (forceKillTimer === null) {
-        forceKillTimer = setTimeout(
-          () => child.kill('SIGKILL'),
+    const stop = (signal: NodeJS.Signals = 'SIGTERM') => {
+      if (stopping || settled) return;
+
+      stopping = Promise.resolve().then(() => terminateProcess(child, signal));
+      if (process.platform === 'win32') {
+        void finish(null, signal);
+      } else {
+        stopping.catch((cause) => {
+          void finish(null, null, cause);
+        });
+        escalation = setTimeout(
+          () => {
+            stopping = terminateProcess(child, 'SIGKILL');
+            stopping.catch((cause) => {
+              void finish(null, null, cause);
+            });
+          },
           options.stopGraceMs || DefaultStopGraceMs
         );
-        forceKillTimer.unref?.();
+        escalation.unref?.();
       }
     };
 
-    const forwardSigint = () => stopChild('SIGINT');
-    const forwardSigterm = () => stopChild('SIGTERM');
-    process.once('SIGINT', forwardSigint);
-    process.once('SIGTERM', forwardSigterm);
+    const interrupt = () => stop('SIGINT');
+    const terminate = () => stop('SIGTERM');
+    process.once('SIGINT', interrupt);
+    process.once('SIGTERM', terminate);
 
     const timeout = options.timeoutMs
       ? setTimeout(() => {
           timedOut = true;
-          stopChild('SIGTERM');
+          stop('SIGTERM');
         }, options.timeoutMs)
       : null;
     timeout?.unref?.();
 
     const cleanup = () => {
       if (timeout) clearTimeout(timeout);
-      if (forceKillTimer) clearTimeout(forceKillTimer);
-      process.removeListener('SIGINT', forwardSigint);
-      process.removeListener('SIGTERM', forwardSigterm);
+      if (escalation) clearTimeout(escalation);
+      process.removeListener('SIGINT', interrupt);
+      process.removeListener('SIGTERM', terminate);
       options.signal?.removeEventListener('abort', abort);
     };
 
-    const abort = () => stopChild('SIGTERM');
-    if (options.signal?.aborted) abort();
-    else options.signal?.addEventListener('abort', abort, { once: true });
+    const finish = async (code, signal, cause?) => {
+      try {
+        await stopping;
+      } catch (error) {
+        cause = error;
+      }
 
-    child.once('error', (cause) => {
       if (settled) return;
       settled = true;
       cleanup();
 
-      reject(new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: ${cause.message}`, {
+      if (cause) reject(new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot run ${command}: ${cause.message}`, {
         cause,
         operation: options.operation || 'spawn',
       }));
-    });
-    // `close` runs after stdout/stderr have closed, so captured diagnostics are
-    // complete. `exit` can fire while pipe data is still pending.
-    child.once('close', (code, signal) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-
-      resolve({
+      else resolve({
         code: code === null ? 1 : code,
         signal,
         stderr: stderr.toString(),
         stdout: stdout.toString(),
         timedOut,
       });
+    };
+
+    child.once('error', (cause) => {
+      void finish(null, null, cause);
     });
+    child.once('close', (code, signal) => {
+      void finish(code, signal);
+    });
+
+    const abort = () => stop('SIGTERM');
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.signal?.aborted) abort();
   });
 }
 
 function startManagedProcess(command: string, args: string[], options: ProcessOptions = {}) {
-  const outputLimit = options.outputLimit || DefaultOutputLimit;
+  if (options.signal?.aborted) {
+    throw new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: operation aborted.`, {
+      cause: options.signal.reason,
+      operation: options.operation || 'spawn',
+    });
+  }
+
+  const limit = options.outputLimit || DefaultOutputLimit;
   const piped = options.stdio !== 'inherit';
   const child = spawn(command, args, {
     cwd: options.cwd,
@@ -178,11 +211,14 @@ function startManagedProcess(command: string, args: string[], options: ProcessOp
     windowsHide: true,
   });
 
-  const stdout = new BoundedCapture(outputLimit);
-  const stderr = new BoundedCapture(outputLimit);
-  let spawnError: HarmonyCliError | null = null;
+  const stdout = new BoundedCapture(limit);
+  const stderr = new BoundedCapture(limit);
+  let failure: HarmonyCliError | null = null;
   let closed = false;
-  let stopRequested = false;
+  let stopped = false;
+  let stopping: Promise<void> | undefined;
+  let stopPromise: Promise<ProcessResult | undefined> | undefined;
+  let finish: (code: number | null, signal: NodeJS.Signals | null) => Promise<void>;
 
   if (piped) {
     child.stdout.on('data', (chunk) => {
@@ -195,34 +231,43 @@ function startManagedProcess(command: string, args: string[], options: ProcessOp
     });
   }
 
-  const forwardSigint = () => {
-    void stop('SIGINT');
+  const interrupt = () => {
+    void stop('SIGINT').catch(() => {});
   };
-  const forwardSigterm = () => {
-    void stop('SIGTERM');
+  const terminate = () => {
+    void stop('SIGTERM').catch(() => {});
   };
   const abort = () => {
-    void stop('SIGTERM');
+    void stop('SIGTERM').catch(() => {});
   };
 
   const cleanup = () => {
-    process.removeListener('SIGINT', forwardSigint);
-    process.removeListener('SIGTERM', forwardSigterm);
+    process.removeListener('SIGINT', interrupt);
+    process.removeListener('SIGTERM', terminate);
     options.signal?.removeEventListener('abort', abort);
   };
 
   const completion = new Promise<ProcessResult>((resolve, reject) => {
     child.once('error', (cause) => {
-      spawnError = new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: ${cause.message}`, {
+      failure = new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: ${cause.message}`, {
         cause,
         operation: options.operation || 'spawn',
       });
     });
-    child.once('close', (code, signal) => {
+    finish = async (code, signal) => {
+      try {
+        await stopping;
+      } catch (cause) {
+        failure = new HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot stop ${command}: ${cause.message}`, {
+          cause, operation: options.operation || 'spawn',
+        });
+      }
+
+      if (closed) return;
       closed = true;
       cleanup();
 
-      if (spawnError) reject(spawnError);
+      if (failure) reject(failure);
       else resolve({
         code: code === null ? 1 : code,
         signal,
@@ -230,6 +275,10 @@ function startManagedProcess(command: string, args: string[], options: ProcessOp
         stdout: stdout.toString(),
         timedOut: false,
       });
+    };
+
+    child.once('close', (code, signal) => {
+      void finish(code, signal);
     });
   });
   // A readiness probe may be the first consumer. Keep early spawn failures from
@@ -237,28 +286,53 @@ function startManagedProcess(command: string, args: string[], options: ProcessOp
   completion.catch(() => {});
 
   async function stop(signal: NodeJS.Signals = 'SIGTERM', graceMs = DefaultStopGraceMs) {
+    if (stopPromise) return stopPromise;
     if (closed) return completion;
 
-    stopRequested = true;
-    child.kill(signal);
-    let timer: NodeJS.Timeout | undefined;
+    stopped = true;
+    stopping = Promise.resolve().then(() => terminateProcess(child, signal));
+    stopPromise = (async () => {
+      if (process.platform === 'win32') {
+        void finish(null, signal);
+        return completion;
+      }
+
+      try {
+        await stopping;
+      } catch {
+        await finish(null, signal);
+        return completion;
+      }
 
-    await Promise.race([
-      completion.catch(() => undefined),
-      new Promise((resolve) => {
-        timer = setTimeout(resolve, graceMs);
-        timer.unref?.();
-      }),
-    ]);
+      let timer: NodeJS.Timeout | undefined;
+
+      await Promise.race([
+        completion.catch(() => undefined),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, graceMs);
+          timer.unref?.();
+        }),
+      ]);
+
+      if (timer) clearTimeout(timer);
+      if (!closed) {
+        stopping = terminateProcess(child, 'SIGKILL');
+        try {
+          await stopping;
+        } catch {
+          await finish(null, signal);
+        }
+      }
 
-    if (timer) clearTimeout(timer);
-    if (!closed) child.kill('SIGKILL');
+      return completion.catch(() => undefined);
+    })();
+    stopPromise.catch(() => {});
 
-    return completion.catch(() => undefined);
+    return stopPromise;
   }
 
-  process.once('SIGINT', forwardSigint);
-  process.once('SIGTERM', forwardSigterm);
+  process.once('SIGINT', interrupt);
+  process.once('SIGTERM', terminate);
   if (options.signal?.aborted) abort();
   else options.signal?.addEventListener('abort', abort, { once: true });
 
@@ -268,7 +342,7 @@ function startManagedProcess(command: string, args: string[], options: ProcessOp
     getStderr: () => stderr.toString(),
     getStdout: () => stdout.toString(),
     stop,
-    wasStopped: () => stopRequested,
+    wasStopped: () => stopped,
   };
 }
 

package/src/run/run.ts

@@ -118,7 +118,10 @@ async function runHarmonyUnlockedAsync(
   };
   const steps: Record<string, number> = {};
 
-  await ensureGeneratedProjectAsync(projectRoot, normalizedOptions, steps);
+  await ensureGeneratedProjectAsync(projectRoot, {
+    ...normalizedOptions,
+    skipGeneratedProjectCheck: true,
+  }, steps);
 
   const plan = await timed(steps, 'buildPlan', () => resolveHarmonyBuildPlanAsync(
     projectRoot,

package/src/tools.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { resolveHarmonyCommand } from '@expo-harmony/expo-modules-autolinking/tool-command';
 
 import {
   resolveHarmonyBuildPath,
@@ -141,43 +142,43 @@ function resolveHarmonyToolchain(): HarmonyToolchain {
 
   let ohpm: HarmonyTool;
   if (env.HARMONY_OHPM) {
-    ohpm = { args: [], command: env.HARMONY_OHPM, source: 'override' };
+    ohpm = { ...resolveHarmonyCommand('ohpm', [], env), source: 'override' };
   } else {
-    const devEcoOhpm = existingFile(layouts.map(layout => path.join(
+    const entry = layouts.map(layout => ({
+      node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_OHPM_NODE || env.HARMONY_NODE }),
+      script: path.join(layout.toolsRoot, 'ohpm', 'bin', 'pm-cli.js'),
+    })).find(candidate => candidate.node && fs.existsSync(candidate.script));
+    const command = existingFile(layouts.map(layout => path.join(
       layout.toolsRoot,
       'ohpm',
       'bin',
       platform === 'win32' ? 'ohpm.bat' : 'ohpm'
     )));
-    ohpm = devEcoOhpm
-      ? { args: [], command: devEcoOhpm, source: 'deveco' }
-      : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
+
+    ohpm = entry
+      ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
+      : command
+        ? { args: [], command, source: 'deveco' }
+        : { args: [], command: platform === 'win32' ? 'ohpm.bat' : 'ohpm', source: 'path' };
   }
 
   let hvigor: HarmonyTool;
   if (env.HARMONY_HVIGORW) {
-    if (/\.(?:c|m)?js$/iu.test(env.HARMONY_HVIGORW)) {
-      hvigor = {
-        args: [env.HARMONY_HVIGORW],
-        command: env.HARMONY_NODE || process.execPath,
-        source: 'override',
-      };
-    } else {
-      hvigor = { args: [], command: env.HARMONY_HVIGORW, source: 'override' };
-    }
+    hvigor = { ...resolveHarmonyCommand('hvigorw', [], env), source: 'override' };
   } else {
-    const devEcoHvigor = layouts.map(layout => ({
-      layout,
-      node: devEcoNode(layout, platform, env),
+    const entry = layouts.map(layout => ({
+      node: devEcoNode(layout, platform, { ...env, HARMONY_NODE: env.HARMONY_HVIGOR_NODE || env.HARMONY_NODE }),
       script: path.join(layout.toolsRoot, 'hvigor', 'bin', 'hvigorw.js'),
     })).find(candidate => candidate.node && fs.existsSync(candidate.script));
-    hvigor = devEcoHvigor
-      ? { args: [devEcoHvigor.script], command: devEcoHvigor.node.command, source: 'deveco' }
+
+    hvigor = entry
+      ? { args: [entry.script], command: entry.node.command, source: 'deveco' }
       : { args: [], command: platform === 'win32' ? 'hvigorw.bat' : 'hvigorw', source: 'path' };
   }
 
   const toolsRoot = layouts.find(layout => (
     hvigor.args[0]?.startsWith(`${layout.toolsRoot}${path.sep}`)
+    || ohpm.args[0]?.startsWith(`${layout.toolsRoot}${path.sep}`)
     || ohpm.command.startsWith(`${layout.toolsRoot}${path.sep}`)
   ))?.toolsRoot || null;
 
@@ -201,10 +202,14 @@ function resolveHarmonyToolchain(): HarmonyToolchain {
 function createHarmonyToolchainEnv(toolchain = resolveHarmonyToolchain()): NodeJS.ProcessEnv {
   return {
     ...process.env,
-    HARMONY_OHPM: toolchain.ohpm.command,
-    // A script-based Hvigor invocation must retain both its script and Node executable.
+    HARMONY_OHPM: toolchain.ohpm.args[0] || toolchain.ohpm.command,
+    HARMONY_OHPM_NODE: toolchain.ohpm.args.length > 0 ? toolchain.ohpm.command : undefined,
+    // Script-based tools must retain both their script and Node executable.
     HARMONY_HVIGORW: toolchain.hvigor.args[0] || toolchain.hvigor.command,
-    ...(toolchain.hvigor.args.length > 0 ? { HARMONY_NODE: toolchain.hvigor.command } : {}),
+    HARMONY_HVIGOR_NODE: toolchain.hvigor.args.length > 0 ? toolchain.hvigor.command : undefined,
+    ...(toolchain.hvigor.args.length > 0
+      ? { HARMONY_NODE: toolchain.hvigor.command }
+      : toolchain.ohpm.args.length > 0 ? { HARMONY_NODE: toolchain.ohpm.command } : {}),
     ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
       ? { DEVECO_SDK_HOME: toolchain.sdkHome }
       : {}),