screenci 0.0.68 → 0.0.70

package/dist/cli.js

@@ -13,33 +13,26 @@ import { determinePackageManager, parsePackageManager, runInit, } from './src/in
 import { SCREENCI_DISABLE_RECORDING_TIMINGS_ENV, SCREENCI_MOCK_RECORD_ENV, } from './src/runtimeMode.js';
 import { DEFAULT_RECORD_UPLOAD_POLICY } from './src/defaults.js';
 import { findDuplicateTitles, formatDuplicateTitlesMessage, } from './src/titleValidation.js';
+import { createLinkSessionSpec, deletePersistedLinkSessionSpec, getCliLinkSessionApiUrl, getDevBackendUrl, getDevFrontendUrl, getLinkSessionFilePath, getScreenCIEnvironment, isStoredLinkSessionReusable, readPersistedLinkSessionSpec, SCREENCI_LINK_SESSION_FILE, writePersistedLinkSessionSpec, } from './src/linkSession.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 };
 const SCREENCI_MOCK_RECORD_DOCS_URL = 'https://screenci.com/docs/reference/cli/#--mock-record';
 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';
+// 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_LINK_SESSION_POLL_INTERVAL_MS = 2_000;
 // `record --poll` keeps a non-interactive session (an agent or CI) waiting for
 // sign-in. We poll on a slower cadence than the interactive loop so a long wait
 // for a human to click the link does not hammer the backend.
 const SCREENCI_LINK_SESSION_POLL_FLAG_INTERVAL_MS = 5_000;
