@smoothbricks/cli 0.10.7 → 0.10.9

package/src/monorepo/ci-workflow.ts

@@ -47,7 +47,7 @@ export function defineCiWorkflow(options: CiWorkflowDefinitionOptions): CiWorkfl
     { kind: CiWorkflowStepKind.ManagedFilesDispatch, name: '🔁 Dispatch managed-file drift healing' },
   ];
   if (options.deploy) {
-    steps.push({ kind: CiWorkflowStepKind.Deploy, name: '🚀 Deploy Staging' });
+    steps.push({ kind: CiWorkflowStepKind.Deploy, name: '🚀 Deploy Environment' });
   }
   steps.push(
     { kind: CiWorkflowStepKind.SaveNxCache, name: '💾 Save Nx cache' },
@@ -75,7 +75,7 @@ permissions:
   # actions:write lets the drift step dispatch the managed-files workflow.
   actions: write
   contents: read
-  statuses: write
+${options.deploy ? '  deployments: write\n' : ''}  statuses: write
 
 defaults:
   run:
@@ -197,11 +197,15 @@ function yamlLinesForStep(step: CiWorkflowStep, options: CiWorkflowDefinitionOpt
     case CiWorkflowStepKind.Deploy:
       return [
         `      - name: ${step.name}`,
-        '        if:',
-        "          ${{ github.event_name == 'push' && github.ref == format('refs/heads/{0}',",
-        '          github.event.repository.default_branch) }}',
+        '        if: >-',
+        '          ${{',
+        "            (github.event_name == 'pull_request' &&",
+        '              contains(fromJSON(\'["opened","reopened","synchronize"]\'), github.event.action) &&',
+        '              github.event.pull_request.head.repo.full_name == github.repository) ||',
+        "            (github.event_name == 'push' && github.ref == 'refs/heads/private')",
+        '          }}',
         ...deployEnvLines(options),
-        `        run: smoo github-ci nx-deploy --configuration staging --mode affected --name "Deploy Staging" --step ${step.number}`,
+        `        run: smoo github-ci nx-deploy --mode run-many --name "Deploy Environment" --step ${step.number}`,
       ];
     case CiWorkflowStepKind.SaveNxCache:
       return [
@@ -251,6 +255,12 @@ function deployEnvLines(options: CiWorkflowDefinitionOptions): string[] {
     '        env:',
     '          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}',
     '          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}',
+    '          GITHUB_CLIENT_SECRET: ${{ secrets.GITHUB_CLIENT_SECRET }}',
+    '          GITHUB_APP_PRIVATE_KEY: ${{ secrets.GITHUB_APP_PRIVATE_KEY }}',
+    '          GITHUB_APP_PRIVATE_KEY_PEM: ${{ secrets.GITHUB_APP_PRIVATE_KEY_PEM }}',
+    '          OAUTH_STATE_SIGNING_KEY: ${{ secrets.OAUTH_STATE_SIGNING_KEY }}',
+    '          MAIL_CAPTURE_CONTROL_TOKEN: ${{ secrets.MAIL_CAPTURE_CONTROL_TOKEN }}',
+    '          TOKEN_ENCRYPTION_KEY: ${{ secrets.TOKEN_ENCRYPTION_KEY }}',
   ];
 }
 

package/src/monorepo/managed-files.test.ts

@@ -1,6 +1,7 @@
 /* biome-ignore-all lint/suspicious/noTemplateCurlyInString: GitHub Actions expressions are asserted literally. */
 import { describe, expect, it } from 'bun:test';
-import { readFile } from 'node:fs/promises';
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { LINUX_PLATFORM_TARGET_GLOBS, PLATFORM_TARGET_GLOBS } from '@smoothbricks/nx-plugin/workspace-config-policy';
 import fc from 'fast-check';
@@ -215,6 +216,21 @@ describe('nx graph project helpers', () => {
     });
     expect(deployTargetInfoFromProjects(sampleProjects, 'preview')).toEqual({ exists: false });
   });
