screenci 0.0.61 → 0.0.63

package/dist/cli.js

@@ -1,12 +1,11 @@
 import { spawn } from 'child_process';
 import { createReadStream } from 'fs';
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, } from 'fs';
-import { createHash } from 'crypto';
-import { createServer } from 'http';
+import { createHash, randomUUID } from 'crypto';
+import { createRequire } from 'module';
 import { appendFile, readdir, readFile, stat, writeFile } from 'fs/promises';
 import { delimiter, dirname, relative as pathRelative, resolve } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { confirm } from '@inquirer/prompts';
 import { Command, CommanderError } from 'commander';
 import pc from 'picocolors';
 import { logger } from './src/logger.js';
@@ -15,8 +14,28 @@ import { SCREENCI_DISABLE_RECORDING_TIMINGS_ENV, SCREENCI_MOCK_RECORD_ENV, } fro
 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';
-const SCREENCI_LOGIN_DOCS_URL = 'https://screenci.com/docs/reference/cli/#screenci-login';
-const SCREENCI_SECRETS_URL = 'https://app.screenci.com/secrets';
+const SCREENCI_RECORD_DOCS_URL = 'https://screenci.com/docs/reference/cli/#screenci-record';
+const SCREENCI_ENVIRONMENT_VARIABLE = 'SCREENCI_ENVIRONMENT';
+const SCREENCI_ENVIRONMENT_OPTION_VALUES = ['local', 'dev', 'prod'];
+const SCREENCI_PRODUCTION_BACKEND_URL = 'https://api.screenci.com';
+const SCREENCI_PRODUCTION_FRONTEND_URL = 'https://app.screenci.com';
+const SCREENCI_DEVELOPMENT_BACKEND_URL = 'https://dev.api.screenci.com';
+const SCREENCI_DEVELOPMENT_FRONTEND_URL = 'https://dev.app.screenci.com';
+const SCREENCI_LINK_SESSION_FILE = 'link-session.json';
+const SCREENCI_LINK_SESSION_POLL_INTERVAL_MS = 2_000;
+const require = createRequire(import.meta.url);
+function parseScreenCIEnvironment(value) {
+    if (value === undefined)
+        return undefined;
+    if (SCREENCI_ENVIRONMENT_OPTION_VALUES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid ${SCREENCI_ENVIRONMENT_VARIABLE} "${value}". Expected one of: ${SCREENCI_ENVIRONMENT_OPTION_VALUES.join(', ')}`);
+}
+function getScreenCIEnvironment() {
+    const parsed = parseScreenCIEnvironment(process.env[SCREENCI_ENVIRONMENT_VARIABLE]);
+    return parsed ?? 'prod';
+}
 export function collectPlaywrightListTitles(suites) {
     const titles = [];
     const visitSuite = (suite) => {
@@ -51,12 +70,15 @@ function extractPlaywrightDiscoveryError(output) {
     }
 }
 function logScreenCISecretGuide() {
-    logger.info(`Guide: ${pc.cyan(SCREENCI_LOGIN_DOCS_URL)}`);
+    logger.info(`Guide: ${pc.cyan(SCREENCI_RECORD_DOCS_URL)}`);
 }
 function getSuggestedScreenciCommand(command) {
-    return determinePackageManager() === 'pnpm'
-        ? `pnpm exec screenci ${command}`
-        : `npx screenci ${command}`;
+    const pm = determinePackageManager();
+    if (pm === 'pnpm')
+        return `pnpm exec screenci ${command}`;
+    if (pm === 'yarn')
+        return `yarn screenci ${command}`;
+    return `npx screenci ${command}`;
 }
 async function collectDiscoveredTestTitles(configPath, additionalArgs, env) {
     const listArgs = [
@@ -67,7 +89,7 @@ async function collectDiscoveredTestTitles(configPath, additionalArgs, env) {
         '--list',
         '--reporter=json',
     ];
-    const spawnSpec = resolveSpawnSpec('playwright', listArgs);
+    const spawnSpec = resolvePlaywrightSpawnSpec(listArgs, dirname(configPath));
     return await new Promise((resolve, reject) => {
         const child = spawn(spawnSpec.command, spawnSpec.args, {
             stdio: ['inherit', 'pipe', 'pipe'],
@@ -178,6 +200,28 @@ function contentTypeForPath(filePath) {
     };
     return contentTypeMap[ext] ?? 'application/octet-stream';
 }
+/**
+ * One-line summary of Studio overrides for CLI output, e.g.
+ * `recording.size (1 → 0.8), narration "intro" (en)`.
+ */
+export function formatStudioChangeSummary(changes) {
+    return changes
+        .map((change) => {
+        const label = change.label ?? 'selection';
+        if (change.kind === 'narration') {
+            return change.language !== undefined
+                ? `${label} (${change.language})`
+                : label;
+        }
+        return change.from !== undefined && change.to !== undefined
+            ? `${label} (${change.from} → ${change.to})`
+            : label;
+    })
+        .join(', ');
+}
+export function formatStudioUrl(appUrl, projectId, videoId) {
+    return `${appUrl}/project/${projectId}/video/${videoId}/studio`;
+}
 class UploadAssetError extends Error {
     constructor(message) {
         super(message);
@@ -196,6 +240,14 @@ class PartialUploadError extends Error {
         this.name = 'PartialUploadError';
     }
 }
+class RecordFailureHintError extends Error {
+    cause;
+    constructor(cause) {
+        super(cause.message);
+        this.name = cause.name;
+        this.cause = cause;
+    }
+}
 function isUploadCancelledError(err) {
     return (err instanceof UploadCancelledError ||
         (err instanceof Error &&
@@ -204,12 +256,12 @@ function isUploadCancelledError(err) {
 function isPartialUploadError(err) {
     return err instanceof PartialUploadError;
 }
+function isRecordFailureHintError(err) {
+    return err instanceof RecordFailureHintError;
+}
 function isUploadAssetError(err) {
     return err instanceof UploadAssetError;
 }
-function supportsInPlaceUploadUpdates(verbose) {
-    return !verbose && process.stdout.isTTY === true && !process.env.CI;
-}
 function formatUploadProgressLine(videoName, status) {
     switch (status) {
         case undefined:
@@ -226,41 +278,13 @@ function formatUploadProgressLine(videoName, status) {
         }
     }
 }
-function createUploadProgressReporter(videoNames, verbose) {
-    const useInPlaceUpdates = supportsInPlaceUploadUpdates(verbose);
-    if (!useInPlaceUpdates) {
-        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();
+function createUploadProgressReporter(videoNames, _verbose) {
     return {
         complete(index, status) {
-            statuses[index] = status;
-            render();
+            logger.info(formatUploadProgressLine(videoNames[index] ?? 'unknown', status));
         },
         info(message) {
-            clear();
             logger.info(message);
-            render();
         },
     };
 }
@@ -302,9 +326,10 @@ async function loadUploadCandidate(screenciDir, entry, verbose) {
         preparedUploadAssets,
     };
 }
-async function uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, verbose, uploadAbort, progressReporter, progressIndex) {
+async function uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, elevenLabsApiKey, verbose, uploadAbort, progressReporter, progressIndex, recordId) {
     const { entry, videoName, data, preparedUploadAssets } = candidate;
     let projectId = null;
+    let videoId = null;
     try {
         uploadAbort.throwIfAborted();
         const recordingPath = resolve(screenciDir, entry, 'recording.mp4');
@@ -312,9 +337,11 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             progressReporter.complete(progressIndex, 'failure');
             return {
                 projectId: null,
+                videoId: null,
                 hadFailure: true,
                 videoName,
                 failureMessage: `Missing recording.mp4 for "${videoName}"`,
+                recordId,
             };
         }
         const recordingHash = await hashFile(recordingPath);
@@ -323,12 +350,16 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             headers: {
                 'Content-Type': 'application/json',
                 'X-ScreenCI-Secret': secret,
+                ...(elevenLabsApiKey
+                    ? { 'X-ElevenLabs-Api-Key': elevenLabsApiKey }
+                    : {}),
             },
             body: JSON.stringify({
                 projectName,
                 videoName,
                 data,
                 recordingHash,
+                recordId,
                 expectedAssets: preparedUploadAssets.map((asset) => ({
                     fileHash: asset.fileHash,
                     size: asset.size,
@@ -346,14 +377,18 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             progressReporter.complete(progressIndex, 'failure');
             return {
                 projectId: null,
+                videoId: null,
                 hadFailure: true,
                 videoName,
                 failureMessage: formatUploadStartFailureMessage(videoName, startResponse.status, text, secret),
+                recordId,
             };
         }
         const startBody = (await startResponse.json());
         const { recordingId } = startBody;
         projectId = startBody.projectId;
+        videoId = startBody.videoId ?? null;
+        const studio = startBody.studio;
         if (verbose) {
             logger.info(`recordingId=${recordingId} projectId=${projectId}`);
             logger.info(`assets=${preparedUploadAssets.length} recordingHash=${recordingHash ?? 'none'}`);
@@ -378,6 +413,9 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                     'Content-Type': 'video/mp4',
                     'Content-Length': String(fileStat.size),
                     'X-ScreenCI-Secret': secret,
+                    ...(elevenLabsApiKey
+                        ? { 'X-ElevenLabs-Api-Key': elevenLabsApiKey }
+                        : {}),
                 },
                 body: stream,
                 signal: uploadAbort.signal,
@@ -389,9 +427,11 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 progressReporter.complete(progressIndex, 'failure');
                 return {
                     projectId,
+                    videoId,
                     hadFailure: true,
                     videoName,
                     failureMessage: `Failed to upload recording for "${videoName}": ${recordingResponse.status} ${text}${hint401(recordingResponse.status, secret)}`,
+                    recordId,
                 };
             }
         }
@@ -400,7 +440,14 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
         }
         progressReporter.complete(progressIndex, 'success');
         cleanupUploadedRecordingDir(screenciDir, entry);
-        return { projectId, hadFailure: false, videoName };
+        return {
+            projectId,
+            videoId,
+            hadFailure: false,
+            videoName,
+            recordId,
+            ...(studio !== undefined && { studio }),
+        };
     }
     catch (err) {
         if (isUploadCancelledError(err)) {
@@ -411,17 +458,21 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             progressReporter.complete(progressIndex, 'failure');
             return {
                 projectId,
+                videoId,
                 hadFailure: true,
                 videoName,
                 failureMessage: err instanceof Error ? err.message : String(err),
+                recordId,
             };
         }
         progressReporter.complete(progressIndex, 'failure');
         return {
             projectId,
+            videoId,
             hadFailure: true,
             videoName,
             failureMessage: `Network error uploading "${videoName}": ${err instanceof Error ? err.message : String(err)}`,
+            recordId,
         };
     }
 }
@@ -524,6 +575,15 @@ function resolveWindowsCmdShim(cmd) {
     }
     return shimName;
 }
+function resolvePlaywrightSpawnSpec(args, searchFrom) {
+    const cliEntrypoint = require.resolve('@playwright/test/cli', {
+        paths: [searchFrom],
+    });
+    return {
+        command: process.execPath,
+        args: [cliEntrypoint, ...args],
+    };
+}
 function forwardChildSignals(child, activityLabel, options = {}) {
     let forwardedSignal = null;
     let forceKillTimer = null;
@@ -591,9 +651,11 @@ function forwardChildSignals(child, activityLabel, options = {}) {
         getForwardedSignal: () => forwardedSignal,
     };
 }
-function clearDirectory(dir) {
+function clearRecordingDirectories(dir) {
     mkdirSync(dir, { recursive: true });
     for (const entry of readdirSync(dir)) {
+        if (entry === SCREENCI_LINK_SESSION_FILE)
+            continue;
         rmSync(resolve(dir, entry), { recursive: true, force: true });
     }
 }
@@ -689,11 +751,15 @@ async function prepareCustomVoiceAssets(data, configDir) {
     }
     return preparedAssets;
 }
-async function collectUploadAssets(data, configDir) {
+export async function collectUploadAssets(data, configDir) {
     const sourceFilePath = data.metadata?.sourceFilePath;
     const assets = new Map();
     for (const event of data.events) {
         if (event.type === 'assetStart') {
+            // Studio assets have no local file — they are uploaded from the Studio
+            // page and merged into the recording by the backend.
+            if ('studio' in event && event.studio === true)
+                continue;
             if (assets.has(`name:${event.name}`))
                 continue;
             const resolvedFile = await readRecordingFile(event.path, configDir, sourceFilePath);
@@ -949,6 +1015,7 @@ async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIf
 }
 export async function uploadRecordings(screenciDir, projectName, apiUrl, secret, specificEntry, verbose = false) {
     const uploadAbort = createUploadAbortController('upload');
+    const recordId = randomUUID();
     let entries;
     try {
         entries = await readdir(screenciDir);
@@ -957,15 +1024,18 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
         logger.warn('No .screenci directory found, skipping upload');
         return {
             projectId: null,
+            recordId: null,
             hadFailures: false,
             failedVideoNames: [],
             failedVideoMessages: [],
+            studioNotices: [],
         };
     }
     if (specificEntry !== undefined) {
         entries = entries.filter((e) => e === specificEntry);
     }
     let firstProjectId = null;
+    const elevenLabsApiKey = process.env.ELEVENLABS_API_KEY?.trim() || undefined;
     try {
         const candidates = (await Promise.all(entries.map(async (entry) => {
             uploadAbort.throwIfAborted();
@@ -974,13 +1044,15 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
         if (candidates.length === 0) {
             return {
                 projectId: null,
+                recordId: null,
                 hadFailures: false,
                 failedVideoNames: [],
                 failedVideoMessages: [],
+                studioNotices: [],
             };
         }
         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)));
+        const results = await Promise.all(candidates.map(async (candidate, index) => await uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, elevenLabsApiKey, verbose, uploadAbort, progressReporter, index, recordId)));
         firstProjectId =
             results.find((result) => result.projectId !== null)?.projectId ?? null;
         const hadFailures = results.some((result) => result.hadFailure);
@@ -990,11 +1062,22 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
         const failedVideoMessages = results.flatMap((result) => result.hadFailure && typeof result.failureMessage === 'string'
             ? [{ videoName: result.videoName, message: result.failureMessage }]
             : []);
+        const studioNotices = results.flatMap((result) => !result.hadFailure && result.studio !== undefined
+            ? [
+                {
+                    videoName: result.videoName,
+                    videoId: result.videoId,
+                    studio: result.studio,
+                },
+            ]
+            : []);
         return {
             projectId: firstProjectId,
+            recordId,
             hadFailures,
             failedVideoNames,
             failedVideoMessages,
+            studioNotices,
         };
     }
     finally {
@@ -1012,16 +1095,38 @@ async function countCompletedRecordings(screenciDir) {
     return entries.filter((entry) => existsSync(resolve(screenciDir, entry, 'data.json'))).length;
 }
 export function getDevBackendUrl() {
-    const devBackendPort = process.env.DEV_BACKEND_PORT;
-    return devBackendPort
-        ? `http://localhost:${devBackendPort}`
-        : 'https://api.screenci.com';
+    switch (getScreenCIEnvironment()) {
+        case 'local': {
+            const devBackendPort = process.env.DEV_BACKEND_PORT;
+            return devBackendPort
+                ? `http://localhost:${devBackendPort}`
+                : 'http://localhost:8787';
+        }
+        case 'dev':
+            return SCREENCI_DEVELOPMENT_BACKEND_URL;
+        case 'prod':
+            return SCREENCI_PRODUCTION_BACKEND_URL;
+    }
 }
 export function getDevFrontendUrl() {
-    const devFrontendPort = process.env.DEV_FRONTEND_PORT;
-    return devFrontendPort
-        ? `http://localhost:${devFrontendPort}`
-        : 'https://app.screenci.com';
+    switch (getScreenCIEnvironment()) {
+        case 'local': {
+            const devFrontendPort = process.env.DEV_FRONTEND_PORT;
+            return devFrontendPort
+                ? `http://localhost:${devFrontendPort}`
+                : 'http://localhost:5173';
+        }
+        case 'dev':
+            return SCREENCI_DEVELOPMENT_FRONTEND_URL;
+        case 'prod':
+            return SCREENCI_PRODUCTION_FRONTEND_URL;
+    }
+}
+export function getCliLinkSessionApiUrl() {
+    return getDevFrontendUrl();
+}
+function getScreenCISecretsUrl() {
+    return `${getDevFrontendUrl()}/secrets`;
 }
 async function writeGitHubProjectOutput(projectUrl) {
     const githubOutput = process.env.GITHUB_OUTPUT;
@@ -1231,10 +1336,11 @@ async function loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath) {
 }
 async function requireScreenCISecret(configPath) {
     const { resolvedConfigPath, screenciConfig } = await loadScreenCIConfigAndEnv(configPath);
-    const secret = process.env.SCREENCI_SECRET;
+    const secret = process.env.SCREENCI_SECRET ??
+        (await ensureScreenciSecret(resolvedConfigPath));
     if (!secret) {
         const envFilePath = await resolveProjectEnvFilePath(resolvedConfigPath);
-        logger.error(`No SCREENCI_SECRET configured. Run ${pc.cyan(getSuggestedScreenciCommand('login'))} or add SCREENCI_SECRET manually to ${envFilePath} by following the guide at ${pc.cyan(SCREENCI_LOGIN_DOCS_URL)}.`);
+        logger.error(`No SCREENCI_SECRET configured. Rerun ${pc.cyan(getSuggestedScreenciCommand('record'))} or add SCREENCI_SECRET manually to ${envFilePath} by following the guide at ${pc.cyan(SCREENCI_RECORD_DOCS_URL)}.`);
         process.exit(1);
     }
     return {
@@ -1278,29 +1384,6 @@ async function updateVideoVisibility(videoId, isPublic, configPath) {
     }
     logger.info(`${isPublic ? 'Made public' : 'Made private'}: ${videoId}`);
 }
-function openBrowser(url) {
-    try {
-        if (process.platform === 'win32') {
-            spawn('cmd', ['/c', 'start', '', url], {
-                detached: true,
-                stdio: 'ignore',
-                shell: true,
-            }).unref();
-            return;
-        }
-        const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
-        spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
-    }
-    catch (err) {
-        logger.warn('Failed to open browser automatically:', err);
-    }
-}
-async function promptToOpenLoginUrlWithSignal(signal) {
-    return await confirm({
-        message: 'Open this link in your browser now?',
-        default: false,
-    }, { signal });
-}
 async function persistScreenCISecret(envFilePath, secret) {
     const nextLine = `SCREENCI_SECRET=${secret}`;
     try {
@@ -1327,147 +1410,137 @@ async function persistScreenCISecret(envFilePath, secret) {
     }
     await writeFile(envFilePath, `${nextLine}\n`);
 }
-async function performBrowserLogin(appUrl, options) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const promptAbort = new AbortController();
-        const finish = (callback) => {
-            if (settled)
-                return;
-            settled = true;
-            promptAbort.abort();
-            callback();
-        };
-        const server = createServer((req, res) => {
-            try {
-                const reqUrl = new URL(req.url ?? '/', 'http://localhost');
-                const secret = reqUrl.searchParams.get('secret');
-                if (secret) {
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end('<html><body style="font-family:sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0"><p style="font-size:1.2rem">Setup complete! You can close this tab.</p></body></html>');
-                    server.close();
-                    finish(() => resolve(secret));
-                }
-                else {
-                    res.writeHead(400, { 'Content-Type': 'text/html' });
-                    res.end('<html><body style="font-family:sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0"><p style="color:red;font-size:1.2rem">Authentication failed: no secret received. Please try again.</p></body></html>');
-                    server.close();
-                    finish(() => reject(new Error('No secret received in callback')));
-                }
-            }
-            catch (err) {
-                res.writeHead(500);
-                res.end('Internal error');
-                server.close();
-                finish(() => reject(err));
-            }
-        });
-        server.listen(0, '127.0.0.1', () => {
-            const port = server.address().port;
-            const callbackUrl = `http://localhost:${port}/callback`;
-            const loginUrl = `${appUrl}/cli-auth?callback=${encodeURIComponent(callbackUrl)}`;
-            logger.info(`Open this link to log in to ScreenCI:\n${loginUrl}\n`);
-            void (async () => {
-                if (options?.openBrowserImmediately) {
-                    openBrowser(loginUrl);
-                    return;
-                }
-                if (settled)
-                    return;
-                const shouldOpen = await promptToOpenLoginUrlWithSignal(promptAbort.signal);
-                if (settled)
-                    return;
-                if (shouldOpen) {
-                    openBrowser(loginUrl);
-                    return;
-                }
-                logger.info('Browser not opened. Keep this command running and open the link manually to continue.');
-            })().catch((err) => {
-                if (settled)
-                    return;
-                if (err instanceof Error &&
-                    (err.name === 'AbortPromptError' ||
-                        err.name === 'AbortError' ||
-                        err.message === 'Prompt was canceled')) {
-                    return;
-                }
-                server.close();
-                finish(() => reject(err));
-            });
-        });
-        const timeout = setTimeout(() => {
-            server.close();
-            finish(() => reject(new Error('Authentication timed out after 15 minutes')));
-        }, 15 * 60 * 1000);
-        server.on('close', () => clearTimeout(timeout));
+function getLinkSessionFilePath(projectDir) {
+    return resolve(projectDir, '.screenci', SCREENCI_LINK_SESSION_FILE);
+}
+async function readPersistedLinkSessionSpec(specPath) {
+    try {
+        const raw = await readFile(specPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            logger.warn(`Ignoring invalid stored link session at ${specPath}.`);
+            rmSync(specPath, { force: true });
+        }
+        return null;
+    }
+}
+async function writePersistedLinkSessionSpec(specPath, spec) {
+    mkdirSync(dirname(specPath), { recursive: true });
+    await writeFile(specPath, `${JSON.stringify(spec, null, 2)}\n`);
+}
+function deletePersistedLinkSessionSpec(specPath) {
+    rmSync(specPath, { force: true });
+}
+function isStoredLinkSessionReusable(spec, options) {
+    return (spec.environment === options.environment &&
+        spec.envFilePath === options.envFilePath &&
+        spec.resolvedConfigPath === options.resolvedConfigPath &&
+        spec.expiresAt > new Date().toISOString());
+}
+async function createLinkSessionSpec(options) {
+    const response = await fetch(`${options.apiUrl}/cli-link/session`, {
+        method: 'POST',
     });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to create link session: ${response.status} ${text}`);
+    }
+    const body = (await response.json());
+    return {
+        token: body.token,
+        appUrl: `${options.appUrl}/cli-auth?session=${encodeURIComponent(body.token)}`,
+        pollUrl: `${options.apiUrl}/cli-link/session?token=${encodeURIComponent(body.token)}`,
+        createdAt: body.createdAt,
+        expiresAt: body.expiresAt,
+        environment: options.environment,
+        ...(options.resolvedConfigPath
+            ? { resolvedConfigPath: options.resolvedConfigPath }
+            : {}),
+        envFilePath: options.envFilePath,
+    };
+}
+async function pollLinkSession(spec) {
+    for (;;) {
+        const response = await fetch(spec.pollUrl);
+        const body = (await response.json());
+        const status = body.status ?? 'invalid';
+        if (status === 'completed' && body.secret) {
+            return { status, secret: body.secret };
+        }
+        if (status === 'expired' || status === 'consumed' || status === 'invalid') {
+            return { status };
+        }
+        if (new Date().toISOString() >= spec.expiresAt) {
+            return { status: 'expired' };
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, SCREENCI_LINK_SESSION_POLL_INTERVAL_MS));
+    }
 }
 export async function ensureScreenciSecret(resolvedConfigPath) {
     const existingSecret = process.env.SCREENCI_SECRET;
     if (existingSecret)
         return existingSecret;
-    const appUrl = getDevFrontendUrl();
     try {
-        const secret = await performBrowserLogin(appUrl, {
-            openBrowserImmediately: true,
-        });
-        process.env.SCREENCI_SECRET = secret;
-        const savePath = resolvedConfigPath
+        const environment = getScreenCIEnvironment();
+        const apiUrl = getCliLinkSessionApiUrl();
+        const appUrl = getDevFrontendUrl();
+        const envFilePath = resolvedConfigPath
             ? await resolveProjectEnvFilePath(resolvedConfigPath)
             : resolve(process.cwd(), '.env');
-        await persistScreenCISecret(savePath, secret);
-        logger.info(`Successfully saved SCREENCI_SECRET to ${savePath}`);
-        return secret;
+        const projectDir = resolvedConfigPath
+            ? dirname(resolvedConfigPath)
+            : process.cwd();
+        const specPath = getLinkSessionFilePath(projectDir);
+        const linkSessionContext = {
+            environment,
+            envFilePath,
+            ...(resolvedConfigPath ? { resolvedConfigPath } : {}),
+        };
+        for (;;) {
+            const storedSpec = await readPersistedLinkSessionSpec(specPath);
+            const spec = storedSpec &&
+                isStoredLinkSessionReusable(storedSpec, linkSessionContext)
+                ? storedSpec
+                : await createLinkSessionSpec({
+                    apiUrl,
+                    appUrl,
+                    ...linkSessionContext,
+                });
+            if (spec !== storedSpec) {
+                await writePersistedLinkSessionSpec(specPath, spec);
+            }
+            logger.info(`Open this link to sign in and connect the CLI:\n${pc.cyan(spec.appUrl)}\n`);
+            const result = await pollLinkSession(spec);
+            if (result.status === 'completed' && result.secret) {
+                process.env.SCREENCI_SECRET = result.secret;
+                await persistScreenCISecret(envFilePath, result.secret);
+                deletePersistedLinkSessionSpec(specPath);
+                logger.info(`Successfully saved SCREENCI_SECRET to ${envFilePath}`);
+                return result.secret;
+            }
+            deletePersistedLinkSessionSpec(specPath);
+        }
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         logger.warn(`Authentication failed: ${msg}`);
-        logger.info(`You can add SCREENCI_SECRET manually to .env later. Get it from ${SCREENCI_SECRETS_URL}.`);
+        logger.info(`You can add SCREENCI_SECRET manually to ${resolvedConfigPath ? await resolveProjectEnvFilePath(resolvedConfigPath) : '.env'} later. Get it from ${getScreenCISecretsUrl()}.`);
         logScreenCISecretGuide();
         return undefined;
     }
 }
-async function runLogin(configPath, open = false) {
-    const { resolvedConfigPath } = await loadScreenCIConfigAndEnv(configPath);
-    if (process.env.SCREENCI_SECRET) {
-        logger.info('SCREENCI_SECRET is already configured.');
-        return;
-    }
-    const savePath = await resolveProjectEnvFilePath(resolvedConfigPath);
-    const appUrl = getDevFrontendUrl();
-    try {
-        const secret = await performBrowserLogin(appUrl, {
-            openBrowserImmediately: open,
-        });
-        process.env.SCREENCI_SECRET = secret;
-        await persistScreenCISecret(savePath, secret);
-        logger.info(`Successfully saved SCREENCI_SECRET to ${savePath}`);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.warn(`Authentication failed: ${msg}`);
-        logger.info(`You can run ${pc.cyan(getSuggestedScreenciCommand('login'))} again or add SCREENCI_SECRET manually to ${savePath}. Get it from ${SCREENCI_SECRETS_URL}.`);
-        logScreenCISecretGuide();
-    }
-}
 export async function main() {
     if (process.argv.length <= 2) {
         logger.error('Error: No command provided');
-        logger.error('Available commands: login, record, test, info, make-public, make-private, 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();
-    program
-        .command('login')
-        .description('Authenticate and save SCREENCI_SECRET for this project')
-        .option('-c, --config <path>', 'path to screenci.config.ts')
-        .option('--open', 'open the login URL in your browser immediately')
-        .action(async (options) => {
-        await runLogin(options.config, options.open === true);
-    });
     // record command — playwright args pass through as-is
     program
         .command('record [playwrightArgs...]')
@@ -1481,13 +1554,13 @@ export async function main() {
             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;
+            if (!(error instanceof Error))
+                throw error;
+            if (error.message.startsWith('Playwright exited with code ')) {
+                playwrightFailure = new RecordFailureHintError(error);
             }
             else {
-                throw error;
+                throw new RecordFailureHintError(error);
             }
         }
         if (process.env.SCREENCI_RECORDING === 'true')
@@ -1511,7 +1584,7 @@ export async function main() {
                     logger.info('All recordings failed.');
                 }
                 else if (!secret) {
-                    logger.info(`No SCREENCI_SECRET configured for uploads. Run ${getSuggestedScreenciCommand('login')} or add it to the project env file.`);
+                    logger.info(`No SCREENCI_SECRET configured for uploads. Rerun ${getSuggestedScreenciCommand('record')} or add it to the project env file.`);
                 }
                 else if (playwrightFailure !== null &&
                     uploadPolicy === 'all-or-nothing') {
@@ -1523,9 +1596,11 @@ export async function main() {
                     }
                     let uploadResult = {
                         projectId: null,
+                        recordId: null,
                         hadFailures: false,
                         failedVideoNames: [],
                         failedVideoMessages: [],
+                        studioNotices: [],
                     };
                     try {
                         uploadResult = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret);
@@ -1536,8 +1611,17 @@ export async function main() {
                         }
                         throw err;
                     }
-                    const { projectId, hadFailures, failedVideoNames, failedVideoMessages, } = uploadResult;
-                    if (projectId !== null) {
+                    const { projectId, recordId, hadFailures, failedVideoNames, failedVideoMessages, studioNotices, } = uploadResult;
+                    if (recordId !== null && projectId !== null) {
+                        const recordUrl = `${appUrl}/record/${recordId}`;
+                        await writeGitHubProjectOutput(recordUrl);
+                        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(recordUrl));
+                    }
+                    else if (projectId !== null) {
                         const projectUrl = `${appUrl}/project/${projectId}`;
                         await writeGitHubProjectOutput(projectUrl);
                         logger.info('');
@@ -1546,6 +1630,19 @@ export async function main() {
                             : 'Recording finished, rendering in progress. Results available at:');
                         logger.info(pc.cyan(projectUrl));
                     }
+                    for (const notice of studioNotices) {
+                        if ('held' in notice.studio) {
+                            logger.info('');
+                            logger.info(`Rendering for "${notice.videoName}" is on hold — configure it in Studio:`);
+                            if (projectId !== null && notice.videoId !== null) {
+                                logger.info(pc.cyan(formatStudioUrl(appUrl, projectId, notice.videoId)));
+                            }
+                        }
+                        else if (notice.studio.appliedChanges.length > 0) {
+                            logger.info('');
+                            logger.info(`Selections were overridden in Studio for "${notice.videoName}": ${formatStudioChangeSummary(notice.studio.appliedChanges)}`);
+                        }
+                    }
                     if (hadFailures) {
                         for (const failedVideo of failedVideoMessages) {
                             logger.warn(formatFailedVideoMessage(failedVideo.videoName, failedVideo.message));
@@ -1623,7 +1720,7 @@ export async function main() {
         .command('init [name]')
         .description('Initialize a new screenci project')
         .option('--agent <name>', 'target agent for skills install, e.g. opencode. Supported agents: https://github.com/vercel-labs/skills#supported-agents')
-        .option('--package-manager <manager>', `package manager to use: npm or pnpm (default: ${defaultPackageManager})`)
+        .option('--package-manager <manager>', `package manager to use: npm, pnpm, or yarn 2+ (default: ${defaultPackageManager})`)
         .option('-y, --yes', 'accept init defaults')
         .option('-v, --verbose', 'verbose output')
         .action(async (name, options) => {
@@ -1631,7 +1728,7 @@ export async function main() {
         await runInit(name, {
             verbose: options['verbose'] ?? false,
             yes: options['yes'] ?? false,
-            packageManager: parsePackageManager(options['packageManager']),
+            packageManager: parsePackageManager(options['packageManager'], process.env['SCREENCI_INIT_CWD'] ?? process.cwd()),
             ...(agent !== undefined ? { agent } : {}),
         });
     });
@@ -1767,7 +1864,7 @@ async function run(command, additionalArgs, customConfigPath, verbose = false, m
         }
         validateArgs(additionalArgs);
         const screenciDir = resolve(dirname(configPath), '.screenci');
-        clearDirectory(screenciDir);
+        clearRecordingDirectories(screenciDir);
     }
     const envForChild = { ...process.env };
     await validateUniqueDiscoveredTestTitles(configPath, additionalArgs, {
@@ -1785,7 +1882,7 @@ async function run(command, additionalArgs, customConfigPath, verbose = false, m
         logger.info(`Using config: ${configPath}`);
     }
     const playwrightArgs = ['test', '--config', configPath, ...additionalArgs];
-    const spawnSpec = resolveSpawnSpec('playwright', playwrightArgs);
+    const spawnSpec = resolvePlaywrightSpawnSpec(playwrightArgs, dirname(configPath));
     const child = spawn(spawnSpec.command, spawnSpec.args, {
         stdio: 'inherit',
         ...(process.platform !== 'win32' ? { detached: true } : {}),
@@ -1840,9 +1937,21 @@ async function run(command, additionalArgs, customConfigPath, verbose = false, m
     });
 }
 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)}`);
 }
+export function logCliError(error) {
+    if (isPartialUploadError(error)) {
+        return;
+    }
+    const errorToLog = isRecordFailureHintError(error) ? error.cause : error;
+    const message = errorToLog instanceof Error ? errorToLog.message : String(errorToLog);
+    logger.error(message);
+    if (isRecordFailureHintError(error)) {
+        logRecordFailureHint();
+    }
+}
 // 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);
@@ -1853,10 +1962,7 @@ if (mainFile &&
         currentRealFile === mainFile ||
         currentFile === realpathSync(mainFile))) {
     main().catch((error) => {
-        if (isPartialUploadError(error)) {
-            process.exit(1);
-        }
-        logger.error('Error:', error.message);
+        logCliError(error);
         process.exit(1);
     });
 }