screenci 0.0.44 → 0.0.46

package/dist/cli.js

@@ -3,14 +3,114 @@ import { createReadStream } from 'fs';
 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 { appendFile, readdir, readFile, stat } from 'fs/promises';
+import { delimiter, 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 ora from 'ora';
 import pc from 'picocolors';
 import { logger } from './src/logger.js';
+import { determinePackageManager, parsePackageManager, runInit, } from './src/init.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 } : {}),
+            ...(spawnSpec.windowsVerbatimArguments !== undefined
+                ? {
+                    windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+                }
+                : {}),
+            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 +150,210 @@ 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));
+            },
+            info(message) {
+                logger.info(message);
+            },
+        };
+    }
+    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;
+    };
+    const clear = () => {
+        if (!hasRendered || videoNames.length === 0)
+            return;
+        process.stdout.write(`\u001B[${videoNames.length}A${Array.from({ length: videoNames.length }, () => '\r\u001B[2K').join('\n')}\n`);
+        hasRendered = false;
+    };
+    render();
+    return {
+        complete(index, status) {
+            statuses[index] = status;
+            render();
+        },
+        info(message) {
+            clear();
+            logger.info(message);
+            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, progressReporter);
+        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'
@@ -106,63 +405,75 @@ function createUploadAbortController(activityLabel) {
         cleanup,
     };
 }
-function quoteWindowsCommandArg(arg) {
-    if (arg.length === 0)
-        return '""';
-    if (/^[A-Za-z0-9_./:\\=-]+$/.test(arg))
-        return arg;
-    return `"${arg.replace(/"/g, '""')}"`;
-}
 function resolveSpawnSpec(cmd, args) {
     if (process.platform !== 'win32') {
         return { command: cmd, args };
     }
-    const windowsCmdsNeedingShell = new Set(['npm', 'npx', 'playwright']);
-    if (!windowsCmdsNeedingShell.has(cmd)) {
+    const windowsCmdShims = new Set(['npm', 'npx', 'playwright', 'pnpm']);
+    if (!windowsCmdShims.has(cmd)) {
         return { command: cmd, args };
     }
-    const commandLine = [cmd, ...args].map(quoteWindowsCommandArg).join(' ');
     return {
-        command: 'cmd',
-        args: ['/d', '/c', commandLine],
+        command: process.env.comspec ?? 'cmd.exe',
+        args: ['/d', '/s', '/c', `"${buildWindowsBatchCommandLine(cmd, args)}"`],
+        windowsVerbatimArguments: true,
     };
 }
-function spawnSilent(cmd, args, cwd) {
-    return new Promise((resolve, reject) => {
-        const spawnSpec = resolveSpawnSpec(cmd, args);
-        const child = spawn(spawnSpec.command, spawnSpec.args, {
-            stdio: 'pipe',
-            ...(spawnSpec.shell !== undefined ? { shell: spawnSpec.shell } : {}),
-            ...(cwd ? { cwd } : {}),
-        });
-        const childSignals = forwardChildSignals(child, cmd);
-        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;
-            }
-            else if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`${cmd} exited with code ${code}`));
-            }
-        });
-        child.on('error', (err) => {
-            childSignals.cleanup();
-            reject(err);
-        });
-    });
+function quoteWindowsBatchArg(arg) {
+    if (arg.length === 0) {
+        return '""';
+    }
+    return `"${arg
+        .replace(/(\\*)"/g, '$1$1\\"')
+        .replace(/(\\+)$/g, '$1$1')
+        .replace(/%/g, '%%')}"`;
+}
+function buildWindowsBatchCommandLine(cmd, args) {
+    return [resolveWindowsCmdShim(cmd), ...args]
+        .map(quoteWindowsBatchArg)
+        .join(' ');
+}
+function resolveWindowsCmdShim(cmd) {
+    const shimName = `${cmd}.cmd`;
+    const pathEntries = process.env.PATH?.split(delimiter) ?? [];
+    for (const entry of pathEntries) {
+        if (!entry)
+            continue;
+        const shimPath = resolve(entry, shimName);
+        if (existsSync(shimPath)) {
+            return shimPath;
+        }
+    }
+    const bundledShimCommands = new Set(['npm', 'npx']);
+    if (bundledShimCommands.has(cmd)) {
+        const bundledShimPath = resolve(dirname(process.execPath), shimName);
+        if (existsSync(bundledShimPath)) {
+            return bundledShimPath;
+        }
+    }
+    return shimName;
 }