+
+  it('recognizes convention-driven deploy-environment targets without per-environment configurations', () => {
+    const projects: NxProjects = {
+      app: {
+        targets: {
+          deploy: {
+            options: { command: 'smoo wrangler deploy-environment --environment {args.environment}' },
+          },
+        },
+      },
+    };
+
+    expect(deployTargetInfoFromProjects(projects, 'staging')).toEqual({ exists: true, provider: 'cloudflare' });
+    expect(deployTargetInfoFromProjects(projects, 'production')).toEqual({ exists: true, provider: 'cloudflare' });
+  });
 });
 
 describe('managed raw files', () => {
@@ -228,6 +244,45 @@ describe('managed raw files', () => {
 
     expect(generated).toBe(source);
   });
+
+  it('exports the restored ttsc cache path while preserving host cache overrides', async () => {
+    const temp = await mkdtemp(join(tmpdir(), 'smoo-github-bootstrap-'));
+    const bin = join(temp, 'bin');
+    await mkdir(bin);
+    const devenv = join(bin, 'devenv');
+    await writeFile(devenv, '#!/bin/sh\nexit 0\n');
+    await chmod(devenv, 0o755);
+
+    try {
+      const cases = [
+        { input: '', expected: join(REPO_ROOT, '.cache', 'ttsc') },
+        { input: join(temp, 'host-ttsc'), expected: join(temp, 'host-ttsc') },
+      ];
+      for (const [index, cache] of cases.entries()) {
+        const githubEnv = join(temp, `github-env-${index}`);
+        const githubPath = join(temp, `github-path-${index}`);
+        const process = Bun.spawn(
+          [join(REPO_ROOT, 'tooling', 'direnv', 'github-actions-bootstrap.sh'), 'build-shell'],
+          {
+            cwd: join(REPO_ROOT, 'tooling', 'direnv'),
+            env: {
+              ...Bun.env,
+              GITHUB_ENV: githubEnv,
+              GITHUB_PATH: githubPath,
+              PATH: `${bin}:${Bun.env.PATH ?? ''}`,
+              TTSC_CACHE_DIR: cache.input,
+            },
+            stderr: 'pipe',
+            stdout: 'pipe',
+          },
+        );
+        expect(await process.exited).toBe(0);
+        expect(await readFile(githubEnv, 'utf8')).toContain(`TTSC_CACHE_DIR=${cache.expected}\n`);
+      }
+    } finally {
+      await rm(temp, { recursive: true, force: true });
+    }
+  });
 });
 
 describe('managed cache actions', () => {

package/src/monorepo/managed-files.ts

@@ -6,6 +6,7 @@ import type { NxTargetConfig, PackageJson } from '../lib/json.js';
 import { listReleasePackages, readPackageJson } from '../lib/workspace.js';
 import { loadNxProjects, type NxProjects, targetNamesFromProjects } from '../nx/index.js';
 import { renderCiWorkflowYaml } from './ci-workflow.js';
+import { renderPrPreviewCleanupWorkflowYaml } from './pr-preview-cleanup-workflow.js';
 import { renderPublishWorkflowYaml } from './publish-workflow.js';
 
 type ManagedKind = 'raw' | 'template' | 'generated';
@@ -24,6 +25,7 @@ interface ManagedFile {
   target: string;
   executable?: boolean;
   releasePackagesOnly?: boolean;
+  cloudflareDeployOnly?: boolean;
 }
 
 /** Split a managed target's content into the managed part and the repo-owned tail. */
@@ -211,6 +213,12 @@ const managedFiles: ManagedFile[] = [
     source: 'ci-workflow',
     target: '.github/workflows/ci.yml',
   },
+  {
+    kind: 'generated',
+    source: 'pr-preview-cleanup-workflow',
+    target: '.github/workflows/pr-preview-cleanup.yml',
+    cloudflareDeployOnly: true,
+  },
   {
     kind: 'generated',
     source: 'publish-workflow',
@@ -272,6 +280,9 @@ function applyManagedFile(
   if (file.releasePackagesOnly === true && !context.hasReleasePackages && !context.hasProductionDeployTargets) {
     return { target: file.target, action: 'skipped' };
   }
+  if (file.cloudflareDeployOnly === true && context.stagingDeployProvider !== 'cloudflare') {
+    return { target: file.target, action: 'skipped' };
+  }
   const target = resolve(root, file.target);
   const content = getManagedContent(file, context);
   if (existsSync(target)) {
@@ -322,6 +333,9 @@ function getManagedContent(file: ManagedFile, context: ManagedFileContext): stri
         runsOn: context.ciRunsOn,
       });
     }
+    if (file.source === 'pr-preview-cleanup-workflow') {
+      return renderPrPreviewCleanupWorkflowYaml({ runsOn: context.ciRunsOn });
+    }
     throw new Error(`Unknown generated managed file source ${file.source}`);
   }
   const sourceRoot = file.kind === 'raw' ? 'managed/raw' : 'managed/templates';
@@ -388,11 +402,16 @@ function deployTargetInfoFromTargets(targets: Record<string, NxTargetConfig>, co
   if (!deploy) {
     return { exists: false };
   }
+  const baseCommandValue = deploy.options?.command ?? deploy.command;
+  const baseCommand = typeof baseCommandValue === 'string' ? baseCommandValue : '';
+  if (baseCommand.includes('smoo wrangler deploy-environment')) {
+    return { exists: true, provider: 'cloudflare' };
+  }
   const config = deploy.configurations?.[configuration];
   if (!config) {
     return { exists: false };
   }
-  const commandValue = config.command ?? config.options?.command ?? deploy.options?.command ?? deploy.command;
+  const commandValue = config.command ?? config.options?.command ?? baseCommand;
   const command = typeof commandValue === 'string' ? commandValue : '';
   return { exists: true, provider: command.includes('wrangler ') ? 'cloudflare' : undefined };
 }

package/src/monorepo/pr-preview-cleanup-workflow.ts

@@ -0,0 +1,44 @@
+/* biome-ignore-all lint/suspicious/noTemplateCurlyInString: GitHub Actions expressions are emitted literally. */
+
+import { renderRunsOnLine } from './github-runs-on.js';
+
+export interface PrPreviewCleanupWorkflowOptions {
+  runsOn?: string | string[];
+}
+
+export function renderPrPreviewCleanupWorkflowYaml(options: PrPreviewCleanupWorkflowOptions = {}): string {
+  return `name: PR Preview Cleanup
+
+on:
+  pull_request:
+    types: [closed]
+
+permissions:
+  contents: read
+
+jobs:
+  cleanup:
+    name: Cleanup PR environment
+    if: github.event.pull_request.head.repo.full_name == github.repository
+${renderRunsOnLine(options.runsOn)}
+    timeout-minutes: 15
+    defaults:
+      run:
+        working-directory: tooling/direnv
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6.0.2
+        with:
+          filter: blob:none
+          fetch-depth: 1
+
+      - name: Setup Nix/devenv
+        uses: ./.github/actions/setup-devenv
+
+      - name: Cleanup PR environment
+        env:
+          CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+        run: smoo wrangler cleanup-pr --pr \${{ github.event.pull_request.number }}
+`;
+}

package/src/monorepo/publish-workflow.ts

@@ -486,7 +486,7 @@ function deployProductionStep(step: PublishWorkflowStep, options: PublishWorkflo
     "          ${{ steps.version.outputs.mode != 'none' && inputs.deploy_environment == 'production' && inputs.dry_run !=",
     "          'true' }}",
     ...deployEnvLines(options),
-    '        run: smoo github-ci nx-deploy --configuration production --mode run-many --verify --name "Deploy Production"',
+    '        run: smoo github-ci nx-deploy --environment production --mode run-many --verify --name "Deploy Production"',
   ];
 }
 
