screenci 0.0.43 → 0.0.45

package/dist/cli.js

@@ -4,13 +4,109 @@ import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync } from 'fs';
 import { createHash } from 'crypto';
 import { createServer } from 'http';
 import { appendFile, mkdir, readdir, readFile, stat, writeFile, } from 'fs/promises';
-import { dirname, relative as pathRelative, resolve } from 'path';
+import { basename, dirname, relative as pathRelative, resolve } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Command, CommanderError } from 'commander';
-import { input, confirm, select } from '@inquirer/prompts';
+import { input } from '@inquirer/prompts';
 import ora from 'ora';
 import pc from 'picocolors';
 import { logger } from './src/logger.js';
+import { SCREENCI_DISABLE_RECORDING_TIMINGS_ENV, SCREENCI_MOCK_RECORD_ENV, } from './src/runtimeMode.js';
+import { DEFAULT_RECORD_UPLOAD_POLICY } from './src/defaults.js';
+import { findDuplicateTitles, formatDuplicateTitlesMessage, } from './src/titleValidation.js';
+const SCREENCI_MOCK_RECORD_DOCS_URL = 'https://screenci.com/docs/reference/cli/#--mock-record';
+export function collectPlaywrightListTitles(suites) {
+    const titles = [];
+    const visitSuite = (suite) => {
+        for (const spec of suite.specs ?? []) {
+            titles.push(spec.title);
+        }
+        for (const child of suite.suites ?? []) {
+            visitSuite(child);
+        }
+    };
+    for (const suite of suites) {
+        visitSuite(suite);
+    }
+    return titles;
+}
+function parsePlaywrightListReport(stdout) {
+    return JSON.parse(stdout);
+}
+async function collectDiscoveredTestTitles(configPath, additionalArgs, env) {
+    const listArgs = [
+        'test',
+        '--config',
+        configPath,
+        ...additionalArgs,
+        '--list',
+        '--reporter=json',
+    ];
+    const spawnSpec = resolveSpawnSpec('playwright', listArgs);
+    return await new Promise((resolve, reject) => {
+        const child = spawn(spawnSpec.command, spawnSpec.args, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+            ...(spawnSpec.shell !== undefined ? { shell: spawnSpec.shell } : {}),
+            env,
+        });
+        const childSignals = forwardChildSignals(child, 'screenci title validation', {
+            killTree: process.platform !== 'win32',
+            exitParentOnForward: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.setEncoding?.('utf8');
+        child.stderr?.setEncoding?.('utf8');
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('close', (code, signal) => {
+            const forwardedSignal = childSignals.getForwardedSignal();
+            childSignals.cleanup();
+            if (forwardedSignal) {
+                process.kill(process.pid, forwardedSignal);
+                return;
+            }
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            if (code !== 0) {
+                if (stderr.trim() === '' && stdout.trim() === '') {
+                    resolve([]);
+                    return;
+                }
+                reject(new Error(stderr.trim() || stdout.trim() || 'Playwright test discovery failed'));
+                return;
+            }
+            try {
+                if (stdout.trim() === '') {
+                    resolve([]);
+                    return;
+                }
+                const report = parsePlaywrightListReport(stdout);
+                resolve(collectPlaywrightListTitles(report.suites ?? []));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.on('error', (err) => {
+            childSignals.cleanup();
+            reject(err);
+        });
+    });
+}
+async function validateUniqueDiscoveredTestTitles(configPath, additionalArgs, env) {
+    const titles = await collectDiscoveredTestTitles(configPath, additionalArgs, env);
+    const duplicates = findDuplicateTitles(titles);
+    if (duplicates.length > 0) {
+        throw new Error(formatDuplicateTitlesMessage(duplicates));
+    }
+}
 function resolveRecordingFileCandidates(filePath, configDir) {
     return [
         filePath,
@@ -50,11 +146,196 @@ class UploadCancelledError extends Error {
         this.name = 'UploadCancelledError';
     }
 }
+class PartialUploadError extends Error {
+    constructor(message = 'Not all recordings succeeded to upload.') {
+        super(message);
+        this.name = 'PartialUploadError';
+    }
+}
 function isUploadCancelledError(err) {
     return (err instanceof UploadCancelledError ||
         (err instanceof Error &&
             (err.name === 'AbortError' || err.name === 'UploadCancelledError')));
 }
+function isPartialUploadError(err) {
+    return err instanceof PartialUploadError;
+}
+function supportsInPlaceUploadUpdates(verbose) {
+    return !verbose && process.stdout.isTTY === true && !process.env.CI;
+}
+function formatUploadProgressLine(videoName, status) {
+    switch (status) {
+        case undefined:
+            return `${pc.cyan('...')} Uploading "${videoName}"`;
+        case 'success':
+            return `${pc.green('✔')} Uploaded "${videoName}"`;
+        case 'failure':
+            return `${pc.red('✖')} Failed to upload "${videoName}"`;
+        case 'cancelled':
+            return `${pc.yellow('!')} Cancelled "${videoName}"`;
+        default: {
+            const exhaustiveCheck = status;
+            return exhaustiveCheck;
+        }
+    }
+}
+function createUploadProgressReporter(videoNames, verbose) {
+    const useInPlaceUpdates = supportsInPlaceUploadUpdates(verbose);
+    if (!useInPlaceUpdates) {
+        if (videoNames.length > 1) {
+            logger.info(`Uploading ${videoNames.length} recordings in parallel...`);
+        }
+        return {
+            complete(index, status) {
+                logger.info(formatUploadProgressLine(videoNames[index] ?? 'unknown', status));
+            },
+        };
+    }
+    const statuses = new Array(videoNames.length);
+    let hasRendered = false;
+    const render = () => {
+        const renderedLines = videoNames.map((videoName, index) => formatUploadProgressLine(videoName, statuses[index]));
+        process.stdout.write(`${hasRendered && videoNames.length > 0 ? `\u001B[${videoNames.length}A` : ''}${renderedLines.map((line) => `\r\u001B[2K${line}`).join('\n')}\n`);
+        hasRendered = true;
+    };
+    render();
+    return {
+        complete(index, status) {
+            statuses[index] = status;
+            render();
+        },
+    };
+}
+async function loadUploadCandidate(screenciDir, entry, verbose) {
+    const dataJsonPath = resolve(screenciDir, entry, 'data.json');
+    if (!existsSync(dataJsonPath)) {
+        if (verbose)
+            logger.info(`Skipping "${entry}": no data.json found`);
+        return null;
+    }
+    let data;
+    try {
+        const raw = await readFile(dataJsonPath, 'utf-8');
+        data = JSON.parse(raw);
+    }
+    catch {
+        logger.warn(`Failed to read ${dataJsonPath}, skipping`);
+        return null;
+    }
+    const videoName = data.metadata?.videoName ?? entry;
+    const preparedUploadAssets = await collectUploadAssets(data, resolve(screenciDir, '..'));
+    return {
+        entry,
+        videoName,
+        data: annotateRecordingDataWithAssetHashes(data, preparedUploadAssets),
+        preparedUploadAssets,
+    };
+}
+async function uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, verbose, uploadAbort, progressReporter, progressIndex) {
+    const { entry, videoName, data, preparedUploadAssets } = candidate;
+    try {
+        uploadAbort.throwIfAborted();
+        const recordingPath = resolve(screenciDir, entry, 'recording.mp4');
+        const recordingHash = existsSync(recordingPath)
+            ? await hashFile(recordingPath)
+            : undefined;
+        const startResponse = await fetch(`${apiUrl}/cli/upload/start`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-ScreenCI-Secret': secret,
+            },
+            body: JSON.stringify({
+                projectName,
+                videoName,
+                data,
+                ...(recordingHash !== undefined ? { recordingHash } : {}),
+                expectedAssets: preparedUploadAssets.map((asset) => ({
+                    fileHash: asset.fileHash,
+                    size: asset.size,
+                    path: asset.path,
+                    ...(typeof asset.contentType === 'string'
+                        ? { contentType: asset.contentType }
+                        : {}),
+                    ...(typeof asset.name === 'string' ? { name: asset.name } : {}),
+                })),
+            }),
+            signal: uploadAbort.signal,
+        });
+        if (!startResponse.ok) {
+            const text = await startResponse.text();
+            progressReporter.complete(progressIndex, 'failure');
+            return {
+                projectId: null,
+                hadFailure: true,
+                videoName,
+                failureMessage: formatUploadStartFailureMessage(videoName, startResponse.status, text, secret),
+            };
+        }
+        const { recordingId, projectId } = (await startResponse.json());
+        if (verbose) {
+            logger.info(`recordingId=${recordingId} projectId=${projectId}`);
+            logger.info(`assets=${preparedUploadAssets.length} recordingHash=${recordingHash ?? 'none'}`);
+        }
+        await uploadAssets(preparedUploadAssets, apiUrl, secret, recordingId, uploadAbort.signal, uploadAbort.throwIfAborted);
+        if (existsSync(recordingPath)) {
+            uploadAbort.throwIfAborted();
+            const fileStat = await stat(recordingPath);
+            if (verbose) {
+                logger.info(`Uploading recording.mp4 size=${(fileStat.size / 1024 / 1024).toFixed(1)}MB`);
+            }
+            const stream = createReadStream(recordingPath);
+            const abortStream = () => {
+                stream.destroy(new UploadCancelledError(`Upload cancelled for "${videoName}"`));
+            };
+            uploadAbort.signal.addEventListener('abort', abortStream, {
+                once: true,
+            });
+            try {
+                const recordingResponse = await fetch(`${apiUrl}/cli/upload/${recordingId}/recording`, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'video/mp4',
+                        'Content-Length': String(fileStat.size),
+                        'X-ScreenCI-Secret': secret,
+                    },
+                    body: stream,
+                    signal: uploadAbort.signal,
+                    // @ts-expect-error Node.js fetch supports duplex for streaming
+                    duplex: 'half',
+                });
+                if (!recordingResponse.ok) {
+                    const text = await recordingResponse.text();
+                    progressReporter.complete(progressIndex, 'failure');
+                    return {
+                        projectId,
+                        hadFailure: true,
+                        videoName,
+                        failureMessage: `Failed to upload recording for "${videoName}": ${recordingResponse.status} ${text}${hint401(recordingResponse.status, secret)}`,
+                    };
+                }
+            }
+            finally {
+                uploadAbort.signal.removeEventListener('abort', abortStream);
+            }
+        }
+        progressReporter.complete(progressIndex, 'success');
+        return { projectId, hadFailure: false, videoName };
+    }
+    catch (err) {
+        if (isUploadCancelledError(err)) {
+            progressReporter.complete(progressIndex, 'cancelled');
+            throw err;
+        }
+        progressReporter.complete(progressIndex, 'failure');
+        return {
+            projectId: null,
+            hadFailure: true,
+            videoName,
+            failureMessage: `Network error uploading "${videoName}": ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
 export function attachUploadAbortStdinListener(input, onAbort) {
     const handleStdinData = (chunk) => {
         const bytes = typeof chunk === 'string'
@@ -160,9 +441,27 @@ function spawnSilent(cmd, args, cwd) {
         });
     });
 }
-function forwardChildSignals(child, activityLabel) {
+function forwardChildSignals(child, activityLabel, options = {}) {
     let forwardedSignal = null;
     let forceKillTimer = null;
+    const killTree = options.killTree ?? false;
+    const exitParentOnForward = options.exitParentOnForward ?? false;
+    const killChild = (signal) => {
+        if (child.pid === undefined)
+            return;
+        if (killTree && process.platform !== 'win32') {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                // Fall back to direct child kill below.
+            }
+        }
+        if (!child.killed) {
+            child.kill(signal);
+        }
+    };
     const forwardSignal = (signal) => {
         if (forwardedSignal !== null)
             return;
@@ -170,31 +469,42 @@ function forwardChildSignals(child, activityLabel) {
         if (process.env.SCREENCI_SIGNAL_LOGGING !== 'silent') {
             logger.info(`Received ${signal}, stopping ${activityLabel}...`);
         }
-        if (!child.killed) {
-            child.kill(signal);
+        killChild(signal);
+        if (exitParentOnForward) {
+            cleanup();
+            process.exit(signal === 'SIGINT' ? 130 : 143);
         }
         forceKillTimer = setTimeout(() => {
             if (child.exitCode === null) {
                 if (process.env.SCREENCI_SIGNAL_LOGGING !== 'silent') {
                     logger.info(`Forcing ${activityLabel} to stop after timeout...`);
                 }
-                child.kill('SIGKILL');
+                killChild('SIGKILL');
+                process.exit(signal === 'SIGINT' ? 130 : 143);
             }
         }, 3000);
         forceKillTimer.unref();
     };
     const handleSigint = () => forwardSignal('SIGINT');
     const handleSigterm = () => forwardSignal('SIGTERM');
+    const cleanupStdinListener = attachUploadAbortStdinListener(process.stdin, (signal) => {
+        if (process.env.SCREENCI_SIGNAL_LOGGING !== 'silent') {
+            logger.info(`Received ${signal}, stopping ${activityLabel}...`);
+        }
+        forwardSignal(signal);
+    });
+    const cleanup = () => {
+        if (forceKillTimer !== null) {
+            clearTimeout(forceKillTimer);
+        }
+        process.off('SIGINT', handleSigint);
+        process.off('SIGTERM', handleSigterm);
+        cleanupStdinListener();
+    };
     process.on('SIGINT', handleSigint);
     process.on('SIGTERM', handleSigterm);
     return {
-        cleanup: () => {
-            if (forceKillTimer !== null) {
-                clearTimeout(forceKillTimer);
-            }
-            process.off('SIGINT', handleSigint);
-            process.off('SIGTERM', handleSigterm);
-        },
+        cleanup,
         getForwardedSignal: () => forwardedSignal,
     };
 }
@@ -219,46 +529,6 @@ function findScreenCIConfig(customPath) {
     }
     return null;
 }
-function findRepoRoot(startDir) {
-    let current = startDir;
-    while (true) {
-        if (existsSync(resolve(current, '.git')) ||
-            existsSync(resolve(current, 'pnpm-workspace.yaml')) ||
-            existsSync(resolve(current, 'package-lock.json')) ||
-            existsSync(resolve(current, 'yarn.lock'))) {
-            return current;
-        }
-        const parent = resolve(current, '..');
-        if (parent === current)
-            return null;
-        current = parent;
-    }
-}
-async function findLatestEntry(screenciDir) {
-    let entries;
-    try {
-        entries = await readdir(screenciDir);
-    }
-    catch {
-        return null;
-    }
-    let latestEntry = null;
-    let latestMtime = 0;
-    for (const entry of entries) {
-        try {
-            const entryPath = resolve(screenciDir, entry);
-            const s = await stat(entryPath);
-            if (s.mtimeMs > latestMtime) {
-                latestMtime = s.mtimeMs;
-                latestEntry = entry;
-            }
-        }
-        catch {
-            // skip unreadable entries
-        }
-    }
-    return latestEntry;
-}
 async function hashFile(filePath) {
     return new Promise((resolveHash, reject) => {
         const hash = createHash('sha256');
@@ -573,7 +843,7 @@ async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIf
         }
     }
 }
-async function uploadRecordings(screenciDir, projectName, apiUrl, secret, specificEntry, verbose = false) {
+export async function uploadRecordings(screenciDir, projectName, apiUrl, secret, specificEntry, verbose = false) {
     const uploadAbort = createUploadAbortController('upload');
     let entries;
     try {
@@ -581,135 +851,62 @@ async function uploadRecordings(screenciDir, projectName, apiUrl, secret, specif
     }
     catch {
         logger.warn('No .screenci directory found, skipping upload');
-        return null;
+        return {
+            projectId: null,
+            hadFailures: false,
+            failedVideoNames: [],
+            failedVideoMessages: [],
+        };
     }
     if (specificEntry !== undefined) {
         entries = entries.filter((e) => e === specificEntry);
     }
     let firstProjectId = null;
     try {
-        for (const entry of entries) {
+        const candidates = (await Promise.all(entries.map(async (entry) => {
             uploadAbort.throwIfAborted();
-            const dataJsonPath = resolve(screenciDir, entry, 'data.json');
-            if (!existsSync(dataJsonPath)) {
-                if (verbose)
-                    logger.info(`Skipping "${entry}": no data.json found`);
-                continue;
-            }
-            let data;
-            try {
-                const raw = await readFile(dataJsonPath, 'utf-8');
-                data = JSON.parse(raw);
-            }
-            catch {
-                logger.warn(`Failed to read ${dataJsonPath}, skipping`);
-                continue;
-            }
-            const videoName = data.metadata?.videoName ?? entry;
-            const preparedUploadAssets = await collectUploadAssets(data, resolve(screenciDir, '..'));
-            data = annotateRecordingDataWithAssetHashes(data, preparedUploadAssets);
-            const uploadSpinner = ora(`Uploading "${videoName}"`).start();
-            try {
-                uploadAbort.throwIfAborted();
-                const recordingPath = resolve(screenciDir, entry, 'recording.mp4');
-                const recordingHash = existsSync(recordingPath)
-                    ? await hashFile(recordingPath)
-                    : undefined;
-                // Step 1: register upload and get recordingId
-                const startResponse = await fetch(`${apiUrl}/cli/upload/start`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'X-ScreenCI-Secret': secret,
-                    },
-                    body: JSON.stringify({
-                        projectName,
-                        videoName,
-                        data,
-                        ...(recordingHash !== undefined ? { recordingHash } : {}),
-                        expectedAssets: preparedUploadAssets.map((asset) => ({
-                            fileHash: asset.fileHash,
-                            size: asset.size,
-                            path: asset.path,
-                            ...(typeof asset.contentType === 'string'
-                                ? { contentType: asset.contentType }
-                                : {}),
-                            ...(typeof asset.name === 'string' ? { name: asset.name } : {}),
-                        })),
-                    }),
-                    signal: uploadAbort.signal,
-                });
-                if (!startResponse.ok) {
-                    const text = await startResponse.text();
-                    uploadSpinner.fail(`Failed to upload "${videoName}"`);
-                    printUploadStartFailureMessage(videoName, startResponse.status, text, secret);
-                    continue;
-                }
-                const { recordingId, projectId } = (await startResponse.json());
-                if (verbose) {
-                    logger.info(`recordingId=${recordingId} projectId=${projectId}`);
-                    logger.info(`assets=${preparedUploadAssets.length} recordingHash=${recordingHash ?? 'none'}`);
-                }
-                if (firstProjectId === null) {
-                    firstProjectId = projectId;
-                }
-                // Step 1b: upload all referenced files via the shared asset flow
-                await uploadAssets(preparedUploadAssets, apiUrl, secret, recordingId, uploadAbort.signal, uploadAbort.throwIfAborted);
-                // Step 2: stream the recording video file (if it exists)
-                if (existsSync(recordingPath)) {
-                    uploadAbort.throwIfAborted();
-                    const fileStat = await stat(recordingPath);
-                    if (verbose) {
-                        logger.info(`Uploading recording.mp4 size=${(fileStat.size / 1024 / 1024).toFixed(1)}MB`);
-                    }
-                    const stream = createReadStream(recordingPath);
-                    const abortStream = () => {
-                        stream.destroy(new UploadCancelledError(`Upload cancelled for "${videoName}"`));
-                    };
-                    uploadAbort.signal.addEventListener('abort', abortStream, {
-                        once: true,
-                    });
-                    try {
-                        const recordingResponse = await fetch(`${apiUrl}/cli/upload/${recordingId}/recording`, {
-                            method: 'PUT',
-                            headers: {
-                                'Content-Type': 'video/mp4',
-                                'Content-Length': String(fileStat.size),
-                                'X-ScreenCI-Secret': secret,
-                            },
-                            body: stream,
-                            signal: uploadAbort.signal,
-                            // @ts-expect-error Node.js fetch supports duplex for streaming
-                            duplex: 'half',
-                        });
-                        if (!recordingResponse.ok) {
-                            const text = await recordingResponse.text();
-                            uploadSpinner.fail(`Failed to upload "${videoName}"`);
-                            logger.warn(`Failed to upload recording for "${videoName}": ${recordingResponse.status} ${text}${hint401(recordingResponse.status, secret)}`);
-                            continue;
-                        }
-                    }
-                    finally {
-                        uploadAbort.signal.removeEventListener('abort', abortStream);
-                    }
-                }
-                uploadSpinner.succeed(`Uploaded "${videoName}"`);
-            }
-            catch (err) {
-                if (isUploadCancelledError(err)) {
-                    uploadSpinner.fail(`Cancelled "${videoName}"`);
-                    throw err;
-                }
-                uploadSpinner.fail(`Error uploading "${videoName}"`);
-                logger.warn(`Network error uploading "${videoName}":`, err);
-            }
+            return await loadUploadCandidate(screenciDir, entry, verbose);
+        }))).filter((candidate) => candidate !== null);
+        if (candidates.length === 0) {
+            return {
+                projectId: null,
+                hadFailures: false,
+                failedVideoNames: [],
+                failedVideoMessages: [],
+            };
         }
-        return firstProjectId;
+        const progressReporter = createUploadProgressReporter(candidates.map((candidate) => candidate.videoName), verbose);
+        const results = await Promise.all(candidates.map(async (candidate, index) => await uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, verbose, uploadAbort, progressReporter, index)));
+        firstProjectId =
+            results.find((result) => result.projectId !== null)?.projectId ?? null;
+        const hadFailures = results.some((result) => result.hadFailure);
+        const failedVideoNames = results
+            .filter((result) => result.hadFailure)
+            .map((result) => result.videoName);
+        const failedVideoMessages = results.flatMap((result) => result.hadFailure && typeof result.failureMessage === 'string'
+            ? [{ videoName: result.videoName, message: result.failureMessage }]
+            : []);
+        return {
+            projectId: firstProjectId,
+            hadFailures,
+            failedVideoNames,
+            failedVideoMessages,
+        };
     }
     finally {
         uploadAbort.cleanup();
     }
 }
+async function countCompletedRecordings(screenciDir) {
+    let entries;
+    try {
+        entries = await readdir(screenciDir);
+    }
+    catch {
+        return 0;
+    }
+    return entries.filter((entry) => existsSync(resolve(screenciDir, entry, 'data.json'))).length;
+}
 export function getDevBackendUrl() {
     const devBackendPort = process.env.DEV_BACKEND_PORT;
     return devBackendPort
@@ -728,40 +925,6 @@ async function writeGitHubProjectOutput(projectUrl) {
         return;
     await appendFile(githubOutput, `screenci_project_url=${projectUrl}\n`);
 }
-async function uploadLatest(configPath, verbose = false) {
-    const { resolvedConfigPath, screenciConfig } = await loadScreenCIConfigAndEnv(configPath);
-    const apiUrl = getDevBackendUrl();
-    const secret = process.env.SCREENCI_SECRET;
-    if (!secret) {
-        logger.error('No secret configured. Set SCREENCI_SECRET in your .env file (get it from the API Key page in the dashboard).');
-        process.exit(1);
-    }
-    const configDir = dirname(resolvedConfigPath);
-    const screenciDir = resolve(configDir, '.screenci');
-    if (verbose) {
-        logger.info(`screenciDir=${screenciDir}`);
-        logger.info(`apiUrl=${apiUrl}`);
-    }
-    const appUrl = getDevFrontendUrl();
-    let projectId = null;
-    try {
-        projectId = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret, undefined, verbose);
-    }
-    catch (err) {
-        if (isUploadCancelledError(err)) {
-            process.exit(130);
-        }
-        throw err;
-    }
-    if (projectId !== null) {
-        const projectUrl = `${appUrl}/project/${projectId}`;
-        await writeGitHubProjectOutput(projectUrl);
-        logger.info('');
-        logger.info('Upload complete, rendering continues in the background.');
-        logger.info('Recording finished, results available at:');
-        logger.info(pc.cyan(projectUrl));
-    }
-}
 async function loadScreenCIConfigAndEnv(configPath) {
     const resolvedConfigPath = findScreenCIConfig(configPath);
     if (!resolvedConfigPath) {
@@ -815,6 +978,17 @@ async function loadEnvFileFromConfigSource(resolvedConfigPath, warnOnFailure) {
         // the existing process env; Playwright will still load the config normally.
     }
 }
+async function resolveConfiguredEnvFilePath(resolvedConfigPath) {
+    try {
+        const screenciConfig = await tryReadConfigFromSource(resolvedConfigPath);
+        if (!screenciConfig.envFile)
+            return undefined;
+        return resolve(dirname(resolvedConfigPath), screenciConfig.envFile);
+    }
+    catch {
+        return undefined;
+    }
+}
 export function extractConfigStringLiteral(configSource, property) {
     const singleQuoteMatch = configSource.match(new RegExp(property + "\\s*:\\s*'([^'\\n]+)'"));
     if (singleQuoteMatch)
@@ -825,6 +999,21 @@ export function extractConfigStringLiteral(configSource, property) {
     const templateLiteralMatch = configSource.match(new RegExp(property + '\\s*:\\s*`([^`\\n]+)`'));
     return templateLiteralMatch?.[1];
 }
+export function extractRecordUploadPolicyLiteral(configSource) {
+    const singleQuoteMatch = configSource.match(/record\s*:\s*\{[\s\S]*?upload\s*:\s*'(passed-only|all-or-nothing)'/);
+    if (singleQuoteMatch) {
+        return singleQuoteMatch[1];
+    }
+    const doubleQuoteMatch = configSource.match(/record\s*:\s*\{[\s\S]*?upload\s*:\s*"(passed-only|all-or-nothing)"/);
+    if (doubleQuoteMatch) {
+        return doubleQuoteMatch[1];
+    }
+    const templateLiteralMatch = configSource.match(/record\s*:\s*\{[\s\S]*?upload\s*:\s*`(passed-only|all-or-nothing)`/);
+    return templateLiteralMatch?.[1];
+}
+function resolveRecordUploadPolicy(config) {
+    return config.record?.upload ?? DEFAULT_RECORD_UPLOAD_POLICY;
+}
 async function tryReadConfigFromSource(resolvedConfigPath) {
     const configSource = await readFile(resolvedConfigPath, 'utf-8');
     const projectName = extractConfigStringLiteral(configSource, 'projectName');
@@ -832,9 +1021,11 @@ async function tryReadConfigFromSource(resolvedConfigPath) {
         throw new Error('Could not determine projectName from screenci.config.ts without importing it.');
     }
     const envFile = extractConfigStringLiteral(configSource, 'envFile');
+    const recordUpload = extractRecordUploadPolicyLiteral(configSource);
     return {
         projectName,
         ...(envFile !== undefined ? { envFile } : {}),
+        ...(recordUpload !== undefined ? { record: { upload: recordUpload } } : {}),
     };
 }
 export function getConfigModuleSpecifier(resolvedConfigPath) {
@@ -850,11 +1041,17 @@ async function loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath) {
         return configModule.default;
     }
     catch (err) {
-        if (err instanceof Error &&
-            err.message.includes('Requiring @playwright/test second time')) {
+        const hasPlaywrightCollision = err instanceof Error &&
+            err.message.includes('Requiring @playwright/test second time');
+        if (hasPlaywrightCollision) {
             logger.warn('Playwright was loaded from multiple module paths. Falling back to static config parsing for upload metadata.');
+        }
+        try {
             return (await tryReadConfigFromSource(resolvedConfigPath));
         }
+        catch {
+            // Preserve the original import error when static parsing cannot recover.
+        }
         throw err;
     }
 }
@@ -917,7 +1114,7 @@ export default defineConfig({
     recordOptions: {
       aspectRatio: '16:9',
       quality: '1080p',
-      fps: 30,
+      fps: 60,
     },
   },
   projects: [
@@ -935,11 +1132,6 @@ function generatePackageJson(includePlaywrightCli = false, screenciDependency =
     }
     return (JSON.stringify({
         type: 'module',
-        scripts: {
-            record: 'screenci record',
-            retry: 'screenci retry',
-            test: 'screenci test',
-        },
         dependencies: {
             screenci: screenciDependency,
             '@playwright/test': '^1.59.0',
@@ -966,20 +1158,6 @@ async function readCurrentScreenciVersion() {
     }
     return 'latest';
 }
-function generateTsconfig() {
-    return `${JSON.stringify({
-        compilerOptions: {
-            module: 'ESNext',
-            moduleResolution: 'bundler',
-            target: 'ESNext',
-            types: ['node'],
-            strict: true,
-            skipLibCheck: true,
-        },
-        include: ['**/*.ts'],
-    }, null, 2)}
-`;
-}
 function generateReadme(projectName) {
     return `# ${projectName}
 
@@ -989,7 +1167,7 @@ This project uses ScreenCI + Playwright to create and upload polished product vi
 
 Write video scripts in \`videos/*.video.ts\` and use \`video(...)\` calls to create product videos. These are very similar to Playwright \`.test.ts\` and \`test(...)\` calls.
 
-Learn more: https://screenci.com/docs/intro/
+Learn more: https://screenci.com/docs
 
 ## Quick start
 
@@ -1014,11 +1192,7 @@ node_modules/
 .env
 `;
 }
-function generateGithubAction(workingDirectory) {
-    const packageLockPath = workingDirectory === '.'
-        ? 'package-lock.json'
-        : `${workingDirectory}/package-lock.json`;
-    const envFilePath = workingDirectory === '.' ? './.env' : `./${workingDirectory}/.env`;
+function generateGithubAction() {
     return `name: ScreenCI
 
 on:
@@ -1038,7 +1212,7 @@ jobs:
           SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
         run: |
           if [ -z "$SCREENCI_SECRET" ]; then
-            echo "::error::SCREENCI_SECRET is not set. Copy it from https://app.screenci.com/secrets or ${envFilePath}, add it under Settings → Secrets and variables → Actions → Repository secrets, and then rerun this action."
+            echo "::error::SCREENCI_SECRET is not set. Copy it from https://app.screenci.com/secrets or ./.env, add it under Settings → Secrets and variables → Actions → Repository secrets, and then rerun this action."
             exit 1
           fi
 
@@ -1048,10 +1222,10 @@ jobs:
         with:
           node-version: 24
           cache: npm
-          cache-dependency-path: ${packageLockPath}
+          cache-dependency-path: package-lock.json
 
       - name: Install dependencies
-        working-directory: ${workingDirectory}
+        working-directory: .
         run: npm ci
 
       - name: Cache Playwright Chromium
@@ -1059,19 +1233,19 @@ jobs:
         id: pw-cache
         with:
           path: ~/.cache/ms-playwright
-          key: playwright-\${{ runner.os }}-\${{ hashFiles('${packageLockPath}') }}
+          key: playwright-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}
 
       - name: Install Chromium
         if: steps.pw-cache.outputs.cache-hit != 'true'
-        working-directory: ${workingDirectory}
-        run: npx playwright install chromium --with-deps
+        working-directory: .
+        run: npx playwright install chromium
 
       - id: record
         name: Record
-        working-directory: ${workingDirectory}
+        working-directory: .
         env:
           SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
-        run: npm run record
+        run: npx screenci record
 `;
 }
 function openBrowser(url) {
@@ -1137,83 +1311,80 @@ function generateExampleVideo() {
     return `import { autoZoom, createNarration, hide, video, voices } from 'screenci'
 
 const narration = createNarration({
-  voice: { name: voices.Sophie, style: 'Clear, friendly product walkthrough' },
+  voice: { name: voices.Sophie },
   languages: {
     en: {
       cues: {
-        docs: 'Use the guide sidebar to open the AI-Supported Editing guide and review the next steps for writing your own videos.',
-      },
-    },
-    es: {
-      cues: {
-        docs: 'Usa la barra lateral de guias para abrir la guia de edicion asistida por IA y revisar los siguientes pasos para escribir tus propios videos.',
+        intro:
+          'This video shows how to get started with ScreenCI [pronounce: screen see eye].',
+        docs: 'You can find the documentation linked right on the front page.',
       },
     },
   },
 })
 
-video('See the next steps in ScreenCI docs', async ({ page }) => {
+video('How to get started', async ({ page }) => {
   await hide(async () => {
-    await page.goto('https://screenci.com/')
-    await page.getByText('ScreenCI', { exact: true }).first().waitFor()
+    await page.goto('https://screenci.com')
+    await page.getByText('ScreenCI').first().waitFor()
   })
 
-  await autoZoom(
-    async () => {
-      await page.getByRole('link', { name: 'View Documentation' }).click()
-      await page
-        .getByRole('link', { name: 'AI-Supported Editing', exact: true })
-        .click()
-      await page.waitForTimeout(1000)
-    },
-    { duration: 400, easing: 'ease-in-out', amount: 0.4 }
-  )
-
+  await narration.intro()
   await narration.docs()
+
+  await autoZoom(async () => {
+    await page.getByRole('link', { name: 'View Documentation' }).click()
+  })
+
+  await page.getByRole('heading', { level: 1, name: 'Installation' }).first().waitFor()
 })
 `;
 }
-async function promptProjectName() {
-    return input({ message: 'Project name:' });
+function getDefaultInitProjectName() {
+    const directoryName = basename(getInitProjectRoot());
+    return directoryName.length > 0 ? directoryName : 'screenci-project';
 }
-async function promptInitDependencies() {
-    return confirm({
-        message: 'Install dependencies now, including Chromium for Playwright? (Y/n)',
-        default: true,
+async function promptProjectName() {
+    return input({
+        message: 'Project name:',
+        default: getDefaultInitProjectName(),
     });
 }
-async function promptInitAiAuthoring() {
-    return confirm({
-        message: 'Do you want to write videos with an AI agent based on a URL and not just source code? If yes, playwright-cli will be also installed.',
-        default: true,
+async function promptYesNo(message, defaultValue) {
+    const answer = await input({
+        message,
+        default: defaultValue ? 'y' : 'n',
+        validate: (value) => {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === '' ||
+                normalized === 'y' ||
+                normalized === 'yes' ||
+                normalized === 'n' ||
+                normalized === 'no') {
+                return true;
+            }
+            return 'Enter y or n';
+        },
     });
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === '')
+        return defaultValue;
+    return normalized === 'y' || normalized === 'yes';
 }
-async function promptInitGithubActionCi() {
-    return confirm({
-        message: 'Do you want to add Github Action CI? (Y/n)',
-        default: true,
-    });
+async function promptInitGithubActionWorkflow() {
+    return promptYesNo('Add a GitHub Actions workflow? (Y/n)', true);
 }
-async function promptInitRepositoryMode() {
-    return select({
-        message: 'Initialize ScreenCI as a standalone project or part of the existing repository?',
-        default: 'standalone',
-        choices: [
-            {
-                name: 'Standalone project',
-                value: 'standalone',
-                description: 'Create a project directory with its own GitHub Action.',
-            },
-            {
-                name: 'Part of existing repository',
-                value: 'existing-repository',
-                description: 'Create ./screenci and add the GitHub Action at the repository root.',
-            },
-        ],
-    });
+async function promptInitPlaywrightBrowsers() {
+    return promptYesNo("Install Playwright browsers (can be done manually via 'npx playwright install chromium')? (Y/n)", true);
+}
+async function promptInitPlaywrightOsDependencies() {
+    return promptYesNo("Install Playwright operating system dependencies (might require sudo / root and can be done manually via 'npx playwright install-deps chromium')? (y/N)", false);
+}
+async function promptInitScreenCISkill() {
+    return promptYesNo("Install the ScreenCI skill for AI agents (can be done manually via 'npx -y skills add screenci/screenci --skill screenci -y')? (Y/n)", true);
 }
-function projectNameToDirectoryName(projectName) {
-    return projectName.trim().replace(/\s+/g, '-');
+async function promptInitPlaywrightCliSkill() {
+    return promptYesNo("Install playwright-cli for URL-based browser inspection (can be done manually via 'npx -y skills add screenci/screenci --skill playwright-cli -y && npm install @playwright/cli')? (Y/n)", true);
 }
 function getInitProjectRoot() {
     return process.env['SCREENCI_INIT_CWD'] ?? process.cwd();
@@ -1221,7 +1392,7 @@ function getInitProjectRoot() {
 function getInitScreenciDependencyOverride() {
     return process.env['SCREENCI_INIT_SCREENCI_DEPENDENCY'];
 }
-export async function ensureScreenciSecret() {
+export async function ensureScreenciSecret(resolvedConfigPath) {
     const existingSecret = process.env.SCREENCI_SECRET;
     if (existingSecret)
         return existingSecret;
@@ -1230,8 +1401,11 @@ export async function ensureScreenciSecret() {
     try {
         const secret = await performBrowserLogin(appUrl);
         process.env.SCREENCI_SECRET = secret;
-        const savePath = resolve(process.cwd(), '.env');
-        await writeFile(savePath, `SCREENCI_SECRET=${secret}\n`);
+        const savePath = resolvedConfigPath
+            ? ((await resolveConfiguredEnvFilePath(resolvedConfigPath)) ??
+                resolve(process.cwd(), '.env'))
+            : resolve(process.cwd(), '.env');
+        await appendFile(savePath, `SCREENCI_SECRET=${secret}\n`);
         logger.info(`Successfully saved SCREENCI_SECRET to ${savePath}`);
         return secret;
     }
@@ -1243,162 +1417,136 @@ export async function ensureScreenciSecret() {
     }
 }
 async function runInit(projectNameArg, options) {
-    const { verbose, install, yes, skill, ci, agent } = options;
+    const { verbose, yes, agent } = options;
     const initCwd = getInitProjectRoot();
-    const existingRepositoryDetected = existsSync(resolve(initCwd, '.git'));
     let projectName = projectNameArg?.trim();
     if (!projectName) {
-        projectName = await promptProjectName();
+        projectName = yes ? getDefaultInitProjectName() : await promptProjectName();
     }
     if (!projectName) {
         logger.error('Error: Project name is required');
         process.exit(1);
     }
-    if (existingRepositoryDetected) {
-        logger.info('Existing repository detected');
-    }
-    const repositoryMode = existingRepositoryDetected
-        ? yes
-            ? 'standalone'
-            : await promptInitRepositoryMode()
-        : 'standalone';
-    const isPartOfExistingRepository = repositoryMode === 'existing-repository';
-    const dirName = isPartOfExistingRepository
-        ? 'screenci'
-        : projectNameToDirectoryName(projectName);
-    const projectDir = resolve(initCwd, dirName);
-    const githubRootDir = isPartOfExistingRepository ? initCwd : projectDir;
-    const githubDir = resolve(githubRootDir, '.github');
-    const githubWorkflowsDir = resolve(githubDir, 'workflows');
+    const projectDir = initCwd;
+    const githubWorkflowsDir = resolve(projectDir, '.github', 'workflows');
     const githubActionPath = resolve(githubWorkflowsDir, 'screenci.yaml');
-    const githubActionProjectDir = isPartOfExistingRepository ? 'screenci' : '.';
-    if (existsSync(projectDir)) {
-        logger.error(`Error: Directory "${dirName}" already exists`);
-        process.exit(1);
-    }
-    const shouldInstallDependencies = yes
+    const shouldAddGithubActionWorkflow = yes
         ? true
-        : install
-            ? true
-            : await promptInitDependencies();
-    const shouldAddPlaywrightCli = yes
+        : await promptInitGithubActionWorkflow();
+    const shouldInstallPlaywrightBrowsers = yes
         ? true
-        : skill
-            ? true
-            : await promptInitAiAuthoring();
-    const shouldAddGithubActionCi = yes
+        : await promptInitPlaywrightBrowsers();
+    const shouldInstallPlaywrightOsDependencies = yes
+        ? false
+        : await promptInitPlaywrightOsDependencies();
+    const shouldInstallScreenCISkill = yes
         ? true
-        : ci
-            ? true
-            : await promptInitGithubActionCi();
-    if (shouldAddGithubActionCi && existsSync(githubActionPath)) {
+        : await promptInitScreenCISkill();
+    const shouldInstallPlaywrightCli = yes
+        ? true
+        : await promptInitPlaywrightCliSkill();
+    if (shouldAddGithubActionWorkflow && existsSync(githubActionPath)) {
         logger.error('Error: GitHub Actions workflow ".github/workflows/screenci.yaml" already exists');
         process.exit(1);
     }
-    const skillsArgs = [
-        '--yes',
-        'skills',
-        'add',
-        'screenci/screenci',
-        ...(agent ? ['--agent', agent] : []),
-        '--skill',
-        'screenci',
-        ...(shouldAddPlaywrightCli ? ['--skill', 'playwright-cli'] : []),
-        '-y',
-    ];
-    const skillsCommand = `npx ${skillsArgs.join(' ')}`;
+    const skills = [];
+    if (shouldInstallScreenCISkill) {
+        skills.push('screenci');
+    }
+    if (shouldInstallPlaywrightCli) {
+        skills.push('playwright-cli');
+    }
+    const skillsArgs = skills.length === 0
+        ? null
+        : [
+            '-y',
+            'skills',
+            'add',
+            'screenci/screenci',
+            ...(agent ? ['--agent', agent] : []),
+            ...skills.flatMap((skillName) => ['--skill', skillName]),
+            '-y',
+        ];
+    const skillsCommand = skillsArgs === null ? null : `npx ${skillsArgs.join(' ')}`;
     const screenciDependency = getInitScreenciDependencyOverride() ?? (await readCurrentScreenciVersion());
+    logger.info("Initializing project in '.'");
     await mkdir(resolve(projectDir, 'videos'), { recursive: true });
-    if (shouldAddGithubActionCi) {
-        if (!existsSync(githubDir)) {
-            await mkdir(githubDir);
-        }
-        if (!existsSync(githubWorkflowsDir)) {
-            await mkdir(githubWorkflowsDir);
-        }
+    if (shouldAddGithubActionWorkflow) {
+        await mkdir(githubWorkflowsDir, { recursive: true });
     }
     await writeFile(resolve(projectDir, 'screenci.config.ts'), generateConfig(projectName));
-    await writeFile(resolve(projectDir, 'package.json'), generatePackageJson(shouldAddPlaywrightCli, screenciDependency));
-    await writeFile(resolve(projectDir, 'tsconfig.json'), generateTsconfig());
+    await writeFile(resolve(projectDir, 'package.json'), generatePackageJson(shouldInstallPlaywrightCli, screenciDependency));
     await writeFile(resolve(projectDir, 'README.md'), generateReadme(projectName));
     await writeFile(resolve(projectDir, '.gitignore'), generateGitignore());
     await writeFile(resolve(projectDir, 'videos', 'example.video.ts'), generateExampleVideo());
-    if (shouldAddGithubActionCi) {
-        await writeFile(githubActionPath, generateGithubAction(githubActionProjectDir));
+    if (shouldAddGithubActionWorkflow) {
+        await writeFile(githubActionPath, generateGithubAction());
     }
-    await writeFile(resolve(projectDir, '.env'), '');
-    logger.info(`Initialized screenci project "${projectName}" in ${projectDir}/`);
+    logger.info(`Initialized screenci project "${projectName}" in .`);
     logger.info('Files created:');
     logger.info('  screenci.config.ts');
     logger.info('  package.json');
-    logger.info('  tsconfig.json');
     logger.info('  README.md');
     logger.info('  .gitignore');
     logger.info('  videos/example.video.ts');
-    if (shouldAddGithubActionCi) {
-        const githubActionDisplayPath = isPartOfExistingRepository
-            ? '.github/workflows/screenci.yaml (outside ./screenci, at repository root)'
-            : '.github/workflows/screenci.yaml';
-        logger.info(`  ${githubActionDisplayPath}`);
+    if (shouldAddGithubActionWorkflow) {
+        logger.info('  .github/workflows/screenci.yaml');
     }
-    logger.info('  .env  (empty placeholder)');
     logger.info('');
-    if (shouldInstallDependencies) {
+    if (skillsArgs !== null) {
         if (verbose) {
             logger.info(`Running '${skillsCommand}'...`);
             await spawnInherited('npx', skillsArgs, projectDir, 'screenci init');
         }
         else {
-            const spinner = ora('Adding ScreenCI skills...').start();
+            const spinner = ora('Adding selected AI skills...').start();
             try {
                 await spawnSilent('npx', skillsArgs, projectDir);
-                spinner.succeed('ScreenCI skills added');
+                spinner.succeed('Selected AI skills added');
             }
             catch (err) {
-                spinner.fail('ScreenCI skills install failed');
+                spinner.fail('AI skills install failed');
                 throw err;
             }
         }
-        if (verbose) {
-            const installArgs = ['install', '--include=dev'];
-            logger.info(`Running 'npm ${installArgs.join(' ')}'...`);
-            await spawnInherited('npm', installArgs, projectDir, 'screenci init');
+    }
+    const installArgs = ['install', '--include=dev'];
+    if (verbose) {
+        logger.info(`Running 'npm ${installArgs.join(' ')}'...`);
+        await spawnInherited('npm', installArgs, projectDir, 'screenci init');
+    }
+    else {
+        const spinner = ora('Running npm install...').start();
+        try {
+            await spawnSilent('npm', installArgs, projectDir);
+            spinner.succeed('npm install complete');
         }
-        else {
-            const spinner = ora('Running npm install...').start();
-            try {
-                const installArgs = ['install', '--include=dev', '--prefix', projectDir];
-                await spawnSilent('npm', installArgs);
-                spinner.succeed('npm install complete');
-            }
-            catch (err) {
-                spinner.fail('npm install failed');
-                throw err;
-            }
+        catch (err) {
+            spinner.fail('npm install failed');
+            throw err;
         }
-        logger.info("Local development requires Chromium for Playwright, running 'npx playwright install chromium --with-deps'...");
-        await spawnInherited('npx', ['playwright', 'install', 'chromium', '--with-deps'], projectDir, 'screenci init');
-        logger.info(`${pc.green('✔')} Playwright installed successfully`);
     }
-    else {
-        logger.info('Dependencies were not installed automatically.');
-        logger.info('Run these commands when you are ready:');
-        logger.info(`  ${skillsCommand}`);
-        logger.info('  npm install --include=dev');
-        logger.info('  npx playwright install chromium --with-deps');
+    if (shouldInstallPlaywrightBrowsers) {
+        logger.info("Installing Playwright Chromium with 'npx playwright install chromium'...");
+        await spawnInherited('npx', ['playwright', 'install', 'chromium'], projectDir, 'screenci init');
+        logger.info(`${pc.green('✔')} Playwright Chromium installed successfully`);
+    }
+    if (shouldInstallPlaywrightOsDependencies) {
+        logger.info("Installing Playwright operating system dependencies with 'npx playwright install-deps chromium'...");
+        await spawnInherited('npx', ['playwright', 'install-deps', 'chromium'], projectDir, 'screenci init');
+        logger.info(`${pc.green('✔')} Playwright operating system dependencies installed successfully`);
     }
     logger.info('');
     logger.info('Next steps:');
-    logger.info(`  cd ${dirName}`);
     logger.info('  Read README.md for setup and recording flow');
-    logger.info('  Docs: https://screenci.com/docs/intro/');
+    logger.info('  Docs: https://screenci.com/docs');
     logger.info('  npx screenci test');
     logger.info('  npx screenci record');
 }
 export async function main() {
     if (process.argv.length <= 2) {
         logger.error('Error: No command provided');
-        logger.error('Available commands: record, test, info, make-public, make-private, retry, init');
+        logger.error('Available commands: record, test, info, make-public, make-private, init');
         process.exit(1);
     }
     const program = new Command();
@@ -1408,10 +1556,24 @@ export async function main() {
     program
         .command('record [playwrightArgs...]')
         .description('Record videos using Playwright')
+        .option('-v, --verbose', 'verbose output')
         .allowUnknownOption(true)
         .action(async () => {
         const parsed = parseRecordCliArgs(getSubcommandArgv('record'));
-        await run('record', parsed.otherArgs, parsed.configPath);
+        let playwrightFailure = null;
+        try {
+            await run('record', parsed.otherArgs, parsed.configPath, parsed.verbose);
+        }
+        catch (error) {
+            logRecordFailureHint();
+            if (error instanceof Error &&
+                error.message.startsWith('Playwright exited with code ')) {
+                playwrightFailure = error;
+            }
+            else {
+                throw error;
+            }
+        }
         if (process.env.SCREENCI_RECORDING === 'true')
             return;
         // After recording, upload results to API if configured
@@ -1426,39 +1588,77 @@ export async function main() {
                 const apiUrl = getDevBackendUrl();
                 const appUrl = getDevFrontendUrl();
                 const secret = process.env.SCREENCI_SECRET;
-                if (!secret) {
-                    logger.info('No secret configured, skipping upload. Set SCREENCI_SECRET in your .env file.');
-                    return;
-                }
+                const uploadPolicy = resolveRecordUploadPolicy(screenciConfig);
                 const configDir = dirname(resolvedConfigPath);
                 const screenciDir = resolve(configDir, '.screenci');
-                let projectId = null;
-                try {
-                    logger.info('');
-                    projectId = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret);
+                const completedRecordingCount = await countCompletedRecordings(screenciDir);
+                if (playwrightFailure !== null && completedRecordingCount === 0) {
+                    logger.info('All recordings failed.');
                 }
-                catch (err) {
-                    if (isUploadCancelledError(err)) {
-                        process.exit(130);
-                    }
-                    throw err;
+                else if (!secret) {
+                    logger.info('No secret configured, skipping upload. Set SCREENCI_SECRET in your .env file.');
+                }
+                else if (playwrightFailure !== null &&
+                    uploadPolicy === 'all-or-nothing') {
+                    logger.info('Some recordings failed, skipping upload because record.upload is "all-or-nothing".');
                 }
-                if (projectId !== null) {
-                    const projectUrl = `${appUrl}/project/${projectId}`;
-                    await writeGitHubProjectOutput(projectUrl);
-                    logger.info('');
-                    logger.info('Recording finished, rendering in progress. Results available at:');
-                    logger.info(pc.cyan(projectUrl));
+                else {
+                    if (playwrightFailure !== null && uploadPolicy === 'passed-only') {
+                        logger.warn('Some recordings failed, uploading successful videos only.');
+                    }
+                    let uploadResult = {
+                        projectId: null,
+                        hadFailures: false,
+                        failedVideoNames: [],
+                        failedVideoMessages: [],
+                    };
+                    try {
+                        logger.info('');
+                        uploadResult = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret);
+                    }
+                    catch (err) {
+                        if (isUploadCancelledError(err)) {
+                            process.exit(130);
+                        }
+                        throw err;
+                    }
+                    const { projectId, hadFailures, failedVideoNames, failedVideoMessages, } = uploadResult;
+                    if (projectId !== null) {
+                        const projectUrl = `${appUrl}/project/${projectId}`;
+                        await writeGitHubProjectOutput(projectUrl);
+                        logger.info('');
+                        logger.info(playwrightFailure !== null
+                            ? 'Recording partially succeeded, rendering in progress. Results available at:'
+                            : 'Recording finished, rendering in progress. Results available at:');
+                        logger.info(pc.cyan(projectUrl));
+                    }
+                    if (hadFailures) {
+                        for (const failedVideo of failedVideoMessages) {
+                            logger.warn(`${failedVideo.videoName}: ${failedVideo.message}`);
+                        }
+                        logger.warn(`Not all recordings succeeded to upload. Failed videos: ${failedVideoNames.join(', ') || 'unknown'}. Some videos may be missing from the project.`);
+                        if (playwrightFailure === null) {
+                            throw new PartialUploadError();
+                        }
+                    }
                 }
             }
             catch (err) {
+                if (isPartialUploadError(err)) {
+                    throw err;
+                }
                 logger.warn('Failed to load config for upload:', err);
             }
         }
+        if (playwrightFailure !== null) {
+            throw playwrightFailure;
+        }
     });
     program
         .command('test [playwrightArgs...]')
         .description('Run Playwright test with screenci.config.ts')
+        .option('--mock-record', 'keep recording-style cursor animation and sleeps during screenci test')
+        .option('-v, --verbose', 'verbose output')
         .allowUnknownOption(true)
         .action(async () => {
         const parsed = parseConfigCliArgs(getSubcommandArgv('test'));
@@ -1475,7 +1675,7 @@ export async function main() {
                 logger.warn('Failed to load config for test env:', err);
             }
         }
-        await run('test', parsed.otherArgs, parsed.configPath);
+        await run('test', parsed.otherArgs, parsed.configPath, parsed.verbose, parsed.mockRecord);
         if (process.env.SCREENCI_RECORDING === 'true')
             return;
         logger.info('');
@@ -1502,33 +1702,18 @@ export async function main() {
         .action(async (id, options) => {
         await updateVideoVisibility(id, false, options['config']);
     });
-    // retry command
-    program
-        .command('retry')
-        .description('Retry uploading all pending recordings')
-        .option('-c, --config <path>', 'path to screenci.config.ts')
-        .option('-v, --verbose', 'verbose output')
-        .action(async (options) => {
-        await uploadLatest(options['config'], options['verbose'] ?? false);
-    });
     // init command
     program
         .command('init [name]')
         .description('Initialize a new screenci project')
-        .option('--install', 'install skills, dependencies, and Chromium without prompting')
-        .option('--ci', 'add GitHub Action CI without prompting')
         .option('--agent <name>', 'target agent for skills install, e.g. opencode. Supported agents: https://github.com/vercel-labs/skills#supported-agents')
-        .option('--skill', 'enable playwright-cli without prompting')
-        .option('-y, --yes', 'answer yes to all init prompts')
+        .option('-y, --yes', 'accept init defaults')
         .option('-v, --verbose', 'verbose output')
         .action(async (name, options) => {
         const agent = options['agent'];
         await runInit(name, {
             verbose: options['verbose'] ?? false,
-            install: options['install'] ?? false,
             yes: options['yes'] ?? false,
-            skill: options['skill'] ?? false,
-            ci: options['ci'] ?? false,
             ...(agent !== undefined ? { agent } : {}),
         });
     });
@@ -1600,6 +1785,8 @@ function parseRecordCliArgs(args) {
 }
 function parseConfigCliArgs(args) {
     let configPath;
+    let verbose = false;
+    let mockRecord = false;
     const otherArgs = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -1614,28 +1801,32 @@ function parseConfigCliArgs(args) {
             configPath = nextArg;
             i++;
         }
+        else if (arg === '--verbose' || arg === '-v') {
+            verbose = true;
+        }
+        else if (arg === '--mock-record') {
+            mockRecord = true;
+        }
         else {
             otherArgs.push(arg);
         }
     }
-    return { configPath, otherArgs };
+    return { configPath, verbose, mockRecord, otherArgs };
 }
 function validateArgs(args) {
-    const disallowedFlags = ['--fully-parallel', '--workers', '-j', '--retries'];
+    const disallowedFlags = ['--retries'];
     for (const arg of args) {
         if (arg === undefined)
             continue;
         // Check if it's a disallowed flag
         if (disallowedFlags.includes(arg)) {
             throw new Error(`Flag "${arg}" is not supported by screenci. ` +
-                'screenci enforces sequential test execution with a single worker and no retries for proper video recording.');
+                'screenci forces retries to 0 for proper video recording.');
         }
-        // Check if it's a --workers=N, -j=N, or --retries=N format
-        if (arg.startsWith('--workers=') ||
-            arg.startsWith('-j=') ||
-            arg.startsWith('--retries=')) {
+        // Check if it's a --retries=N format
+        if (arg.startsWith('--retries=')) {
             throw new Error(`Flag "${arg}" is not supported by screenci. ` +
-                'screenci enforces sequential test execution with a single worker and no retries for proper video recording.');
+                'screenci forces retries to 0 for proper video recording.');
         }
     }
 }
@@ -1672,7 +1863,7 @@ function spawnInherited(cmd, args, cwd, activityLabel = cmd) {
         });
     });
 }
-async function run(command, additionalArgs, customConfigPath) {
+async function run(command, additionalArgs, customConfigPath, verbose = false, mockRecord = false) {
     const configPath = findScreenCIConfig(customConfigPath);
     if (!configPath) {
         const errorMsg = customConfigPath
@@ -1684,47 +1875,69 @@ async function run(command, additionalArgs, customConfigPath) {
     if (command === 'test' || process.env.SCREENCI_RECORDING !== 'true') {
         await loadEnvFileFromConfigSource(configPath, false);
     }
-    const envForChild = { ...process.env };
     // Only validate args for record command
     if (command === 'record') {
-        await ensureScreenciSecret();
+        await ensureScreenciSecret(configPath);
         validateArgs(additionalArgs);
         const screenciDir = resolve(dirname(configPath), '.screenci');
         clearDirectory(screenciDir);
     }
-    if (process.env.SCREENCI_RECORDING !== 'true') {
+    const envForChild = { ...process.env };
+    await validateUniqueDiscoveredTestTitles(configPath, additionalArgs, {
+        ...envForChild,
+        ...(command === 'record' ? { SCREENCI_RECORDING: 'true' } : {}),
+        ...(command === 'test' && !mockRecord
+            ? { [SCREENCI_DISABLE_RECORDING_TIMINGS_ENV]: 'true' }
+            : {}),
+        ...(command === 'test' && mockRecord
+            ? { [SCREENCI_MOCK_RECORD_ENV]: 'true' }
+            : {}),
+    });
+    if (verbose && process.env.SCREENCI_RECORDING !== 'true') {
         logger.info(`Using config: ${configPath}`);
     }
     const playwrightArgs = ['test', '--config', configPath, ...additionalArgs];
     const spawnSpec = resolveSpawnSpec('playwright', playwrightArgs);
     const child = spawn(spawnSpec.command, spawnSpec.args, {
         stdio: 'inherit',
+        ...(process.platform !== 'win32' ? { detached: true } : {}),
         ...(spawnSpec.shell !== undefined ? { shell: spawnSpec.shell } : {}),
         env: {
             ...envForChild,
             // Enable recording only for record command
             ...(command === 'record' ? { SCREENCI_RECORDING: 'true' } : {}),
+            ...(command === 'test' && !mockRecord
+                ? { [SCREENCI_DISABLE_RECORDING_TIMINGS_ENV]: 'true' }
+                : {}),
+            ...(command === 'test' && mockRecord
+                ? { [SCREENCI_MOCK_RECORD_ENV]: 'true' }
+                : {}),
         },
     });
-    const childSignals = forwardChildSignals(child, `screenci ${command}`);
+    const childSignals = forwardChildSignals(child, `screenci ${command}`, {
+        killTree: process.platform !== 'win32',
+        exitParentOnForward: true,
+    });
     return new Promise((resolve, reject) => {
         child.on('close', (code, signal) => {
-            const forwardedSignal = childSignals.getForwardedSignal();
-            childSignals.cleanup();
-            if (forwardedSignal) {
-                process.kill(process.pid, forwardedSignal);
-                return;
-            }
-            if (signal) {
-                process.kill(process.pid, signal);
-                return;
-            }
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`Playwright exited with code ${code}`));
-            }
+            void (async () => {
+                const forwardedSignal = childSignals.getForwardedSignal();
+                childSignals.cleanup();
+                if (forwardedSignal) {
+                    process.kill(process.pid, forwardedSignal);
+                    return;
+                }
+                if (signal) {
+                    process.kill(process.pid, signal);
+                    return;
+                }
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Playwright exited with code ${code}`));
+                }
+            })().catch(reject);
         });
         child.on('error', (err) => {
             childSignals.cleanup();
@@ -1732,6 +1945,11 @@ async function run(command, additionalArgs, customConfigPath) {
         });
     });
 }
+function logRecordFailureHint() {
+    logger.info('');
+    logger.info(`If ${pc.cyan('screenci test')} works but ${pc.cyan('screenci record')} fails, try ${pc.cyan('screenci test --mock-record')}.`);
+    logger.info(`More info: ${pc.cyan(SCREENCI_MOCK_RECORD_DOCS_URL)}`);
+}
 // Only run if this file is being executed directly
 // Check if this module is the main module (handles symlinks properly)
 const currentFile = fileURLToPath(import.meta.url);
@@ -1742,6 +1960,9 @@ if (mainFile &&
         currentRealFile === mainFile ||
         currentFile === realpathSync(mainFile))) {
     main().catch((error) => {
+        if (isPartialUploadError(error)) {
+            process.exit(1);
+        }
         logger.error('Error:', error.message);
         process.exit(1);
     });