screenci 0.0.62 → 0.0.64

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,44 @@ 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';
+}
+/**
+ * Reports whether the current session can complete an interactive browser
+ * sign-in. A session is interactive only when both stdin and stdout are
+ * attached to a terminal and no signal marks the run as automated. This is the
+ * proxy for "a human is present to open the sign-in link" — it does not attempt
+ * to identify any particular caller (CI, a piped shell, or an automated tool).
+ *
+ * Dependency-injected so tests can force a value without a real terminal.
+ */
+export function detectInteractiveSession(env = process.env, stdout = process.stdout, stdin = process.stdin) {
+    if (env.SCREENCI_NONINTERACTIVE === '1')
+        return false;
+    if (env.CI === 'true')
+        return false;
+    return Boolean(stdout.isTTY) && Boolean(stdin.isTTY);
+}
 export function collectPlaywrightListTitles(suites) {
     const titles = [];
     const visitSuite = (suite) => {
@@ -51,7 +86,7 @@ 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) {
     const pm = determinePackageManager();
@@ -70,7 +105,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'],
@@ -181,6 +216,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);
@@ -199,6 +256,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 &&
@@ -207,12 +272,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:
@@ -229,41 +294,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();
         },
     };
 }
@@ -305,9 +342,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');
@@ -315,9 +353,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);
@@ -326,12 +366,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,
@@ -349,14 +393,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'}`);
@@ -381,6 +429,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,
@@ -392,9 +443,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,
                 };
             }
         }
@@ -403,7 +456,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)) {
@@ -414,17 +474,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,
         };
     }
 }
@@ -527,6 +591,32 @@ function resolveWindowsCmdShim(cmd) {
     }
     return shimName;
 }