@@ -778,16 +778,19 @@ function renderMacosPlatformSteps(options: PublishWorkflowDefinitionOptions): st
     '',
     `      # Step ${stepNumber++}`,
     '      - name: 🍎 Build selected macOS and iOS release outputs',
+    '        id: platform-outputs',
     '        run:',
     `          smoo release build-platform-outputs --bump "${githubExpression(
       'inputs.bump',
     )}" --ref "${githubExpression('github.sha')}" --targets "${MACOS_PLATFORM_TARGET_GLOBS.join(',')}" --output`,
-    `          "${githubExpression('runner.temp')}/macos-platform-outputs"`,
+    `          "${githubExpression('runner.temp')}/macos-platform-outputs" --github-output "$GITHUB_OUTPUT"`,
     '',
     `      # Step ${stepNumber++}`,
-    '      - name: 🧪 Unit test macOS and iOS packages',
+    '      - name: 🧪 Unit test selected macOS and iOS packages',
+    `        if: steps.platform-outputs.outputs.projects != ''`,
     '        run:',
-    `          smoo github-ci nx-run-many --targets test --projects-with-targets "${MACOS_PLATFORM_TARGET_GLOBS.join(',')}"`,
+    '          smoo github-ci nx-run-many --targets test --projects',
+    `          "${githubExpression('steps.platform-outputs.outputs.projects')}"`,
     '',
     `      # Step ${stepNumber++}`,
     '      - name: 📤 Upload macOS platform outputs',
