screenci 0.0.34 → 0.0.38

package/dist/cli.js

@@ -1,7 +1,6 @@
-#!/usr/bin/env node
-import { spawn, spawnSync } from 'child_process';
+import { spawn } from 'child_process';
 import { createReadStream } from 'fs';
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, } from 'fs';
+import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync } from 'fs';
 import { createHash } from 'crypto';
 import { createServer } from 'http';
 import { appendFile, mkdir, readdir, readFile, stat, writeFile, } from 'fs/promises';
@@ -107,68 +106,6 @@ function createUploadAbortController(activityLabel) {
         cleanup,
     };
 }
-function parseDockerfileVersion(dockerfilePath) {
-    let content;
-    try {
-        content = readFileSync(dockerfilePath, 'utf-8');
-    }
-    catch {
-        return 'unknown';
-    }
-    const fromLine = content
-        .split('\n')
-        .find((line) => line.trim().toUpperCase().startsWith('FROM'));
-    if (!fromLine)
-        return 'unknown';
-    const match = fromLine.match(/:([^\s@]+)/);
-    return match?.[1] ?? 'unknown';
-}
-const CONTAINER_RUNTIME_DOCS_URL = 'https://screenci.com/docs/guides/getting-started/#prerequisites';
-function prerequisitesMessage() {
-    return `See prerequisites: ${pc.blue(CONTAINER_RUNTIME_DOCS_URL)}`;
-}
-const MIN_CONTAINER_RUNTIME_MAJOR_VERSION = {
-    podman: 3,
-    docker: 27,
-};
-function parseContainerRuntimeMajorVersion(versionOutput) {
-    const match = versionOutput.match(/(\d+)(?:\.\d+){0,2}/);
-    if (!match)
-        return null;
-    const majorVersion = Number.parseInt(match[1] ?? '', 10);
-    return Number.isNaN(majorVersion) ? null : majorVersion;
-}
-function checkContainerRuntime(runtime) {
-    const result = spawnSync(runtime, ['--version'], { encoding: 'utf8' });
-    if (result.status !== 0 || result.error !== undefined) {
-        return null;
-    }
-    const version = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
-    return {
-        runtime,
-        version,
-        majorVersion: parseContainerRuntimeMajorVersion(version),
-    };
-}
-function getPreferredContainerRuntime() {
-    const podman = checkContainerRuntime('podman');
-    if (podman)
-        return podman;
-    return checkContainerRuntime('docker');
-}
-function exitContainerRuntimeNotFound(runtime) {
-    logger.error(`Error: ${runtime} not found.`);
-    logger.error(`Install ${runtime} or remove the --${runtime} flag.`);
-    logger.error(prerequisitesMessage());
-    process.exit(1);
-}
-function warnIfContainerRuntimeVersionIsOld(runtimeCheck) {
-    const minimumVersion = MIN_CONTAINER_RUNTIME_MAJOR_VERSION[runtimeCheck.runtime];
-    if (runtimeCheck.majorVersion !== null &&
-        runtimeCheck.majorVersion < minimumVersion) {
-        logger.warn(`Your ${runtimeCheck.runtime} version (${runtimeCheck.version}) is quite old. We recommend updating. ${prerequisitesMessage()}`);
-    }
-}
 function spawnSilent(cmd, args, cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn(cmd, args, { stdio: 'pipe', ...(cwd ? { cwd } : {}) });
@@ -235,58 +172,6 @@ function forwardChildSignals(child, activityLabel) {
         getForwardedSignal: () => forwardedSignal,
     };
 }