+function isModuleNotFoundError(error) {
+    return (error instanceof Error &&
+        error.code === 'MODULE_NOT_FOUND');
+}
+function resolvePlaywrightCliEntrypoint(searchFrom) {
+    // Prefer the @playwright/test installed alongside the user's config, since it
+    // is declared as a peer dependency of the project being recorded.
+    try {
+        return require.resolve('@playwright/test/cli', { paths: [searchFrom] });
+    }
+    catch (error) {
+        if (!isModuleNotFoundError(error))
+            throw error;
+    }
+    // Fall back to the copy resolvable from the screenci CLI's own install. This
+    // keeps discovery working when Playwright is hoisted to a parent install or
+    // bundled with the CLI rather than next to the config file.
+    return require.resolve('@playwright/test/cli');
+}
+function resolvePlaywrightSpawnSpec(args, searchFrom) {
+    const cliEntrypoint = resolvePlaywrightCliEntrypoint(searchFrom);
+    return {
+        command: process.execPath,
+        args: [cliEntrypoint, ...args],
+    };
+}
 function forwardChildSignals(child, activityLabel, options = {}) {
     let forwardedSignal = null;
     let forceKillTimer = null;
@@ -594,26 +684,72 @@ 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 });
     }
 }
 function findScreenCIConfig(customPath) {
     if (customPath) {
         const resolvedPath = resolve(process.cwd(), customPath);
-        if (existsSync(resolvedPath)) {
-            return resolvedPath;
+        return existsSync(resolvedPath)
+            ? { kind: 'found', path: resolvedPath }
+            : { kind: 'not-found' };
+    }
+    // Walk up from the current directory looking for a flat `screenci.config.ts`,
+    // which is what's present when the command runs from inside the `screenci/`
+    // island. We deliberately do NOT auto-use a nested
+    // `screenci/screenci.config.ts`: running the CLI from outside the island
+    // resolves the `screenci` binary from the registry (npx download) rather than
+    // the version-pinned island install, so it would silently run a different
+    // version. Instead we detect the island and ask the user to `cd` into it.
+    let current = process.cwd();
+    let islandConfigPath;
+    while (true) {
+        const flatConfig = resolve(current, 'screenci.config.ts');
+        if (existsSync(flatConfig)) {
+            return { kind: 'found', path: flatConfig };
+        }
+        if (islandConfigPath === undefined) {
+            const islandConfig = resolve(current, 'screenci', 'screenci.config.ts');
+            if (existsSync(islandConfig)) {
+                islandConfigPath = islandConfig;
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    if (islandConfigPath !== undefined) {
+        return { kind: 'island-not-entered', islandConfigPath };
+    }
+    return { kind: 'not-found' };
+}
+// Resolve the config path, or log a helpful message and exit. Centralizes the
+// `cd screenci` guidance so every command (test/record/info/...) behaves the
+// same when invoked from outside the island.
+function resolveScreenCIConfigPathOrExit(customPath) {
+    const resolution = findScreenCIConfig(customPath);
+    switch (resolution.kind) {
+        case 'found':
+            return resolution.path;
+        case 'island-not-entered': {
+            const islandDir = dirname(resolution.islandConfigPath);
+            const relDir = pathRelative(process.cwd(), islandDir) || '.';
+            logger.error(`Error: no screenci.config.ts found here, but found ${pc.cyan(`${relDir}/screenci.config.ts`)}. Run ${pc.cyan(`cd ${relDir}`)} and rerun the command from there.`);
+            return process.exit(1);
+        }
+        case 'not-found': {
+            logger.error(customPath
+                ? `Error: Config file not found: ${customPath}`
+                : 'Error: screenci.config.ts not found in the current directory or any parent.');
+            return process.exit(1);
         }
-        return null;
-    }
-    const cwd = process.cwd();
-    const configPath = resolve(cwd, 'screenci.config.ts');
-    if (existsSync(configPath)) {
-        return configPath;
     }
-    return null;
 }
 async function hashFile(filePath) {
     return new Promise((resolveHash, reject) => {
@@ -692,11 +828,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);
@@ -952,6 +1092,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);
@@ -960,15 +1101,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();
@@ -977,13 +1121,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);
@@ -993,11 +1139,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 {
@@ -1015,16 +1172,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;
@@ -1033,14 +1212,7 @@ async function writeGitHubProjectOutput(projectUrl) {
     await appendFile(githubOutput, `screenci_project_url=${projectUrl}\n`);
 }
 async function loadScreenCIConfigAndEnv(configPath) {
-    const resolvedConfigPath = findScreenCIConfig(configPath);
-    if (!resolvedConfigPath) {
-        const errorMsg = configPath
-            ? `Error: Config file not found: ${configPath}`
-            : 'Error: screenci.config.ts not found in current directory';
-        logger.error(errorMsg);
-        process.exit(1);
-    }
+    const resolvedConfigPath = resolveScreenCIConfigPathOrExit(configPath);
     let screenciConfig;
     try {
         screenciConfig =
@@ -1232,12 +1404,18 @@ async function loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath) {
         throw err;
     }
 }
-async function requireScreenCISecret(configPath) {
+async function requireScreenCISecret(configPath, opts = {}) {
     const { resolvedConfigPath, screenciConfig } = await loadScreenCIConfigAndEnv(configPath);
-    const secret = process.env.SCREENCI_SECRET;
+    const secret = process.env.SCREENCI_SECRET ??
+        (await ensureScreenciSecret(resolvedConfigPath, opts));
     if (!secret) {
+        // In a non-interactive session ensureScreenciSecret already printed the
+        // sign-in link and the next step, so we exit without repeating guidance.
+        if (opts.interactive === false) {
+            process.exit(1);
+        }
         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 {
@@ -1248,7 +1426,7 @@ async function requireScreenCISecret(configPath) {
     };
 }
 async function fetchProjectInfo(configPath) {
-    const { screenciConfig, secret, apiUrl } = await requireScreenCISecret(configPath);
+    const { screenciConfig, secret, apiUrl } = await requireScreenCISecret(configPath, { interactive: detectInteractiveSession() });
     const url = new URL(`${apiUrl}/cli/project-info`);
     url.searchParams.set('projectName', screenciConfig.projectName);
     const res = await fetch(url.toString(), {
@@ -1267,7 +1445,9 @@ async function printProjectInfo(configPath) {
     process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
 }
 async function updateVideoVisibility(videoId, isPublic, configPath) {
-    const { secret, apiUrl } = await requireScreenCISecret(configPath);
+    const { secret, apiUrl } = await requireScreenCISecret(configPath, {
+        interactive: detectInteractiveSession(),
+    });
     const method = isPublic ? 'PUT' : 'DELETE';
     const res = await fetch(`${apiUrl}/cli/public-video/${videoId}`, {
         method,
@@ -1281,29 +1461,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 {
@@ -1330,147 +1487,177 @@ 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 pollLinkSessionOnce(spec) {
+    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 === 'pending' && new Date().toISOString() >= spec.expiresAt) {
+        return { status: 'expired' };
+    }
+    return { status };
 }
-export async function ensureScreenciSecret(resolvedConfigPath) {
+async function pollLinkSession(spec) {
+    for (;;) {
+        const result = await pollLinkSessionOnce(spec);
+        if (result.status === 'completed' && result.secret) {
+            return result;
+        }
+        if (result.status === 'expired' ||
+            result.status === 'consumed' ||
+            result.status === 'invalid') {
+            return result;
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, SCREENCI_LINK_SESSION_POLL_INTERVAL_MS));
+    }
+}
+export async function ensureScreenciSecret(resolvedConfigPath, opts = {}) {
+    const interactive = opts.interactive ?? true;
     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 } : {}),
+        };
+        const ensureSpec = async () => {
+            const storedSpec = await readPersistedLinkSessionSpec(specPath);
+            const spec = storedSpec &&
+                isStoredLinkSessionReusable(storedSpec, linkSessionContext)
+                ? storedSpec
+                : await createLinkSessionSpec({
+                    apiUrl,
+                    appUrl,
+                    ...linkSessionContext,
+                });
+            if (spec !== storedSpec) {
+                await writePersistedLinkSessionSpec(specPath, spec);
+            }
+            return spec;
+        };
+        const saveCompletedSecret = async (secret) => {
+            process.env.SCREENCI_SECRET = secret;
+            await persistScreenCISecret(envFilePath, secret);
+            deletePersistedLinkSessionSpec(specPath);
+            logger.info(`Successfully saved SCREENCI_SECRET to ${envFilePath}`);
+            return secret;
+        };
+        if (!interactive) {
+            // Non-interactive sessions cannot complete a browser sign-in here, so we
+            // never block. Reuse or create the persisted session and check its status
+            // once; if a stored session is stale, recreate it and check once more.
+            // When the session is already completed (the sign-in happened between
+            // runs) we pick up the secret; otherwise we print the link and return so
+            // the caller can surface it and rerun later.
+            let spec = await ensureSpec();
+            let result = await pollLinkSessionOnce(spec);
+            if (result.status === 'expired' ||
+                result.status === 'consumed' ||
+                result.status === 'invalid') {
+                deletePersistedLinkSessionSpec(specPath);
+                spec = await ensureSpec();
+                result = await pollLinkSessionOnce(spec);
+            }
+            if (result.status === 'completed' && result.secret) {
+                return await saveCompletedSecret(result.secret);
+            }
+            logger.info(`Sign-in required to record. Open this link to sign in and choose a plan:\n${pc.cyan(spec.appUrl)}\n` +
+                `This session is non-interactive, so sign-in can't complete here. After signing in, rerun ${pc.cyan(getSuggestedScreenciCommand('record'))} to continue.`);
+            return undefined;
+        }
+        for (;;) {
+            const spec = await ensureSpec();
+            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) {
+                return await saveCompletedSecret(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...]')
@@ -1484,20 +1671,23 @@ 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')
             return;
-        // After recording, upload results to API if configured
-        const resolvedConfigPath = findScreenCIConfig(parsed.configPath);
-        if (resolvedConfigPath) {
+        // 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.
+        const resolution = findScreenCIConfig(parsed.configPath);
+        if (resolution.kind === 'found') {
+            const resolvedConfigPath = resolution.path;
             try {
                 const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
                 loadEnvFile(screenciConfig.envFile
@@ -1514,7 +1704,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') {
@@ -1526,9 +1716,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);
@@ -1539,8 +1731,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('');
@@ -1549,6 +1750,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));
@@ -1580,8 +1794,11 @@ export async function main() {
         .action(async () => {
         const parsed = parseConfigCliArgs(getSubcommandArgv('test'));
         let configMockRecord = false;
-        const resolvedConfigPath = findScreenCIConfig(parsed.configPath);
-        if (resolvedConfigPath) {
+        // Best-effort env preload before handing off to `run`, which performs the
+        // authoritative resolution (and emits the `cd screenci` guidance on miss).
+        const resolution = findScreenCIConfig(parsed.configPath);
+        if (resolution.kind === 'found') {
+            const resolvedConfigPath = resolution.path;
             try {
                 const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
                 configMockRecord = screenciConfig.test?.mockRecord ?? false;
@@ -1752,25 +1969,20 @@ function validateArgs(args) {
     }
 }
 async function run(command, additionalArgs, customConfigPath, verbose = false, mockRecord = false) {
-    const configPath = findScreenCIConfig(customConfigPath);
-    if (!configPath) {
-        const errorMsg = customConfigPath
-            ? `Error: Config file not found: ${customConfigPath}`
-            : 'Error: screenci.config.ts not found in current directory';
-        logger.error(errorMsg);
-        process.exit(1);
-    }
+    const configPath = resolveScreenCIConfigPathOrExit(customConfigPath);
     if (command === 'test' || process.env.SCREENCI_RECORDING !== 'true') {
         await loadEnvFileFromConfigSource(configPath, false);
     }
     // Only validate args for record command
     if (command === 'record') {
         if (!process.env.SCREENCI_SECRET) {
-            await requireScreenCISecret(configPath);
+            await requireScreenCISecret(configPath, {
+                interactive: detectInteractiveSession(),
+            });
         }
         validateArgs(additionalArgs);
         const screenciDir = resolve(dirname(configPath), '.screenci');
-        clearDirectory(screenciDir);
+        clearRecordingDirectories(screenciDir);
     }
     const envForChild = { ...process.env };
     await validateUniqueDiscoveredTestTitles(configPath, additionalArgs, {
@@ -1788,7 +2000,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 } : {}),
@@ -1843,9 +2055,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);
@@ -1856,10 +2080,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);
     });
 }