screenci 0.0.44 → 0.0.46

package/dist/src/init.js

@@ -0,0 +1,674 @@
+import { spawn } from 'child_process';
+import { existsSync, realpathSync } from 'fs';
+import { appendFile, mkdir, readFile, writeFile } from 'fs/promises';
+import { basename, delimiter, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { Command, CommanderError } from 'commander';
+import { input } from '@inquirer/prompts';
+import ora from 'ora';
+import pc from 'picocolors';
+import { logger } from './logger.js';
+const PLAYWRIGHT_TEST_VERSION = '^1.59.0';
+const PLAYWRIGHT_CLI_VERSION = 'latest';
+const NODE_TYPES_VERSION = '^25.9.1';
+export function determinePackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent?.includes('pnpm')) {
+        return 'pnpm';
+    }
+    return 'npm';
+}
+function resolveSpawnSpec(cmd, args) {
+    if (process.platform !== 'win32') {
+        return { command: cmd, args };
+    }
+    const windowsCmdShims = new Set(['npm', 'npx', 'playwright', 'pnpm']);
+    if (!windowsCmdShims.has(cmd)) {
+        return { command: cmd, args };
+    }
+    return {
+        command: process.env.comspec ?? 'cmd.exe',
+        args: ['/d', '/s', '/c', `"${buildWindowsBatchCommandLine(cmd, args)}"`],
+        windowsVerbatimArguments: true,
+    };
+}
+function quoteWindowsBatchArg(arg) {
+    if (arg.length === 0) {
+        return '""';
+    }
+    return `"${arg
+        .replace(/(\\*)"/g, '$1$1\\"')
+        .replace(/(\\+)$/g, '$1$1')
+        .replace(/%/g, '%%')}"`;
+}
+function buildWindowsBatchCommandLine(cmd, args) {
+    return [resolveWindowsCmdShim(cmd), ...args]
+        .map(quoteWindowsBatchArg)
+        .join(' ');
+}
+function resolveWindowsCmdShim(cmd) {
+    const shimName = `${cmd}.cmd`;
+    const pathEntries = process.env.PATH?.split(delimiter) ?? [];
+    for (const entry of pathEntries) {
+        if (!entry)
+            continue;
+        const shimPath = resolve(entry, shimName);
+        if (existsSync(shimPath)) {
+            return shimPath;
+        }
+    }
+    const bundledShimCommands = new Set(['npm', 'npx']);
+    if (bundledShimCommands.has(cmd)) {
+        const bundledShimPath = resolve(dirname(process.execPath), shimName);
+        if (existsSync(bundledShimPath)) {
+            return bundledShimPath;
+        }
+    }
+    return shimName;
+}
+function forwardChildSignals(child, activityLabel) {
+    let forwardedSignal = null;
+    const forwardSignal = (signal) => {
+        if (forwardedSignal !== null)
+            return;
+        forwardedSignal = signal;
+        if (process.env.SCREENCI_SIGNAL_LOGGING !== 'silent') {
+            logger.info(`Received ${signal}, stopping ${activityLabel}...`);
+        }
+        if (!child.killed) {
+            child.kill(signal);
+        }
+    };
+    const cleanup = () => {
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
+    };
+    const onSigint = () => forwardSignal('SIGINT');
+    const onSigterm = () => forwardSignal('SIGTERM');
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    return {
+        cleanup,
+        getForwardedSignal: () => forwardedSignal,
+    };
+}
+function spawnSilent(cmd, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const spawnSpec = resolveSpawnSpec(cmd, args);
+        const child = spawn(spawnSpec.command, spawnSpec.args, {
+            stdio: 'pipe',
+            ...(spawnSpec.shell !== undefined ? { shell: spawnSpec.shell } : {}),
+            ...(spawnSpec.windowsVerbatimArguments !== undefined
+                ? {
+                    windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+                }
+                : {}),
+            ...(cwd ? { cwd } : {}),
+        });
+        const childSignals = forwardChildSignals(child, cmd);
+        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;
+            }
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${cmd} exited with code ${code}`));
+        });
+        child.on('error', (err) => {
+            childSignals.cleanup();
+            reject(err);
+        });
+    });
+}
+function spawnInherited(cmd, args, cwd, activityLabel = cmd) {
+    const spawnSpec = resolveSpawnSpec(cmd, args);
+    const child = spawn(spawnSpec.command, spawnSpec.args, {
+        stdio: 'inherit',
+        ...(spawnSpec.shell !== undefined ? { shell: spawnSpec.shell } : {}),
+        ...(spawnSpec.windowsVerbatimArguments !== undefined
+            ? {
+                windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+            }
+            : {}),
+        ...(cwd ? { cwd } : {}),
+    });
+    const childSignals = forwardChildSignals(child, activityLabel);
+    return new Promise((resolve, reject) => {
+        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;
+            }
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${cmd} exited with code ${code}`));
+        });
+        child.on('error', (err) => {
+            childSignals.cleanup();
+            reject(err);
+        });
+    });
+}
+export function parsePackageManager(value) {
+    if (value === undefined) {
+        return determinePackageManager();
+    }
+    if (value === 'npm' || value === 'pnpm') {
+        return value;
+    }
+    throw new Error('Expected package manager to be one of: npm, pnpm');
+}
+function getPackageManagerCommand(packageManager) {
+    if (packageManager === 'pnpm') {
+        return {
+            screenciRun: 'pnpm exec screenci',
+            playwrightRun: 'pnpm exec playwright',
+            installCommand: 'pnpm',
+            installArgs: (pkg) => ['add', '--save-dev', pkg],
+            skillsCommand: 'pnpm',
+            skillsArgs: (skills, agent) => [
+                'dlx',
+                'skills',
+                'add',
+                'screenci/screenci',
+                ...(agent ? ['--agent', agent] : []),
+                ...skills.flatMap((skillName) => ['--skill', skillName]),
+                '-y',
+            ],
+            skillsManualCommand: (skills, agent) => ['pnpm', 'dlx', 'skills', 'add', 'screenci/screenci']
+                .concat(agent ? ['--agent', agent] : [])
+                .concat(skills.flatMap((skillName) => ['--skill', skillName]))
+                .concat(['-y'])
+                .join(' '),
+            cacheName: 'pnpm',
+            lockfileName: 'pnpm-lock.yaml',
+        };
+    }
+    return {
+        screenciRun: 'npx screenci',
+        playwrightRun: 'npx playwright',
+        installCommand: 'npm',
+        installArgs: (pkg) => ['install', '--save-dev', pkg],
+        skillsCommand: 'npm',
+        skillsArgs: (skills, agent) => [
+            'exec',
+            '--yes',
+            '--package=skills',
+            '--',
+            'skills',
+            'add',
+            'screenci/screenci',
+            ...(agent ? ['--agent', agent] : []),
+            ...skills.flatMap((skillName) => ['--skill', skillName]),
+            '-y',
+        ],
+        skillsManualCommand: (skills, agent) => [
+            'npm',
+            'exec',
+            '--yes',
+            '--package=skills',
+            '--',
+            'skills',
+            'add',
+            'screenci/screenci',
+        ]
+            .concat(agent ? ['--agent', agent] : [])
+            .concat(skills.flatMap((skillName) => ['--skill', skillName]))
+            .concat(['-y'])
+            .join(' '),
+        cacheName: 'npm',
+        lockfileName: 'package-lock.json',
+    };
+}
+function generateEmptyPackageJson() {
+    return '{\n  "type": "module"\n}\n';
+}
+async function readCurrentScreenciVersion() {
+    const currentFileDir = dirname(fileURLToPath(import.meta.url));
+    const packageJsonPaths = [
+        resolve(currentFileDir, 'package.json'),
+        resolve(currentFileDir, '../package.json'),
+    ];
+    for (const packageJsonPath of packageJsonPaths) {
+        try {
+            const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+            if (typeof packageJson.version === 'string') {
+                return packageJson.version;
+            }
+        }
+        catch {
+            // Try the next candidate path.
+        }
+    }
+    return 'latest';
+}
+function generateGitignore() {
+    return `# ScreenCI
+.screenci
+.playwright-cli/
+.env
+
+# Playwright
+node_modules/
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+/playwright/.auth/
+`;
+}
+async function writeInitGitignore(projectDir) {
+    const gitignorePath = resolve(projectDir, '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        await writeFile(gitignorePath, generateGitignore());
+        return;
+    }
+    const existing = await readFile(gitignorePath, 'utf-8');
+    const separator = existing.length === 0
+        ? ''
+        : existing.endsWith('\n\n')
+            ? ''
+            : existing.endsWith('\n')
+                ? '\n'
+                : '\n\n';
+    await appendFile(gitignorePath, `${separator}${generateGitignore()}`);
+}
+async function installInitDependencies(projectDir, verbose, screenciDependency, includePlaywrightCli, packageManager) {
+    const commands = getPackageManagerCommand(packageManager);
+    const installSteps = [
+        {
+            message: 'Installing Playwright Test...',
+            args: commands.installArgs(`@playwright/test@${PLAYWRIGHT_TEST_VERSION}`),
+        },
+        {
+            message: 'Installing ScreenCI...',
+            args: commands.installArgs(`screenci@${screenciDependency}`),
+        },
+        {
+            message: 'Installing Node.js types...',
+            args: commands.installArgs(`@types/node@${NODE_TYPES_VERSION}`),
+        },
+    ];
+    if (includePlaywrightCli) {
+        installSteps.push({
+            message: 'Installing playwright-cli...',
+            args: commands.installArgs(`@playwright/cli@${PLAYWRIGHT_CLI_VERSION}`),
+        });
+    }
+    for (const step of installSteps) {
+        if (verbose) {
+            logger.info(`Running '${commands.installCommand} ${step.args.join(' ')}'...`);
+            await spawnInherited(commands.installCommand, step.args, projectDir, 'screenci init');
+        }
+        else {
+            const spinner = ora(step.message).start();
+            try {
+                await spawnSilent(commands.installCommand, step.args, projectDir);
+                spinner.succeed(step.message.replace(/\.\.\.$/, ' complete'));
+            }
+            catch (err) {
+                spinner.fail(step.message.replace(/\.\.\.$/, ' failed'));
+                throw err;
+            }
+        }
+    }
+}
+function printInitNextSteps(projectDir, packageManager) {
+    const resolvedProjectDir = realpathSync(projectDir);
+    const commands = getPackageManagerCommand(packageManager);
+    logger.info(`${pc.green('✔ Success!')} Created a ScreenCI project at ${resolvedProjectDir}`);
+    logger.info('');
+    logger.info('Inside that directory, you can run several commands:');
+    logger.info('');
+    logger.info(`  ${pc.cyan(`${commands.screenciRun} test`)}`);
+    logger.info('    Runs your video scripts in Playwright.');
+    logger.info('');
+    logger.info(`  ${pc.cyan(`${commands.screenciRun} test --ui`)}`);
+    logger.info('    Starts the interactive UI mode.');
+    logger.info('');
+    logger.info(`  ${pc.cyan(`${commands.screenciRun} test videos/example.video.ts`)}`);
+    logger.info('    Runs the example video script.');
+    logger.info('');
+    logger.info(`  ${pc.cyan(`${commands.screenciRun} record`)}`);
+    logger.info('    Records and uploads videos.');
+    logger.info('');
+    logger.info('We suggest that you begin by typing:');
+    logger.info('');
+    logger.info(`    ${pc.cyan(`${commands.screenciRun} test`)}`);
+    logger.info('');
+    logger.info('And check out the following files:');
+    logger.info('  - ./videos/example.video.ts - Example video script');
+    logger.info('  - ./screenci.config.ts - ScreenCI configuration');
+    logger.info('');
+    logger.info(`Visit ${pc.cyan('https://screenci.com/docs')} for more information.`);
+    logger.info('');
+    logger.info('Happy hacking! 🎥');
+}
+function generateGithubAction(packageManager) {
+    const commands = getPackageManagerCommand(packageManager);
+    return `name: ScreenCI
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  record:
+    runs-on: ubuntu-latest
+    environment:
+      name: screenci
+      url: \${{ steps.record.outputs.screenci_project_url }}
+    steps:
+      - name: Check SCREENCI_SECRET
+        env:
+          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 or ./.env, 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@v4
+        with:
+          node-version: 24
+          cache: ${commands.cacheName}
+          cache-dependency-path: ${commands.lockfileName}
+
+      - name: Install dependencies
+        working-directory: .
+        env:
+          HUSKY: 0
+          npm_config_strict_dep_builds: false
+        run: ${packageManager === 'pnpm' ? 'pnpm install --frozen-lockfile' : 'npm ci'}
+
+      - name: Cache Playwright Chromium
+        uses: actions/cache@v5
+        id: pw-cache
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-\${{ runner.os }}-\${{ hashFiles('${commands.lockfileName}') }}
+
+      - name: Install Chromium
+        if: steps.pw-cache.outputs.cache-hit != 'true'
+        working-directory: .
+        run: ${commands.playwrightRun} install chromium
+
+      - id: record
+        name: Record
+        working-directory: .
+        env:
+          SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
+        run: ${commands.screenciRun} record
+`;
+}
+function generateExampleVideo() {
+    return `import { autoZoom, createNarration, hide, video, voices } from 'screenci'
+
+const narration = createNarration({
+  voice: { name: voices.Sophie },
+  languages: {
+    en: {
+      cues: {
+        intro:
+          'This video shows how to get started with ScreenCI [pronounce: screen see eye].',
+        docs: 'You can find the documentation linked right on the front page.',
+      },
+    },
+  },
+})
+
+video('How to get started', async ({ page }) => {
+  await hide(async () => {
+    await page.goto('https://screenci.com')
+    await page.waitForLoadState('networkidle');
+  })
+
+  await narration.intro()
+  await narration.docs()
+
+  await autoZoom(async () => {
+    await page.getByRole('link', { name: 'View Documentation' }).click()
+  })
+
+})
+`;
+}
+function getInitProjectRoot() {
+    return process.env['SCREENCI_INIT_CWD'] ?? process.cwd();
+}
+function getDefaultInitProjectName() {
+    const directoryName = basename(getInitProjectRoot());
+    return directoryName.length > 0 ? directoryName : 'screenci-project';
+}
+async function promptProjectName() {
+    return input({
+        message: 'Project name:',
+        default: getDefaultInitProjectName(),
+    });
+}
+async function promptYesNo(message, defaultValue) {
+    const answer = await input({
+        message,
+        default: defaultValue ? 'y' : 'n',
+        validate: (value) => {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === '' ||
+                normalized === 'y' ||
+                normalized === 'yes' ||
+                normalized === 'n' ||
+                normalized === 'no') {
+                return true;
+            }
+            return 'Enter y or n';
+        },
+    });
+    const normalized = answer.trim().toLowerCase();
+    if (normalized === '')
+        return defaultValue;
+    return normalized === 'y' || normalized === 'yes';
+}
+async function promptInitGithubActionWorkflow() {
+    return promptYesNo('Add a GitHub Actions workflow? (Y/n)', true);
+}
+async function promptInitPlaywrightBrowsersForPackageManager(packageManager) {
+    const commands = getPackageManagerCommand(packageManager);
+    return promptYesNo(`Install Playwright browsers (can be done manually via '${commands.playwrightRun} install chromium')? (Y/n)`, true);
+}
+async function promptInitPlaywrightOsDependenciesForPackageManager(packageManager) {
+    const commands = getPackageManagerCommand(packageManager);
+    return promptYesNo(`Install Playwright operating system dependencies (might require sudo / root and can be done manually via '${commands.playwrightRun} install-deps chromium')? (y/N)`, false);
+}
+async function promptInitScreenCISkill(packageManager) {
+    const commands = getPackageManagerCommand(packageManager);
+    return promptYesNo(`Install the ScreenCI skill for AI agents (can be done manually via '${commands.skillsManualCommand(['screenci'])}')? (Y/n)`, true);
+}
+async function promptInitPlaywrightCliSkillForPackageManager(packageManager) {
+    const installPlaywrightCli = packageManager === 'pnpm'
+        ? 'pnpm add --save-dev @playwright/cli'
+        : 'npm install @playwright/cli';
+    const commands = getPackageManagerCommand(packageManager);
+    return promptYesNo(`Install playwright-cli for URL-based browser inspection (can be done manually via '${commands.skillsManualCommand(['playwright-cli'])} && ${installPlaywrightCli}')? (Y/n)`, true);
+}
+function getInitScreenciDependencyOverride() {
+    return process.env['SCREENCI_INIT_SCREENCI_DEPENDENCY'];
+}
+export async function runInit(projectNameArg, options) {
+    const { verbose, yes, agent, packageManager } = options;
+    const commands = getPackageManagerCommand(packageManager);
+    const initCwd = getInitProjectRoot();
+    let projectName = projectNameArg?.trim();
+    if (!projectName) {
+        projectName = yes ? getDefaultInitProjectName() : await promptProjectName();
+    }
+    if (!projectName) {
+        logger.error('Error: Project name is required');
+        process.exit(1);
+    }
+    const projectDir = initCwd;
+    const githubWorkflowsDir = resolve(projectDir, '.github', 'workflows');
+    const githubActionPath = resolve(githubWorkflowsDir, 'screenci.yaml');
+    const shouldAddGithubActionWorkflow = yes
+        ? true
+        : await promptInitGithubActionWorkflow();
+    const shouldInstallPlaywrightBrowsers = yes
+        ? true
+        : await promptInitPlaywrightBrowsersForPackageManager(packageManager);
+    const shouldInstallPlaywrightOsDependencies = yes
+        ? false
+        : await promptInitPlaywrightOsDependenciesForPackageManager(packageManager);
+    const shouldInstallScreenCISkill = yes
+        ? true
+        : await promptInitScreenCISkill(packageManager);
+    const shouldInstallPlaywrightCli = yes
+        ? true
+        : await promptInitPlaywrightCliSkillForPackageManager(packageManager);
+    if (shouldAddGithubActionWorkflow && existsSync(githubActionPath)) {
+        logger.error('Error: GitHub Actions workflow ".github/workflows/screenci.yaml" already exists');
+        process.exit(1);
+    }
+    const skills = [];
+    if (shouldInstallScreenCISkill) {
+        skills.push('screenci');
+    }
+    if (shouldInstallPlaywrightCli) {
+        skills.push('playwright-cli');
+    }
+    const skillsArgs = skills.length === 0 ? null : commands.skillsArgs(skills, agent);
+    const skillsCommand = skillsArgs === null
+        ? null
+        : `${commands.skillsCommand} ${skillsArgs.join(' ')}`;
+    const screenciDependency = getInitScreenciDependencyOverride() ?? (await readCurrentScreenciVersion());
+    const packageJsonPath = resolve(projectDir, 'package.json');
+    const hasExistingPackageJson = existsSync(packageJsonPath);
+    logger.info("Initializing project in '.'");
+    await mkdir(resolve(projectDir, 'videos'), { recursive: true });
+    if (shouldAddGithubActionWorkflow) {
+        await mkdir(githubWorkflowsDir, { recursive: true });
+    }
+    await writeFile(resolve(projectDir, 'screenci.config.ts'), generateConfig(projectName));
+    if (!hasExistingPackageJson) {
+        await writeFile(packageJsonPath, generateEmptyPackageJson());
+    }
+    await writeInitGitignore(projectDir);
+    await writeFile(resolve(projectDir, 'videos', 'example.video.ts'), generateExampleVideo());
+    if (shouldAddGithubActionWorkflow) {
+        await writeFile(githubActionPath, generateGithubAction(packageManager));
+    }
+    if (skillsArgs !== null) {
+        if (verbose) {
+            logger.info(`Running '${skillsCommand}'...`);
+            await spawnInherited(commands.skillsCommand, skillsArgs, projectDir, 'screenci init');
+        }
+        else {
+            const spinner = ora('Adding selected AI skills...').start();
+            try {
+                await spawnSilent(commands.skillsCommand, skillsArgs, projectDir);
+                spinner.succeed('Selected AI skills added');
+            }
+            catch (err) {
+                spinner.fail('AI skills install failed');
+                throw err;
+            }
+        }
+    }
+    await installInitDependencies(projectDir, verbose, screenciDependency, shouldInstallPlaywrightCli, packageManager);
+    if (shouldInstallPlaywrightBrowsers) {
+        logger.info(`Installing Playwright Chromium with '${commands.playwrightRun} install chromium'...`);
+        await spawnInherited(packageManager === 'pnpm' ? 'pnpm' : 'npx', packageManager === 'pnpm'
+            ? ['exec', 'playwright', 'install', 'chromium']
+            : ['playwright', 'install', 'chromium'], projectDir, 'screenci init');
+        logger.info(`${pc.green('✔')} Playwright Chromium installed successfully`);
+    }
+    if (shouldInstallPlaywrightOsDependencies) {
+        logger.info(`Installing Playwright operating system dependencies with '${commands.playwrightRun} install-deps chromium'...`);
+        await spawnInherited(packageManager === 'pnpm' ? 'pnpm' : 'npx', packageManager === 'pnpm'
+            ? ['exec', 'playwright', 'install-deps', 'chromium']
+            : ['playwright', 'install-deps', 'chromium'], projectDir, 'screenci init');
+        logger.info(`${pc.green('✔')} Playwright operating system dependencies installed successfully`);
+    }
+    printInitNextSteps(projectDir, packageManager);
+}
+function handleCreateCommanderError(err) {
+    if (!(err instanceof CommanderError)) {
+        throw err;
+    }
+    if (err.code === 'commander.help' || err.code === 'commander.helpDisplayed') {
+        return;
+    }
+    logger.error(`Error: ${err.message}`);
+    process.exit(1);
+}
+export async function runCreateScreenciCli(argv = process.argv) {
+    const defaultPackageManager = determinePackageManager();
+    const program = new Command();
+    program.name('create-screenci');
+    program.description('Initialize a new screenci project');
+    program.argument('[name]');
+    program.exitOverride();
+    program.option('--agent <name>', 'target agent for skills install, e.g. opencode. Supported agents: https://github.com/vercel-labs/skills#supported-agents');
+    program.option('--package-manager <manager>', `package manager to use: npm or pnpm (default: ${defaultPackageManager})`);
+    program.option('-y, --yes', 'accept init defaults');
+    program.option('-v, --verbose', 'verbose output');
+    program.action(async (name, options) => {
+        const agent = options['agent'];
+        await runInit(name, {
+            verbose: options['verbose'] ?? false,
+            yes: options['yes'] ?? false,
+            packageManager: parsePackageManager(options['packageManager']),
+            ...(agent !== undefined ? { agent } : {}),
+        });
+    });
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (err) {
+        handleCreateCommanderError(err);
+    }
+}
+function generateConfig(projectName) {
+    return `import { defineConfig } from 'screenci'
+
+export default defineConfig({
+  projectName: ${JSON.stringify(projectName)},
+  envFile: '.env',
+  videoDir: './videos',
+  /* Run videos in files in parallel */
+  fullyParallel: true,
+  /* Opt out of parallel tests on CI. */
+  workers: process.env.CI ? 1 : undefined,
+  use: {
+    recordOptions: {
+      aspectRatio: '16:9',
+      quality: '1080p',
+      fps: 60,
+    },
+  },
+  projects: [
+    {
+      name: 'chromium',
+    },
+  ],
+})
+`;
+}
+//# sourceMappingURL=init.js.map