test(cloudflare): Add Vite-build support to the integration-test runner

Teach the integration-test runner to support suites that opt into the Sentry
Vite plugin. When a suite ships a `vite.config.*`, the runner runs `vite build`
first (so the plugin's auto-instrumentation transform runs) and points
`wrangler dev` at the generated `dist/<worker>/wrangler.json`, matched to the
right source config via its `userConfigPath`. Suites without a Vite config keep
running straight from source, unchanged.

No suite uses this path yet; the auto-instrument feature commits that follow add
their own `vite-autoinstrument/*` integration suites.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: JPeer264

dev-packages/cloudflare-integration-tests/package.json

@@ -29,11 +29,13 @@
     "openai": "5.18.1"
   },
   "devDependencies": {
+    "@cloudflare/vite-plugin": "1.34.0",
     "@cloudflare/workers-types": "^4.20260426.0",
     "@sentry-internal/test-utils": "10.67.0",
     "@sentry/conventions": "0.16.0",
     "eslint-plugin-regexp": "^3.1.0",
     "prisma": "6.15.0",
+    "vite": "7.3.2",
     "vitest": "^3.2.6",
     "wrangler": "4.86.0"
   },

dev-packages/cloudflare-integration-tests/runner.ts

@@ -1,8 +1,8 @@
 import type { Envelope, EnvelopeItemType } from '@sentry/core';
 import { normalize } from '@sentry/core';
 import { createBasicSentryServer } from '@sentry-internal/test-utils';
-import { spawn } from 'child_process';
-import { existsSync } from 'fs';
+import { spawn, spawnSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { inspect } from 'util';
 import { expect } from 'vitest';
@@ -18,6 +18,60 @@ export function cleanupChildProcesses(): void {
 
 process.on('exit', cleanupChildProcesses);
 
+/**
+ * Resolve the wrangler config `wrangler dev` should serve for a worker.
+ *
+ * Most suites run straight from source (`wrangler dev --config <name>.jsonc`).
+ * A suite that opts into the Sentry Vite plugin instead ships a `vite.config.*`
+ * (and no top-level `main` in its wrangler config): for those we run `vite build`
+ * first — so the plugin's build-time auto-instrumentation transform runs — and
+ * point wrangler at the generated config under `dist/<worker>/wrangler.json`.
+ *
+ * `wranglerConfigName` selects which source config the Vite build corresponds to
+ * (`wrangler.jsonc` for the main worker, `wrangler-sub-worker.jsonc` for a sub),
+ * so a Vite suite's generated output is matched to the right worker.
+ */
+function resolveWorkerConfig(testPath: string, wranglerConfigName: string): string {
+  const sourceConfig = join(testPath, wranglerConfigName);
+  const viteConfig = ['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs']
+    .map(name => join(testPath, name))
+    .find(existsSync);
+
+  // No Vite config → serve the source wrangler config unchanged (existing path).
+  if (!viteConfig) {
+    return sourceConfig;
+  }
+
+  const result = spawnSync('vite', ['build'], { cwd: testPath, stdio: process.env.DEBUG ? 'inherit' : 'ignore' });
+  if (result.status !== 0) {
+    throw new Error(`vite build failed for ${testPath} (exit code ${result.status})`);
+  }
+
+  // `@cloudflare/vite-plugin` emits one directory per worker under `dist/`, each
+  // containing a resolved `wrangler.json`. Match the one whose original config is
+  // this worker's source config so multi-worker suites map correctly.
+  const distDir = join(testPath, 'dist');
+  const builtConfig = readdirSync(distDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => join(distDir, entry.name, 'wrangler.json'))
+    .find(configPath => existsSync(configPath) && builtFromSource(configPath, sourceConfig));
+
+  if (!builtConfig) {
+    throw new Error(`Could not locate a Vite-built wrangler config for ${sourceConfig} under ${distDir}`);
+  }
+  return builtConfig;
+}
+
+/** Whether a generated `wrangler.json` was built from the given source config. */
+function builtFromSource(builtConfigPath: string, sourceConfigPath: string): boolean {
+  try {
+    const built = JSON.parse(readFileSync(builtConfigPath, 'utf8')) as { userConfigPath?: string; configPath?: string };
+    return built.userConfigPath === sourceConfigPath || built.configPath === sourceConfigPath;
+  } catch {
+    return false;
+  }
+}
+
 // Wrangler can report "Ready" before it can actually handle requests.
 // This retries fetch on connection errors and transient 500 responses to handle this race condition.
 // The budget (maxRetries * retryDelayMs) must cover the "ready-but-not-serving" window, which can be
@@ -299,7 +353,7 @@ export function createRunner(...paths: string[]) {
               [
                 'dev',
                 '--config',
-                join(testPath, 'wrangler-sub-worker.jsonc'),
+                resolveWorkerConfig(testPath, 'wrangler-sub-worker.jsonc'),
                 '--show-interactive-dev-session',
                 'false',
                 '--var',
@@ -325,7 +379,7 @@ export function createRunner(...paths: string[]) {
             [
               'dev',
               '--config',
-              join(testPath, 'wrangler.jsonc'),
+              resolveWorkerConfig(testPath, 'wrangler.jsonc'),
               '--show-interactive-dev-session',
               'false',
               '--var',