Update CLI to show static warning for old architecture in run-windows and interactive prompt for init-windows

change/@react-native-windows-cli-df0889c3-e18b-4f66-82ef-3b55c9294c4b.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Update CLI to show static warning for old architecture in run-windows and interactive prompt for init-windows (#15029)",
+  "packageName": "@react-native-windows/cli",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

change/@react-native-windows-telemetry-2e2f5bfc-794a-42c2-8ec0-fccb4e6e19cf.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Update CLI to show static warning for old architecture in run-windows and interactive prompt for init-windows (#15029)",
+  "packageName": "@react-native-windows/telemetry",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

packages/@react-native-windows/cli/src/commands/initWindows/initWindows.ts

@@ -30,6 +30,8 @@ import {
 } from '../../utils/telemetryHelpers';
 import {copyAndReplaceWithChangedCallback} from '../../generator-common';
 import * as nameHelpers from '../../utils/nameHelpers';
+import {showOldArchitectureWarning} from '../../utils/oldArchWarning';
+import {promptForArchitectureChoice} from '../../utils/architecturePrompt';
 import type {InitOptions} from './initWindowsOptions';
 import {initOptions} from './initWindowsOptions';
 
@@ -154,6 +156,9 @@ export class InitWindows {
       return;
     }
 
+    const userDidNotPassTemplate = !process.argv.some(arg =>
+      arg.startsWith('--template'),
+    );
     this.options.template ??=
       (this.rnwConfig?.['init-windows']?.template as string | undefined) ??
       this.getDefaultTemplateName();
@@ -166,10 +171,23 @@ export class InitWindows {
       );
     }
 
-    if (this.options.template.startsWith('old')) {
-      spinner.warn(
-        `The legacy '${this.options.template}' template targets the React Native Old Architecture, which will eventually be deprecated. See https://microsoft.github.io/react-native-windows/docs/new-architecture for details on switching to the New Architecture.`,
-      );
+    const isOldArchTemplate = this.options.template.startsWith('old');
+    const promptFlag = this.options.prompt;
+
+    if (isOldArchTemplate) {
+      showOldArchitectureWarning();
+
+      if (userDidNotPassTemplate && promptFlag) {
+        const promptResult = await promptForArchitectureChoice();
+
+        if (
+          !promptResult.shouldContinueWithOldArch &&
+          !promptResult.userCancelled
+        ) {
+          spinner.info('Switching to New Architecture template (cpp-app)...');
+          this.options.template = 'cpp-app';
+        }
+      }
     }
 
     const templateConfig = this.templates.get(this.options.template)!;
@@ -303,6 +321,7 @@ function optionSanitizer(key: keyof InitOptions, value: any): any {
     case 'overwrite':
     case 'telemetry':
     case 'list':
+    case 'prompt':
       return value === undefined ? false : value; // Return value
   }
 }
@@ -316,6 +335,19 @@ async function getExtraProps(): Promise<Record<string, any>> {
   return extraProps;
 }
 
+function sanitizeOptions(
+  opts: Record<string, any>,
+  sanitizer: (key: keyof InitOptions, value: any) => any,
+): Record<string, any> {
+  const sanitized: Record<string, any> = {};
+  for (const key in opts) {
+    if (Object.prototype.hasOwnProperty.call(opts, key)) {
+      sanitized[key] = sanitizer(key as keyof InitOptions, opts[key]);
+    }
+  }
+  return sanitized;
+}
+
 /**
  * The function run when calling `npx @react-native-community/cli init-windows`.
  * @param args Unprocessed args passed from react-native CLI.
@@ -336,6 +368,7 @@ async function initWindows(
   );
 
   let initWindowsError: Error | undefined;
+
   try {
     await initWindowsInternal(args, config, options);
   } catch (ex) {
@@ -344,7 +377,11 @@ async function initWindows(
     Telemetry.trackException(initWindowsError);
   }
 
-  await endTelemetrySession(initWindowsError, getExtraProps);
+  // Now, instead of custom fields, just pass the final options object
+  await endTelemetrySession(initWindowsError, getExtraProps, options, opts =>
+    sanitizeOptions(opts, optionSanitizer),
+  );
+
   setExitProcessWithError(options.logging, initWindowsError);
 }
 

packages/@react-native-windows/cli/src/commands/initWindows/initWindowsOptions.ts

@@ -14,6 +14,7 @@ export interface InitOptions {
   overwrite?: boolean;
   telemetry?: boolean;
   list?: boolean;
+  prompt?: boolean;
 }
 
 export const initOptions: CommandOption[] = [
@@ -52,4 +53,8 @@ export const initOptions: CommandOption[] = [
     description:
       'Shows a list with all available templates with their descriptions.',
   },
+  {
+    name: '--no-prompt',
+    description: 'Skip any interactive prompts and use default choices.',
+  },
 ];

packages/@react-native-windows/cli/src/commands/runWindows/runWindows.ts

@@ -33,6 +33,7 @@ import type {RunWindowsOptions} from './runWindowsOptions';
 import {runWindowsOptions} from './runWindowsOptions';
 import {autolinkWindowsInternal} from '../autolinkWindows/autolinkWindows';
 import type {AutoLinkOptions} from '../autolinkWindows/autolinkWindowsOptions';
+import {showOldArchitectureWarning} from '../../utils/oldArchWarning';
 
 /**
  * Sanitizes the given option for telemetry.
@@ -208,9 +209,7 @@ async function runWindowsInternal(
 
   // Warn about old architecture projects
   if (config.project.windows?.rnwConfig?.projectArch === 'old') {
-    newWarn(
-      'This project is using the React Native (for Windows) Old Architecture, which will eventually be deprecated. See https://microsoft.github.io/react-native-windows/docs/new-architecture for details on switching to the New Architecture.',
-    );
+    showOldArchitectureWarning();
   }
 
   // Get the solution file

packages/@react-native-windows/cli/src/e2etest/architecturePrompt.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import {promptForArchitectureChoice} from '../utils/architecturePrompt';
+
+// Mock prompts module
+jest.mock('prompts', () => {
+  return jest.fn();
+});
+
+import prompts from 'prompts';
+const mockPrompts = prompts as jest.MockedFunction<typeof prompts>;
+
+describe('architecturePrompt', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('returns true when user chooses Y', async () => {
+    mockPrompts.mockResolvedValue({choice: 'y'});
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(true);
+    expect(result.userCancelled).toBe(false);
+  });
+
+  test('returns true when user chooses Y (uppercase)', async () => {
+    mockPrompts.mockResolvedValue({choice: 'Y'});
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(true);
+    expect(result.userCancelled).toBe(false);
+  });
+
+  test('returns false when user chooses N', async () => {
+    mockPrompts.mockResolvedValue({choice: 'n'});
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(false);
+    expect(result.userCancelled).toBe(false);
+  });
+
+  test('returns false when user chooses N (uppercase)', async () => {
+    mockPrompts.mockResolvedValue({choice: 'N'});
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(false);
+    expect(result.userCancelled).toBe(false);
+  });
+
+  test('returns true with userCancelled when user cancels with no input', async () => {
+    mockPrompts.mockResolvedValue({});
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(true);
+    expect(result.userCancelled).toBe(true);
+  });
+
+  test('returns true with userCancelled when prompts throws cancellation error', async () => {
+    mockPrompts.mockRejectedValue(new Error('User cancelled'));
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(true);
+    expect(result.userCancelled).toBe(true);
+  });
+
+  test('returns true and not cancelled on other errors', async () => {
+    mockPrompts.mockRejectedValue(new Error('Some other error'));
+
+    const result = await promptForArchitectureChoice();
+
+    expect(result.shouldContinueWithOldArch).toBe(true);
+    expect(result.userCancelled).toBe(false);
+  });
+});

packages/@react-native-windows/cli/src/e2etest/initWindows.test.ts

@@ -26,6 +26,7 @@ function validateOptionName(
     case 'overwrite':
     case 'telemetry':
     case 'list':
+    case 'prompt':
       return true;
   }
   throw new Error(
@@ -55,6 +56,7 @@ test('initOptions - validate options', () => {
 
     // Validate all command options are present in InitOptions
     const optionName = commanderNameToOptionName(commandOption.name);
+
     expect(
       validateOptionName(commandOption.name, optionName as keyof InitOptions),
     ).toBe(true);

packages/@react-native-windows/cli/src/utils/architecturePrompt.ts

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import prompts from 'prompts';
+import chalk from 'chalk';
+export interface ArchitecturePromptResult {
+  shouldContinueWithOldArch: boolean;
+  userCancelled: boolean;
+}
+
+export async function promptForArchitectureChoice(): Promise<ArchitecturePromptResult> {
+  try {
+    const response = await prompts(
+      {
+        type: 'text',
+        name: 'choice',
+        message: 'Would you like to continue using the Old Architecture? (Y/N)',
+        validate: (value: string) => {
+          const normalized = value.trim().toLowerCase();
+          if (normalized === 'y' || normalized === 'n') {
+            return true;
+          }
+          return "Invalid input. Please enter 'Y' for Yes or 'N' for No.";
+        },
+      },
+      {
+        onCancel: () => {
+          throw new Error('User cancelled');
+        },
+      },
+    );
+
+    if (!response.choice) {
+      return {shouldContinueWithOldArch: true, userCancelled: true};
+    }
+
+    const normalizedChoice = response.choice.trim().toLowerCase();
+    if (normalizedChoice === 'y') {
+      console.log(
+        chalk.yellow(
+          'Proceeding with Old Architecture. You can migrate later using our migration guide: https://microsoft.github.io/react-native-windows/docs/new-architecture',
+        ),
+      );
+      return {shouldContinueWithOldArch: true, userCancelled: false};
+    } else {
+      console.log(
+        chalk.green(
+          'Great choice! Setting up the project with New Architecture support.',
+        ),
+      );
+      return {shouldContinueWithOldArch: false, userCancelled: false};
+    }
+  } catch (error) {
+    if ((error as Error).message === 'User cancelled') {
+      return {shouldContinueWithOldArch: true, userCancelled: true};
+    }
+    console.log(
+      chalk.yellow(
+        'Proceeding with Old Architecture. You can migrate later using our migration guide: https://microsoft.github.io/react-native-windows/docs/new-architecture',
+      ),
+    );
+    return {shouldContinueWithOldArch: true, userCancelled: false};
+  }
+}

packages/@react-native-windows/cli/src/utils/oldArchWarning.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Displays a warning message about the Old Architecture template.
+ */
+export function showOldArchitectureWarning(): void {
+  console.log(
+    chalk.yellow(
+      `⚠️ This project is using the React Native (for Windows) Old Architecture. The old architecture will begin to be removed starting with [email protected].`,
+    ),
+  );
+  console.log();
+  console.log(
+    chalk.cyan(
+      '💡 It is strongly recommended to move to the new architecture as soon as possible to take advantage of improved performance, long-term support, and modern capabilities.',
+    ),
+  );
+  console.log();
+  console.log(
+    chalk.blue(
+      '🔗 Learn more: https://microsoft.github.io/react-native-windows/docs/new-architecture',
+    ),
+  );
+  console.log();
+}

packages/@react-native-windows/cli/src/utils/telemetryHelpers.ts

@@ -151,6 +151,8 @@ export async function startTelemetrySession(
 export async function endTelemetrySession(
   error?: Error,
   getExtraProps?: () => Promise<Record<string, any>>,
+  finalOptions?: Record<string, any>,
+  optionSanitizer?: (opts: Record<string, any>) => Record<string, any>,
 ) {
   if (!Telemetry.isEnabled()) {
     // Bail early so don't waste time here
@@ -166,8 +168,13 @@ export async function endTelemetrySession(
       error instanceof CodedError ? (error as CodedError).type : 'Unknown';
   }
 
-  Telemetry.endCommand(
-    endInfo,
-    getExtraProps ? await getExtraProps() : undefined,
-  );
+  // Get extra properties
+  const extraProps = getExtraProps ? await getExtraProps() : undefined;
+
+  // Sanitize and attach finalOptions if provided
+  if (finalOptions && optionSanitizer) {
+    endInfo.finalOptions = optionSanitizer(finalOptions);
+  }
+
+  Telemetry.endCommand(endInfo, extraProps);
 }

packages/@react-native-windows/telemetry/src/telemetry.ts

@@ -28,6 +28,7 @@ export interface CommandStartInfo {
 
 export interface CommandEndInfo {
   resultCode: errorUtils.CodedErrorType;
+  finalOptions?: Record<string, any>;
 }
 
 interface CommandInfo {