-const CONTAINER_LOG_FILTER = [
-    /^Running ScreenCI /,
-    /^Using config:/,
-    /^Starting Xvfb /,
-    /^Xvfb started /,
-    /^Recording video to:/,
-    /^Recording with /,
-    /^Stopping recording\.\.\./,
-    /^FFmpeg exited /,
-    /^Video saved to:/,
-    /^Events saved to:/,
-];
-function spawnContainerRecording(cmd, args) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(cmd, args, { stdio: ['inherit', 'pipe', 'pipe'] });
-        const childSignals = forwardChildSignals(child, 'screenci record');
-        function forwardFiltered(chunk, out) {
-            const lines = chunk.toString().split('\n');
-            for (const line of lines) {
-                if (line === '')
-                    continue;
-                if (!CONTAINER_LOG_FILTER.some((re) => re.test(line.trimStart()))) {
-                    out.write(line + '\n');
-                }
-            }
-        }
-        child.stdout?.on('data', (chunk) => forwardFiltered(chunk, process.stdout));
-        child.stderr?.on('data', (chunk) => forwardFiltered(chunk, process.stderr));
-        child.on('close', (code, signal) => {
-            const forwardedSignal = childSignals.getForwardedSignal();
-            childSignals.cleanup();
-            if (forwardedSignal) {
-                process.kill(process.pid, forwardedSignal);
-                return;
-            }
-            if (signal) {
-                process.kill(process.pid, signal);
-                return;
-            }
-            else if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(`${cmd} exited with code ${code}`));
-            }
-        });
-        child.on('error', (err) => {
-            childSignals.cleanup();
-            reject(err);
-        });
-    });
-}
 function clearDirectory(dir) {
     mkdirSync(dir, { recursive: true });
     for (const entry of readdirSync(dir)) {
@@ -876,17 +761,34 @@ async function loadScreenCIConfigAndEnv(configPath) {
     return { resolvedConfigPath, screenciConfig };
 }
 function loadEnvFile(envFilePath, warnOnFailure) {
-    if (process.env.CI)
-        return;
     try {
         process.loadEnvFile(envFilePath);
     }
     catch (err) {
-        if (warnOnFailure) {
+        if (warnOnFailure && !isMissingFileError(err)) {
             logger.warn(`Failed to load env file ${envFilePath}:`, err);
         }
     }
 }
+function isMissingFileError(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'code' in err &&
+        err.code === 'ENOENT');
+}
+async function loadEnvFileFromConfigSource(resolvedConfigPath, warnOnFailure) {
+    try {
+        const screenciConfig = await tryReadConfigFromSource(resolvedConfigPath);
+        if (screenciConfig.envFile) {
+            const envFilePath = resolve(dirname(resolvedConfigPath), screenciConfig.envFile);
+            loadEnvFile(envFilePath, warnOnFailure);
+        }
+    }
+    catch {
+        // Config import may require Playwright context or dynamic values. Continue with
+        // the existing process env; Playwright will still load the config normally.
+    }
+}
 export function extractConfigStringLiteral(configSource, property) {
     const singleQuoteMatch = configSource.match(new RegExp(property + "\\s*:\\s*'([^'\\n]+)'"));
     if (singleQuoteMatch)
@@ -971,11 +873,7 @@ async function updateVideoVisibility(videoId, isPublic, configPath) {
     }
     logger.info(`${isPublic ? 'Made public' : 'Made private'}: ${videoId}`);
 }
-function generateConfig(projectName, initTarget) {
-    const baseURLBlock = initTarget
-        ? `    baseURL: ${JSON.stringify(initTarget.baseURL)},
-`
-        : '';
+function generateConfig(projectName) {
     return `import { defineConfig } from 'screenci'
 
 export default defineConfig({
@@ -983,7 +881,7 @@ export default defineConfig({
   envFile: '.env',
   videoDir: './videos',
   use: {
-${baseURLBlock}    recordOptions: {
+    recordOptions: {
       aspectRatio: '16:9',
       quality: '1080p',
       fps: 30,
@@ -997,13 +895,12 @@ ${baseURLBlock}    recordOptions: {
 })
 `;
 }
-function generatePackageJson(packageName, includePlaywrightCli = false, screenciDependency = 'latest') {
+function generatePackageJson(includePlaywrightCli = false, screenciDependency = 'latest') {
     const devDependencies = {};
     if (includePlaywrightCli) {
         devDependencies['@playwright/cli'] = 'latest';
     }
     return (JSON.stringify({
-        name: packageName,
         type: 'module',
         scripts: {
             record: 'screenci record',
@@ -1012,6 +909,7 @@ function generatePackageJson(packageName, includePlaywrightCli = false, screenci
         },
         dependencies: {
             screenci: screenciDependency,
+            '@playwright/test': '^1.59.0',
         },
         devDependencies,
     }, null, 2) + '\n');
@@ -1075,15 +973,6 @@ Learn more: https://screenci.com/docs/intro/
 4. View results on screenci.com and optionally enable a public URL to embed the video on your site.
 `;
 }
-function generateDockerfile() {
-    return `FROM ghcr.io/screenci/record:latest
-
-COPY package.json ./
-RUN npm install
-COPY screenci.config.ts ./
-COPY videos ./videos
-`;
-}
 function generateGitignore() {
     return `/playwright-report/
 .screenci
@@ -1092,8 +981,12 @@ node_modules/
 .env
 `;
 }
-function generateGithubAction() {
-    return `name: Record
+function generateGithubAction(workingDirectory) {
+    const packageLockPath = workingDirectory === '.'
+        ? 'package-lock.json'
+        : `${workingDirectory}/package-lock.json`;
+    const envFilePath = workingDirectory === '.' ? './.env' : `./${workingDirectory}/.env`;
+    return `name: ScreenCI
 
 on:
   push:
@@ -1112,27 +1005,37 @@ jobs:
           SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
         run: |
           if [ -z "$SCREENCI_SECRET" ]; then
-            echo "::error::SCREENCI_SECRET is not set. Copy it from https://app.screenci.com/secrets and add it under Settings → Secrets and variables → Actions → Repository secrets, and then rerun this action."
+            echo "::error::SCREENCI_SECRET is not set. Copy it from https://app.screenci.com/secrets or ${envFilePath}, add it under Settings → Secrets and variables → Actions → Repository secrets, and then rerun this action."
             exit 1
           fi
 
       - uses: actions/checkout@v4
 
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@v4
         with:
-          node-version: latest
+          node-version: 24
+          cache: npm
+          cache-dependency-path: ${packageLockPath}
 
       - name: Install dependencies
-        working-directory: screenci
-        run: npm install --include=dev
+        working-directory: ${workingDirectory}
+        run: npm ci
+
+      - name: Cache Playwright Chromium
+        uses: actions/cache@v5
+        id: pw-cache
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-\${{ runner.os }}-\${{ hashFiles('${packageLockPath}') }}
 
       - name: Install Chromium
-        working-directory: screenci
+        if: steps.pw-cache.outputs.cache-hit != 'true'
+        working-directory: ${workingDirectory}
         run: npx playwright install chromium --with-deps
 
       - id: record
         name: Record
-        working-directory: screenci
+        working-directory: ${workingDirectory}
         env:
           SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
         run: npm run record
@@ -1196,15 +1099,11 @@ const narration = createNarration({
   languages: {
     en: {
       cues: {
-        intro:
-          'This example opens your app at the configured base URL first, then uses ScreenCI [pronounce: screen see eye] to show the next steps for creating your first videos.',
         docs: 'Use the guide sidebar to open the AI-Supported Editing guide and review the next steps for writing your own videos.',
       },
     },
     es: {
       cues: {
-        intro:
-          'Este ejemplo abre primero tu aplicacion en la URL base configurada y despues usa ScreenCI [pronounce: screen see eye] para mostrar los siguientes pasos para crear tus primeros videos.',
         docs: 'Usa la barra lateral de guias para abrir la guia de edicion asistida por IA y revisar los siguientes pasos para escribir tus propios videos.',
       },
     },
@@ -1212,14 +1111,6 @@ const narration = createNarration({
 })
 
 video('See the next steps in ScreenCI docs', async ({ page }) => {
-  await hide(async () => {
-    await page.goto('/')
-    await page.waitForLoadState('domcontentloaded')
-  })
-
-  await narration.intro
-  await page.waitForTimeout(1000)
-
   await hide(async () => {
     await page.goto('https://screenci.com/')
     await page.getByText('ScreenCI', { exact: true }).first().waitFor()
@@ -1262,95 +1153,30 @@ async function promptInitGithubActionCi() {
         default: true,
     });
 }
-async function promptInitTargetMode() {
+async function promptInitRepositoryMode() {
     return select({
-        message: 'Should videos run against a local development server or a public URL?',
+        message: 'Initialize ScreenCI as a standalone project or part of the existing repository?',
+        default: 'standalone',
         choices: [
-            { name: 'Local development server', value: 'local' },
-            { name: 'Public URL', value: 'public' },
+            {
+                name: 'Standalone project',
+                value: 'standalone',
+                description: 'Create a project directory with its own GitHub Action.',
+            },
+            {
+                name: 'Part of existing repository',
+                value: 'existing-repository',
+                description: 'Create ./screenci and add the GitHub Action at the repository root.',
+            },
         ],
-        default: 'local',
-    });
-}
-async function promptInitTargetUrl(mode) {
-    return input({
-        message: mode === 'local' ? 'Local development server URL:' : 'Public app URL:',
-        default: mode === 'local' ? 'http://localhost:3000' : 'https://screenci.com',
     });
 }
-function normalizeInitUrl(url) {
-    try {
-        return new URL(url.trim()).toString();
-    }
-    catch {
-        logger.error(`Error: Invalid URL "${url}"`);
-        process.exit(1);
-    }
+function projectNameToDirectoryName(projectName) {
+    return projectName.trim().replace(/\s+/g, '-');
 }
 function getInitProjectRoot() {
     return process.env['SCREENCI_INIT_CWD'] ?? process.cwd();
 }
-function isSourceCliEntrypoint(entrypoint) {
-    return (entrypoint?.endsWith('/cli.ts') === true ||
-        entrypoint?.endsWith('\\cli.ts') === true);
-}
-function getDevScreenciPackageRoot() {
-    const explicitRoot = process.env.SCREENCI_DEV_PACKAGE_ROOT?.trim();
-    if (explicitRoot)
-        return resolve(explicitRoot);
-    if (!isSourceCliEntrypoint(process.argv[1]))
-        return undefined;
-    return dirname(fileURLToPath(import.meta.url));
-}
-function getLocalScreenciDependency(packageRoot, projectDir) {
-    const relativePath = pathRelative(projectDir, packageRoot) || '.';
-    const normalizedPath = relativePath.replace(/\\/g, '/');
-    return `file:${normalizedPath.startsWith('.') ? normalizedPath : `./${normalizedPath}`}`;
-}
-async function buildLocalScreenciPackage(packageRoot) {
-    logger.info(`Using local screenci package: ${packageRoot}`);
-    logger.info("Running 'npm run build' for local screenci package...");
-    await spawnInherited('npm', ['run', 'build'], packageRoot, 'screenci dev build');
-}
-async function installLocalScreenciPackage(projectDir, packageRoot) {
-    const packageJsonPath = resolve(projectDir, 'package.json');
-    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
-    packageJson.dependencies = {
-        ...packageJson.dependencies,
-        screenci: getLocalScreenciDependency(packageRoot, projectDir),
-    };
-    await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
-    logger.info('Installing local screenci package into this project...');
-    await spawnInherited('npm', ['install', '--install-links'], projectDir, 'screenci dev install');
-}
-function buildChildEnv() {
-    const { PATH, HOME, USER, LOGNAME, TMPDIR, TEMP, TMP, CI } = process.env;
-    return {
-        PATH,
-        HOME,
-        USER,
-        LOGNAME,
-        TMPDIR,
-        TEMP,
-        TMP,
-        CI,
-        SCREENCI_SECRET: process.env.SCREENCI_SECRET,
-        SCREENCI_INIT_CWD: process.env.SCREENCI_INIT_CWD,
-        DEV_FRONTEND_PORT: process.env.DEV_FRONTEND_PORT,
-        DEV_BACKEND_PORT: process.env.DEV_BACKEND_PORT,
-        SCREENCI_LOCAL_IMAGE: process.env.SCREENCI_LOCAL_IMAGE,
-        SCREENCI_IN_CONTAINER: process.env.SCREENCI_IN_CONTAINER,
-        SCREENCI_RECORD: process.env.SCREENCI_RECORD,
-        SCREENCI_SIGNAL_LOGGING: process.env.SCREENCI_SIGNAL_LOGGING,
-        SCREENCI_DEV_PACKAGE_ROOT: process.env.SCREENCI_DEV_PACKAGE_ROOT,
-    };
-}
-function requireContainerRuntime() {
-    const runtime = detectContainerRuntime();
-    if (runtime === 'podman' || runtime === 'docker')
-        return runtime;
-    throw new Error('No container runtime available');
-}
 async function runInitAuth() {
     const appUrl = getDevFrontendUrl();
     try {
@@ -1387,18 +1213,10 @@ async function ensureScreenciSecret() {
         return undefined;
     }
 }
-function checkNodeVersion() {
-    const [major] = process.versions.node.split('.').map(Number);
-    if (major === undefined || major < 18) {
-        logger.error(`Error: Node.js 18 or higher is required (current: v${process.versions.node})`);
-        process.exit(1);
-    }
-}
 async function runInit(projectNameArg, options) {
     const { verbose, install, yes, skill, ci } = options;
-    checkNodeVersion();
-    checkContainerRuntimeForInit();
     const initCwd = getInitProjectRoot();
+    const existingRepositoryDetected = existsSync(resolve(initCwd, '.git'));
     let projectName = projectNameArg?.trim();
     if (!projectName) {
         projectName = await promptProjectName();
@@ -1407,25 +1225,28 @@ async function runInit(projectNameArg, options) {
         logger.error('Error: Project name is required');
         process.exit(1);
     }
-    const dirName = 'screenci';
+    if (existingRepositoryDetected) {
+        logger.info('Existing repository detected');
+    }
+    const repositoryMode = existingRepositoryDetected
+        ? yes
+            ? 'standalone'
+            : await promptInitRepositoryMode()
+        : 'standalone';
+    const isPartOfExistingRepository = repositoryMode === 'existing-repository';
+    const dirName = isPartOfExistingRepository
+        ? 'screenci'
+        : projectNameToDirectoryName(projectName);
     const projectDir = resolve(initCwd, dirName);
-    const githubDir = resolve(initCwd, '.github');
+    const githubRootDir = isPartOfExistingRepository ? initCwd : projectDir;
+    const githubDir = resolve(githubRootDir, '.github');
     const githubWorkflowsDir = resolve(githubDir, 'workflows');
     const githubActionPath = resolve(githubWorkflowsDir, 'screenci.yaml');
+    const githubActionProjectDir = isPartOfExistingRepository ? 'screenci' : '.';
     if (existsSync(projectDir)) {
         logger.error(`Error: Directory "${dirName}" already exists`);
         process.exit(1);
     }
-    const initTarget = yes
-        ? undefined
-        : await (async () => {
-            const mode = await promptInitTargetMode();
-            const baseURL = normalizeInitUrl(await promptInitTargetUrl(mode));
-            return {
-                mode,
-                baseURL,
-            };
-        })();
     const shouldInstallDependencies = yes
         ? true
         : install
@@ -1456,13 +1277,7 @@ async function runInit(projectNameArg, options) {
         '-y',
     ];
     const skillsCommand = `npx ${skillsArgs.join(' ')}`;
-    const devScreenciPackageRoot = getDevScreenciPackageRoot();
-    const screenciDependency = devScreenciPackageRoot
-        ? getLocalScreenciDependency(devScreenciPackageRoot, projectDir)
-        : await readCurrentScreenciVersion();
-    if (devScreenciPackageRoot) {
-        await buildLocalScreenciPackage(devScreenciPackageRoot);
-    }
+    const screenciDependency = await readCurrentScreenciVersion();
     await mkdir(resolve(projectDir, 'videos'), { recursive: true });
     if (shouldAddGithubActionCi) {
         if (!existsSync(githubDir)) {
@@ -1472,15 +1287,14 @@ async function runInit(projectNameArg, options) {
             await mkdir(githubWorkflowsDir);
         }
     }
-    await writeFile(resolve(projectDir, 'screenci.config.ts'), generateConfig(projectName, initTarget));
-    await writeFile(resolve(projectDir, 'package.json'), generatePackageJson(dirName, shouldAddPlaywrightCli, screenciDependency));
+    await writeFile(resolve(projectDir, 'screenci.config.ts'), generateConfig(projectName));
+    await writeFile(resolve(projectDir, 'package.json'), generatePackageJson(shouldAddPlaywrightCli, screenciDependency));
     await writeFile(resolve(projectDir, 'tsconfig.json'), generateTsconfig());
     await writeFile(resolve(projectDir, 'README.md'), generateReadme(projectName));
-    await writeFile(resolve(projectDir, 'Dockerfile'), generateDockerfile());
     await writeFile(resolve(projectDir, '.gitignore'), generateGitignore());
     await writeFile(resolve(projectDir, 'videos', 'example.video.ts'), generateExampleVideo());
     if (shouldAddGithubActionCi) {
-        await writeFile(githubActionPath, generateGithubAction());
+        await writeFile(githubActionPath, generateGithubAction(githubActionProjectDir));
     }
     await writeFile(resolve(projectDir, '.env'), '');
     logger.info(`Initialized screenci project "${projectName}" in ${projectDir}/`);
@@ -1489,11 +1303,13 @@ async function runInit(projectNameArg, options) {
     logger.info('  package.json');
     logger.info('  tsconfig.json');
     logger.info('  README.md');
-    logger.info('  Dockerfile');
     logger.info('  .gitignore');
     logger.info('  videos/example.video.ts');
     if (shouldAddGithubActionCi) {
-        logger.info('  .github/workflows/screenci.yaml');
+        const githubActionDisplayPath = isPartOfExistingRepository
+            ? '.github/workflows/screenci.yaml (outside ./screenci, at repository root)'
+            : '.github/workflows/screenci.yaml';
+        logger.info(`  ${githubActionDisplayPath}`);
     }
     logger.info('  .env  (empty placeholder)');
     logger.info('');
@@ -1514,24 +1330,14 @@ async function runInit(projectNameArg, options) {
             }
         }
         if (verbose) {
-            const installArgs = devScreenciPackageRoot
-                ? ['install', '--include=dev', '--install-links']
-                : ['install', '--include=dev'];
+            const installArgs = ['install', '--include=dev'];
             logger.info(`Running 'npm ${installArgs.join(' ')}'...`);
             await spawnInherited('npm', installArgs, projectDir, 'screenci init');
         }
         else {
             const spinner = ora('Running npm install...').start();
             try {
-                const installArgs = devScreenciPackageRoot
-                    ? [
-                        'install',
-                        '--include=dev',
-                        '--install-links',
-                        '--prefix',
-                        projectDir,
-                    ]
-                    : ['install', '--include=dev', '--prefix', projectDir];
+                const installArgs = ['install', '--include=dev', '--prefix', projectDir];
                 await spawnSilent('npm', installArgs);
                 spinner.succeed('npm install complete');
             }
@@ -1575,42 +1381,8 @@ export async function main() {
         .allowUnknownOption(true)
         .action(async () => {
         const parsed = parseRecordCliArgs(getSubcommandArgv('record'));
-        if (parsed.forcedRuntime === 'both') {
-            logger.error('Error: --podman and --docker cannot be used together');
-            process.exit(1);
-        }
-        const useContainer = process.env.SCREENCI_IN_CONTAINER !== 'true';
-        // Validate early so we don't build the container unnecessarily
-        if (useContainer) {
-            validateArgs(parsed.otherArgs);
-        }
-        // On the host, load .env so SCREENCI_SECRET is available for uploads
-        if (process.env.SCREENCI_IN_CONTAINER !== 'true') {
-            const resolvedConfigForSecret = findScreenCIConfig(parsed.configPath);
-            if (resolvedConfigForSecret) {
-                try {
-                    const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigForSecret);
-                    if (screenciConfig.envFile) {
-                        const envFilePath = resolve(dirname(resolvedConfigForSecret), screenciConfig.envFile);
-                        loadEnvFile(envFilePath, false);
-                    }
-                }
-                catch {
-                    // Config import failed — continue with whatever is already in env
-                }
-            }
-        }
-        if (useContainer) {
-            await ensureScreenciSecret();
-        }
-        if (useContainer) {
-            await runWithContainer(parsed.otherArgs, parsed.configPath, parsed.verbose, parsed.forcedRuntime);
-        }
-        else {
-            await run('record', parsed.otherArgs, parsed.configPath);
-        }
-        // Upload only from the host, not from inside the container
-        if (process.env.SCREENCI_IN_CONTAINER === 'true')
+        await run('record', parsed.otherArgs, parsed.configPath);
+        if (process.env.SCREENCI_RECORDING === 'true')
             return;
         // After recording, upload results to API if configured
         const resolvedConfigPath = findScreenCIConfig(parsed.configPath);
@@ -1632,6 +1404,7 @@ export async function main() {
                 const screenciDir = resolve(configDir, '.screenci');
                 let projectId = null;
                 try {
+                    logger.info('');
                     projectId = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret);
                 }
                 catch (err) {
@@ -1659,9 +1432,23 @@ export async function main() {
         .allowUnknownOption(true)
         .action(async () => {
         const parsed = parseConfigCliArgs(getSubcommandArgv('test'));
+        const resolvedConfigPath = findScreenCIConfig(parsed.configPath);
+        if (resolvedConfigPath) {
+            try {
+                const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
+                if (screenciConfig.envFile) {
+                    const envFilePath = resolve(dirname(resolvedConfigPath), screenciConfig.envFile);
+                    loadEnvFile(envFilePath, true);
+                }
+            }
+            catch (err) {
+                logger.warn('Failed to load config for test env:', err);
+            }
+        }
         await run('test', parsed.otherArgs, parsed.configPath);
-        if (process.env.SCREENCI_IN_CONTAINER === 'true')
+        if (process.env.SCREENCI_RECORDING === 'true')
             return;
+        logger.info('');
         logger.info(`Tests passed. Run ${pc.cyan('npx screenci record')} to render the videos.`);
     });
     program
@@ -1756,7 +1543,6 @@ function getSubcommandArgv(command) {
 function parseRecordCliArgs(args) {
     let configPath;
     let verbose = false;
-    let forcedRuntime;
     const otherArgs = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -1774,12 +1560,6 @@ function parseRecordCliArgs(args) {
         else if (arg === '--verbose' || arg === '-v') {
             verbose = true;
         }
-        else if (arg === '--podman') {
-            forcedRuntime = forcedRuntime === 'docker' ? 'both' : 'podman';
-        }
-        else if (arg === '--docker') {
-            forcedRuntime = forcedRuntime === 'podman' ? 'both' : 'docker';
-        }
         else {
             otherArgs.push(arg);
         }
@@ -1787,7 +1567,6 @@ function parseRecordCliArgs(args) {
     return {
         configPath,
         verbose,
-        forcedRuntime,
         otherArgs,
     };
 }
@@ -1860,122 +1639,6 @@ function spawnInherited(cmd, args, cwd, activityLabel = cmd) {
         });
     });
 }
-export function detectContainerRuntime(forcedRuntime) {
-    const runtimeCheck = forcedRuntime
-        ? checkContainerRuntime(forcedRuntime)
-        : getPreferredContainerRuntime();
-    if (runtimeCheck) {
-        warnIfContainerRuntimeVersionIsOld(runtimeCheck);
-        return runtimeCheck.runtime;
-    }
-    if (forcedRuntime) {
-        exitContainerRuntimeNotFound(forcedRuntime);
-    }
-    logger.error('Error: Neither podman nor docker found.');
-    logger.error('Please install podman (recommended) or docker to use screenci record.');
-    logger.error(prerequisitesMessage());
-    process.exit(1);
-}
-function checkContainerRuntimeForInit() {
-    const runtimeCheck = getPreferredContainerRuntime();
-    if (!runtimeCheck) {
-        logger.warn('Neither podman nor docker found. Install one before running screenci record.');
-        logger.warn(prerequisitesMessage());
-        return;
-    }
-    warnIfContainerRuntimeVersionIsOld(runtimeCheck);
-}
-async function buildProjectImage(containerRuntime, dockerfilePath, configDir, verbose) {
-    if (verbose) {
-        await spawnInherited(containerRuntime, ['build', '-f', dockerfilePath, '-t', 'screenci', configDir], undefined, 'Building project image');
-        return;
-    }
-    await spawnSilent(containerRuntime, [
-        'build',
-        '-f',
-        dockerfilePath,
-        '-t',
-        'screenci',
-        configDir,
-    ]);
-}
-async function runWithContainer(additionalArgs, customConfigPath, verbose = false, forcedRuntime) {
-    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 configDir = dirname(configPath);
-    const repoRoot = findRepoRoot(configDir);
-    if (!repoRoot) {
-        logger.error('Error: Could not find repository root (.git or pnpm-workspace.yaml)');
-        process.exit(1);
-    }
-    logger.info('Preparing ScreenCI recording container...');
-    const containerRuntime = detectContainerRuntime(forcedRuntime);
-    const imageName = process.env['SCREENCI_LOCAL_IMAGE']
-        ? 'screenci'
-        : 'ghcr.io/screenci/record:latest';
-    logger.info(`Using ${containerRuntime} with image ${imageName}`);
-    if (process.env['SCREENCI_LOCAL_IMAGE']) {
-        logger.info('SCREENCI_LOCAL_IMAGE set — skipping screenci image build');
-    }
-    else {
-        const imageExists = spawnSync(containerRuntime, ['image', 'exists', imageName], {
-            stdio: 'ignore',
-        }).status === 0;
-        if (!imageExists) {
-            logger.info(`Image ${imageName} not found locally, pulling...`);
-            if (verbose) {
-                await spawnInherited(containerRuntime, ['pull', imageName]);
-            }
-            else {
-                await spawnSilent(containerRuntime, ['pull', imageName]);
-            }
-        }
-    }
-    clearDirectory(resolve(configDir, '.screenci'));
-    const secret = process.env['SCREENCI_SECRET'];
-    if (secret === undefined) {
-        logger.error('Error: SCREENCI_SECRET is not set');
-        process.exit(1);
-    }
-    logger.info('Starting ScreenCI recording container...');
-    const containerBaseHost = containerRuntime === 'docker'
-        ? 'host.docker.internal'
-        : 'host.containers.internal';
-    await spawnContainerRecording(containerRuntime, [
-        'run',
-        '--rm',
-        ...(containerRuntime === 'docker'
-            ? ['--add-host', 'host.docker.internal:host-gateway']
-            : []),
-        ...(process.env.CI !== undefined ? ['-e', `CI=${process.env.CI}`] : []),
-        '-e',
-        'SCREENCI_IN_CONTAINER=true',
-        '-e',
-        `SCREENCI_CONTAINER_BASE_HOST=${containerBaseHost}`,
-        '-e',
-        'SCREENCI_RECORD=true',
-        '-e',
-        `SCREENCI_SECRET=${secret}`,
-        '-e',
-        'SCREENCI_SIGNAL_LOGGING=silent',
-        '-v',
-        `${configDir}/.screenci:/app/.screenci`,
-        '-v',
-        `${configPath}:/app/screenci.config.ts`,
-        '-v',
-        `${configDir}/videos:/app/videos`,
-        imageName,
-        'screenci',
-        'record',
-        ...additionalArgs,
-    ]);
-}
 async function run(command, additionalArgs, customConfigPath) {
     const configPath = findScreenCIConfig(customConfigPath);
     if (!configPath) {
@@ -1985,6 +1648,10 @@ async function run(command, additionalArgs, customConfigPath) {
         logger.error(errorMsg);
         process.exit(1);
     }
+    if (command === 'test' || process.env.SCREENCI_RECORDING !== 'true') {
+        await loadEnvFileFromConfigSource(configPath, false);
+    }
+    const envForChild = { ...process.env };
     // Only validate args for record command
     if (command === 'record') {
         await ensureScreenciSecret();
@@ -1992,30 +1659,16 @@ async function run(command, additionalArgs, customConfigPath) {
         const screenciDir = resolve(dirname(configPath), '.screenci');
         clearDirectory(screenciDir);
     }
-    const mode = command === 'test' ? 'tests' : 'recorder';
-    if (process.env.SCREENCI_IN_CONTAINER !== 'true') {
-        logger.info(`Running ScreenCI ${mode} with npx...`);
+    if (process.env.SCREENCI_RECORDING !== 'true') {
         logger.info(`Using config: ${configPath}`);
     }
-    const devScreenciPackageRoot = getDevScreenciPackageRoot();
-    if (devScreenciPackageRoot) {
-        const configDir = dirname(configPath);
-        await buildLocalScreenciPackage(devScreenciPackageRoot);
-        await installLocalScreenciPackage(configDir, devScreenciPackageRoot);
-    }
-    const playwrightArgs = [
-        'playwright',
-        'test',
-        '--config',
-        configPath,
-        ...additionalArgs,
-    ];
-    const child = spawn('npx', playwrightArgs, {
+    const playwrightArgs = ['test', '--config', configPath, ...additionalArgs];
+    const child = spawn('playwright', playwrightArgs, {
         stdio: 'inherit',
         env: {
-            ...buildChildEnv(),
+            ...envForChild,
             // Enable recording only for record command
-            ...(command === 'record' ? { SCREENCI_RECORD: 'true' } : {}),
+            ...(command === 'record' ? { SCREENCI_RECORDING: 'true' } : {}),
         },
     });
     const childSignals = forwardChildSignals(child, `screenci ${command}`);
@@ -2048,8 +1701,11 @@ async function run(command, additionalArgs, customConfigPath) {
 // Check if this module is the main module (handles symlinks properly)
 const currentFile = fileURLToPath(import.meta.url);
 const mainFile = process.argv[1] ? realpathSync(process.argv[1]) : null;
+const currentRealFile = realpathSync(currentFile);
 if (mainFile &&
-    (currentFile === mainFile || currentFile === realpathSync(mainFile))) {
+    (currentFile === mainFile ||
+        currentRealFile === mainFile ||
+        currentFile === realpathSync(mainFile))) {
     main().catch((error) => {
         logger.error('Error:', error.message);
         process.exit(1);