feat(cli-integ): also run integ test suites on Windows - DO NOT MERGE

.projenrc.ts

@@ -1769,6 +1769,10 @@ new CdkCliIntegTestsWorkflow(repo, {
   testEnvironment: TEST_ENVIRONMENT,
   buildRunsOn: POWERFUL_RUNNER,
   testRunsOn: POWERFUL_RUNNER,
+  // Also run the integ suites on Windows to catch platform-specific
+  // regressions (paths, subprocess spawning). Uses the free standard runner
+  // for now; switch to a larger runner label once one is provisioned.
+  windowsTestRunsOn: 'windows-latest',
 
   allowUpstreamVersions: [
     // cloud-assembly-schema gets referenced under multiple versions

packages/@aws-cdk-testing/cli-integ/lib/index.ts

@@ -5,6 +5,7 @@ export * from './memoize';
 export * from './resource-pool';
 export * from './with-sam';
 export * from './shell';
+export * from './timing';
 export * from './with-aws';
 export * from './with-cdk-app';
 export * from './with-packages';

packages/@aws-cdk-testing/cli-integ/lib/npm.ts

@@ -40,7 +40,8 @@ export async function npmQueryInstalledVersion(packageName: string, dir: string)
  * Use NPM preinstalled on the machine to look up a list of TypeScript versions
  */
 export function typescriptVersionsSync(): string[] {
-  const { stdout } = spawnSync('npm', ['--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json'], { encoding: 'utf-8' });
+  // Invoke npm through Node: on Windows `npm` is a `.cmd` file, which spawnSync cannot execute directly
+  const { stdout } = spawnSync(process.execPath, [require.resolve('npm'), '--silent', 'view', `typescript@>=${MINIMUM_VERSION}`, 'version', '--json'], { encoding: 'utf-8' });
 
   const versions: string[] = JSON.parse(stdout);
   return Array.from(new Set(versions.map(v => v.split('.').slice(0, 2).join('.'))));
@@ -50,7 +51,7 @@ export function typescriptVersionsSync(): string[] {
  * Use NPM preinstalled on the machine to query publish times of versions
  */
 export function typescriptVersionsYoungerThanDaysSync(days: number, versions: string[]): string[] {
-  const { stdout } = spawnSync('npm', ['--silent', 'view', 'typescript', 'time', '--json'], { encoding: 'utf-8' });
+  const { stdout } = spawnSync(process.execPath, [require.resolve('npm'), '--silent', 'view', 'typescript', 'time', '--json'], { encoding: 'utf-8' });
   const versionTsMap: Record<string, string> = JSON.parse(stdout);
 
   const cutoffDate = new Date(Date.now() - (days * 24 * 3600 * 1000));

packages/@aws-cdk-testing/cli-integ/lib/process.ts

@@ -48,11 +48,23 @@ export class Process {
    * Spawn a process with a TTY attached.
    */
   public static spawnTTY(command: string, args: string[], options: pty.IPtyForkOptions | pty.IWindowsPtyForkOptions = {}): IProcess {
-    const process = pty.spawn(command, args, {
+    // ConPTY resolves the spawned file with SearchPath, which only finds real
+    // executables — not the .cmd shims npm creates for CLI entrypoints. Route
+    // the command through the shell, like Process.spawn does with 'shell: true'.
+    if (process.platform === 'win32') {
+      args = ['/c', command, ...args];
+      command = process.env.ComSpec ?? 'cmd.exe';
+    }
+    const ptyProcess = pty.spawn(command, args, {
       name: 'xterm-color',
+      // Wide enough that no output line ever hits the terminal width: ConPTY
+      // (unlike Unix ptys) renders the screen buffer and inserts hard line
+      // breaks at the width, which splits long prompts across lines and
+      // breaks the line-based prompt matching in shell().
+      cols: 512,
       ...options,
     });
-    return new PtyProcess(process);
+    return new PtyProcess(ptyProcess);
   }
 
   /**

packages/@aws-cdk-testing/cli-integ/lib/shell.ts

@@ -4,6 +4,7 @@ import * as os from 'os';
 import * as path from 'path';
 import type { TestContext } from './integ-test';
 import { Process } from './process';
+import { formatDuration } from './timing';
 import type { TemporaryDirectoryContext } from './with-temporary-directory';
 
 /**
@@ -36,6 +37,7 @@ export async function shell(command: string[], options: ShellOptions = {}): Prom
   // We choose the lazy one.
   const spawnOptions = { ...options, env } as any;
 
+  const startTime = Date.now();
   const child = tty
     ? Process.spawnTTY(command[0], command.slice(1), spawnOptions)
     : Process.spawn(command[0], command.slice(1), spawnOptions);
@@ -109,6 +111,10 @@ export async function shell(command: string[], options: ShellOptions = {}): Prom
     child.onError(reject);
 
     child.onExit(code => {
+      // Always report how long the command took, on success and on failure alike,
+      // so slow steps can be found by reading the log. Pairs with the '💻' line above.
+      writeToOutputs(`⏱️  ${formatDuration(Date.now() - startTime)} ${command.join(' ')}\n`);
+
       const stderrOutput = Buffer.concat(stderr).toString('utf-8');
       const stdoutOutput = Buffer.concat(stdout).toString('utf-8');
       const out = (options.onlyStderr ? stderrOutput : stdoutOutput + stderrOutput).trim();
@@ -282,7 +288,22 @@ export class ShellHelper {
 export function rimraf(fsPath: string): boolean {
   try {
     let success = true;
-    const isDir = fs.lstatSync(fsPath).isDirectory();
+    const stat = fs.lstatSync(fsPath);
+
+    // Remove links without recursing into their target: a directory may
+    // link to shared content that other tests are still using (e.g. the
+    // shared 'node_modules' on Windows).
+    if (stat.isSymbolicLink()) {
+      try {
+        fs.unlinkSync(fsPath);
+      } catch {
+        // On Windows, directory links (junctions) must be removed with rmdir
+        fs.rmdirSync(fsPath);
+      }
+      return true;
+    }
+
+    const isDir = stat.isDirectory();
 
     if (isDir) {
       for (const file of fs.readdirSync(fsPath)) {
@@ -310,13 +331,13 @@ export function rimraf(fsPath: string): boolean {
 }
 
 export function addToShellPath(x: string) {
-  const parts = process.env.PATH?.split(':') ?? [];
+  const parts = process.env.PATH?.split(path.delimiter) ?? [];
 
   if (!parts.includes(x)) {
     parts.unshift(x);
   }
 
-  process.env.PATH = parts.join(':');
+  process.env.PATH = parts.join(path.delimiter);
 }
 
 /**
@@ -339,7 +360,28 @@ export function addToShellPath(x: string) {
 class LastLine {
   private lastLine: string = '';
 
+  // win32 only: the last completed line that had visible content, see below
+  private lastVisibleLine: string = '';
+
   public append(chunk: string): void {
+    if (process.platform === 'win32') {
+      // ConPTY renders the screen buffer instead of streaming plain text:
+      // prompts are drawn with cursor-positioning escape sequences, padded
+      // with spaces to the terminal width, and followed by "lines" that
+      // contain nothing but more escape sequences. Match against the last
+      // line that had visible content, so control-only lines don't erase a
+      // prompt that was just drawn.
+      const lines = stripAnsi(chunk).split(/\r?\n/);
+      this.lastLine += lines[0];
+      for (const line of lines.slice(1)) {
+        if (this.lastLine.trim().length > 0) {
+          this.lastVisibleLine = this.lastLine;
+        }
+        this.lastLine = line;
+      }
+      return;
+    }
+
     const lines = chunk.split(os.EOL);
     if (lines.length === 1) {
       // chunk doesn't contain a new line so just append
@@ -351,10 +393,30 @@ class LastLine {
   }
 
   public get(): string {
+    if (process.platform === 'win32' && this.lastLine.trim().length === 0) {
+      return this.lastVisibleLine;
+    }
     return this.lastLine;
   }
 
   public reset() {
     this.lastLine = '';
+    this.lastVisibleLine = '';
   }
 }
+
+const ESC = '\u001b';
+// CSI sequences (cursor movement, erase, colors) and OSC sequences (window title)
+const ANSI_REGEX = new RegExp(`${ESC}\\[[0-9;?]*[@-~]|${ESC}\\][^${ESC}\\u0007]*(?:\\u0007|${ESC}\\\\)`, 'g');
+
+/**
+ * Remove ANSI escape sequences from terminal output.
+ *
+ * Windows ConPTY renders the screen buffer rather than streaming plain text:
+ * once the cursor reaches the bottom of the buffer, lines arrive as absolute
+ * cursor-positioning sequences instead of newline-terminated text. Prompt
+ * matching must look at the text only.
+ */
+function stripAnsi(chunk: string): string {
+  return chunk.replace(ANSI_REGEX, '');
+}

packages/@aws-cdk-testing/cli-integ/lib/timing.ts

@@ -0,0 +1,69 @@
+/**
+ * Duration reporting for the integ test log.
+ *
+ * Every command run through `shell()` reports how long it took. Operations that
+ * do real work *without* spawning a process (recursive copies, directory walks,
+ * waiting on another worker) need to report themselves, or they show up as
+ * unexplained gaps in a test's duration. This matters most on Windows, where
+ * writing and deleting many small files is far slower than on Linux.
+ *
+ * Both helpers use the same '💻' / '⏱️' line shape as `shell()`, so a single
+ * search for '⏱️' in a test log finds every measured step.
+ */
+
+/**
+ * Render a duration in milliseconds for humans reading the test log.
+ *
+ * Uses the same units as the per-test durations in the GitHub Actions summary
+ * ('2m17s', '9.4s', '386ms'), so the two can be compared without converting.
+ */
+export function formatDuration(millis: number): string {
+  if (millis < 1_000) {
+    return `${millis}ms`;
+  }
+
+  if (millis < 60_000) {
+    return `${(millis / 1_000).toFixed(1)}s`;
+  }
+
+  // Round to whole seconds before splitting, so we can never render '1m60s'
+  const totalSeconds = Math.round(millis / 1_000);
+  return `${Math.floor(totalSeconds / 60)}m${totalSeconds % 60}s`;
+}
+
+/**
+ * Run an async operation, reporting how long it took.
+ *
+ * The duration is reported whether the operation succeeds or throws, so a step
+ * that spent two minutes before failing is still visible in the log.
+ */
+export async function timed<A>(
+  description: string,
+  output: NodeJS.WritableStream | undefined,
+  block: () => Promise<A>,
+): Promise<A> {
+  output?.write(`💻 ${description}\n`);
+  const startTime = Date.now();
+  try {
+    return await block();
+  } finally {
+    output?.write(`⏱️  ${formatDuration(Date.now() - startTime)} ${description}\n`);
+  }
+}
+
+/**
+ * `timed`, for operations that are synchronous.
+ */
+export function timedSync<A>(
+  description: string,
+  output: NodeJS.WritableStream | undefined,
+  block: () => A,
+): A {
+  output?.write(`💻 ${description}\n`);
+  const startTime = Date.now();
+  try {
+    return block();
+  } finally {
+    output?.write(`⏱️  ${formatDuration(Date.now() - startTime)} ${description}\n`);
+  }
+}