screenci 0.0.90 → 0.0.91

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createReadStream } from 'fs';
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, } from 'fs';
 import { createHash, randomUUID } from 'crypto';
 import { createRequire } from 'module';
-import { appendFile, readdir, readFile, stat, writeFile } from 'fs/promises';
+import { appendFile, mkdir, readdir, readFile, rm, stat, writeFile, } from 'fs/promises';
 import { delimiter, dirname, isAbsolute, relative as pathRelative, resolve, } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Command, CommanderError } from 'commander';
@@ -17,7 +17,7 @@ import { findDuplicateTitles, formatDuplicateTitlesMessage, } from './src/titleV
 import { getCliLinkSessionApiUrl, getDevBackendUrl, getDevFrontendUrl, getScreenCISecretsUrl, persistScreenCISecret, } from './src/linkSession.js';
 import { OVERLAY_CACHE_DIR_NAME } from './src/htmlRasterizer.js';
 import { maybeExtractVoiceSampleAudio } from './src/voiceSampleAudio.js';
-import { ANON_SESSION_FILE, anonCredential, checkAnonSessionStatus, deleteAnonSessionFile, evaluateAnonRecordingGate, formatAnonTermsNotice, getOrCreateAnonToken, secretCredential, SCREENCI_TERMS_URL, } from './src/anonSession.js';
+import { ANON_MAX_VIDEOS_PER_RECORDING, ANON_SESSION_FILE, ANON_TOKEN_HEADER, anonCredential, checkAnonSessionStatus, deleteAnonSessionFile, evaluateAnonRecordingGate, formatAnonPostRecordNotice, formatAnonTermsNotice, getOrCreateAnonToken, readAnonSessionRecordUrl, saveAnonSessionRecordUrl, secretCredential, } from './src/anonSession.js';
 // Re-export the environment-aware URL helpers so existing importers (and tests)
 // can keep importing them from the CLI entrypoint.
 export { getCliLinkSessionApiUrl, getDevBackendUrl, getDevFrontendUrl };
@@ -31,6 +31,8 @@ const SCREENCI_RECORD_DOCS_URL = 'https://screenci.com/docs/reference/cli/#scree
 // Records the recordId of the most recent `screenci record` upload so
 // `screenci info` can report exactly the run that was just made.
 const SCREENCI_LAST_RECORD_FILE = 'last-record.json';
