screenci 0.0.63 → 0.0.64

package/dist/src/init.js

@@ -1,7 +1,7 @@
 import { spawn } from 'child_process';
-import { existsSync, readFileSync, realpathSync } from 'fs';
+import { existsSync, readFileSync, realpathSync, rmSync } from 'fs';
 import { appendFile, mkdir, readFile, writeFile } from 'fs/promises';
-import { basename, delimiter, dirname, resolve } from 'path';
+import { basename, delimiter, dirname, relative, resolve, sep } from 'path';
 import { fileURLToPath } from 'url';
 import { Command, CommanderError } from 'commander';
 import { input } from '@inquirer/prompts';
@@ -47,14 +47,22 @@ export function detectPackageManagerFromPackageJson(dir) {
     return null;
 }
 export function determinePackageManager(cwd) {
+    // 1. The package manager that spawned the process is explicit intent
+    //    (`pnpm create screenci`, `yarn create screenci`, `npm init screenci`) and
+    //    always wins — including npm, so `npm init` gives an npm island even in a
+    //    pnpm/yarn repo. Check pnpm/yarn before npm because their user-agent
+    //    strings also contain an `npm/...` segment.
     const userAgent = process.env.npm_config_user_agent;
     if (userAgent?.includes('pnpm'))
         return 'pnpm';
     if (userAgent?.includes('yarn'))
         return 'yarn';
-    // Filesystem detection is only performed during init (when cwd is provided).
-    // record/test commands rely solely on the user agent, which correctly reflects
-    // how the CLI was invoked (e.g. "pnpm exec screenci record" sets the agent).
+    if (userAgent?.includes('npm'))
+        return 'npm';
+    // 2. No package-manager wrapper set a user agent (e.g. a global or direct
+    //    `screenci init`). Fall back to the surrounding repo's toolchain so the
+    //    island matches it, then to npm. Pass `--package-manager` to override.
+    //    (record/test pass no cwd and rely solely on the user agent.)
     if (cwd !== undefined) {
         const fromLockfile = detectPackageManagerFromLockfile(cwd);
         if (fromLockfile)
@@ -77,15 +85,31 @@ export function detectPnpmWorkspace(cwd) {
     }
     return false;
 }
-function detectYarnWorkspace(cwd) {
-    try {
-        const raw = readFileSync(resolve(cwd, 'package.json'), 'utf-8');
-        const pkg = JSON.parse(raw);
-        return pkg.workspaces !== undefined;
-    }
-    catch {
-        return false;
+/**
+ * Locate the repository root by walking up from `startDir` until a `.git`
+ * directory is found. Used to place the GitHub Actions workflow (which GitHub
+ * only discovers at the repo root) and the agent skills. Falls back to
+ * `startDir` when no `.git` is found.
+ */
+function findRepoRoot(startDir) {
+    let current = startDir;
+    while (true) {
+        if (existsSync(resolve(current, '.git')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
     }
+    return startDir;
+}
+/**
+ * Convert a filesystem-relative path to a POSIX-style path suitable for YAML
+ * `working-directory` / `cache-dependency-path` fields in the workflow.
+ */
+function toWorkflowPath(relativePath) {
+    const normalized = relativePath.split(sep).join('/');
+    return normalized.length === 0 ? '.' : normalized;
 }
 function resolveSpawnSpec(cmd, args) {
     if (process.platform !== 'win32') {
@@ -314,7 +338,12 @@ function getPackageManagerCommand(packageManager, isWorkspace = false) {
             screenciRun: 'pnpm exec screenci',
             playwrightRun: 'pnpm exec playwright',
             installCommand: 'pnpm',
-            installArgs: (pkg) => ['add', '--save-dev', ...workspaceFlag, pkg],
+            installArgs: (...pkgs) => [
+                'add',
+                '--save-dev',
+                ...workspaceFlag,
+                ...pkgs,
+            ],
             screenciInstallArgs: (pkg) => [
                 'add',
                 '--save-dev',
@@ -343,7 +372,7 @@ function getPackageManagerCommand(packageManager, isWorkspace = false) {
             screenciRun: 'yarn screenci',
             playwrightRun: 'yarn playwright',
             installCommand: 'yarn',
-            installArgs: (pkg) => ['add', '--dev', ...workspaceFlag, pkg],
+            installArgs: (...pkgs) => ['add', '--dev', ...workspaceFlag, ...pkgs],
             screenciInstallArgs: (pkg) => ['add', '--dev', ...workspaceFlag, pkg],
             skillsCommand: 'yarn',
             skillsArgs: (skills, agent) => [
@@ -364,7 +393,7 @@ function getPackageManagerCommand(packageManager, isWorkspace = false) {
         screenciRun: 'npx screenci',
         playwrightRun: 'npx playwright',
         installCommand: 'npm',
-        installArgs: (pkg) => ['install', '--save-dev', pkg],
+        installArgs: (...pkgs) => ['install', '--save-dev', ...pkgs],
         screenciInstallArgs: (pkg) => ['install', '--save-dev', pkg],
         skillsCommand: 'npm',
         skillsArgs: (skills, agent) => [
@@ -405,21 +434,112 @@ function getSkillsManualCommand(packageManager, skills, agent) {
         .concat(['-y'])
         .join(' ');
 }
-function generateEmptyPackageJson() {
-    return '{\n  "type": "module"\n}\n';
+/**
+ * Turn a human project name into a valid npm package name for the island's own
+ * package.json. We use the project name (the repository root directory name by
+ * default) directly. The name must NOT be `screenci` (a package cannot depend
+ * on a package with its own name), so we fall back to `screenci-videos` only
+ * when the slug is empty or would collide with `screenci`.
+ */
+export function toIslandPackageName(projectName) {
+    const slug = projectName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (slug.length === 0 || slug === 'screenci') {
+        return 'screenci-videos';
+    }
+    return slug;
 }
-async function ensurePackageJsonTypeModule(packageJsonPath) {
-    try {
-        const raw = await readFile(packageJsonPath, 'utf-8');
-        const pkg = JSON.parse(raw);
-        if (pkg['type'] === 'module')
-            return;
-        pkg['type'] = 'module';
-        await writeFile(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+function generateIslandPackageJson(projectName) {
+    return (JSON.stringify({
+        name: toIslandPackageName(projectName),
+        private: true,
+        type: 'module',
+        scripts: {
+            test: 'screenci test',
+            record: 'screenci record',
+        },
+    }, null, 2) + '\n');
+}
+function generateIslandTsconfig() {
+    // Minimal config so an editor type-checks the island as its own project
+    // instead of inheriting a surrounding repo's tsconfig or the legacy TS
+    // defaults. `module`/`moduleResolution` let TypeScript read screenci's ESM
+    // `exports` map; `target` gives the example's async/await a modern lib.
+    return (JSON.stringify({
+        compilerOptions: {
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            target: 'ESNext',
+        },
+    }, null, 2) + '\n');
+}
+/**
+ * Resolve the package-manager-specific command a user types to run the island's
+ * own `test` / `record` scripts. npm needs `run` for non-`test` scripts and `--`
+ * to forward flags; pnpm and yarn forward both implicitly.
+ */
+function getIslandScriptInvocations(packageManager) {
+    if (packageManager === 'pnpm') {
+        return {
+            test: 'pnpm test',
+            testUi: 'pnpm test --ui',
+            record: 'pnpm record',
+        };
     }
-    catch {
-        // Malformed or unreadable package.json — leave it untouched.
+    if (packageManager === 'yarn') {
+        return {
+            test: 'yarn test',
+            testUi: 'yarn test --ui',
+            record: 'yarn record',
+        };
     }
+    return {
+        test: 'npm test',
+        testUi: 'npm test -- --ui',
+        record: 'npm run record',
+    };
+}
+export function generateIslandReadme(projectName, packageManager) {
+    const scripts = getIslandScriptInvocations(packageManager);
+    return `# ${projectName}
+
+ScreenCI video scripts for this project. Edit the \`*.video.ts\` files in
+\`videos/\` to script your recordings.
+
+## Commands
+
+- \`${scripts.test}\` tests your video scripts fast locally.
+- \`${scripts.testUi}\` tests your video scripts in interactive UI mode.
+- \`${scripts.record}\` records and pauses for first-time setup if needed.
+
+## Learn more
+
+Visit https://screenci.com/docs for the full documentation.
+`;
+}
+function generatePnpmWorkspaceYaml(pnpmMajor) {
+    // A nested `pnpm-workspace.yaml` makes pnpm treat the island as its own
+    // workspace root, so a surrounding monorepo workspace does not absorb it (no
+    // hoisting, no `-w` install). It also pre-approves the ffmpeg-static build
+    // script so non-interactive installs (e.g. `pnpm install --frozen-lockfile`
+    // in CI) build the bundled binary without prompting.
+    //
+    // pnpm 10 and 11 spell this approval differently: pnpm 11 removed
+    // `onlyBuiltDependencies` in favour of the `allowBuilds` map. Emit the key
+    // that matches the installed pnpm so the approval is actually honoured.
+    const buildApproval = pnpmMajor >= 11
+        ? `allowBuilds:
+  ffmpeg-static: true
+`
+        : `onlyBuiltDependencies:
+  - ffmpeg-static
+`;
+    return `packages:
+  - '.'
+
+${buildApproval}`;
 }
 function parseSemverTriplet(version) {
     const match = version
@@ -522,6 +642,15 @@ async function ensureSupportedPnpmVersion(cwd) {
     if (!versionSupport.supported) {
         throw buildUnsupportedPnpmError(versionSupport);
     }
+    return versionSupport;
+}
+// A supported pnpm version always parses (the support check rejects malformed
+// versions), so the major is reliable here; fall back to 10 defensively.
+function pnpmMajorFromSupport(versionSupport) {
+    const parsed = versionSupport.detectedVersion
+        ? parseSemverTriplet(versionSupport.detectedVersion)
+        : null;
+    return parsed?.[0] ?? 10;
 }
 export function parseYarnVersionSupport(versionOutput) {
     const detectedVersion = versionOutput.trim();
@@ -642,26 +771,27 @@ async function writeInitGitignore(projectDir, packageManager) {
     await appendFile(gitignorePath, `${separator}${content}`);
 }
 async function installInitDependencies(projectDir, verbose, screenciDependency, includePlaywrightCli, commands) {
+    // Packages that share identical install flags are installed in a single
+    // command so the package manager resolves the dependency graph once instead
+    // of once per package. ScreenCI stays separate because on pnpm it needs an
+    // extra '--allow-build=ffmpeg-static' flag the others don't carry.
+    const sharedPackages = [
+        `@playwright/test@${PLAYWRIGHT_TEST_VERSION}`,
+        `@types/node@${NODE_TYPES_VERSION}`,
+        ...(includePlaywrightCli
+            ? [`@playwright/cli@${PLAYWRIGHT_CLI_VERSION}`]
+            : []),
+    ];
     const installSteps = [
         {
-            message: 'Installing Playwright Test...',
-            args: commands.installArgs(`@playwright/test@${PLAYWRIGHT_TEST_VERSION}`),
+            message: 'Installing dependencies...',
+            args: commands.installArgs(...sharedPackages),
         },
         {
             message: 'Installing ScreenCI...',
             args: commands.screenciInstallArgs(`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(' ')}'...`);
@@ -680,12 +810,12 @@ async function installInitDependencies(projectDir, verbose, screenciDependency,
         }
     }
 }
-function printInitNextSteps(projectDir, packageManager) {
+function printInitNextSteps(projectDir, islandDirName, 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('You can now run these commands:');
     logger.info('');
     logger.info(`  ${pc.cyan(`${commands.screenciRun} test`)}`);
     logger.info('    Tests your video scripts fast locally.');
@@ -698,18 +828,23 @@ function printInitNextSteps(projectDir, packageManager) {
     logger.info('');
     logger.info('We suggest that you begin by typing:');
     logger.info('');
+    logger.info(`    ${pc.cyan(`cd ${islandDirName}`)}`);
     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(`  - ./${islandDirName}/videos/example.video.ts - Example video script`);
+    logger.info(`  - ./${islandDirName}/screenci.config.ts - ScreenCI configuration`);
+    logger.info(`  - ./${islandDirName}/README.md - Project commands and docs link`);
     logger.info('');
     logger.info(`Visit ${pc.cyan('https://screenci.com/docs')} for more information.`);
     logger.info('');
     logger.info('Happy hacking! 🎥');
 }
-function generateGithubAction(packageManager, isWorkspace = false) {
-    const commands = getPackageManagerCommand(packageManager, isWorkspace);
+function generateGithubAction(packageManager, islandWorkflowPath) {
+    const commands = getPackageManagerCommand(packageManager);
+    const cacheDependencyPath = islandWorkflowPath === '.'
+        ? commands.lockfileName
+        : `${islandWorkflowPath}/${commands.lockfileName}`;
     return `name: ScreenCI
 
 on:
@@ -739,22 +874,22 @@ jobs:
         with:
           node-version: 24
           cache: ${commands.cacheName}
-          cache-dependency-path: ${commands.lockfileName}
+          cache-dependency-path: ${cacheDependencyPath}
 
       - name: Install dependencies
-        working-directory: .
+        working-directory: ${islandWorkflowPath}
         env:
           HUSKY: 0
           npm_config_strict_dep_builds: false
         run: ${commands.frozenInstallCommand}
 
       - name: Install Chromium Headless Shell
-        working-directory: .
+        working-directory: ${islandWorkflowPath}
         run: ${commands.playwrightRun} install --only-shell chromium
 
       - id: record
         name: Record
-        working-directory: .
+        working-directory: ${islandWorkflowPath}
         env:
           SCREENCI_SECRET: \${{ secrets.SCREENCI_SECRET }}
         run: ${commands.screenciRun} record
@@ -854,12 +989,20 @@ function getInitScreenciDependencyOverride() {
 export async function runInit(projectNameArg, options) {
     const { verbose, yes, agent, packageManager } = options;
     const initCwd = getInitProjectRoot();
-    const isWorkspace = packageManager === 'pnpm'
-        ? detectPnpmWorkspace(initCwd)
-        : packageManager === 'yarn'
-            ? detectYarnWorkspace(initCwd)
-            : false;
-    const commands = getPackageManagerCommand(packageManager, isWorkspace);
+    const commands = getPackageManagerCommand(packageManager);
+    // ScreenCI scaffolds a self-contained `screenci/` island under the current
+    // directory: its own package.json + local install, deliberately NOT a member
+    // of any surrounding workspace. This keeps installation deterministic in
+    // monorepos. The GitHub workflow and agent skills, however, must live at the
+    // repository root (that is where GitHub and coding agents discover them).
+    const repoRoot = findRepoRoot(initCwd);
+    const islandDir = resolve(initCwd, 'screenci');
+    const islandDirName = toWorkflowPath(relative(initCwd, islandDir));
+    const islandWorkflowPath = toWorkflowPath(relative(repoRoot, islandDir));
+    if (existsSync(islandDir)) {
+        logger.error(`Error: ${islandDirName}/ already exists. Remove it (or run init in a different directory) and try again.`);
+        process.exit(1);
+    }
     if (packageManager === 'yarn') {
         await ensureSupportedYarnVersion(initCwd);
     }
@@ -871,8 +1014,7 @@ export async function runInit(projectNameArg, options) {
         logger.error('Error: Project name is required');
         process.exit(1);
     }
-    const projectDir = initCwd;
-    const githubWorkflowsDir = resolve(projectDir, '.github', 'workflows');
+    const githubWorkflowsDir = resolve(repoRoot, '.github', 'workflows');
     const githubActionPath = resolve(githubWorkflowsDir, 'screenci.yaml');
     const shouldAddGithubActionWorkflow = yes
         ? true
@@ -889,10 +1031,13 @@ export async function runInit(projectNameArg, options) {
     const shouldInstallPlaywrightCli = yes
         ? true
         : await promptInitPlaywrightCliSkillForPackageManager(packageManager, agent);
-    if (shouldAddGithubActionWorkflow && existsSync(githubActionPath)) {
-        logger.error('Error: GitHub Actions workflow ".github/workflows/screenci.yaml" already exists');
-        process.exit(1);
+    // The workflow lives at the repo root. If one already exists, skip it (do not
+    // overwrite, do not fail) so re-running init stays non-destructive.
+    const workflowAlreadyExists = shouldAddGithubActionWorkflow && existsSync(githubActionPath);
+    if (workflowAlreadyExists) {
+        logger.info(`Skipping GitHub Actions workflow: ${toWorkflowPath(relative(repoRoot, githubActionPath))} already exists`);
     }
+    const shouldWriteGithubActionWorkflow = shouldAddGithubActionWorkflow && !workflowAlreadyExists;
     const skills = [];
     if (shouldInstallScreenCISkill) {
         skills.push('screenci');
@@ -905,61 +1050,99 @@ export async function runInit(projectNameArg, options) {
         ? null
         : `${commands.skillsCommand} ${skillsArgs.join(' ')}`;
     const screenciDependency = getInitScreenciDependencyOverride() ?? (await readCurrentScreenciVersion());
-    const packageJsonPath = resolve(projectDir, 'package.json');
-    const hasExistingPackageJson = existsSync(packageJsonPath);
-    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());
-    }
-    else {
-        await ensurePackageJsonTypeModule(packageJsonPath);
-    }
-    await writeInitGitignore(projectDir, packageManager);
-    await writeFile(resolve(projectDir, 'videos', 'example.video.ts'), generateExampleVideo());
-    if (shouldAddGithubActionWorkflow) {
-        await writeFile(githubActionPath, generateGithubAction(packageManager, isWorkspace));
-    }
-    if (packageManager === 'pnpm') {
-        await ensureSupportedPnpmVersion(projectDir);
-    }
-    if (packageManager === 'yarn') {
-        await writeFile(resolve(projectDir, '.yarnrc.yml'), 'nodeLinker: node-modules\n');
-    }
-    if (skillsArgs !== null) {
-        if (verbose) {
-            logger.info(`Running '${skillsCommand}'...`);
-            await spawnInherited(commands.skillsCommand, skillsArgs, projectDir, 'screenci init');
+    // Everything below creates files / runs installs. If anything fails (or the
+    // user interrupts), roll back the `screenci/` directory we created so the
+    // next `init` run starts from a clean slate. Pre-existing repo-root files
+    // (e.g. .github/, .claude/) are left untouched.
+    let islandCreated = false;
+    let scaffoldComplete = false;
+    const removePartialIsland = () => {
+        if (!islandCreated || scaffoldComplete)
+            return;
+        try {
+            rmSync(islandDir, { recursive: true, force: true });
         }
-        else {
-            const spinner = ora('Adding selected AI skills...').start();
-            try {
-                await spawnSilent(commands.skillsCommand, skillsArgs, projectDir);
-                spinner.succeed('Installing selected AI skills');
+        catch {
+            // best-effort cleanup
+        }
+    };
+    const onSigint = () => {
+        removePartialIsland();
+        process.exit(130);
+    };
+    const onSigterm = () => {
+        removePartialIsland();
+        process.exit(143);
+    };
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    process.on('exit', removePartialIsland);
+    try {
+        await mkdir(resolve(islandDir, 'videos'), { recursive: true });
+        islandCreated = true;
+        await writeFile(resolve(islandDir, 'screenci.config.ts'), generateConfig(projectName));
+        await writeFile(resolve(islandDir, 'package.json'), generateIslandPackageJson(projectName));
+        await writeFile(resolve(islandDir, 'tsconfig.json'), generateIslandTsconfig());
+        await writeFile(resolve(islandDir, 'README.md'), generateIslandReadme(projectName, packageManager));
+        await writeInitGitignore(islandDir, packageManager);
+        await writeFile(resolve(islandDir, 'videos', 'example.video.ts'), generateExampleVideo());
+        if (packageManager === 'pnpm') {
+            // Resolve (and gate on) the pnpm version before writing the workspace
+            // file so the build-approval key matches the installed pnpm.
+            const pnpmVersionSupport = await ensureSupportedPnpmVersion(islandDir);
+            await writeFile(resolve(islandDir, 'pnpm-workspace.yaml'), generatePnpmWorkspaceYaml(pnpmMajorFromSupport(pnpmVersionSupport)));
+        }
+        if (packageManager === 'yarn') {
+            await writeFile(resolve(islandDir, '.yarnrc.yml'), 'nodeLinker: node-modules\n');
+        }
+        if (shouldWriteGithubActionWorkflow) {
+            await mkdir(githubWorkflowsDir, { recursive: true });
+            await writeFile(githubActionPath, generateGithubAction(packageManager, islandWorkflowPath));
+        }
+        // Install skills at the repo root so coding agents discover them when the
+        // repository is opened as the workspace.
+        if (skillsArgs !== null) {
+            if (verbose) {
+                logger.info(`Running '${skillsCommand}'...`);
+                await spawnInherited(commands.skillsCommand, skillsArgs, repoRoot, 'screenci init');
             }
-            catch (err) {
-                spinner.fail('AI skills install failed');
-                throw err;
+            else {
+                const spinner = ora('Adding selected AI skills...').start();
+                try {
+                    await spawnSilent(commands.skillsCommand, skillsArgs, repoRoot);
+                    spinner.succeed('Installing selected AI skills');
+                }
+                catch (err) {
+                    spinner.fail('AI skills install failed');
+                    throw err;
+                }
             }
         }
+        await installInitDependencies(islandDir, verbose, screenciDependency, shouldInstallPlaywrightCli, commands);
+        if (shouldInstallPlaywrightBrowsers) {
+            logger.info(`Installing Playwright Chromium headless shell with '${commands.playwrightRun} install --only-shell chromium'...`);
+            const [browserCmd, ...browserArgs] = buildPlaywrightSpawnArgs(packageManager, 'install', '--only-shell', 'chromium');
+            await spawnInherited(browserCmd, browserArgs, islandDir, 'screenci init');
+            logger.info(`${pc.green('✔')} Playwright Chromium headless shell installed successfully`);
+        }
+        if (shouldInstallPlaywrightOsDependencies) {
+            logger.info(`Installing Playwright operating system dependencies with '${commands.playwrightRun} install-deps chromium'...`);
+            const [depsCmd, ...depsArgs] = buildPlaywrightSpawnArgs(packageManager, 'install-deps', 'chromium');
+            await spawnInherited(depsCmd, depsArgs, islandDir, 'screenci init');
+            logger.info(`${pc.green('✔')} Playwright operating system dependencies installed successfully`);
+        }
+        scaffoldComplete = true;
     }
-    await installInitDependencies(projectDir, verbose, screenciDependency, shouldInstallPlaywrightCli, commands);
-    if (shouldInstallPlaywrightBrowsers) {
-        logger.info(`Installing Playwright Chromium headless shell with '${commands.playwrightRun} install --only-shell chromium'...`);
-        const [browserCmd, ...browserArgs] = buildPlaywrightSpawnArgs(packageManager, 'install', '--only-shell', 'chromium');
-        await spawnInherited(browserCmd, browserArgs, projectDir, 'screenci init');
-        logger.info(`${pc.green('✔')} Playwright Chromium headless shell installed successfully`);
+    catch (err) {
+        removePartialIsland();
+        throw err;
     }
-    if (shouldInstallPlaywrightOsDependencies) {
-        logger.info(`Installing Playwright operating system dependencies with '${commands.playwrightRun} install-deps chromium'...`);
-        const [depsCmd, ...depsArgs] = buildPlaywrightSpawnArgs(packageManager, 'install-deps', 'chromium');
-        await spawnInherited(depsCmd, depsArgs, projectDir, 'screenci init');
-        logger.info(`${pc.green('✔')} Playwright operating system dependencies installed successfully`);
+    finally {
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
+        process.off('exit', removePartialIsland);
     }
-    printInitNextSteps(projectDir, packageManager);
+    printInitNextSteps(islandDir, islandDirName, packageManager);
 }
 function handleCreateCommanderError(err) {
     if (!(err instanceof CommanderError)) {