Merge remote-tracking branch 'origin/main' into thelarkinn-dogfood-rush-daemon

main (#6090) now keeps rush-client from loading @microsoft/rush-lib with on-demand
requires and lazy start-command resolution. Take that implementation for the client
and drop this branch's overlapping client-only modules (RushJsonLocation,
RushXCommandLineArguments, DaemonLaunchCommand and bundledRushVersion) and their
change files. The daemon-side changes in this branch are unaffected.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: TheLarkInn

apps/rush-cli-client/bin/rush-client

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+// Node >= 22.1 reuses compiled code across invocations; this does not change the environment.
+require('node:module').enableCompileCache?.();
 require('../lib-commonjs/start.js');

apps/rush-cli-client/bin/rushx-client

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+// Node >= 22.1 reuses compiled code across invocations; this does not change the environment.
+require('node:module').enableCompileCache?.();
 require('../lib-commonjs/startRushX.js');

apps/rush-cli-client/src/bundledRushVersion.ts

@@ -7,13 +7,9 @@ import { JsonFile } from '@rushstack/node-core-library';
 import type { IConnectOrStartDaemonOptions } from '@rushstack/rush-client-core';
 import { computeDaemonWorkspaceKey, resolveDaemonPathsFromProcess } from '@rushstack/rush-daemon-transport';
 import { readDaemonInstallationMetadata } from '@rushstack/rush-daemon/lib/DaemonInstallation';
-import {
-  DaemonLauncherUnavailableError,
-  getSelectedDaemonStartCommand
-} from '@rushstack/rush-daemon/lib/DaemonLaunchCommand';
-import type { IVersionSelectedDaemonLaunch } from '@rushstack/rush-daemon/lib/VersionSelectedDaemonLauncher';
+import type * as VersionSelectedDaemonLauncherModule from '@rushstack/rush-daemon/lib/VersionSelectedDaemonLauncher';
 