+const SCREENCI_RECORD_LOCK_FILE = '.record.lock';
+const SCREENCI_RECORD_LOCK_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 const require = createRequire(import.meta.url);
 /**
  * Reports whether the current session can complete an interactive browser
@@ -228,9 +230,9 @@ const UPLOAD_ASSET_LABEL = {
     cursor: 'Cursor',
 };
 export function formatStudioUrl(appUrl, projectId, videoId) {
-    // The video hub resolves `?studio` to the right language page and scrolls it
-    // to Studio, so we never need to guess the language in the printed link.
-    return `${appUrl}/project/${projectId}/video/${videoId}?studio`;
+    // The video hub resolves `?editor` to the right language page and scrolls it
+    // to Editor, so we never need to guess the language in the printed link.
+    return `${appUrl}/project/${projectId}/video/${videoId}?editor`;
 }
 class UploadAssetError extends Error {
     constructor(message) {
@@ -350,12 +352,37 @@ async function loadUploadCandidate(screenciDir, entry, verbose) {
     return {
         entry,
         videoName,
+        displayVideoName: videoName,
         data,
         preparedUploadAssets,
     };
 }
+function disambiguateUploadCandidateDisplayNames(candidates) {
+    const counts = new Map();
+    for (const candidate of candidates) {
+        counts.set(candidate.videoName, (counts.get(candidate.videoName) ?? 0) + 1);
+    }
+    return candidates.map((candidate) => {
+        if ((counts.get(candidate.videoName) ?? 0) <= 1)
+            return candidate;
+        const languages = candidate.data.metadata?.languages;
+        if (Array.isArray(languages) && languages.length === 1) {
+            const [language] = languages;
+            if (typeof language === 'string' && language.length > 0) {
+                return {
+                    ...candidate,
+                    displayVideoName: `${candidate.videoName} [${language}]`,
+                };
+            }
+        }
+        if (candidate.entry !== candidate.videoName) {
+            return { ...candidate, displayVideoName: candidate.entry };
+        }
+        return candidate;
+    });
+}
 async function uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, credential, verbose, uploadAbort, progressReporter, progressIndex, recordId, expectedScreenshotCount) {
-    const { entry, videoName, data: rawData, preparedUploadAssets } = candidate;
+    const { entry, videoName, displayVideoName, data: rawData, preparedUploadAssets, } = candidate;
     let projectId = null;
     let videoId = null;
     let plan = null;
@@ -376,8 +403,8 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 projectId: null,
                 videoId: null,
                 hadFailure: true,
-                videoName,
-                failureMessage: `Missing ${recordingFileName} for "${videoName}"`,
+                videoName: displayVideoName,
+                failureMessage: `Missing ${recordingFileName} for "${displayVideoName}"`,
                 recordId,
             };
         }
@@ -392,8 +419,8 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 projectId: null,
                 videoId: null,
                 hadFailure: true,
-                videoName,
-                failureMessage: formatUnresolvedAssetMessage(videoName, unresolved),
+                videoName: displayVideoName,
+                failureMessage: formatUnresolvedAssetMessage(displayVideoName, unresolved),
                 recordId,
             };
         }
@@ -437,7 +464,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                     videoId: null,
                     hadFailure: true,
                     elevenLabsKeyMissing: true,
-                    videoName,
+                    videoName: displayVideoName,
                     recordId,
                 };
             }
@@ -445,8 +472,8 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 projectId: null,
                 videoId: null,
                 hadFailure: true,
-                videoName,
-                failureMessage: formatUploadStartFailureMessage(videoName, startResponse.status, text, credential.value),
+                videoName: displayVideoName,
+                failureMessage: formatUploadStartFailureMessage(displayVideoName, startResponse.status, text, credential.value),
                 recordId,
             };
         }
@@ -461,7 +488,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
         // the render for this video fails with the dependency error until fixed.
         if (startBody.dependencyErrors && startBody.dependencyErrors.length > 0) {
             for (const depError of startBody.dependencyErrors) {
-                logger.error(`Render dependency error in "${videoName}": ${depError.detail}. This render will fail until it is fixed.`);
+                logger.error(`Render dependency error in "${displayVideoName}": ${depError.detail}. This render will fail until it is fixed.`);
             }
         }
         // A missing ElevenLabs key is a hard failure returned as an error response
@@ -508,8 +535,8 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 projectId,
                 videoId,
                 hadFailure: true,
-                videoName,
-                failureMessage: `Failed to upload recording for "${videoName}": ${recordingResponse.status} ${extractBackendError(text)}${hint401(recordingResponse.status, credential.value)}`,
+                videoName: displayVideoName,
+                failureMessage: `Failed to upload recording for "${displayVideoName}": ${recordingResponse.status} ${extractBackendError(text)}${hint401(recordingResponse.status, credential.value)}`,
                 recordId,
                 ...(plan !== null && { plan }),
             };
@@ -520,7 +547,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             projectId,
             videoId,
             hadFailure: false,
-            videoName,
+            videoName: displayVideoName,
             recordId,
             ...(studio !== undefined && { studio }),
             ...(plan !== null && { plan }),
@@ -541,7 +568,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 projectId,
                 videoId,
                 hadFailure: true,
-                videoName,
+                videoName: displayVideoName,
                 failureMessage: err instanceof Error ? err.message : String(err),
                 recordId,
                 ...(plan !== null && { plan }),
@@ -552,8 +579,8 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             projectId,
             videoId,
             hadFailure: true,
-            videoName,
-            failureMessage: `Network error uploading "${videoName}": ${err instanceof Error ? err.message : String(err)}`,
+            videoName: displayVideoName,
+            failureMessage: `Network error uploading "${displayVideoName}": ${err instanceof Error ? err.message : String(err)}`,
             recordId,
             ...(plan !== null && { plan }),
         };
@@ -1332,6 +1359,32 @@ export function formatFailedVideoMessage(videoName, message) {
     }
     return `${videoName}: ${message}`;
 }
+function quoteFailedVideoName(videoName) {
+    return `'${videoName.replaceAll("'", "\\'")}'`;
+}
+export function formatFailedVideoNamesSummary(videoNames) {
+    if (videoNames.length === 0)
+        return 'unknown';
+    return videoNames
+        .map((videoName) => quoteFailedVideoName(videoName))
+        .join(', ');
+}
+export function collapseFailedVideoWarnings(failures) {
+    const byMessage = new Map();
+    for (const failure of failures) {
+        const names = byMessage.get(failure.message);
+        if (names)
+            names.push(failure.videoName);
+        else
+            byMessage.set(failure.message, [failure.videoName]);
+    }
+    return [...byMessage.entries()].map(([message, videoNames]) => {
+        if (videoNames.length === 1) {
+            return formatFailedVideoMessage(videoNames[0] ?? 'unknown', message);
+        }
+        return message;
+    });
+}
 export function printUploadStartFailureMessage(videoName, status, responseText, secret) {
     const message = formatUploadStartFailureMessage(videoName, status, responseText, secret);
     if (responseText.trim().length > 0) {
@@ -1514,7 +1567,7 @@ async function uploadAssets(assets, apiUrl, credential, recordingId, signal, thr
         }
     }
 }
-export async function uploadRecordings(screenciDir, projectName, apiUrl, credential, specificEntry, verbose = false) {
+export async function uploadRecordings(screenciDir, projectName, apiUrl, credential, specificEntry, verbose = false, allowedVideoNames) {
     const uploadAbort = createUploadAbortController('upload');
     const recordId = randomUUID();
     let entries;
@@ -1527,6 +1580,7 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, credent
             projectId: null,
             recordId: null,
             hadFailures: false,
+            uploadedVideoNames: [],
             failedVideoNames: [],
             failedVideoMessages: [],
             studioNotices: [],
@@ -1540,33 +1594,66 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, credent
     }
     let firstProjectId = null;
     try {
-        const candidates = (await Promise.all(entries.map(async (entry) => {
+        const candidates = disambiguateUploadCandidateDisplayNames((await Promise.all(entries.map(async (entry) => {
             uploadAbort.throwIfAborted();
             return await loadUploadCandidate(screenciDir, entry, verbose);
-        }))).filter((candidate) => candidate !== null);
-        if (candidates.length === 0) {
+        }))).filter((candidate) => candidate !== null));
+        const requestedVideoNames = allowedVideoNames !== undefined ? new Set(allowedVideoNames) : null;
+        const filteredCandidates = requestedVideoNames === null
+            ? candidates
+            : candidates.filter((candidate) => requestedVideoNames.has(candidate.videoName));
+        if (filteredCandidates.length === 0) {
+            const missingRequestedVideoNames = requestedVideoNames === null
+                ? []
+                : [...requestedVideoNames].filter((videoName) => !candidates.some((candidate) => candidate.videoName === videoName));
             return {
                 projectId: null,
                 recordId: null,
-                hadFailures: false,
-                failedVideoNames: [],
-                failedVideoMessages: [],
+                hadFailures: missingRequestedVideoNames.length > 0,
+                uploadedVideoNames: [],
+                failedVideoNames: missingRequestedVideoNames,
+                failedVideoMessages: missingRequestedVideoNames.map((videoName) => ({
+                    videoName,
+                    message: `No recorded output found for "${videoName}"`,
+                })),
                 studioNotices: [],
                 elevenLabsKeyMissingVideos: [],
                 notices: [],
                 plan: null,
             };
         }
-        const progressReporter = createUploadProgressReporter(candidates.map((candidate) => candidate.videoName), verbose);
+        if (credential.header === ANON_TOKEN_HEADER &&
+            filteredCandidates.length > ANON_MAX_VIDEOS_PER_RECORDING) {
+            const failureMessage = `Anonymous trials are capped at ${ANON_MAX_VIDEOS_PER_RECORDING} videos/screenshots per recording. Split this into smaller runs or sign up to record more in one run.`;
+            return {
+                projectId: null,
+                recordId: null,
+                hadFailures: true,
+                uploadedVideoNames: [],
+                failedVideoNames: filteredCandidates.map((candidate) => candidate.displayVideoName),
+                failedVideoMessages: filteredCandidates.map((candidate) => ({
+                    videoName: candidate.displayVideoName,
+                    message: failureMessage,
+                })),
+                studioNotices: [],
+                elevenLabsKeyMissingVideos: [],
+                notices: [],
+                plan: null,
+            };
+        }
+        const progressReporter = createUploadProgressReporter(filteredCandidates.map((candidate) => candidate.displayVideoName), verbose);
         // Screenshots from this run render together on one machine; the backend
         // waits for all of them to land before dispatching the batch, so it needs
         // to know how many to expect.
-        const screenshotCount = candidates.filter((candidate) => candidate.data.output === 'screenshot').length;
-        const results = await Promise.all(candidates.map(async (candidate, index) => await uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, credential, verbose, uploadAbort, progressReporter, index, recordId, screenshotCount)));
+        const screenshotCount = filteredCandidates.filter((candidate) => candidate.data.output === 'screenshot').length;
+        const results = await Promise.all(filteredCandidates.map(async (candidate, index) => await uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, credential, verbose, uploadAbort, progressReporter, index, recordId, screenshotCount)));
         firstProjectId =
             results.find((result) => result.projectId !== null)?.projectId ?? null;
         const resolvedPlan = results.find((result) => result.plan !== undefined)?.plan ?? null;
         const hadFailures = results.some((result) => result.hadFailure);
+        const uploadedVideoNames = results
+            .filter((result) => !result.hadFailure)
+            .map((result) => result.videoName);
         const failedVideoNames = results
             .filter((result) => result.hadFailure)
             .map((result) => result.videoName);
@@ -1588,6 +1675,7 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, credent
             projectId: firstProjectId,
             recordId,
             hadFailures,
+            uploadedVideoNames,
             failedVideoNames,
             failedVideoMessages,
             studioNotices,
@@ -1616,6 +1704,35 @@ async function writeGitHubProjectOutput(projectUrl) {
         return;
     await appendFile(githubOutput, `screenci_project_url=${projectUrl}\n`);
 }
+/**
+ * The builder titles each per-language Playwright test `${videoName} [${lang}]`
+ * (src/builder.ts) so every language pass has a unique test title, while the
+ * shared grouping key it writes to `metadata.videoName` carries NO language
+ * suffix. `screenci record` discovers the videos to expect by their test titles,
+ * but the uploader matches those against each recording's `metadata.videoName`.
+ * Strip the trailing ` [<lang>]` so the requested name matches the recorded one;
+ * otherwise a language-decorated title never matches and every upload reports
+ * "No recorded output found". Only a language-code-shaped bracket is stripped, so
+ * an unrelated trailing bracket in a video name is left intact.
+ */
+export function stripTestTitleLanguageSuffix(title) {
+    // Language codes are lowercase (ISO 639: en, es, zh, ...), with an optional
+    // region subtag (pt-BR). Requiring lowercase avoids stripping unrelated
+    // capitalized brackets like ` [New]`.
+    return title.replace(/ \[[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})?\]$/, '');
+}
+async function collectRequestedRecordVideoNames(configPath, additionalArgs, languages) {
+    const envForDiscovery = {
+        ...process.env,
+        SCREENCI_CONFIG_DIR: dirname(configPath),
+        SCREENCI_RECORDING: 'true',
+        ...(languages ? { [SCREENCI_LANGUAGES_ENV]: languages } : {}),
+    };
+    const titles = await collectDiscoveredTestTitles(configPath, additionalArgs, envForDiscovery);
+    // Requested names are matched against `metadata.videoName` (no language
+    // suffix), so recover the videoName from each per-language test title.
+    return [...new Set(titles.map(stripTestTitleLanguageSuffix))];
+}
 async function loadScreenCIConfigAndEnv(configPath) {
     const resolvedConfigPath = resolveScreenCIConfigPathOrExit(configPath);
     let screenciConfig;
@@ -1938,6 +2055,134 @@ async function triggerRemoteRun(configPath, grep, languages) {
         ? `Triggered the remote recording workflow for "${screenciConfig.projectName}" (${filters.join(', ')}).`
         : `Triggered the remote recording workflow for "${screenciConfig.projectName}".`);
 }