@@ -940,7 +943,7 @@ function renderFinalLinuxPublishSteps(options: PublishWorkflowDefinitionOptions)
       "          ${{ needs.linux-release-candidate.outputs.mode != 'none' && inputs.deploy_environment == 'production' &&",
       "          inputs.dry_run != 'true' }}",
       ...deployEnvLines(options),
-      '        run: smoo github-ci nx-deploy --configuration production --mode run-many --verify --name "Deploy Production"',
+      '        run: smoo github-ci nx-deploy --environment production --mode run-many --verify --name "Deploy Production"',
     );
   }
   lines.push(

package/src/monorepo/tool-validation.test.ts

@@ -3,10 +3,12 @@ import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import {
+  applyDevenvPackageDefaults,
   applyRootDevDependencyDefaults,
   applyToolConfigDefaults,
   applyToolingPackageDefaults,
   readToolContext,
+  validateDevenvPackages,
   validateToolConfig,
 } from './tool-validation.js';
 
@@ -89,6 +91,88 @@ describe('tool configuration validation', () => {
       expect(devenv).toContain('nodejs_latest');
       expect(devenv).toContain('coreutils');
       expect(devenv).toContain('git-format-staged');
+      expect(devenv).toContain('go # Builds ttsc source plugins');
+      expect(devenv).not.toContain('sccache');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('requires Go for managed TypeScript source-plugin builds without forcing Rust tools', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      const devenvPath = join(root, 'tooling/direnv/devenv.nix');
+      await mkdir(dirname(devenvPath), { recursive: true });
+      await writeFile(
+        devenvPath,
+        `{
+  pkgs,
+  ...
+}: {
+  packages = with pkgs; [
+    nodejs_latest
+    bun
+    git
+    git-format-staged
+    jq
+    alejandra
+    coreutils
+    gnutar
+  ];
+}
+`,
+      );
+
+      expect(validateDevenvPackages(root)).toBe(1);
+      applyDevenvPackageDefaults(root);
+      expect(validateDevenvPackages(root)).toBe(0);
+      const devenv = await readFile(devenvPath, 'utf8');
+      expect(devenv).toContain('go # Builds ttsc source plugins');
+      expect(devenv).not.toContain('sccache');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('requires Rust compiler helpers only when the workspace contains Cargo manifests', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      const crateRoot = join(root, 'packages/native');
+      await mkdir(crateRoot, { recursive: true });
+      await writeFile(join(crateRoot, 'Cargo.toml'), '[package]\nname = "native"\nversion = "0.0.0"\n');
+      const devenvPath = join(root, 'tooling/direnv/devenv.nix');
+      await mkdir(dirname(devenvPath), { recursive: true });
+      await writeFile(
+        devenvPath,
+        `{
+  pkgs,
+  lib,
+  ...
+}: {
+  packages = with pkgs; [
+    nodejs_latest
+    bun
+    git
+    git-format-staged
+    jq
+    alejandra
+    coreutils
+    gnutar
+    go
+    stdenv.cc.cc.lib
+  ];
+}
+`,
+      );
+
+      expect(validateDevenvPackages(root)).toBe(2);
+      applyDevenvPackageDefaults(root);
+      expect(validateDevenvPackages(root)).toBe(0);
+      const devenv = await readFile(devenvPath, 'utf8');
+      expect(devenv).toContain('sccache # Rust compiler wrapper and cache');
+      expect(devenv).toContain('++ lib.optionals pkgs.stdenv.isLinux [');
+      expect(devenv).toContain('pkgs.stdenv.cc');
+      expect(devenv).toContain('stdenv.cc.cc.lib');
     } finally {
       await rm(root, { recursive: true, force: true });
     }
@@ -141,6 +225,7 @@ describe('tool configuration validation', () => {
     alejandra
     coreutils
     gnutar
+    go
   ];
 }
 `,

package/src/monorepo/tool-validation.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import typia from 'typia';
 import { cliPackageVersion, isSmoothBricksCodebasePackageName } from '../lib/cli-package.js';
@@ -67,12 +67,24 @@ const rootDevDependencies: RequiredDependency[] = [
 
 const cliPackageName = '@smoothbricks/cli';
 
-const requiredDevenvPackages = ['bun', 'git', 'git-format-staged', 'jq', 'alejandra', 'coreutils', 'gnutar'];
+const requiredDevenvPackages = ['bun', 'git', 'git-format-staged', 'jq', 'alejandra', 'coreutils', 'gnutar', 'go'];
 // Any explicit nodejs provider is fine — the pinned major is the repo's choice
 // (Lambda parity, org convergence, …). Whether the pins in package.json agree
 // with the runtime is validated against the live PATH (validateRootRuntimeVersions),
 // never against a version template here.
 const nodePackagePattern = /(^|\s)nodejs(_\d+|_latest)?(\s|#|$)/m;
+const requiredRustDevenvPackages = ['sccache'];
+const linuxCompilerPackage = 'pkgs.stdenv.cc';
+const ignoredNativeManifestDirectories = new Set([
+  '.devenv',
+  '.direnv',
+  '.git',
+  '.nx',
+  'dist',
+  'node_modules',
+  'target',
+  'vendor',
+]);
 
 const obsoleteTtscPatchedDependencyKey = 'ttsc@0.19.3';
 
@@ -201,7 +213,9 @@ export function applyDevenvPackageDefaults(root: string): void {
     changed = next !== content || changed;
     content = next;
   }
-  for (const name of requiredDevenvPackages) {
+  const compilesRust = workspaceCompilesRust(root);
+  const requiredPackages = [...requiredDevenvPackages, ...(compilesRust ? requiredRustDevenvPackages : [])];
+  for (const name of requiredPackages) {
     if (hasNixPackage(content, name)) {
       continue;
     }
@@ -209,6 +223,11 @@ export function applyDevenvPackageDefaults(root: string): void {
     changed = next !== content || changed;
     content = next;
   }
+  if (compilesRust && !hasLinuxCompilerPackage(content)) {
+    const next = addLinuxCompilerPackage(content);
+    changed = next !== content || changed;
+    content = next;
+  }
   if (changed) {
     writeFileSync(path, content);
     console.log('updated        tooling/direnv/devenv.nix packages');
@@ -316,12 +335,20 @@ export function validateDevenvPackages(root: string): number {
     );
     failures++;
   }
-  for (const name of requiredDevenvPackages) {
+  const compilesRust = workspaceCompilesRust(root);
+  const requiredPackages = [...requiredDevenvPackages, ...(compilesRust ? requiredRustDevenvPackages : [])];
+  for (const name of requiredPackages) {
     if (!hasNixPackage(content, name)) {
       console.error(`tooling/direnv/devenv.nix packages must include ${name}`);
       failures++;
     }
   }
+  if (compilesRust && !hasLinuxCompilerPackage(content)) {
+    console.error(
+      'tooling/direnv/devenv.nix packages must include pkgs.stdenv.cc in a Linux-only package block for Rust builds',
+    );
+    failures++;
+  }
   return failures;
 }
 
@@ -330,7 +357,9 @@ function addNixPackage(content: string, name: string, comment: string): string {
   if (hasNixPackage(content, name)) {
     return content;
   }
-  const packagesStart = content.indexOf('  packages = with pkgs; [');
+  const directPackagesStart = content.indexOf('  packages = with pkgs; [');
+  const groupedPackagesStart = content.indexOf('    (with pkgs; [');
+  const packagesStart = directPackagesStart === -1 ? groupedPackagesStart : directPackagesStart;
   if (packagesStart === -1) {
     return content;
   }
@@ -342,6 +371,60 @@ function hasNixPackage(content: string, name: string): boolean {
   return new RegExp(`(^|\\s)${escapeRegex(name)}(\\s|#|$)`, 'm').test(content);
 }
 
+function workspaceCompilesRust(root: string): boolean {
+  return containsCargoManifest(root);
+}
+
+function containsCargoManifest(directory: string): boolean {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name === 'Cargo.toml') {
+      return true;
+    }
+    if (
+      entry.isDirectory() &&
+      entry.name.startsWith('.') === false &&
+      ignoredNativeManifestDirectories.has(entry.name) === false &&
+      containsCargoManifest(join(directory, entry.name))
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function hasLinuxCompilerPackage(content: string): boolean {
+  const linuxPackages = /\+\+\s+lib\.optionals\s+pkgs\.stdenv\.isLinux\s+\[([\s\S]*?)\]/g;
+  return [...content.matchAll(linuxPackages)].some((match) => hasNixPackage(match[1] ?? '', linuxCompilerPackage));
+}
+
+function addLinuxCompilerPackage(content: string): string {
+  if (hasLinuxCompilerPackage(content)) {
+    return content;
+  }
+  const directStart = content.indexOf('  packages = with pkgs; [');
+  if (directStart !== -1) {
+    const listEnd = content.indexOf('\n  ];', directStart);
+    if (listEnd === -1) {
+      return content;
+    }
+    const listBody = content.slice(directStart + '  packages = with pkgs; ['.length, listEnd);
+    const replacement = `  packages =\n    (with pkgs; [${listBody}\n    ])\n    ++ lib.optionals pkgs.stdenv.isLinux [\n      ${linuxCompilerPackage}\n    ];`;
+    return `${content.slice(0, directStart)}${replacement}${content.slice(listEnd + '\n  ];'.length)}`;
+  }
+
+  const packagesStart = content.indexOf('  packages =');
+  const nextOption = content.indexOf('\n\n  ', packagesStart);
+  if (packagesStart === -1 || nextOption === -1) {
+    return content;
+  }
+  const terminator = content.lastIndexOf(';', nextOption);
+  if (terminator < packagesStart) {
+    return content;
+  }
+  const linuxPackages = `\n    ++ lib.optionals pkgs.stdenv.isLinux [\n      ${linuxCompilerPackage}\n    ]`;
+  return `${content.slice(0, terminator)}${linuxPackages}${content.slice(terminator)}`;
+}
+
 function nixPackageComment(name: string): string {
   if (name === 'coreutils') {
     return '# Provides fmt for commit message wrapping';
@@ -352,6 +435,12 @@ function nixPackageComment(name: string): string {
   if (name === 'git') {
     return '# Git hooks and repository inspection';
   }
+  if (name === 'go') {
+    return '# Builds ttsc source plugins';
+  }
+  if (name === 'sccache') {
+    return '# Rust compiler wrapper and cache';
+  }
   return '';
 }
 

package/src/playwright/index.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'bun:test';
+import { type ChromiumSetupDependencies, ensureChromium } from './index.js';
+
+interface RunCall {
+  readonly command: string;
+  readonly args: string[];
+  readonly cwd: string;
+  readonly env?: Record<string, string>;
+}
+
+function setupDependencies(
+  env: ChromiumSetupDependencies['env'],
+  existingPaths: readonly string[],
+  calls: RunCall[],
+): ChromiumSetupDependencies {
+  const existing = new Set(existingPaths);
+  return {
+    env,
+    exists: (path) => existing.has(path),
+    run: async (command, args, cwd, runEnv) => {
+      calls.push({ command, args, cwd, ...(runEnv ? { env: runEnv } : {}) });
+    },
+  };
+}
+
+describe('ensureChromium', () => {
+  it('uses preinstalled Chrome without invoking Playwright install on an ephemeral GitHub runner', async () => {
+    const calls: RunCall[] = [];
+    const executablePath = '/fixture/google-chrome';
+
+    const result = await ensureChromium(
+      '/workspace/package',
+      setupDependencies(
+        { GITHUB_ACTIONS: 'true', PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH: executablePath },
+        [executablePath],
+        calls,
+      ),
+    );
+
+    expect(result).toEqual({ mode: 'system', executablePath });
+    expect(calls).toEqual([]);
+  });
+
+  it('installs Chromium into the persistent host-runner cache', async () => {
+    const calls: RunCall[] = [];
+
+    const result = await ensureChromium(
+      '/workspace/package',
+      setupDependencies({ GITHUB_ACTIONS: 'true' }, ['/var/cache/ci'], calls),
+    );
+
+    expect(result).toEqual({ mode: 'persistent-cache', browserCachePath: '/var/cache/ci/ms-playwright' });
+    expect(calls).toEqual([
+      {
+        command: 'playwright',
+        args: ['install', 'chromium', '--only-shell'],
+        cwd: '/workspace/package',
+        env: { PLAYWRIGHT_BROWSERS_PATH: '/var/cache/ci/ms-playwright' },
+      },
+    ]);
+  });
+
+  it('fails rather than downloading when an ephemeral GitHub runner has no system Chrome', async () => {
+    const calls: RunCall[] = [];
+
+    await expect(
+      ensureChromium('/workspace/package', setupDependencies({ GITHUB_ACTIONS: 'true' }, [], calls)),
+    ).rejects.toThrow('Refusing to download');
+    expect(calls).toEqual([]);
+  });
+
+  it('honors an explicit developer cache outside GitHub Actions', async () => {
+    const calls: RunCall[] = [];
+
+    const result = await ensureChromium(
+      '/workspace/package',
+      setupDependencies({ PLAYWRIGHT_BROWSERS_PATH: '/tmp/browser-cache' }, [], calls),
+    );
+
+    expect(result).toEqual({ mode: 'developer-cache', browserCachePath: '/tmp/browser-cache' });
+    expect(calls).toEqual([
+      {
+        command: 'playwright',
+        args: ['install', 'chromium', '--only-shell'],
+        cwd: '/workspace/package',
+        env: { PLAYWRIGHT_BROWSERS_PATH: '/tmp/browser-cache' },
+      },
+    ]);
+  });
+});