-import { BUNDLED_RUSH_VERSION } from './bundledRushVersion';
+import { getBundledRushVersion, loadVersionSelectedDaemonLauncher } from './lazyRushModules';
 
 export function getDaemonConnectionOptions(
   repoRoot: string,
@@ -25,7 +21,7 @@ export function getDaemonConnectionOptions(
   const daemonPackagePath: string = require.resolve('@rushstack/rush-daemon/package.json');
   const daemonPackage: { version: string; bin: { rushd: string } } = JsonFile.load(daemonPackagePath);
   if (autoStart && readDaemonInstallationMetadata(daemonPackagePath).rushVersion !== rushVersion) {
-    throw new DaemonLauncherUnavailableError(
+    throw new (loadVersionSelectedDaemonLauncher().DaemonLauncherUnavailableError)(
       rushVersion,
       'The synchronous launcher only supports its installed engine; use asynchronous version selection.'
     );
@@ -34,7 +30,7 @@ export function getDaemonConnectionOptions(
     paths: resolveDaemonPathsFromProcess(computeDaemonWorkspaceKey({ canonicalRepoRoot, rushVersion })),
     expectedDaemonVersion: daemonPackage.version,
     startCommand: autoStart
-      ? getSelectedDaemonStartCommand(daemonPackagePath, {
+      ? loadVersionSelectedDaemonLauncher().getSelectedDaemonStartCommand(daemonPackagePath, {
           repoRoot: canonicalRepoRoot,
           rushVersion,
           environment
@@ -57,17 +53,25 @@ export async function getDaemonConnectionOptionsAsync(
     false
   );
   if (!autoStart) return { paths: options.paths };
-  // The bundled runtime needs no selection; its bootstrap re-attests before binding.
-  if (rushVersion === BUNDLED_RUSH_VERSION)
-    return getDaemonConnectionOptions(repoRoot, rushVersion, environment, true);
-  // Selecting another installation uses the engine's installer APIs, so it is loaded only when needed.
-  const { selectDaemonLauncherAsync } = await import(
-    '@rushstack/rush-daemon/lib/VersionSelectedDaemonLauncher'
-  );
-  const launch: IVersionSelectedDaemonLaunch = await selectDaemonLauncherAsync({
-    repoRoot: fs.realpathSync.native(repoRoot),
-    rushVersion,
-    environment
-  });
+  if (rushVersion === getBundledRushVersion()) {
+    const daemonPackagePath: string = require.resolve('@rushstack/rush-daemon/package.json');
+    if (readDaemonInstallationMetadata(daemonPackagePath).rushVersion !== rushVersion) {
+      // Preserve the eager synchronous launcher error.
+      return getDaemonConnectionOptions(repoRoot, rushVersion, environment, true);
+    }
+    // The bundled runtime's bootstrap re-attests before binding. Resolve it only if a start is needed.
+    return {
+      ...options,
+      resolveStartCommandAsync: async () =>
+        getDaemonConnectionOptions(repoRoot, rushVersion, environment, true).startCommand!
+    };
+  }
+  const { selectDaemonLauncherAsync } = loadVersionSelectedDaemonLauncher();
+  const launch: VersionSelectedDaemonLauncherModule.IVersionSelectedDaemonLaunch =
+    await selectDaemonLauncherAsync({
+      repoRoot: fs.realpathSync.native(repoRoot),
+      rushVersion,
+      environment
+    });
   return { ...options, expectedDaemonVersion: launch.daemonVersion, startCommand: launch.startCommand };
 }

apps/rush-cli-client/src/daemonConnectionOptions.ts

@@ -3,12 +3,12 @@
 
 import * as path from 'node:path';
 
+import type { IDaemonConfigurationJson } from '@microsoft/rush-lib';
+// A deep import keeps the warm connect path from evaluating the @microsoft/rush-lib entry point.
 import {
   daemonEnvironmentVariables,
-  resolveDaemonConfiguration,
-  type IDaemonConfigurationJson
+  resolveDaemonConfiguration
 } from '@microsoft/rush-lib/lib/api/DaemonConfiguration';
-import { tryFindRushJsonLocation } from '@microsoft/rush-lib/lib/api/RushJsonLocation';
 import { JsonFile } from '@rushstack/node-core-library';
 import {
   DaemonClientError,
@@ -21,15 +21,19 @@ import {
 } from '@rushstack/rush-client-core';
 import type { DaemonVerbosity, IDaemonRequestEnvelope } from '@rushstack/rush-daemon-protocol';
 import { ConsoleTerminalProvider } from '@rushstack/terminal';
-import { DaemonLauncherUnavailableError } from '@rushstack/rush-daemon/lib/DaemonLaunchCommand';
 
-import { BUNDLED_RUSH_VERSION } from './bundledRushVersion';
 import { executeDaemonCommandAsync } from './daemonCommands';
 import { formatAdmissionFailure, getConfiguredAdmission } from './ClientAdmissionControls';
 import { ClientOperationRenderer } from './ClientOperationRenderer';
 import { getDaemonConnectionOptionsAsync } from './daemonConnectionOptions';
 import { selectClientRoute, type IClientRoute } from './routing';
 import { writeStreamAsync } from './writeStreamAsync';
+import {
+  getBundledRushVersion,
+  loadMinimalRushConfiguration,
+  loadVersionSelectedDaemonLauncher,
+  tryFindRushJsonLocation
+} from './lazyRushModules';
 
 interface IWorkspaceJson {
   readonly rushVersion: string;
@@ -39,7 +43,7 @@ interface IWorkspaceJson {
 export async function launchClientAsync(rushx: boolean): Promise<void> {
   const cwd: string = process.cwd();
   const environment: Readonly<NodeJS.ProcessEnv> = Object.freeze({ ...process.env });
-  const rushJsonPath: string | undefined = tryFindRushJsonLocation({ startingFolder: cwd });
+  const rushJsonPath: string | undefined = tryFindRushJsonLocation(cwd);
   const workspace: IWorkspaceJson | undefined = rushJsonPath ? JsonFile.load(rushJsonPath) : undefined;
   const config: Readonly<Required<IDaemonConfigurationJson>> = resolveDaemonConfiguration(
     workspace?.daemon,
@@ -53,7 +57,7 @@ export async function launchClientAsync(rushx: boolean): Promise<void> {
     hasTerminal: !!(process.stdin.isTTY || process.stdout.isTTY || process.stderr.isTTY)
   });
   const selectedVersion: string =
-    environment.RUSH_PREVIEW_VERSION ?? workspace?.rushVersion ?? BUNDLED_RUSH_VERSION;
+    environment.RUSH_PREVIEW_VERSION ?? workspace?.rushVersion ?? getBundledRushVersion();
   if (!rushx && route.commandName === 'daemon') {
     if ((route.argv[1] === 'start' || route.argv[1] === 'restart') && process.argv.includes('--no-daemon')) {
       throw new Error(`--no-daemon cannot be combined with daemon ${route.argv[1]}.`);
@@ -120,7 +124,10 @@ export async function launchClientAsync(rushx: boolean): Promise<void> {
     };
     client = await connectOrStartDaemonAsync(connection);
   } catch (error) {
-    if (!(error instanceof DaemonClientError) && !(error instanceof DaemonLauncherUnavailableError))
+    if (
+      !(error instanceof DaemonClientError) &&
+      !(error instanceof loadVersionSelectedDaemonLauncher().DaemonLauncherUnavailableError)
+    )
       throw error;
     process.stderr.write(`rush-client: ${error.message} Using in-process Rush.\n`);
     launchInProcess(route.argv, rushx, selectedVersion);
@@ -154,9 +161,9 @@ export async function launchClientAsync(rushx: boolean): Promise<void> {
   };
   try {
     if (rushx) {
-      // Rushx discovery output needs the frontend's configuration loader, which loads the engine.
-      const { MinimalRushConfiguration } = await import('@microsoft/rush/lib/MinimalRushConfiguration');
-      MinimalRushConfiguration.loadFromDefaultLocation((line) => discoveryLines.push(line));
+      loadMinimalRushConfiguration().MinimalRushConfiguration.loadFromDefaultLocation((line) =>
+        discoveryLines.push(line)
+      );
     }
     await renderer.initializeAsync();
     outcome = await executeWithDaemonRestartAsync(client, connection, {
@@ -219,7 +226,7 @@ function launchInProcess(argv: ReadonlyArray<string>, rushx: boolean, selectedVe
   const executable: string = rushx ? 'rushx' : 'rush';
   const rushFolder: string = path.dirname(require.resolve('@microsoft/rush/package.json'));
   process.argv = [process.execPath, path.join(rushFolder, 'bin', executable), ...argv];
-  if (selectedVersion !== BUNDLED_RUSH_VERSION) {
+  if (selectedVersion !== getBundledRushVersion()) {
     // Old Rush releases reject new RUSH_* names. Only strip this launcher's own inputs;
     // the request snapshot was captured earlier and is never mutated.
     for (const name of [...Object.values(daemonEnvironmentVariables), 'RUSH_DAEMON_EXPERIMENTAL']) {

apps/rush-cli-client/src/launchClient.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+// The warm daemon connect path must not load the @microsoft/rush-lib bundle (hundreds of milliseconds).
+// Modules that depend on it are loaded here on demand, only by fallback, rushx, startup and version selection.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import type * as RushLibModule from '@microsoft/rush-lib';
+import type * as MinimalRushConfigurationModule from '@microsoft/rush/lib/MinimalRushConfiguration';
+import type * as VersionSelectedDaemonLauncherModule from '@rushstack/rush-daemon/lib/VersionSelectedDaemonLauncher';
+
+export function loadRushLib(): typeof RushLibModule {
+  return require('@microsoft/rush-lib');
+}
+
+export function loadMinimalRushConfiguration(): typeof MinimalRushConfigurationModule {
+  return require('@microsoft/rush/lib/MinimalRushConfiguration');
+}
+
+export function loadVersionSelectedDaemonLauncher(): typeof VersionSelectedDaemonLauncherModule {
+  return require('@rushstack/rush-daemon/lib/VersionSelectedDaemonLauncher');
+}
+
+/** Equals `Rush.version`. */
+export function getBundledRushVersion(): string {
+  return (require('@microsoft/rush-lib/package.json') as { version: string }).version;
+}
+
+/** Same search as `RushConfiguration.tryFindRushJsonLocation({ startingFolder })`. */
+export function tryFindRushJsonLocation(startingFolder: string): string | undefined {
+  let currentFolder: string = startingFolder;
+  let parentFolder: string = path.dirname(currentFolder);
+  while (parentFolder && parentFolder !== currentFolder) {
+    const rushJsonFilename: string = path.join(currentFolder, 'rush.json');
+    if (fs.existsSync(rushJsonFilename)) return rushJsonFilename;
+    currentFolder = parentFolder;
+    parentFolder = path.dirname(currentFolder);
+  }
+  return undefined;
+}

apps/rush-cli-client/src/lazyRushModules.ts

@@ -2,11 +2,9 @@
 // See LICENSE in the project root for license information.
 
 import type { IDaemonRequestAdmissionOptions } from '@rushstack/rush-daemon-protocol';
-import {
-  parseRushXCommandLineArguments,
-  type IRushXCommandLineArguments
-} from '@microsoft/rush-lib/lib/cli/RushXCommandLineArguments';
+import type { IRushXCommandLineArguments } from '@microsoft/rush-lib';
 
+import { loadRushLib } from './lazyRushModules';
 import { parseClientAdmissionControls, type IClientAdmissionControls } from './ClientAdmissionControls';
 
 const neverDaemonize: ReadonlySet<string> = new Set([
@@ -56,7 +54,7 @@ export function selectClientRoute(options: IClientRouteOptions): IClientRoute {
     ...(separator < 0 ? [] : controls.argv.slice(separator))
   ];
   const rushxArguments: IRushXCommandLineArguments | undefined = options.rushx
-    ? parseRushXCommandLineArguments(argv, options.environment)
+    ? loadRushLib().RushXCommand.parseArguments(argv, options.environment)
     : undefined;
   const commandName: string | undefined = rushxArguments ? rushxArguments.commandName || undefined : argv[0];
   const reporterControls: boolean =

apps/rush-cli-client/src/routing.ts

@@ -69,9 +69,7 @@ describe(getConfiguredAdmission.name, () => {
   });
 
   it('keeps an explicitly configured timeout as one absolute deadline', () => {
-    expect(getConfiguredAdmission({ queueTimeoutSeconds: 1.5, explicit: true })).toEqual({
-      waitTimeoutMs: 1500
-    });
+    expect(getConfiguredAdmission({ queueTimeoutSeconds: 1.5, explicit: true })).toEqual({ waitTimeoutMs: 1500 });
   });
 });
 

apps/rush-cli-client/src/test/ClientAdmissionControls.test.ts

@@ -27,7 +27,11 @@ export interface INativeBuildTestFixture {
   readonly folder: string;
   readonly environment: NodeJS.ProcessEnv;
   readonly paths: IDaemonPaths;
-  invokeAsync(argv: ReadonlyArray<string>, rushx?: boolean): Promise<INativeBuildResult>;
+  invokeAsync(
+    argv: ReadonlyArray<string>,
+    rushx?: boolean,
+    nodeArgs?: ReadonlyArray<string>
+  ): Promise<INativeBuildResult>;
   snapshotAsync(...args: string[]): Promise<IDaemonGraphSnapshotPayload['snapshot']>;
   runAsync(work: (fixture: INativeBuildTestFixture) => Promise<void>): Promise<void>;
   trackWatch(child: ChildProcess, closed: Promise<unknown[]>): void;
@@ -125,17 +129,22 @@ export function createNativeBuildTestFixture(): INativeBuildTestFixture {
     })
   );
 
-  function invokeAsync(argv: ReadonlyArray<string>, rushx: boolean = false): Promise<INativeBuildResult> {
+  function invokeAsync(
+    argv: ReadonlyArray<string>,
+    rushx: boolean = false,
+    nodeArgs: ReadonlyArray<string> = []
+  ): Promise<INativeBuildResult> {
     if (!acceptingInvocations) throw new Error('The native build fixture is already closing.');
-    return spawnClientAsync(argv, rushx);
+    return spawnClientAsync(argv, rushx, nodeArgs);
   }
 
   async function spawnClientAsync(
     argv: ReadonlyArray<string>,
-    rushx: boolean = false
+    rushx: boolean = false,
+    nodeArgs: ReadonlyArray<string> = []
   ): Promise<INativeBuildResult> {
     const entry: string = path.resolve(__dirname, rushx ? '../../bin/rushx-client' : '../../bin/rush-client');
-    const child = spawn(process.execPath, [entry, ...argv], {
+    const child = spawn(process.execPath, [...nodeArgs, entry, ...argv], {
       cwd: rushx ? path.join(folder, 'b') : folder,
       env: environment,
       stdio: ['ignore', 'pipe', 'pipe']

apps/rush-cli-client/src/test/NativeBuildTestFixture.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+// Preloaded with `node --require` by startupBudget.test.ts. Reports the loaded module count and the loaded
+// Rush modules on one short stderr line (a large synchronous write to a pipe at exit can be truncated).
+import * as fs from 'node:fs';
+
+process.once('exit', () => {
+  const modules: string[] = Object.keys(require.cache);
+  const report: { count: number; rushModules: string[] } = {
+    count: modules.length,
+    rushModules: modules.filter((name) => /[\\/](rush-lib|rush|rush-daemon)[\\/](lib-commonjs|dist)[\\/]/.test(name))
+  };
+  fs.writeSync(2, `\nrush-client-startup-modules:${JSON.stringify(report)}\n`);
+});