+function getRecordRunLockPath(screenciDir) {
+    return resolve(screenciDir, SCREENCI_RECORD_LOCK_FILE);
+}
+function defaultIsPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ESRCH') {
+            return false;
+        }
+        return true;
+    }
+}
+function parseRecordRunLock(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.pid === 'number' &&
+            Number.isInteger(parsed.pid) &&
+            parsed.pid > 0 &&
+            typeof parsed.startedAt === 'string' &&
+            parsed.startedAt.length > 0 &&
+            typeof parsed.projectName === 'string' &&
+            parsed.projectName.length > 0
+            ? {
+                pid: parsed.pid,
+                startedAt: parsed.startedAt,
+                projectName: parsed.projectName,
+            }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecordRunLockStale(lock, now, isPidAlive, maxAgeMs) {
+    const startedAtMs = Date.parse(lock.startedAt);
+    if (Number.isNaN(startedAtMs))
+        return true;
+    if (now.getTime() - startedAtMs > maxAgeMs)
+        return true;
+    return !isPidAlive(lock.pid);
+}
+function formatRecordRunLockError(lock) {
+    return `Another 'screenci record' is in progress (pid ${lock.pid}, started ${lock.startedAt}, project "${lock.projectName}"). Wait for it or remove .screenci/.record.lock.`;
+}
+export async function acquireRecordRunLock(screenciDir, projectName, deps = {}) {
+    const resolvedDeps = {
+        fs: deps.fs ?? { mkdir, readFile, writeFile, rm },
+        clock: deps.clock ?? (() => new Date()),
+        isPidAlive: deps.isPidAlive ?? defaultIsPidAlive,
+        pid: deps.pid ?? process.pid,
+        addSignalListener: deps.addSignalListener ?? process.on.bind(process),
+        removeSignalListener: deps.removeSignalListener ?? process.off.bind(process),
+        removeLockSync: deps.removeLockSync ??
+            ((lockPath) => {
+                rmSync(lockPath, { force: true });
+            }),
+        maxAgeMs: deps.maxAgeMs ?? SCREENCI_RECORD_LOCK_MAX_AGE_MS,
+    };
+    const lockPath = getRecordRunLockPath(screenciDir);
+    const lock = {
+        pid: resolvedDeps.pid,
+        startedAt: resolvedDeps.clock().toISOString(),
+        projectName,
+    };
+    await resolvedDeps.fs.mkdir(screenciDir, { recursive: true });
+    for (;;) {
+        try {
+            await resolvedDeps.fs.writeFile(lockPath, `${JSON.stringify(lock, null, 2)}\n`, { flag: 'wx' });
+            break;
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                !('code' in error) ||
+                error.code !== 'EEXIST') {
+                throw error;
+            }
+            let existingLock = null;
+            try {
+                existingLock = parseRecordRunLock(await resolvedDeps.fs.readFile(lockPath, 'utf-8'));
+            }
+            catch {
+                existingLock = null;
+            }
+            if (existingLock !== null &&
+                !isRecordRunLockStale(existingLock, resolvedDeps.clock(), resolvedDeps.isPidAlive, resolvedDeps.maxAgeMs)) {
+                throw new Error(formatRecordRunLockError(existingLock));
+            }
+            await resolvedDeps.fs.rm(lockPath, { force: true });
+        }
+    }
+    let released = false;
+    const removeLockSync = () => {
+        if (released)
+            return;
+        released = true;
+        resolvedDeps.removeSignalListener('SIGINT', handleSigint);
+        resolvedDeps.removeSignalListener('SIGTERM', handleSigterm);
+        try {
+            resolvedDeps.removeLockSync(lockPath);
+        }
+        catch {
+            // best-effort during signal shutdown
+        }
+    };
+    const release = async () => {
+        if (released)
+            return;
+        released = true;
+        resolvedDeps.removeSignalListener('SIGINT', handleSigint);
+        resolvedDeps.removeSignalListener('SIGTERM', handleSigterm);
+        try {
+            await resolvedDeps.fs.rm(lockPath, { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    };
+    const handleSigint = () => removeLockSync();
+    const handleSigterm = () => removeLockSync();
+    resolvedDeps.addSignalListener('SIGINT', handleSigint);
+    resolvedDeps.addSignalListener('SIGTERM', handleSigterm);
+    return { release };
+}
 function getLastRecordFilePath(screenciDir) {
     return resolve(screenciDir, SCREENCI_LAST_RECORD_FILE);
 }
@@ -2043,14 +2288,18 @@ export async function ensureAnonRecordingAllowedOrExit(screenciDir, apiUrl, appU
         // upload. Skip a `claimed` session: that user already accepted the
         // versioned Terms when they signed up (the upload path self-upgrades).
         if (status.status !== 'claimed') {
-            logger.info(pc.cyan(formatAnonTermsNotice()));
+            logger.info(formatAnonTermsNotice());
         }
         return;
     }
     const intro = gate.reason === 'expired'
         ? 'Your free ScreenCI trial has expired.'
-        : "You've already used your one free ScreenCI trial recording.";
+        : "You've used all your free ScreenCI trial recordings.";
+    const previousRecordUrl = gate.reason === 'used' ? await readAnonSessionRecordUrl(screenciDir) : null;
     logger.error(`${intro}\n` +
+        (previousRecordUrl
+            ? `Previous recording: ${pc.cyan(previousRecordUrl)}\n`
+            : '') +
         `Sign up to keep recording (no watermark, no limits): ${pc.cyan(appUrl)}\n` +
         'After signing up, re-run this command in the same folder and it links automatically.');
     process.exit(1);
@@ -2060,7 +2309,7 @@ export async function ensureAnonRecordingAllowedOrExit(screenciDir, apiUrl, appU
 // re-sends the existing recordings without re-running Playwright). A non-null
 // `playwrightFailure` means the preceding record run had failures, which tunes
 // the messaging and the upload policy; `retry` always passes null.
-async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verbose) {
+async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verbose, requestedVideoNames) {
     // After recording, upload results to API if configured. `run` already
     // resolved the config (or exited), so this best-effort lookup only acts
     // when a flat config is present in/under the current directory.
@@ -2098,6 +2347,7 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
                 projectId: null,
                 recordId: null,
                 hadFailures: false,
+                uploadedVideoNames: [],
                 failedVideoNames: [],
                 failedVideoMessages: [],
                 studioNotices: [],
@@ -2106,7 +2356,7 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
                 plan: null,
             };
             try {
-                uploadResult = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, credential, undefined, verbose);
+                uploadResult = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, credential, undefined, verbose, requestedVideoNames);
             }
             catch (err) {
                 if (isUploadCancelledError(err)) {
@@ -2114,9 +2364,12 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
                 }
                 throw err;
             }
-            const { projectId, recordId, hadFailures, failedVideoNames, failedVideoMessages, studioNotices, elevenLabsKeyMissingVideos, notices, plan, } = uploadResult;
+            const { projectId, recordId, hadFailures, uploadedVideoNames, failedVideoNames, failedVideoMessages, studioNotices, elevenLabsKeyMissingVideos, notices, plan, } = uploadResult;
+            const requestedUploadSucceeded = !hadFailures &&
+                (requestedVideoNames === undefined ||
+                    requestedVideoNames.every((videoName) => uploadedVideoNames.includes(videoName)));
             // Remember this run so `screenci info` can report exactly it.
-            if (recordId !== null) {
+            if (recordId !== null && requestedUploadSucceeded) {
                 await saveLastRecordId(screenciDir, recordId);
             }
             // Emit upload-failure warnings (stderr) before the results block.
@@ -2126,13 +2379,15 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
             // it from its URL. Reporting failures first keeps the URL directly
             // under its message.
             if (hadFailures) {
-                for (const failedVideo of failedVideoMessages) {
-                    logger.warn(formatFailedVideoMessage(failedVideo.videoName, failedVideo.message));
+                for (const warning of collapseFailedVideoWarnings(failedVideoMessages)) {
+                    logger.warn(warning);
                 }
-                logger.warn(`Not all recordings succeeded to upload. Failed videos: ${failedVideoNames.join(', ') || 'unknown'}. Some videos may be missing from the project.`);
+                logger.warn(`Not all recordings succeeded to upload. Failed videos: ${formatFailedVideoNamesSummary(failedVideoNames)}. Some videos may be missing from the project.`);
             }
-            if (recordId !== null && projectId !== null) {
+            let resultUrl = null;
+            if (requestedUploadSucceeded && recordId !== null && projectId !== null) {
                 const recordUrl = `${appUrl}/record/${recordId}`;
+                resultUrl = recordUrl;
                 await writeGitHubProjectOutput(recordUrl);
                 logger.info('');
                 logger.info(playwrightFailure !== null
@@ -2140,8 +2395,9 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
                     : 'Recording finished, rendering in progress. Results available at:');
                 logger.info(pc.cyan(recordUrl));
             }
-            else if (projectId !== null) {
+            else if (requestedUploadSucceeded && projectId !== null) {
                 const projectUrl = `${appUrl}/project/${projectId}`;
+                resultUrl = projectUrl;
                 await writeGitHubProjectOutput(projectUrl);
                 logger.info('');
                 logger.info(playwrightFailure !== null
@@ -2149,8 +2405,25 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
                     : 'Recording finished, rendering in progress. Results available at:');
                 logger.info(pc.cyan(projectUrl));
             }
-            if (usedAnonCredential && (recordId !== null || projectId !== null)) {
-                logger.info(`Recorded without an account. Open the link above to view it, and sign up to keep it (by continuing you agree to the Terms: ${SCREENCI_TERMS_URL}).`);
+            if (usedAnonCredential && resultUrl !== null) {
+                try {
+                    await saveAnonSessionRecordUrl(screenciDir, credential.value, resultUrl);
+                }
+                catch (err) {
+                    logger.warn(`Failed to remember anonymous recording URL: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                // Report how many trial recordings remain after this run. Best-effort:
+                // checkAnonSessionStatus never throws (it falls back on failure), so a
+                // transient outage just shows the optimistic remaining count.
+                const postStatus = await checkAnonSessionStatus(credential.value, {
+                    backendUrl: apiUrl,
+                });
+                if (postStatus.status === 'pending') {
+                    logger.info(formatAnonPostRecordNotice(postStatus.remaining));
+                }
+                else {
+                    logger.info(`Recorded without an account. Sign up to keep it.`);
+                }
             }
             if (notices.length > 0) {
                 logger.info('');
@@ -2158,14 +2431,9 @@ async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verb
                     logger.notice(notice);
                 }
             }
-            if (projectId !== null && plan !== 'business') {
+            if (projectId !== null && plan === 'starter') {
                 logger.info('');
-                if (plan === 'free') {
-                    logger.info('You are on the free tier, so this render includes a ScreenCI watermark. Upgrade to remove it and get more renders, more active videos, and expressive narration:');
-                }
-                else {
-                    logger.info('Upgrade for more renders, more active videos, and expressive narration:');
-                }
+                logger.info('Upgrade for more renders, more active videos, and expressive narration:');
                 logger.info(pc.cyan(`${appUrl}/select-plan`));
             }
             for (const notice of studioNotices) {
@@ -2229,35 +2497,49 @@ export async function main() {
             await triggerRemoteRun(parsed.configPath, extractGrep(parsed.otherArgs), parsed.languages);
             return;
         }
-        let playwrightFailure = null;
-        // UPLOAD_EXISTING re-sends the recordings already on disk under `.screenci`
-        // without re-running Playwright (resend the last local run when only the
-        // upload failed). We skip the recording run and fall straight through to
-        // the upload below, treating the on-disk recordings as the complete set.
-        const uploadExisting = isUploadExistingEnabled();
-        if (!uploadExisting) {
-            try {
-                await run('record', parsed.otherArgs, parsed.configPath, parsed.verbose, false, parsed.languages);
-            }
-            catch (error) {
-                if (!(error instanceof Error))
-                    throw error;
-                if (error.message.startsWith('Playwright exited with code ')) {
-                    playwrightFailure = new RecordFailureHintError(error);
+        validateArgs(parsed.otherArgs);
+        const resolvedConfigPath = resolveScreenCIConfigPathOrExit(parsed.configPath);
+        await loadEnvFileFromConfigSource(resolvedConfigPath, false);
+        const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
+        const screenciDir = resolve(dirname(resolvedConfigPath), '.screenci');
+        const requestedVideoNames = parsed.otherArgs.length > 0 || parsed.languages !== undefined
+            ? await collectRequestedRecordVideoNames(resolvedConfigPath, parsed.otherArgs, parsed.languages)
+            : undefined;
+        const recordRunLock = await acquireRecordRunLock(screenciDir, screenciConfig.projectName);
+        try {
+            let playwrightFailure = null;
+            // UPLOAD_EXISTING re-sends the recordings already on disk under `.screenci`
+            // without re-running Playwright (resend the last local run when only the
+            // upload failed). We skip the recording run and fall straight through to
+            // the upload below, treating the on-disk recordings as the complete set.
+            const uploadExisting = isUploadExistingEnabled();
+            if (!uploadExisting) {
+                try {
+                    await run('record', parsed.otherArgs, parsed.configPath, parsed.verbose, false, parsed.languages);
                 }
-                else {
-                    throw new RecordFailureHintError(error);
+                catch (error) {
+                    if (!(error instanceof Error))
+                        throw error;
+                    if (error.message.startsWith('Playwright exited with code ')) {
+                        playwrightFailure = new RecordFailureHintError(error);
+                    }
+                    else {
+                        throw new RecordFailureHintError(error);
+                    }
                 }
             }
+            else {
+                logger.info('UPLOAD_EXISTING set: skipping Playwright recording and re-uploading existing .screenci recordings.');
+            }
+            if (process.env.SCREENCI_RECORDING === 'true')
+                return;
+            await uploadRecordedVideosForConfig(parsed.configPath, playwrightFailure, parsed.verbose, requestedVideoNames);
+            if (playwrightFailure !== null) {
+                throw playwrightFailure;
+            }
         }
-        else {
-            logger.info('UPLOAD_EXISTING set: skipping Playwright recording and re-uploading existing .screenci recordings.');
-        }
-        if (process.env.SCREENCI_RECORDING === 'true')
-            return;
-        await uploadRecordedVideosForConfig(parsed.configPath, playwrightFailure, parsed.verbose);
-        if (playwrightFailure !== null) {
-            throw playwrightFailure;
+        finally {
+            await recordRunLock.release();
         }
     });
     program