+// `record --poll-auth` does not wait forever: after this long without a
+// completed sign-in we stop polling and exit cleanly so an agent or CI step does
+// not hang indefinitely. The link stays valid, so the command can be rerun. The
+// default can be overridden with SCREENCI_POLL_AUTH_TIMEOUT_MS (milliseconds).
+const SCREENCI_LINK_SESSION_POLL_FLAG_TIMEOUT_MS = 5 * 60 * 1_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
@@ -221,25 +214,6 @@ 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`;
 }
@@ -368,7 +342,15 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
     let plan = null;
     try {
         uploadAbort.throwIfAborted();
-        const recordingPath = resolve(screenciDir, entry, 'recording.mp4');
+        // A screenshot recording uploads its raw page capture (always a PNG) through
+        // the same recording endpoint a video uses; the renderer reads those bytes as
+        // the capture. Videos upload recording.mp4. Output kind defaults to 'video'.
+        const isScreenshot = data.output === 'screenshot';
+        const recordingFileName = isScreenshot
+            ? (data.screenshot?.path ?? 'screenshot.png')
+            : 'recording.mp4';
+        const recordingContentType = isScreenshot ? 'image/png' : 'video/mp4';
+        const recordingPath = resolve(screenciDir, entry, recordingFileName);
         if (!existsSync(recordingPath)) {
             progressReporter.complete(progressIndex, 'failure');
             return {
@@ -376,7 +358,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 videoId: null,
                 hadFailure: true,
                 videoName,
-                failureMessage: `Missing recording.mp4 for "${videoName}"`,
+                failureMessage: `Missing ${recordingFileName} for "${videoName}"`,
                 recordId,
             };
         }
@@ -434,7 +416,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
         uploadAbort.throwIfAborted();
         const fileStat = await stat(recordingPath);
         if (verbose) {
-            logger.info(`Uploading recording.mp4 size=${(fileStat.size / 1024 / 1024).toFixed(1)}MB`);
+            logger.info(`Uploading ${recordingFileName} size=${(fileStat.size / 1024 / 1024).toFixed(1)}MB`);
         }
         const recordingResponse = await withUploadRetry(async () => {
             const stream = createReadStream(recordingPath);
@@ -446,7 +428,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 return await fetch(`${apiUrl}/cli/upload/${recordingId}/recording`, {
                     method: 'PUT',
                     headers: {
-                        'Content-Type': 'video/mp4',
+                        'Content-Type': recordingContentType,
                         'Content-Length': String(fileStat.size),
                         'X-ScreenCI-Secret': secret,
                         ...(elevenLabsApiKey
@@ -1201,43 +1183,6 @@ async function countCompletedRecordings(screenciDir) {
     }
     return entries.filter((entry) => existsSync(resolve(screenciDir, entry, 'data.json'))).length;
 }
-export function getDevBackendUrl() {
-    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() {
-    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() {
-    // The `/cli-link/session` routes are Convex HTTP actions served from the same
-    // backend host as the `/cli/*` upload endpoints. We hit that host directly
-    // rather than the frontend: the frontend only forwards these routes via the
-    // vite dev-server proxy, which does not exist on the hosted dev/prod frontend
-    // (a POST there returns 405). The CLI runs under Node, so there is no CORS
-    // constraint that would require going through the frontend origin.
-    return getDevBackendUrl();
-}
 function getScreenCISecretsUrl() {
     return `${getDevFrontendUrl()}/secrets`;
 }
@@ -1463,25 +1408,6 @@ async function requireScreenCISecret(configPath, opts = {}) {
         apiUrl: getDevBackendUrl(),
     };
 }
-async function fetchProjectInfo(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(), {
-        headers: {
-            'X-ScreenCI-Secret': secret,
-        },
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`Failed to fetch project info: ${res.status} ${text}${hint401(res.status, secret)}`);
-    }
-    return (await res.json());
-}
-async function printProjectInfo(configPath) {
-    const info = await fetchProjectInfo(configPath);
-    process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
-}
 async function updateVideoVisibility(videoId, isPublic, configPath) {
     const { secret, apiUrl } = await requireScreenCISecret(configPath, {
         interactive: detectInteractiveSession(),
@@ -1499,6 +1425,62 @@ async function updateVideoVisibility(videoId, isPublic, configPath) {
     }
     logger.info(`${isPublic ? 'Made public' : 'Made private'}: ${videoId}`);
 }
+function getLastRecordFilePath(screenciDir) {
+    return resolve(screenciDir, SCREENCI_LAST_RECORD_FILE);
+}
+/**
+ * Persists the recordId of the just-completed `screenci record` upload so a
+ * later `screenci info` can report exactly that run. Best-effort: a
+ * failure to write must not fail the record command.
+ */
+async function saveLastRecordId(screenciDir, recordId) {
+    try {
+        mkdirSync(screenciDir, { recursive: true });
+        await writeFile(getLastRecordFilePath(screenciDir), `${JSON.stringify({ recordId, savedAt: new Date().toISOString() }, null, 2)}\n`);
+    }
+    catch (err) {
+        logger.warn(`Failed to record run id for info: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function readLastRecordId(screenciDir) {
+    try {
+        const raw = await readFile(getLastRecordFilePath(screenciDir), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.recordId === 'string' ? parsed.recordId : null;
+    }
+    catch (err) {
+        if (!isMissingFileError(err)) {
+            logger.warn(`Ignoring invalid stored record at ${getLastRecordFilePath(screenciDir)}.`);
+        }
+        return null;
+    }
+}
+// `screenci info` prints every project video and its public URLs as JSON. When
+// this machine has recorded a run (a recordId is stored in
+// .screenci/last-record.json), the backend also attaches, to the videos from
+// that run, a per-language `latestRecord` with render status and record-pinned
+// URLs. Without a local run, only the project-wide listing with `static` URLs is
+// returned. The server does the merge; the CLI just passes the recordId.
+async function printInfo(configPath) {
+    const { resolvedConfigPath, screenciConfig, secret, apiUrl } = await requireScreenCISecret(configPath, {
+        interactive: detectInteractiveSession(),
+    });
+    const screenciDir = resolve(dirname(resolvedConfigPath), '.screenci');
+    const recordId = await readLastRecordId(screenciDir);
+    const url = new URL(`${apiUrl}/cli/info`);
+    url.searchParams.set('projectName', screenciConfig.projectName);
+    if (recordId)
+        url.searchParams.set('record', recordId);
+    const res = await fetch(url.toString(), {
+        headers: { 'X-ScreenCI-Secret': secret },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Failed to fetch info: ${res.status} ${text}${hint401(res.status, secret)}`);
+    }
+    const data = await res.json();
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
 async function persistScreenCISecret(envFilePath, secret) {
     const nextLine = `SCREENCI_SECRET=${secret}`;
     try {
@@ -1525,57 +1507,6 @@ async function persistScreenCISecret(envFilePath, secret) {
     }
     await writeFile(envFilePath, `${nextLine}\n`);
 }
-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());
@@ -1588,7 +1519,16 @@ async function pollLinkSessionOnce(spec) {
     }
     return { status };
 }