-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 +481,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 +541,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');
@@ -494,6 +776,16 @@ export function formatUploadStartFailureMessage(videoName, status, responseText,
     }
     return `Failed to start upload for "${videoName}": ${status}${hint401(status, secret)}`;
 }
+const EXPRESSIVE_TIER_ERROR_PREFIX = 'Expressive narration and style prompts require the Business tier.';
+export function formatFailedVideoMessage(videoName, message) {
+    if (message.startsWith(EXPRESSIVE_TIER_ERROR_PREFIX)) {
+        return [
+            `${videoName}: ${message}`,
+            "If you want to keep using the current tier, remove `voice.style` or `modelType: 'expressive'` from `createNarration()`.",
+        ].join('\n');
+    }
+    return `${videoName}: ${message}`;
+}
 export function printUploadStartFailureMessage(videoName, status, responseText, secret) {
     const message = formatUploadStartFailureMessage(videoName, status, responseText, secret);
     if (responseText.trim().length > 0) {
@@ -502,7 +794,15 @@ export function printUploadStartFailureMessage(videoName, status, responseText,
     }
     logger.warn(message);
 }
-async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIfAborted) {
+async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIfAborted, progressReporter) {
+    const logInfo = (message) => {
+        if (progressReporter) {
+            progressReporter.info(message);
+        }
+        else {
+            logger.info(message);
+        }
+    };
     for (const asset of assets) {
         throwIfAborted();
         try {
@@ -528,7 +828,7 @@ async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIf
             }
             const checkBody = (await checkRes.json());
             if (checkBody.exists) {
-                logger.info(`Asset already exists: ${asset.path}`);
+                logInfo(`Asset already exists: ${asset.path}`);
                 continue;
             }
             if (!asset.fileBuffer || !asset.contentType) {
@@ -555,14 +855,14 @@ async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIf
             if (!res.ok) {
                 const text = await res.text();
                 if (res.status === 409 && text.includes('already exists')) {
-                    logger.info(`Asset already exists: ${asset.path}`);
+                    logInfo(`Asset already exists: ${asset.path}`);
                 }
                 else {
                     logger.warn(`Failed to upload asset ${asset.path}: ${res.status} ${text}${hint401(res.status, secret)}`);
                 }
             }
             else {
-                logger.info(`Asset uploaded: ${asset.path}`);
+                logInfo(`Asset uploaded: ${asset.path}`);
             }
         }
         catch (err) {
@@ -573,7 +873,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 +881,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 +955,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 +1008,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 +1029,27 @@ 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];
+}
+export function extractMockRecordLiteral(configSource) {
+    const match = configSource.match(/test\s*:\s*\{[\s\S]*?mockRecord\s*:\s*(true|false)/);
+    if (!match)
+        return undefined;
+    return match[1] === 'true';
+}
+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 +1057,13 @@ 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);
+    const mockRecord = extractMockRecordLiteral(configSource);
     return {
         projectName,
         ...(envFile !== undefined ? { envFile } : {}),
+        ...(recordUpload !== undefined ? { record: { upload: recordUpload } } : {}),
+        ...(mockRecord !== undefined ? { test: { mockRecord } } : {}),
     };
 }
 export function getConfigModuleSpecifier(resolvedConfigPath) {
@@ -850,11 +1079,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;
     }
 }
