@smoothbricks/cli 0.10.7 → 0.10.9

package/src/playwright/index.ts

@@ -0,0 +1,73 @@
+import { existsSync } from 'node:fs';
+import { run } from '../lib/run.js';
+
+const HOST_CACHE_ROOT = '/var/cache/ci';
+const HOST_BROWSER_CACHE = `${HOST_CACHE_ROOT}/ms-playwright`;
+const SYSTEM_CHROME_PATHS = [
+  '/usr/bin/google-chrome',
+  '/usr/bin/chromium-browser',
+  '/usr/bin/chromium',
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+] as const;
+
+export interface ChromiumSetupDependencies {
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly exists: (path: string) => boolean;
+  readonly run: (command: string, args: string[], cwd: string, env?: Record<string, string>) => Promise<void>;
+}
+
+export type ChromiumSetupResult =
+  | { readonly mode: 'persistent-cache'; readonly browserCachePath: string }
+  | { readonly mode: 'system'; readonly executablePath: string }
+  | { readonly mode: 'developer-cache'; readonly browserCachePath?: string };
+
+const defaultDependencies: ChromiumSetupDependencies = {
+  env: process.env,
+  exists: existsSync,
+  run,
+};
+
+/**
+ * Ensure Chromium is available without polluting ephemeral GitHub runners.
+ * Persistent host runners and developer machines may install into their
+ * respective caches; ephemeral GitHub runners must use their image's browser.
+ */
+export async function ensureChromium(
+  cwd = process.cwd(),
+  dependencies: ChromiumSetupDependencies = defaultDependencies,
+): Promise<ChromiumSetupResult> {
+  const { env, exists, run: runCommand } = dependencies;
+  const githubActions = env.GITHUB_ACTIONS === 'true';
+
+  if (githubActions && exists(HOST_CACHE_ROOT)) {
+    await runCommand('playwright', ['install', 'chromium', '--only-shell'], cwd, {
+      PLAYWRIGHT_BROWSERS_PATH: HOST_BROWSER_CACHE,
+    });
+    console.log(`Chromium ready in persistent cache: ${HOST_BROWSER_CACHE}`);
+    return { mode: 'persistent-cache', browserCachePath: HOST_BROWSER_CACHE };
+  }
+
+  if (githubActions) {
+    const candidates = [env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH, ...SYSTEM_CHROME_PATHS].filter(
+      (path): path is string => typeof path === 'string' && path.length > 0,
+    );
+    const executablePath = candidates.find(exists);
+    if (!executablePath) {
+      throw new Error(
+        `GitHub-hosted runner has no preinstalled Chromium. Refusing to download; searched: ${candidates.join(', ')}`,
+      );
+    }
+    console.log(`Using preinstalled Chromium: ${executablePath}`);
+    return { mode: 'system', executablePath };
+  }
+
+  const browserCachePath = env.PLAYWRIGHT_BROWSERS_PATH;
+  await runCommand(
+    'playwright',
+    ['install', 'chromium', '--only-shell'],
+    cwd,
+    browserCachePath ? { PLAYWRIGHT_BROWSERS_PATH: browserCachePath } : undefined,
+  );
+  console.log(browserCachePath ? `Chromium ready in configured cache: ${browserCachePath}` : 'Chromium ready.');
+  return browserCachePath ? { mode: 'developer-cache', browserCachePath } : { mode: 'developer-cache' };
+}

package/src/release/__tests__/bootstrap-npm-packages.test.ts

@@ -4,6 +4,7 @@ import {
   bootstrapNpmPackages,
   NPM_BOOTSTRAP_DIST_TAG,
   NPM_BOOTSTRAP_VERSION,
+  NPM_BOOTSTRAP_VISIBILITY_TIMEOUT_MS,
 } from '../bootstrap-npm-packages.js';
 import type { ReleasePackageInfo } from '../core.js';
 
@@ -70,6 +71,45 @@ describe('bootstrap npm packages', () => {
     expect(shell.prompts).toEqual([]);
   });
 
