refactor: convert TS private methods and accessors to #private

Extend the earlier field-only #private conversion to also cover
private methods and accessors across apps/lockfile-explorer,
apps/playwright-browser-tunnel, apps/rundown, apps/rush-mcp-server,
apps/rush-serve-dashboard, libraries/rush-daemon,
libraries/rush-daemon-transport, libraries/rush-terminal-renderer,
libraries/rushell, rush-plugins, and vscode-extensions. Strips one
conventional leading underscore from each converted member name.

Reverted two members that the symbol-aware tool converted but that
are unsafe in practice:
- rush-buildxl-graph-plugin's test-only 'declare private _configHash'
  cannot use 'declare' with a private identifier (TS18019), matching
  the earlier decision to keep it TS-private for the
  Object.setPrototypeOf mock.
- AmazonS3Client's '_writeWarningLine' is spied on and stubbed via
  '(s3Client as any)._writeWarningLine' in AmazonS3Client.test.ts,
  which requires runtime reflection that true private fields do not
  support.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 8ebd5bf2-c44b-42d5-be25-e7936d4b0a14

Author: bmiddha

apps/lockfile-explorer/src/cli/lint/LintCommandLineParser.ts

@@ -22,7 +22,7 @@ export class LintCommandLineParser extends CommandLineParser {
 
     this.globalTerminal = terminal;
 
-    this._populateActions();
+    this.#populateActions();
   }
 
   protected override async onExecuteAsync(): Promise<void> {
@@ -33,7 +33,7 @@ export class LintCommandLineParser extends CommandLineParser {
     await super.onExecuteAsync();
   }
 
-  private _populateActions(): void {
+  #populateActions(): void {
     const terminal: ITerminal = this.globalTerminal;
     this.addAction(new InitAction(terminal));
     this.addAction(new CheckAction(terminal));

apps/lockfile-explorer/src/cli/lint/actions/CheckAction.ts

@@ -59,7 +59,7 @@ export class CheckAction extends CommandLineAction {
     this.#docMap = new Map();
   }
 
-  private async _checkVersionCompatibilityAsync(
+  async #checkVersionCompatibilityAsync(
     shrinkwrapFileMajorVersion: number,
     packages: lockfileTypes.PackageSnapshots | undefined,
     dependencyPath: pnpmTypes.DepPath,
@@ -79,7 +79,7 @@ export class CheckAction extends CommandLineAction {
       await Promise.all(
         Object.entries(packages[dependencyPath].dependencies ?? {}).map(
           async ([dependencyPackageName, dependencyPackageVersion]) => {
-            await this._checkVersionCompatibilityAsync(
+            await this.#checkVersionCompatibilityAsync(
               shrinkwrapFileMajorVersion,
               packages,
               splicePackageWithVersion(
@@ -96,7 +96,7 @@ export class CheckAction extends CommandLineAction {
     }
   }
 
-  private async _searchAndValidateDependenciesAsync(
+  async #searchAndValidateDependenciesAsync(
     project: RushConfigurationProject,
     requiredVersions: Record<string, string>
   ): Promise<void> {
@@ -139,10 +139,10 @@ export class CheckAction extends CommandLineAction {
                 this.#rushConfiguration.getProjectByName(dependencyName);
               if (dependencyProject && !this.#checkedProjects?.has(dependencyProject)) {
                 this.#checkedProjects!.add(project);
-                await this._searchAndValidateDependenciesAsync(dependencyProject, requiredVersions);
+                await this.#searchAndValidateDependenciesAsync(dependencyProject, requiredVersions);
               }
             } else {
-              await this._checkVersionCompatibilityAsync(
+              await this.#checkVersionCompatibilityAsync(
                 shrinkwrapFileMajorVersion,
                 packages,
                 fullDependencyPath,
@@ -156,7 +156,7 @@ export class CheckAction extends CommandLineAction {
     );
   }
 
-  private async _performVersionRestrictionCheckAsync(
+  async #performVersionRestrictionCheckAsync(
     requiredVersions: Record<string, string>,
     projectName: string
   ): Promise<string | undefined> {
@@ -169,7 +169,7 @@ export class CheckAction extends CommandLineAction {
         );
       }
       this.#checkedProjects.add(project);
-      await this._searchAndValidateDependenciesAsync(project, requiredVersions);
+      await this.#searchAndValidateDependenciesAsync(project, requiredVersions);
       return undefined;
     } catch (e) {
       return e.message;
@@ -201,7 +201,7 @@ export class CheckAction extends CommandLineAction {
       async ({ requiredVersions, project, rule }) => {
         switch (rule) {
           case 'restrict-versions': {
-            const message: string | undefined = await this._performVersionRestrictionCheckAsync(
+            const message: string | undefined = await this.#performVersionRestrictionCheckAsync(
               requiredVersions,
               project
             );

apps/lockfile-explorer/src/utils/PackageUpdateChecker.ts

@@ -170,7 +170,7 @@ export class PackageUpdateChecker {
       return undefined;
     }
 
-    const cacheFilePath: string = this._getCacheFilePath();
+    const cacheFilePath: string = this.#getCacheFilePath();
 
     let latestVersion: string | undefined;
     if (!this.#forceCheck) {
@@ -200,7 +200,7 @@ export class PackageUpdateChecker {
     };
   }
 
-  private _getCacheFilePath(): string {
+  #getCacheFilePath(): string {
     // Replace characters that are unsafe in file names (e.g. the "/" in scoped package names).
     const sanitizedName: string = this.#packageName.replace(/[^a-zA-Z0-9._-]/g, '_');
     return `${CACHE_FOLDER}/${sanitizedName}.json`;

apps/playwright-browser-tunnel/src/PlaywrightBrowserTunnel.ts

@@ -159,7 +159,7 @@ export class PlaywrightTunnel {
     terminal.writeLine(`keepRunning: ${this.#keepRunning}`);
     while (this.#keepRunning) {
       if (!this.#initWsPromise) {
-        this.#initWsPromise = this._initPlaywrightBrowserTunnelAsync();
+        this.#initWsPromise = this.#initPlaywrightBrowserTunnelAsync();
       } else {
         terminal.writeLine(`Tunnel is already running with status: ${this.status}`);
       }
@@ -197,7 +197,7 @@ export class PlaywrightTunnel {
   // TODO: We should implement an uninstall command to remove installed Playwright browsers
   // public async uninstallPlaywrightBrowsersAsync(): Promise<void> {}
 
-  private async _runCommandAsync(command: string, args: string[]): Promise<void> {
+  async #runCommandAsync(command: string, args: string[]): Promise<void> {
     const tmpPath: string = this.#playwrightInstallPath;
     await FileSystem.ensureFolderAsync(tmpPath);
     this.#terminal.writeLine(`Running command: ${command} ${args.join(' ')} in ${tmpPath}`);
@@ -227,30 +227,30 @@ export class PlaywrightTunnel {
     await Executable.waitForExitAsync(cp, { throwOnNonZeroExitCode: true, throwOnSignal: true });
   }
 
-  private async _installPlaywrightCoreAsync({
+  async #installPlaywrightCoreAsync({
     playwrightVersion
   }: Pick<IHandshake, 'playwrightVersion'>): Promise<void> {
     this.#terminal.writeLine(`Installing playwright-core version ${playwrightVersion}`);
-    await this._runCommandAsync('npm', [
+    await this.#runCommandAsync('npm', [
       'install',
       `playwright-core-${playwrightVersion}@npm:playwright-core@${playwrightVersion}`
     ]);
   }
 
-  private async _installPlaywrightBrowsersAsync({
+  async #installPlaywrightBrowsersAsync({
     playwrightVersion,
     browserName
   }: Pick<IHandshake, 'playwrightVersion' | 'browserName'>): Promise<void> {
-    await this._installPlaywrightCoreAsync({ playwrightVersion });
+    await this.#installPlaywrightCoreAsync({ playwrightVersion });
     this.#terminal.writeLine(`Executing playwright-core version ${playwrightVersion}`);
-    await this._runCommandAsync('node', [
+    await this.#runCommandAsync('node', [
       `node_modules/playwright-core-${playwrightVersion}/cli.js`,
       'install',
       browserName
     ]);
   }
 
-  private async _tryConnectAsync(): Promise<WebSocket> {
+  async #tryConnectAsync(): Promise<WebSocket> {
     const wsEndpoint: string | undefined = this.#wsEndpoint;
     if (!wsEndpoint) {
       throw new Error('WebSocket endpoint is not defined');
@@ -269,14 +269,14 @@ export class PlaywrightTunnel {
 
   // TODO: Only supporting one test at a time.
   // Need to support multiple simultaneous connections for parallel tests.
-  private async _pollConnectionAsync(): Promise<WebSocket> {
+  async #pollConnectionAsync(): Promise<WebSocket> {
     this.#terminal.writeLine(`Waiting for WebSocket connection`);
     return await new Promise((resolve, reject) => {
       this.#pollInterval = setInterval(() => {
         if (this.#pendingConnectionAttempt) {
           return; // Skip if a connection attempt is already in progress
         }
-        const connectionPromise: Promise<WebSocket> = this._tryConnectAsync();
+        const connectionPromise: Promise<WebSocket> = this.#tryConnectAsync();
         this.#pendingConnectionAttempt = connectionPromise;
         connectionPromise
           .then((ws: WebSocket) => {
@@ -294,7 +294,7 @@ export class PlaywrightTunnel {
     });
   }
 
-  private async _waitForIncomingConnectionAsync(): Promise<WebSocket> {
+  async #waitForIncomingConnectionAsync(): Promise<WebSocket> {
     this.#terminal.writeLine('Waiting for incoming WebSocket connection');
 
     return await new Promise<WebSocket>((resolve, reject) => {
@@ -334,7 +334,7 @@ export class PlaywrightTunnel {
   // TODO: If a user runs this for the first time, `this._playwrightBrowsersInstalled` will be empty
   // and it will try to install the browsers every time. We should persist this information. Maybe a cache file with text per
   // machine instance?
-  private async _setupPlaywrightAsync({
+  async #setupPlaywrightAsync({
     playwrightVersion,
     browserName
   }: Pick<IHandshake, 'playwrightVersion' | 'browserName'>): Promise<typeof import('playwright-core')> {
@@ -344,15 +344,15 @@ export class PlaywrightTunnel {
       this.#terminal.writeLine(
         `Playwright browser not found. Installing playwright-core version ${playwrightVersion}`
       );
-      await this._installPlaywrightBrowsersAsync({ playwrightVersion, browserName });
+      await this.#installPlaywrightBrowsersAsync({ playwrightVersion, browserName });
       this.#playwrightBrowsersInstalled.add(browserKey);
     }
 
     this.#terminal.writeLine(`Using playwright-core version ${playwrightVersion} for browser server`);
     return await import(`${this.#playwrightInstallPath}/node_modules/playwright-core-${playwrightVersion}`);
   }
 
-  private async _getPlaywrightBrowserServerProxyAsync({
+  async #getPlaywrightBrowserServerProxyAsync({
     browserName,
     playwrightVersion,
     launchOptions
@@ -385,7 +385,7 @@ export class PlaywrightTunnel {
       `Launch options after validation: ${JSON.stringify(logOptions)} (headless: false enforced)`
     );
 
-    const playwright: typeof import('playwright-core') = await this._setupPlaywrightAsync({
+    const playwright: typeof import('playwright-core') = await this.#setupPlaywrightAsync({
       playwrightVersion,
       browserName
     });
@@ -410,7 +410,7 @@ export class PlaywrightTunnel {
     };
   }
 
-  private _validateHandshake(rawHandshake: unknown): IHandshake {
+  #validateHandshake(rawHandshake: unknown): IHandshake {
     if (
       typeof rawHandshake !== 'object' ||
       rawHandshake === null ||
@@ -447,7 +447,7 @@ export class PlaywrightTunnel {
   }
 
   // ws1 is the tunnel websocket, ws2 is the browser server websocket
-  private async _setupForwardingAsync(ws1: WebSocket, ws2: WebSocket): Promise<void> {
+  async #setupForwardingAsync(ws1: WebSocket, ws2: WebSocket): Promise<void> {
     this.#terminal.writeLine('Setting up message forwarding between ws1 and ws2');
     this.#terminal.writeLine(`  ws1 (tunnel) readyState: ${getWebSocketReadyStateString(ws1.readyState)}`);
     this.#terminal.writeLine(`  ws2 (browser) readyState: ${getWebSocketReadyStateString(ws2.readyState)}`);
@@ -519,16 +519,16 @@ export class PlaywrightTunnel {
    * and setting up the browser server.
    * Returns when the handshake is complete and the browser server is running.
    */
-  private async _initPlaywrightBrowserTunnelAsync(): Promise<WebSocket> {
+  async #initPlaywrightBrowserTunnelAsync(): Promise<WebSocket> {
     let handshake: IHandshake | undefined = undefined;
     let client: WebSocket | undefined = undefined;
     let browserServer: BrowserServer | undefined = undefined;
 
     this.status = 'waiting-for-connection';
     const ws: WebSocket =
       this.#mode === 'poll-connection'
-        ? await this._pollConnectionAsync()
-        : await this._waitForIncomingConnectionAsync();
+        ? await this.#pollConnectionAsync()
+        : await this.#waitForIncomingConnectionAsync();
 
     ws.on('open', () => {
       this.#terminal.writeLine(`WebSocket connection established`);
@@ -564,7 +564,7 @@ export class PlaywrightTunnel {
             const rawHandshakeString: string = data.toString();
             const rawHandshake: unknown = JSON.parse(rawHandshakeString);
             terminal.writeLine(`Received handshake: ${rawHandshakeString}`);
-            handshake = this._validateHandshake(rawHandshake);
+            handshake = this.#validateHandshake(rawHandshake);
 
             // Call the onBeforeLaunch callback if provided
             if (this.#onBeforeLaunch) {
@@ -582,7 +582,7 @@ export class PlaywrightTunnel {
 
             this.status = 'setting-up-browser-server';
             const browserServerProxy: IBrowserServerProxy =
-              await this._getPlaywrightBrowserServerProxyAsync(handshake);
+              await this.#getPlaywrightBrowserServerProxyAsync(handshake);
             client = browserServerProxy.client;
             browserServer = browserServerProxy.browserServer;
 
@@ -616,7 +616,7 @@ export class PlaywrightTunnel {
             await Async.sleepAsync(2000);
 
             ws.send(JSON.stringify({ action: 'handshakeAck' }));
-            await this._setupForwardingAsync(ws, client);
+            await this.#setupForwardingAsync(ws, client);
 
             // Clean up message handler after successful handshake
             ws.off('message', onMessageHandler);

apps/rundown/src/Rundown.ts

@@ -34,7 +34,7 @@ export class Rundown {
     // ["path/to/launcher.js", "path/to/target-script.js", "first-target-arg"]
     const nodeArgs: string[] = [path.join(__dirname, 'launcher.js'), absoluteScriptPath, ...expandedArgs];
 
-    await this._spawnLauncherAsync(nodeArgs, quiet, ignoreExitCode);
+    await this.#spawnLauncherAsync(nodeArgs, quiet, ignoreExitCode);
 
     if (!quiet) {
       console.log();
@@ -107,7 +107,7 @@ export class Rundown {
     FileSystem.writeFile(reportPath, data);
   }
 
-  private async _spawnLauncherAsync(
+  async #spawnLauncherAsync(
     nodeArgs: string[],
     quiet: boolean,
     ignoreExitCode: boolean

apps/rundown/src/launcher.ts

@@ -31,7 +31,7 @@ class Launcher {
     return [nodeArg, this.targetScriptPathArg, ...remainderArgs];
   }
 
-  private _sendIpcTraceBatch(): void {
+  #sendIpcTraceBatch(): void {
     if (this.#ipcTraceRecordsBatch.length > 0) {
       const batch: IIpcTraceRecord[] = [...this.#ipcTraceRecordsBatch];
       this.#ipcTraceRecordsBatch.length = 0;
@@ -49,7 +49,7 @@ class Launcher {
     const importedModules: Set<unknown> = this.#importedModules; // for closure
     const importedModulePaths: Set<string> = this.#importedModulePaths; // for closure
     const ipcTraceRecordsBatch: IIpcTraceRecord[] = this.#ipcTraceRecordsBatch; // for closure
-    const sendIpcTraceBatch: () => void = this._sendIpcTraceBatch.bind(this); // for closure
+    const sendIpcTraceBatch: () => void = this.#sendIpcTraceBatch.bind(this); // for closure
 
     function hookedRequire(this: NodeModule, moduleName: string): unknown {
       // NOTE: The "this" pointer is the calling NodeModule, so we rely on closure
@@ -100,7 +100,7 @@ class Launcher {
     _copyProperties(hookedRequire, realRequire);
 
     process.on('exit', () => {
-      this._sendIpcTraceBatch();
+      this.#sendIpcTraceBatch();
       process.send!({
         id: 'done'
       } as IIpcDone);

apps/rush-mcp-server/src/server.ts

@@ -29,21 +29,21 @@ export class RushMCPServer extends McpServer {
   }
 
   public async startAsync(): Promise<void> {
-    this._initializeTools();
-    this._registerTools();
+    this.#initializeTools();
+    this.#registerTools();
 
     await this.#pluginLoader.loadAsync();
   }
 
-  private _initializeTools(): void {
+  #initializeTools(): void {
     this.#tools.push(new RushConflictResolverTool());
     this.#tools.push(new RushMigrateProjectTool(this.#rushWorkspacePath));
     this.#tools.push(new RushCommandValidatorTool());
     this.#tools.push(new RushWorkspaceDetailsTool());
     this.#tools.push(new RushProjectDetailsTool());
   }
 
-  private _registerTools(): void {
+  #registerTools(): void {
     process.chdir(this.#rushWorkspacePath);
 
     for (const tool of this.#tools) {

apps/rush-mcp-server/src/tools/conflict-resolver.tool.ts

@@ -22,7 +22,7 @@ export class RushConflictResolverTool extends BaseTool {
     });
   }
 
-  private _tryGetSubspaceNameFromLockfilePath(
+  #tryGetSubspaceNameFromLockfilePath(
     lockfilePath: string,
     rushConfiguration: RushConfiguration
   ): string | null {
@@ -37,7 +37,7 @@ export class RushConflictResolverTool extends BaseTool {
 
   public async executeAsync({ lockfilePath }: { lockfilePath: string }): Promise<CallToolResult> {
     const rushConfiguration: RushConfiguration = await getRushConfiguration();
-    const subspaceName: string | null = this._tryGetSubspaceNameFromLockfilePath(
+    const subspaceName: string | null = this.#tryGetSubspaceNameFromLockfilePath(
       lockfilePath,
       rushConfiguration
     );