@@ -906,174 +1141,6 @@ async function updateVideoVisibility(videoId, isPublic, configPath) {
     }
     logger.info(`${isPublic ? 'Made public' : 'Made private'}: ${videoId}`);
 }
-function generateConfig(projectName) {
-    return `import { defineConfig } from 'screenci'
-
-export default defineConfig({
-  projectName: ${JSON.stringify(projectName)},
-  envFile: '.env',
-  videoDir: './videos',
-  use: {
-    recordOptions: {
-      aspectRatio: '16:9',
-      quality: '1080p',
-      fps: 30,
-    },
-  },
-  projects: [
-    {
-      name: 'chromium',
-    },
-  ],
-})
-`;
-}
-function generatePackageJson(includePlaywrightCli = false, screenciDependency = 'latest') {
-    const devDependencies = {};
-    if (includePlaywrightCli) {
-        devDependencies['@playwright/cli'] = 'latest';
-    }
-    return (JSON.stringify({
-        type: 'module',
-        scripts: {
-            record: 'screenci record',
-            retry: 'screenci retry',
-            test: 'screenci test',
-        },
-        dependencies: {
-            screenci: screenciDependency,
-            '@playwright/test': '^1.59.0',
-        },
-        devDependencies,
-    }, null, 2) + '\n');
-}
-async function readCurrentScreenciVersion() {
-    const currentFileDir = dirname(fileURLToPath(import.meta.url));
-    const packageJsonPaths = [
-        resolve(currentFileDir, 'package.json'),
-        resolve(currentFileDir, '../package.json'),
-    ];
-    for (const packageJsonPath of packageJsonPaths) {
-        try {
-            const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
-            if (typeof packageJson.version === 'string') {
-                return packageJson.version;
-            }
-        }
-        catch {
-            // Try the next candidate path.
-        }
-    }
-    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}
-
-This project uses ScreenCI + Playwright to create and upload polished product videos.
-
-## How video recording works
-
-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/
-
-## Quick start
-
-1. Create your own videos in \`videos/*.video.ts\`, either manually or with an AI agent using your source code or a URL.
-
-2. Run videos locally to test the script working:
-
-   \`npx screenci test\` or with UI mode: \`npx screenci test --ui\`
-
-3. Record videos:
-
-   \`npx screenci record\`
-
-4. View results on screenci.com and optionally enable a public URL to embed the video on your site.
-`;
-}
-function generateGitignore() {
-    return `/playwright-report/
-.screenci
-.playwright-cli/
-node_modules/
-.env
-`;
-}
-function generateGithubAction(workingDirectory) {
-    const packageLockPath = workingDirectory === '.'
-        ? 'package-lock.json'
-        : `${workingDirectory}/package-lock.json`;
-    const envFilePath = workingDirectory === '.' ? './.env' : `./${workingDirectory}/.env`;
-    return `name: ScreenCI
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  record:
-    runs-on: ubuntu-latest
-    environment:
-      name: screenci
-      url: \${{ steps.record.outputs.screenci_project_url }}
-    steps:
-      - name: Check SCREENCI_SECRET
-        env:
-          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."
-            exit 1
-          fi
-
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24
-          cache: npm
-          cache-dependency-path: ${packageLockPath}
-
-      - name: Install dependencies
-        working-directory: ${workingDirectory}
-        run: npm ci
-
-      - name: Cache Playwright Chromium
-        uses: actions/cache@v5
-        id: pw-cache
-        with:
-          path: ~/.cache/ms-playwright
-          key: playwright-\${{ runner.os }}-\${{ hashFiles('${packageLockPath}') }}
-
-      - name: Install Chromium
-        if: steps.pw-cache.outputs.cache-hit != 'true'
-        working-directory: ${workingDirectory}
-        run: npx playwright install chromium --with-deps
-
-      - id: record
-        name: Record
-        working-directory: ${workingDirectory}
-        env:
-          SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
-        run: npm run record
-`;
-}
 function openBrowser(url) {
     try {
         if (process.platform === 'win32') {
@@ -1133,95 +1200,7 @@ async function performBrowserLogin(appUrl) {
         server.on('close', () => clearTimeout(timeout));
     });
 }
-function generateExampleVideo() {
-    return `import { autoZoom, createNarration, hide, video, voices } from 'screenci'
-
-const narration = createNarration({
-  voice: { name: voices.Sophie, style: 'Clear, friendly product walkthrough' },
-  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.',
-      },
-    },
-  },
-})
-
-video('See the next steps in ScreenCI docs', async ({ page }) => {
-  await hide(async () => {
-    await page.goto('https://screenci.com/')
-    await page.getByText('ScreenCI', { exact: true }).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.docs()
-})
-`;
-}
-async function promptProjectName() {
-    return input({ message: 'Project name:' });
-}
-async function promptInitDependencies() {
-    return confirm({
-        message: 'Install dependencies now, including Chromium for Playwright? (Y/n)',
-        default: true,
-    });
-}
-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 promptInitGithubActionCi() {
-    return confirm({
-        message: 'Do you want to add Github Action CI? (Y/n)',
-        default: 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.',
-            },
-        ],
-    });
-}
-function projectNameToDirectoryName(projectName) {
-    return projectName.trim().replace(/\s+/g, '-');
-}
-function getInitProjectRoot() {
-    return process.env['SCREENCI_INIT_CWD'] ?? process.cwd();
-}
-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 +1209,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;
     }
