canary-lab 0.1.0

package/dist/shared/configs/playwright.base.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseConfig = void 0;
+exports.baseConfig = {
+    testDir: './e2e',
+    fullyParallel: false,
+    workers: 1,
+    retries: 0,
+    reporter: [['list']],
+    timeout: 90_000,
+    use: {
+        trace: 'retain-on-failure',
+        screenshot: 'only-on-failure',
+    },
+};

package/dist/shared/e2e-runner/log-marker-fixture.d.ts

@@ -0,0 +1,13 @@
+import { expect } from '@playwright/test';
+/**
+ * Extended Playwright `test` that writes XML markers into every service log
+ * listed in logs/manifest.json. If the manifest doesn't exist because tests
+ * are run directly with Playwright instead of `canary-lab run`, the fixture
+ * is a no-op.
+ * https://playwright.dev/docs/extensibility
+ */
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    _logMarker: void;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { expect };
+export type { APIRequestContext, Page } from '@playwright/test';

package/dist/shared/e2e-runner/log-marker-fixture.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = exports.test = void 0;
+const test_1 = require("@playwright/test");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return test_1.expect; } });
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("./paths");
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Extended Playwright `test` that writes XML markers into every service log
+ * listed in logs/manifest.json. If the manifest doesn't exist because tests
+ * are run directly with Playwright instead of `canary-lab run`, the fixture
+ * is a no-op.
+ * https://playwright.dev/docs/extensibility
+ */
+exports.test = test_1.test.extend({
+    _logMarker: [
+        async ({}, use, testInfo) => {
+            if (!fs_1.default.existsSync(paths_1.MANIFEST_PATH)) {
+                await use(undefined);
+                return;
+            }
+            const manifest = JSON.parse(fs_1.default.readFileSync(paths_1.MANIFEST_PATH, 'utf-8'));
+            const slug = slugify(testInfo.title);
+            const openTag = `<test-case-${slug}>\n`;
+            const closeTag = `</test-case-${slug}>\n`;
+            for (const logPath of manifest.serviceLogs) {
+                fs_1.default.appendFileSync(logPath, openTag);
+            }
+            await use(undefined);
+            for (const logPath of manifest.serviceLogs) {
+                fs_1.default.appendFileSync(logPath, closeTag);
+            }
+        },
+        { auto: true },
+    ],
+});

package/dist/shared/e2e-runner/paths.d.ts

@@ -0,0 +1,8 @@
+export declare const ROOT: string;
+export declare const FEATURES_DIR: string;
+export declare const LOGS_DIR: string;
+export declare const PIDS_DIR: string;
+export declare const MANIFEST_PATH: string;
+export declare const SUMMARY_PATH: string;
+export declare const RERUN_SIGNAL: string;
+export declare const RESTART_SIGNAL: string;

package/dist/shared/e2e-runner/paths.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESTART_SIGNAL = exports.RERUN_SIGNAL = exports.SUMMARY_PATH = exports.MANIFEST_PATH = exports.PIDS_DIR = exports.LOGS_DIR = exports.FEATURES_DIR = exports.ROOT = void 0;
+const path_1 = __importDefault(require("path"));
+const project_root_1 = require("../runtime/project-root");
+exports.ROOT = (0, project_root_1.getProjectRoot)();
+exports.FEATURES_DIR = (0, project_root_1.getFeaturesDir)();
+exports.LOGS_DIR = path_1.default.join(exports.ROOT, 'logs');
+exports.PIDS_DIR = path_1.default.join(exports.LOGS_DIR, 'pids');
+exports.MANIFEST_PATH = path_1.default.join(exports.LOGS_DIR, 'manifest.json');
+exports.SUMMARY_PATH = path_1.default.join(exports.LOGS_DIR, 'e2e-summary.json');
+exports.RERUN_SIGNAL = path_1.default.join(exports.LOGS_DIR, '.rerun');
+exports.RESTART_SIGNAL = path_1.default.join(exports.LOGS_DIR, '.restart');

package/dist/shared/e2e-runner/runner.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/shared/e2e-runner/runner.js