+  it('uploads every placeholder before polling all pending packages with backoff', async () => {
+    const shell = new RecordingBootstrapShell({
+      packages: [stable, missing],
+      existing: [],
+      visibleAfterChecks: { [stable.name]: 2, [missing.name]: 3 },
+    });
+
+    await bootstrapNpmPackages(shell, { dryRun: false, skipLogin: true, packages: [], otp: '111222' });
+
+    expect(shell.events).toEqual([
+      `publish:${stable.name}`,
+      `publish:${missing.name}`,
+      `view:${stable.name}:${NPM_BOOTSTRAP_VERSION}`,
+      `view:${missing.name}:${NPM_BOOTSTRAP_VERSION}`,
+      'wait:1000',
+      `view:${stable.name}:${NPM_BOOTSTRAP_VERSION}`,
+      `view:${missing.name}:${NPM_BOOTSTRAP_VERSION}`,
+      'wait:2000',
+      `view:${missing.name}:${NPM_BOOTSTRAP_VERSION}`,
+    ]);
+  });
+
+  it('times out after bounded backoff without suggesting another bootstrap', async () => {
+    const shell = new RecordingBootstrapShell({
+      packages: [missing],
+      existing: [],
+      visibleAfterChecks: { [missing.name]: Number.POSITIVE_INFINITY },
+    });
+
+    await expect(
+      bootstrapNpmPackages(shell, { dryRun: false, skipLogin: true, packages: [], otp: '111222' }),
+    ).rejects.toThrow('Retry smoo release trust-publisher later; do not bootstrap again.');
+
+    const waited = shell.events
+      .filter((event) => event.startsWith('wait:'))
+      .reduce((total, event) => total + Number(event.slice('wait:'.length)), 0);
+    expect(waited).toBe(NPM_BOOTSTRAP_VISIBILITY_TIMEOUT_MS);
+  });
+
   it('rejects unknown package selections before npm login', async () => {
     const shell = new RecordingBootstrapShell({ packages: [stable], existing: [] });
 
@@ -82,6 +122,7 @@ describe('bootstrap npm packages', () => {
 });
 
 class RecordingBootstrapShell implements BootstrapNpmPackagesShell<ReleasePackageInfo> {
+  readonly events: string[] = [];
   readonly logs: string[] = [];
   readonly published: Array<{ name: string; otp: string }> = [];
   readonly prompts: string[] = [];
@@ -89,11 +130,19 @@ class RecordingBootstrapShell implements BootstrapNpmPackagesShell<ReleasePackag
   private readonly packages: ReleasePackageInfo[];
   private readonly existing: Set<string>;
   private readonly otps: string[];
-
-  constructor(options: { packages: ReleasePackageInfo[]; existing: string[]; otps?: string[] }) {
+  private readonly visibilityChecks = new Map<string, number>();
+  private readonly visibleAfterChecks: Readonly<Record<string, number>>;
+
+  constructor(options: {
+    packages: ReleasePackageInfo[];
+    existing: string[];
+    otps?: string[];
+    visibleAfterChecks?: Record<string, number>;
+  }) {
     this.packages = options.packages;
     this.existing = new Set(options.existing);
     this.otps = [...(options.otps ?? [])];
+    this.visibleAfterChecks = options.visibleAfterChecks ?? {};
   }
 
   listReleasePackages(): ReleasePackageInfo[] {
@@ -104,11 +153,19 @@ class RecordingBootstrapShell implements BootstrapNpmPackagesShell<ReleasePackag
     return this.existing.has(name);
   }
 
+  async packageVersionExists(name: string, version: string): Promise<boolean> {
+    this.events.push(`view:${name}:${version}`);
+    const checks = (this.visibilityChecks.get(name) ?? 0) + 1;
+    this.visibilityChecks.set(name, checks);
+    return checks >= (this.visibleAfterChecks[name] ?? 1);
+  }
+
   async login(): Promise<void> {
     this.logins += 1;
   }
 
   async publishPlaceholder(pkg: ReleasePackageInfo, env?: Record<string, string>): Promise<void> {
+    this.events.push(`publish:${pkg.name}`);
     this.published.push({ name: pkg.name, otp: env?.NPM_CONFIG_OTP ?? '' });
   }
 
@@ -121,6 +178,10 @@ class RecordingBootstrapShell implements BootstrapNpmPackagesShell<ReleasePackag
     return otp;
   }
 
+  async wait(milliseconds: number): Promise<void> {
+    this.events.push(`wait:${milliseconds}`);
+  }
+
   log(message: string): void {
     this.logs.push(message);
   }

package/src/release/bootstrap-npm-packages.ts

@@ -2,6 +2,9 @@ import type { ReleasePackageInfo } from './core.js';
 
 export const NPM_BOOTSTRAP_VERSION = '0.0.0-bootstrap.0';
 export const NPM_BOOTSTRAP_DIST_TAG = 'bootstrap';
+export const NPM_BOOTSTRAP_VISIBILITY_TIMEOUT_MS = 120_000;
+
+const NPM_BOOTSTRAP_POLL_DELAYS_MS = [0, 1_000, 2_000, 4_000, 8_000, 15_000, 30_000, 30_000, 30_000] as const;
 
 export interface BootstrapNpmPackagesOptions {
   dryRun: boolean;
@@ -13,9 +16,11 @@ export interface BootstrapNpmPackagesOptions {
 export interface BootstrapNpmPackagesShell<Package extends ReleasePackageInfo = ReleasePackageInfo> {
   listReleasePackages(): Package[];
   packageExists(name: string): Promise<boolean>;
+  packageVersionExists(name: string, version: string): Promise<boolean>;
   login(): Promise<void>;
   publishPlaceholder(pkg: Package, env?: Record<string, string>): Promise<void>;
   promptOtp(packageName: string): Promise<string>;
+  wait(milliseconds: number): Promise<void>;
   log(message: string): void;
 }
 
@@ -54,15 +59,44 @@ export async function bootstrapNpmPackages<Package extends ReleasePackageInfo>(
   if (!options.skipLogin) {
     await shell.login();
   }
+  // Upload every placeholder before waiting for npm registry propagation. Keeping the
+  // phases separate prevents one slow package from blocking the remaining uploads.
   for (const pkg of missing) {
     shell.log(`${pkg.name}: publishing npm placeholder.`);
     const otp = options.otp ?? (await shell.promptOtp(pkg.name));
     await shell.publishPlaceholder(pkg, { NPM_CONFIG_OTP: otp });
   }
+
+  await waitForPublishedPackages(shell, missing);
   shell.log('Bootstrap complete. Run smoo release trust-publisher before the first CI publish.');
   return missing;
 }
 
+async function waitForPublishedPackages<Package extends ReleasePackageInfo>(
+  shell: BootstrapNpmPackagesShell<Package>,
+  packages: readonly Package[],
+): Promise<void> {
+  let pending = [...packages];
+  for (const delayMs of NPM_BOOTSTRAP_POLL_DELAYS_MS) {
+    if (delayMs > 0) {
+      await shell.wait(delayMs);
+    }
+    const visible = await Promise.all(
+      pending.map((pkg) => shell.packageVersionExists(pkg.name, NPM_BOOTSTRAP_VERSION)),
+    );
+    pending = pending.filter((_, index) => !visible[index]);
+    if (pending.length === 0) {
+      return;
+    }
+  }
+
+  throw new Error(
+    `Bootstrap uploads succeeded, but npm did not expose these packages after ${NPM_BOOTSTRAP_VISIBILITY_TIMEOUT_MS / 1_000} seconds: ${pending
+      .map((pkg) => pkg.name)
+      .join(', ')}. Retry smoo release trust-publisher later; do not bootstrap again.`,
+  );
+}
+
 function selectedReleasePackages<Package extends ReleasePackageInfo>(
   packages: Package[],
   selections: string[],

package/src/release/index.ts

@@ -4,6 +4,7 @@ import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { Writable } from 'node:stream';
+import { setTimeout as delay } from 'node:timers/promises';
 import { $ } from 'bun';
 import typia from 'typia';
 import { githubCiApplyOutputs, githubCiNxRunMany } from '../github-ci/index.js';
@@ -79,6 +80,7 @@ export interface ReleaseRepairPendingOptions {
 
 export interface ReleasePlatformOutputsOptions {
   bump: string;
+  githubOutput?: string;
   output: string;
   ref?: string;
   targets: string;
@@ -220,7 +222,7 @@ export async function releaseCollectPlatformOutputs(
       : `Release platform outputs: building current outputs for ${packageSummary(currentPackages)}.`,
   );
   const outputRoot = resolve(root, options.output);
-  await githubCiNxRunMany(root, {
+  const currentRuns = await githubCiNxRunMany(root, {
     targets: options.targets,
     projects: releasePackageProjects(currentPackages),
     collectOutputs: join(outputRoot, 'current'),
@@ -235,6 +237,12 @@ export async function releaseCollectPlatformOutputs(
     targets,
     restoreRef,
   );
+  if (options.githubOutput) {
+    const projects = [
+      ...new Set(currentRuns.runs.flatMap((run) => run.projects.map((project) => project.project))),
+    ].sort((left, right) => left.localeCompare(right));
+    await appendFile(options.githubOutput, `projects=${projects.join(',')}\n`);
+  }
 }
 
 export async function releaseTrustPublisher(root: string, options: ReleaseTrustPublisherOptions): Promise<void> {
@@ -251,9 +259,11 @@ export async function releaseTrustPublisher(root: string, options: ReleaseTrustP
           {
             listReleasePackages: () => listReleasePackages(root),
             packageExists: (name) => npmPackageExists(root, name),
+            packageVersionExists: (name, version) => npmPublishedVersionExists(root, name, version),
             login: () => runLatestNpm(root, ['login', '--auth-type=web']),
             publishPlaceholder: (pkg, env) => publishPlaceholderPackage(root, pkg, env),
             promptOtp: (packageName) => promptForNpmOtp(packageName),
+            wait: delay,
             log: (message) => console.log(message),
           },
           bootstrapOptions,
@@ -460,9 +470,11 @@ export async function releaseBootstrapNpmPackages(
     {
       listReleasePackages: () => listReleasePackages(root),
       packageExists: (name) => npmPackageExists(root, name),
+      packageVersionExists: (name, version) => npmPublishedVersionExists(root, name, version),
       login: () => runLatestNpm(root, ['login', '--auth-type=web']),
       publishPlaceholder: (pkg, env) => publishPlaceholderPackage(root, pkg, env),
       promptOtp: (packageName) => promptForNpmOtp(packageName),
+      wait: delay,
       log: (message) => console.log(message),
     },
     {
@@ -961,12 +973,13 @@ function releaseRepairOutputsShell(
 ): ReleaseRepairOutputsShell<ReleasePackage> {
   return {
     ...releaseTargetCheckoutShell(root),
-    collectRepairTargetOutputs: (target) =>
-      githubCiNxRunMany(root, {
+    collectRepairTargetOutputs: async (target) => {
+      await githubCiNxRunMany(root, {
         targets: targetGlobs,
         projects: releasePackageProjects(target.npmPackages),
         collectOutputs: join(outputRoot, target.sha),
-      }),
+      });
+    },
   };
 }
 
@@ -1506,6 +1519,19 @@ async function npmPackageExists(root: string, name: string): Promise<boolean> {
   return result.exitCode === 0;
 }
 
+async function npmPublishedVersionExists(root: string, name: string, version: string): Promise<boolean> {
+  const spec = `${name}@${version}`;
+  const args = ['view', spec, 'version', '--json'];
+  const result = await runResult('nix', ['shell', 'nixpkgs#nodejs_latest', '-c', 'npm', ...args], root);
+  if (result.exitCode === 0) {
+    return true;
+  }
+  if (/\bE404\b|404 Not Found/i.test(`${result.stdout}\n${result.stderr}`)) {
+    return false;
+  }
+  throw new Error(npmCommandFailedMessage(args, result.exitCode, result.stdout, result.stderr));
+}
+
 async function assertCleanGitTree(root: string): Promise<void> {
   const result = await $`git status --porcelain --untracked-files=no`.cwd(root).quiet().nothrow();
   if (result.exitCode !== 0) {

package/src/wrangler/cloudflare.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'bun:test';
+import { CloudflareApiError, CloudflareRestClient } from './cloudflare.js';
+
+type CloudflareFetcher = NonNullable<ConstructorParameters<typeof CloudflareRestClient>[2]>;
+
+function jsonFetcher(body: unknown, status = 200): CloudflareFetcher {
+  return async () =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+}
+
+describe('CloudflareRestClient', () => {
+  it('accepts nullable diagnostics in successful API envelopes', async () => {
+    const client = new CloudflareRestClient(
+      'account-id',
+      'api-token',
+      jsonFetcher({
+        result: [
+          {
+            id: 'domain-id',
+            hostname: 'app.pr45.example.com',
+            service: 'app-pr45',
+          },
+        ],
+        success: true,
+        errors: null,
+        messages: null,
+        result_info: {
+          page: 1,
+          per_page: 1000,
+          count: 1,
+          total_count: 1,
+        },
+      }),
+    );
+
+    await expect(client.listWorkerDomains()).resolves.toEqual([
+      {
+        id: 'domain-id',
+        hostname: 'app.pr45.example.com',
+        service: 'app-pr45',
+      },
+    ]);
+  });
+
+  it('preserves structured Cloudflare API failures', async () => {
+    const client = new CloudflareRestClient(
+      'account-id',
+      'api-token',
+      jsonFetcher(
+        {
+          result: null,
+          success: false,
+          errors: [{ code: 10000, message: 'Authentication error' }],
+          messages: [],
+        },
+        403,
+      ),
+    );
+
+    try {
+      await client.listWorkerDomains();
+      throw new Error('expected listWorkerDomains to fail');
+    } catch (error) {
+      expect(error).toBeInstanceOf(CloudflareApiError);
+      expect(error).toMatchObject({
+        message:
+          'Cloudflare API /accounts/account-id/workers/domains?per_page=1000&page=1 failed: Authentication error',
+        status: 403,
+        codes: [10000],
+      });
+    }
+  });
+});