@@ -1242,166 +1224,14 @@ export async function ensureScreenciSecret() {
         return undefined;
     }
 }
-async function runInit(projectNameArg, options) {
-    const { verbose, install, yes, skill, ci, agent } = options;
-    const initCwd = getInitProjectRoot();
-    const existingRepositoryDetected = existsSync(resolve(initCwd, '.git'));
-    let projectName = projectNameArg?.trim();
-    if (!projectName) {
-        projectName = 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 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
-        ? true
-        : install
-            ? true
-            : await promptInitDependencies();
-    const shouldAddPlaywrightCli = yes
-        ? true
-        : skill
-            ? true
-            : await promptInitAiAuthoring();
-    const shouldAddGithubActionCi = yes
-        ? true
-        : ci
-            ? true
-            : await promptInitGithubActionCi();
-    if (shouldAddGithubActionCi && 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 screenciDependency = getInitScreenciDependencyOverride() ?? (await readCurrentScreenciVersion());
-    await mkdir(resolve(projectDir, 'videos'), { recursive: true });
-    if (shouldAddGithubActionCi) {
-        if (!existsSync(githubDir)) {
-            await mkdir(githubDir);
-        }
-        if (!existsSync(githubWorkflowsDir)) {
-            await mkdir(githubWorkflowsDir);
-        }
-    }
-    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, '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));
-    }
-    await writeFile(resolve(projectDir, '.env'), '');
-    logger.info(`Initialized screenci project "${projectName}" in ${projectDir}/`);
-    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}`);
-    }
-    logger.info('  .env  (empty placeholder)');
-    logger.info('');
-    if (shouldInstallDependencies) {
-        if (verbose) {
-            logger.info(`Running '${skillsCommand}'...`);
-            await spawnInherited('npx', skillsArgs, projectDir, 'screenci init');
-        }
-        else {
-            const spinner = ora('Adding ScreenCI skills...').start();
-            try {
-                await spawnSilent('npx', skillsArgs, projectDir);
-                spinner.succeed('ScreenCI skills added');
-            }
-            catch (err) {
-                spinner.fail('ScreenCI 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');
-        }
-        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;
-            }
-        }
-        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');
-    }
-    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('  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();
+    const defaultPackageManager = determinePackageManager();
     program.name('screenci');
     program.exitOverride();
     // record command — playwright args pass through as-is
@@ -1412,7 +1242,20 @@ export async function main() {
         .allowUnknownOption(true)
         .action(async () => {
         const parsed = parseRecordCliArgs(getSubcommandArgv('record'));
-        await run('record', parsed.otherArgs, parsed.configPath, parsed.verbose);
+        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
@@ -1427,47 +1270,86 @@ 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.');
                 }
-                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 === 'all-or-nothing') {
+                    logger.info('Some recordings failed, skipping upload because record.upload is "all-or-nothing".');
+                }
+                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(formatFailedVideoMessage(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'));
+        let configMockRecord = false;
         const resolvedConfigPath = findScreenCIConfig(parsed.configPath);
         if (resolvedConfigPath) {
             try {
                 const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
+                configMockRecord = screenciConfig.test?.mockRecord ?? false;
                 if (screenciConfig.envFile) {
                     const envFilePath = resolve(dirname(resolvedConfigPath), screenciConfig.envFile);
                     loadEnvFile(envFilePath, true);
@@ -1477,7 +1359,7 @@ export async function main() {
                 logger.warn('Failed to load config for test env:', err);
             }
         }
-        await run('test', parsed.otherArgs, parsed.configPath, parsed.verbose);
+        await run('test', parsed.otherArgs, parsed.configPath, parsed.verbose, parsed.mockRecord || configMockRecord);
         if (process.env.SCREENCI_RECORDING === 'true')
             return;
         logger.info('');
@@ -1504,33 +1386,20 @@ 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('--package-manager <manager>', `package manager to use: npm or pnpm (default: ${defaultPackageManager})`)
+        .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,
+            packageManager: parsePackageManager(options['packageManager']),
             ...(agent !== undefined ? { agent } : {}),
         });
     });
@@ -1603,6 +1472,7 @@ 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];
@@ -1620,65 +1490,33 @@ function parseConfigCliArgs(args) {
         else if (arg === '--verbose' || arg === '-v') {
             verbose = true;
         }
+        else if (arg === '--mock-record') {
+            mockRecord = true;
+        }
         else {
             otherArgs.push(arg);
         }
     }
-    return { configPath, verbose, 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.');
         }
     }
 }
-function spawnInherited(cmd, args, cwd, activityLabel = cmd) {
-    const spawnSpec = resolveSpawnSpec(cmd, args);
-    const child = spawn(spawnSpec.command, spawnSpec.args, {
-        stdio: 'inherit',
-        ...(spawnSpec.shell !== undefined ? { shell: spawnSpec.shell } : {}),
-        ...(cwd ? { cwd } : {}),
-    });
-    const childSignals = forwardChildSignals(child, activityLabel);
-    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;
-            }
-            else if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`${cmd} exited with code ${code}`));
-            }
-        });
-        child.on('error', (err) => {
-            childSignals.cleanup();
-            reject(err);
-        });
-    });
-}
-async function run(command, additionalArgs, customConfigPath, verbose = false) {
+async function run(command, additionalArgs, customConfigPath, verbose = false, mockRecord = false) {
     const configPath = findScreenCIConfig(customConfigPath);
     if (!configPath) {
         const errorMsg = customConfigPath
@@ -1690,14 +1528,24 @@ async function run(command, additionalArgs, customConfigPath, verbose = false) {
     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);
     }
+    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}`);
     }
@@ -1705,32 +1553,49 @@ async function run(command, additionalArgs, customConfigPath, verbose = false) {
     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 } : {}),
+        ...(spawnSpec.windowsVerbatimArguments !== undefined
+            ? {
+                windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+            }
+            : {}),
         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();
@@ -1738,6 +1603,11 @@ async function run(command, additionalArgs, customConfigPath, verbose = false) {
         });
     });
 }
+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);
@@ -1748,6 +1618,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);
     });