@@ -0,0 +1,567 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const child_process_1 = require("child_process");
+const startup_1 = require("../launcher/startup");
+const iterm_1 = require("../launcher/iterm");
+const terminal_1 = require("../launcher/terminal");
+const paths_1 = require("./paths");
+// ─── Paths (local to runner) ────────────────────────────────────────────────
+const SWITCH_SCRIPT = path_1.default.join(__dirname, '../env-switcher/switch.js');
+const SUMMARY_REPORTER = path_1.default.resolve(__dirname, 'summary-reporter.js');
+// ─── Readline helpers (same pattern as shared/launcher/index.ts) ────────────
+function prompt(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+async function selectOption(rl, label, options) {
+    console.log(`\n${label}`);
+    options.forEach((opt, i) => console.log(`  ${i + 1}) ${opt}`));
+    while (true) {
+        const answer = await prompt(rl, `Select [1-${options.length}]: `);
+        const idx = parseInt(answer.trim(), 10) - 1;
+        if (idx >= 0 && idx < options.length)
+            return options[idx];
+        console.log(`  Please enter a number between 1 and ${options.length}`);
+    }
+}
+// ─── Feature discovery (same as shared/launcher/index.ts) ───────────────────
+function discoverFeatures() {
+    const features = [];
+    const dirs = fs_1.default
+        .readdirSync(paths_1.FEATURES_DIR, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+    for (const dir of dirs) {
+        const configPath = ['feature.config.cjs', 'feature.config.js', 'feature.config.ts']
+            .map((name) => path_1.default.join(paths_1.FEATURES_DIR, dir, name))
+            .find((candidate) => fs_1.default.existsSync(candidate));
+        if (!configPath)
+            continue;
+        try {
+            const mod = require(configPath);
+            features.push(mod.config ?? mod.default);
+        }
+        catch {
+            // skip malformed configs
+        }
+    }
+    return features;
+}
+// ─── Repo check (same as shared/launcher/index.ts) ─────────────────────────
+function checkRepos(feature) {
+    if (!feature.repos?.length)
+        return true;
+    let allOk = true;
+    for (const repo of feature.repos) {
+        const resolved = (0, startup_1.resolvePath)(repo.localPath);
+        if (!fs_1.default.existsSync(resolved)) {
+            console.error(`\n  Missing repo: ${repo.name}`);
+            console.error(`  Expected at: ${resolved}`);
+            if (repo.cloneUrl) {
+                console.error(`  Clone it with:\n    git clone ${repo.cloneUrl} ${resolved}`);
+            }
+            allOk = false;
+        }
+    }
+    return allOk;
+}
+function buildServiceList(feature) {
+    const services = [];
+    for (const repo of feature.repos ?? []) {
+        const dir = (0, startup_1.resolvePath)(repo.localPath);
+        const commands = repo.startCommands ?? [];
+        for (let i = 0; i < commands.length; i++) {
+            const normalized = (0, startup_1.normalizeStartCommand)(commands[i], `${repo.name}-cmd-${i + 1}`);
+            const safeName = normalized
+                .name.replace(/[^a-z0-9]+/gi, '-')
+                .toLowerCase();
+            const logPath = path_1.default.join(paths_1.LOGS_DIR, `svc-${safeName}.log`);
+            services.push({
+                name: normalized.name,
+                safeName,
+                logPath,
+                command: normalized.command,
+                cwd: dir,
+                healthUrl: normalized.healthCheck?.url,
+                healthTimeout: normalized.healthCheck?.timeoutMs,
+            });
+        }
+    }
+    return services;
+}
+function buildTeedCommand(svc) {
+    // LOG_MODE=plain tells apps to use synchronous console.log instead of async
+    // loggers (e.g. Pino/sonic-boom), so XML markers land in the right position.
+    // stdout+stderr go to both the iTerm tab and the log file via tee.
+    return `LOG_MODE=plain ${svc.command} 2>&1 | tee -a ${svc.logPath}`;
+}
+function openTabs(terminal, tabs, label) {
+    if (terminal === 'iTerm') {
+        (0, iterm_1.openItermTabs)(tabs, label);
+    }
+    else {
+        (0, terminal_1.openTerminalTabs)(tabs, label);
+    }
+}
+async function launchServices(services, terminal) {
+    // Always kill existing processes so we own the tee pipe and capture all logs.
+    // Without this, externally-started services have no log file and XML markers
+    // cannot be extracted.
+    for (const svc of services) {
+        const pid = resolveRunningPid(svc);
+        if (pid) {
+            process.stdout.write(`  Stopping existing ${svc.name} (PID ${pid})... `);
+            await killProcess(pid);
+            console.log('stopped');
+        }
+    }
+    const tabs = [];
+    for (const svc of services) {
+        // Create/truncate log file for a clean run
+        fs_1.default.writeFileSync(svc.logPath, '');
+        tabs.push({
+            dir: svc.cwd,
+            command: buildTeedCommand(svc),
+            name: svc.name,
+        });
+    }
+    if (tabs.length === 0) {
+        return;
+    }
+    openTabs(terminal, tabs, `  Opening ${terminal} tabs for ${tabs.length} service(s)...`);
+}
+async function pollHealthChecks(services, timeoutMs = 120_000) {
+    const checksNeeded = services.filter((s) => s.healthUrl);
+    if (checksNeeded.length === 0)
+        return;
+    console.log('\n  Waiting for health checks...');
+    const deadline = Date.now() + timeoutMs;
+    for (const svc of checksNeeded) {
+        process.stdout.write(`    ${svc.name}: `);
+        while (Date.now() < deadline) {
+            if (await (0, startup_1.isHealthy)(svc.healthUrl, svc.healthTimeout)) {
+                console.log('healthy');
+                break;
+            }
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+        if (Date.now() >= deadline) {
+            console.log('TIMEOUT');
+            throw new Error(`Health check timed out for ${svc.name} at ${svc.healthUrl}`);
+        }
+    }
+    console.log('');
+}
+function writeManifest(services) {
+    const manifest = { serviceLogs: services.map((s) => s.logPath) };
+    fs_1.default.writeFileSync(paths_1.MANIFEST_PATH, JSON.stringify(manifest, null, 2) + '\n');
+}
+// ─── Restart unhealthy services ─────────────────────────────────────────────
+function readPid(safeName) {
+    const pidPath = path_1.default.join(paths_1.PIDS_DIR, `${safeName}.pid`);
+    if (!fs_1.default.existsSync(pidPath))
+        return null;
+    const pid = parseInt(fs_1.default.readFileSync(pidPath, 'utf-8').trim(), 10);
+    return isNaN(pid) ? null : pid;
+}
+function portFromHealthUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.port) {
+            return parseInt(parsed.port, 10);
+        }
+        return parsed.protocol === 'https:' ? 443 : 80;
+    }
+    catch {
+        return null;
+    }
+}
+function lookupPidByPort(port) {
+    try {
+        const output = (0, child_process_1.execFileSync)('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        const pid = parseInt(output.split('\n')[0]?.trim() ?? '', 10);
+        return Number.isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function killProcessSync(pid) {
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        return;
+    }
+    // Best-effort sync kill for signal handlers — send SIGKILL after SIGTERM
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        // ignore
+    }
+}
+async function killProcess(pid) {
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        return;
+    }
+    // Wait up to 5s for graceful shutdown
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline && isProcessAlive(pid)) {
+        await new Promise((r) => setTimeout(r, 200));
+    }
+    if (isProcessAlive(pid)) {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function resolveRunningPid(svc) {
+    const pidFromFile = readPid(svc.safeName);
+    if (pidFromFile && isProcessAlive(pidFromFile)) {
+        return pidFromFile;
+    }
+    if (!svc.healthUrl) {
+        return null;
+    }
+    const port = portFromHealthUrl(svc.healthUrl);
+    if (!port) {
+        return null;
+    }
+    const pidFromPort = lookupPidByPort(port);
+    if (pidFromPort && isProcessAlive(pidFromPort)) {
+        return pidFromPort;
+    }
+    return null;
+}
+async function restartAllServices(services, terminal) {
+    console.log('\n  Restarting all configured services...');
+    // Kill all running services first
+    for (const svc of services) {
+        process.stdout.write(`    ${svc.name}: `);
+        const pid = resolveRunningPid(svc);
+        if (pid) {
+            process.stdout.write(`stopping PID ${pid}... `);
+            await killProcess(pid);
+            console.log('stopped');
+        }
+        else {
+            console.log('no existing process found');
+        }
+    }
+    // Re-launch all in terminal tabs with tee
+    const tabs = services.map((svc) => ({
+        dir: svc.cwd,
+        command: buildTeedCommand(svc),
+        name: svc.name,
+    }));
+    openTabs(terminal, tabs, `  Re-opening ${terminal} tabs for ${tabs.length} service(s)...`);
+    await pollHealthChecks(services);
+}
+// ─── Playwright ─────────────────────────────────────────────────────────────
+const RUN_TIMEOUT = 10 * 60 * 1000; // 10 minutes — safety net for hung runs
+function runPlaywright(featureDir, headed) {
+    return new Promise((resolve, reject) => {
+        const playwrightArgs = [
+            'playwright',
+            'test',
+            `--reporter=${SUMMARY_REPORTER},list`,
+            ...(headed ? ['--headed'] : []),
+        ];
+        const child = (0, child_process_1.spawn)('npx', playwrightArgs, {
+            cwd: featureDir,
+            env: {
+                ...process.env,
+                CANARY_LAB_PROJECT_ROOT: paths_1.ROOT,
+            },
+            stdio: 'inherit',
+            shell: false,
+        });
+        const timer = setTimeout(() => {
+            console.log('\n  Playwright run timed out after 10 minutes, killing...');
+            child.kill('SIGTERM');
+            setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    // already dead
+                }
+            }, 5000);
+        }, RUN_TIMEOUT);
+        const forwardSigInt = () => child.kill('SIGINT');
+        const forwardSigTerm = () => child.kill('SIGTERM');
+        process.on('SIGINT', forwardSigInt);
+        process.on('SIGTERM', forwardSigTerm);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            process.off('SIGINT', forwardSigInt);
+            process.off('SIGTERM', forwardSigTerm);
+            reject(err);
+        });
+        child.on('exit', (code) => {
+            clearTimeout(timer);
+            process.off('SIGINT', forwardSigInt);
+            process.off('SIGTERM', forwardSigTerm);
+            resolve(code ?? 1);
+        });
+    });
+}
+// ─── Log enrichment ─────────────────────────────────────────────────────────
+function extractLogsForTest(slug, serviceLogs) {
+    const logs = {};
+    const openTag = `<${slug}>`;
+    const closeTag = `</${slug}>`;
+    for (const logPath of serviceLogs) {
+        if (!fs_1.default.existsSync(logPath))
+            continue;
+        const content = fs_1.default.readFileSync(logPath, 'utf-8');
+        const openIdx = content.indexOf(openTag);
+        const closeIdx = content.indexOf(closeTag);
+        if (openIdx === -1 || closeIdx === -1 || closeIdx <= openIdx)
+            continue;
+        const snippet = content
+            .slice(openIdx + openTag.length, closeIdx)
+            .trim();
+        if (snippet.length > 0) {
+            const svcName = path_1.default.basename(logPath, '.log');
+            logs[svcName] = snippet;
+        }
+    }
+    return logs;
+}
+function enrichSummaryWithLogs() {
+    if (!fs_1.default.existsSync(paths_1.SUMMARY_PATH) || !fs_1.default.existsSync(paths_1.MANIFEST_PATH))
+        return;
+    const summary = JSON.parse(fs_1.default.readFileSync(paths_1.SUMMARY_PATH, 'utf-8'));
+    const manifest = JSON.parse(fs_1.default.readFileSync(paths_1.MANIFEST_PATH, 'utf-8'));
+    if (!Array.isArray(summary.failed) || summary.failed.length === 0)
+        return;
+    // Enrich: replace string slugs with {name, logs} objects
+    summary.failed = summary.failed.map((entry) => {
+        const slug = typeof entry === 'string' ? entry : entry.name;
+        const logs = extractLogsForTest(slug, manifest.serviceLogs);
+        return { name: slug, logs };
+    });
+    fs_1.default.writeFileSync(paths_1.SUMMARY_PATH, JSON.stringify(summary, null, 2) + '\n');
+}
+// ─── Summary ────────────────────────────────────────────────────────────────
+function printSummary() {
+    if (!fs_1.default.existsSync(paths_1.SUMMARY_PATH)) {
+        console.log('\n  No summary file found.');
+        return;
+    }
+    const summary = JSON.parse(fs_1.default.readFileSync(paths_1.SUMMARY_PATH, 'utf-8'));
+    console.log('\n  ──── E2E Summary ────');
+    console.log(`  Total:  ${summary.total}`);
+    console.log(`  Passed: ${summary.passed}`);
+    console.log(`  Failed: ${summary.failed.length}`);
+    if (summary.failed.length > 0) {
+        console.log(`  Failures:`);
+        for (const entry of summary.failed) {
+            const name = typeof entry === 'string' ? entry : entry.name;
+            console.log(`    - ${name}`);
+        }
+    }
+    console.log('');
+}
+// ─── Watch mode ─────────────────────────────────────────────────────────────
+async function watchMode(services, featureDir, headed, terminal) {
+    // Clean any stale signal files
+    try {
+        fs_1.default.unlinkSync(paths_1.RERUN_SIGNAL);
+    }
+    catch { /* ignore */ }
+    try {
+        fs_1.default.unlinkSync(paths_1.RESTART_SIGNAL);
+    }
+    catch { /* ignore */ }
+    console.log('  ──── Watch Mode ────');
+    console.log('  Waiting for signal...');
+    console.log('    touch logs/.rerun    — re-run tests');
+    console.log('    touch logs/.restart  — restart services + re-run');
+    console.log('    Ctrl+C               — stop everything');
+    console.log('');
+    while (true) {
+        await new Promise((r) => setTimeout(r, 1000));
+        const doRestart = fs_1.default.existsSync(paths_1.RESTART_SIGNAL);
+        const doRerun = fs_1.default.existsSync(paths_1.RERUN_SIGNAL);
+        if (!doRestart && !doRerun)
+            continue;
+        // Consume signal files
+        try {
+            fs_1.default.unlinkSync(paths_1.RESTART_SIGNAL);
+        }
+        catch { /* ignore */ }
+        try {
+            fs_1.default.unlinkSync(paths_1.RERUN_SIGNAL);
+        }
+        catch { /* ignore */ }
+        if (doRestart) {
+            await restartAllServices(services, terminal);
+        }
+        console.log(`\n  Re-running Playwright tests${headed ? ' (headed)' : ''}...\n`);
+        await runPlaywright(featureDir, headed);
+        enrichSummaryWithLogs();
+        printSummary();
+        console.log('  ──── Watch Mode ────');
+        console.log('  Waiting for signal...\n');
+    }
+}
+// ─── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let envSetApplied = false;
+    let appliedFeatureDir = '';
+    let cleanedUp = false;
+    let services = [];
+    // Cleanup stops all launched services and reverts env sets.
+    const cleanup = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        // Stop service processes
+        if (services.length > 0) {
+            console.log('\n  Stopping services...');
+            for (const svc of services) {
+                const pid = resolveRunningPid(svc);
+                if (pid) {
+                    process.stdout.write(`    ${svc.name}: stopping PID ${pid}... `);
+                    killProcessSync(pid);
+                    console.log('stopped');
+                }
+            }
+        }
+        if (envSetApplied) {
+            console.log('\n  Reverting env files...');
+            try {
+                (0, child_process_1.execFileSync)(process.execPath, [SWITCH_SCRIPT, appliedFeatureDir, '--revert'], {
+                    stdio: 'inherit',
+                });
+            }
+            catch {
+                console.error('  Warning: env revert failed. Run `yarn env:revert` manually.');
+            }
+        }
+    };
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(130);
+    });
+    process.on('SIGTERM', () => {
+        cleanup();
+        process.exit(143);
+    });
+    try {
+        console.log('\n  Canary Lab — E2E Runner\n');
+        // ── 1. Discover features
+        const features = discoverFeatures();
+        if (features.length === 0) {
+            console.error('No features found. Add a feature.config.cjs to a features/<name>/ folder.');
+            process.exit(1);
+        }
+        // ── 2. Select feature
+        const labels = features.map((f) => `${f.name} — ${f.description}`);
+        const chosen = await selectOption(rl, 'Which feature?', labels);
+        const feature = features[labels.indexOf(chosen)];
+        // ── 3. Select environment
+        let env;
+        if (feature.envs.length === 1) {
+            env = feature.envs[0];
+            console.log(`\n  Environment: ${env}`);
+        }
+        else {
+            env = await selectOption(rl, 'Which environment?', feature.envs);
+        }
+        // ── 4. Select terminal
+        const terminalChoice = await selectOption(rl, 'Which terminal?', ['iTerm', 'Terminal']);
+        // ── 5. Headed?
+        const headedChoice = await selectOption(rl, 'Run headed (browser visible)?', ['No (headless)', 'Yes (headed)']);
+        const headed = headedChoice.startsWith('Yes');
+        // ── 6. Check repos
+        console.log('\n  Checking prerequisites...');
+        if (!checkRepos(feature)) {
+            console.error('\n  Please clone the missing repos and try again.');
+            process.exit(1);
+        }
+        console.log('  All repos present.');
+        // ── 7. Apply env sets
+        const envSetsDir = path_1.default.join(feature.featureDir, 'envsets');
+        if (fs_1.default.existsSync(path_1.default.join(envSetsDir, 'envsets.config.json'))) {
+            const envSets = fs_1.default
+                .readdirSync(envSetsDir, { withFileTypes: true })
+                .filter((d) => d.isDirectory())
+                .map((d) => d.name)
+                .sort();
+            let chosenSet;
+            if (envSets.includes(env)) {
+                chosenSet = env;
+            }
+            else if (envSets.length === 1) {
+                chosenSet = envSets[0];
+            }
+            else {
+                chosenSet = await selectOption(rl, `Which env set for ${feature.name}?`, envSets);
+            }
+            console.log(`\n  Applying env set: ${chosenSet}`);
+            (0, child_process_1.execFileSync)(process.execPath, [SWITCH_SCRIPT, feature.featureDir, '--apply', chosenSet], { stdio: 'inherit' });
+            envSetApplied = true;
+            appliedFeatureDir = feature.featureDir;
+        }
+        rl.close();
+        // ── 8. Prepare logs directory
+        fs_1.default.rmSync(paths_1.LOGS_DIR, { recursive: true, force: true });
+        fs_1.default.mkdirSync(paths_1.PIDS_DIR, { recursive: true });
+        // ── 9. Build service list and launch in terminal tabs (with tee to log files)
+        services = buildServiceList(feature);
+        await launchServices(services, terminalChoice);
+        writeManifest(services);
+        // ── 10. Wait for health checks
+        await pollHealthChecks(services);
+        // ── 11. Run Playwright
+        console.log(`  Running Playwright tests${headed ? ' (headed)' : ''}...\n`);
+        await runPlaywright(feature.featureDir, headed);
+        // ── 12. Enrich summary with log snippets and print
+        enrichSummaryWithLogs();
+        printSummary();
+        // ── 13. Enter watch mode (loops forever until Ctrl+C)
+        await watchMode(services, feature.featureDir, headed, terminalChoice);
+    }
+    catch (err) {
+        cleanup();
+        throw err;
+    }
+}
+if (require.main === module) {
+    main().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/shared/e2e-runner/summary-reporter.d.ts

@@ -0,0 +1,7 @@
+import type { FullResult, Reporter, TestCase, TestResult } from '@playwright/test/reporter';
+declare class SummaryReporter implements Reporter {
+    private results;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(_result: FullResult): void;
+}
+export default SummaryReporter;