-async function pollLinkSession(spec, pollIntervalMs = SCREENCI_LINK_SESSION_POLL_INTERVAL_MS) {
+function getPollAuthTimeoutMs() {
+    const raw = process.env.SCREENCI_POLL_AUTH_TIMEOUT_MS;
+    if (raw === undefined)
+        return SCREENCI_LINK_SESSION_POLL_FLAG_TIMEOUT_MS;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0
+        ? parsed
+        : SCREENCI_LINK_SESSION_POLL_FLAG_TIMEOUT_MS;
+}
+async function pollLinkSession(spec, pollIntervalMs = SCREENCI_LINK_SESSION_POLL_INTERVAL_MS, deadlineEpochMs) {
     for (;;) {
         const result = await pollLinkSessionOnce(spec);
         if (result.status === 'completed' && result.secret) {
@@ -1599,6 +1539,11 @@ async function pollLinkSession(spec, pollIntervalMs = SCREENCI_LINK_SESSION_POLL
             result.status === 'invalid') {
             return result;
         }
+        // Stop before sleeping again once the optional deadline has passed so
+        // `--poll-auth` cannot block forever waiting for a human to sign in.
+        if (deadlineEpochMs !== undefined && Date.now() >= deadlineEpochMs) {
+            return { status: 'timed-out' };
+        }
         await new Promise((resolveDelay) => setTimeout(resolveDelay, pollIntervalMs));
     }
 }
@@ -1672,14 +1617,24 @@ export async function ensureScreenciSecret(resolvedConfigPath, opts = {}) {
                 // a slow cadence until the human finishes signing in, and continue
                 // recording automatically once the secret lands. We re-print the link
                 // on every (re)created session so the latest valid link is always
-                // visible, including after a stale session is recreated.
+                // visible, including after a stale session is recreated. We do not wait
+                // forever: after a default timeout we stop polling and exit cleanly so
+                // an agent or CI step does not hang. The link stays valid for a rerun.
+                const timeoutMs = getPollAuthTimeoutMs();
+                const timeoutMinutes = Math.round(timeoutMs / 60_000);
+                const deadlineEpochMs = Date.now() + timeoutMs;
                 for (;;) {
                     logger.info(`Sign-in required to record. Open this link to sign in:\n${pc.cyan(spec.appUrl)}\n` +
-                        `Waiting for sign-in (checking every 5 seconds). Recording continues automatically once you finish.`);
-                    const polled = await pollLinkSession(spec, SCREENCI_LINK_SESSION_POLL_FLAG_INTERVAL_MS);
+                        `Waiting for sign-in (checking every 5 seconds, up to ${timeoutMinutes} minutes). Recording continues automatically once you finish.`);
+                    const polled = await pollLinkSession(spec, SCREENCI_LINK_SESSION_POLL_FLAG_INTERVAL_MS, deadlineEpochMs);
                     if (polled.status === 'completed' && polled.secret) {
                         return await saveCompletedSecret(polled.secret);
                     }
+                    if (polled.status === 'timed-out' || Date.now() >= deadlineEpochMs) {
+                        logger.info(`Timed out after ${timeoutMinutes} minutes waiting for sign-in. The link is still valid:\n${pc.cyan(spec.appUrl)}\n` +
+                            `After signing in, rerun ${pc.cyan(getSuggestedScreenciCommand('record'))} to continue, or ${pc.cyan(getSuggestedScreenciCommand('record', '--poll-auth'))} to wait again.`);
+                        return undefined;
+                    }
                     deletePersistedLinkSessionSpec(specPath);
                     spec = await ensureSpec();
                 }
@@ -1721,7 +1676,7 @@ export async function main() {
         .command('record [playwrightArgs...]')
         .description('Record videos using Playwright')
         .option('-v, --verbose', 'verbose output')
-        .option('--poll-auth', 'wait for sign-in to complete (polling every 5s) instead of exiting, then continue recording')
+        .option('--poll-auth', 'wait for sign-in to complete (polling every 5s, up to 5 minutes) instead of exiting, then continue recording')
         .allowUnknownOption(true)
         .action(async () => {
         const parsed = parseRecordCliArgs(getSubcommandArgv('record'));
@@ -1792,6 +1747,10 @@ export async function main() {
                         throw err;
                     }
                     const { projectId, recordId, hadFailures, failedVideoNames, failedVideoMessages, studioNotices, plan, } = uploadResult;
+                    // Remember this run so `screenci info` can report exactly it.
+                    if (recordId !== null) {
+                        await saveLastRecordId(screenciDir, recordId);
+                    }
                     if (recordId !== null && projectId !== null) {
                         const recordUrl = `${appUrl}/record/${recordId}`;
                         await writeGitHubProjectOutput(recordUrl);
@@ -1823,9 +1782,9 @@ export async function main() {
                                 logger.info(pc.cyan(formatStudioUrl(appUrl, projectId, notice.videoId)));
                             }
                         }
-                        else if (notice.studio.appliedChanges.length > 0) {
+                        else if (notice.studio.applied) {
                             logger.info('');
-                            logger.info(`Selections were overridden in Studio for "${notice.videoName}": ${formatStudioChangeSummary(notice.studio.appliedChanges)}`);
+                            logger.info(`Studio configuration applied for "${notice.videoName}".`);
                         }
                     }
                     if (hadFailures) {
@@ -1884,10 +1843,10 @@ export async function main() {
     });
     program
         .command('info')
-        .description('Print remote project info as JSON')
+        .description("Print the latest record run's video URLs and render status as JSON")
         .option('-c, --config <path>', 'path to screenci.config.ts')
         .action(async (options) => {
-        await printProjectInfo(options['config']);
+        await printInfo(options['config']);
     });
     program
         .command('make-public <id>')