@smoothbricks/cli 0.10.8 → 0.10.10

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

@@ -9,6 +9,7 @@ import { type NxProjects, targetNamesFromProjects } from '../nx/index.js';
 import {
   deployTargetInfoFromProjects,
   extractInlineLocalBlocksForTest,
+  hasExactTargetForTest,
   INLINE_LOCAL_BEGIN,
   INLINE_LOCAL_END,
   LOCAL_SECTION_MARKER,
@@ -128,7 +129,14 @@ describe('managed-file inline local blocks', () => {
   it("reinserting refuses when the anchor no longer appears — never silently drops the repo's customization", () => {
     const fresh = ['a:', '  - one', 'b:'].join('\n'); // '  - two' is gone
     expect(() => reinsertInlineLocalBlocksForTest(fresh, [{ anchor: '  - two', lines: '  - repo-owned' }])).toThrow(
-      /no longer matches/,
+      /matches no line/,
+    );
+  });
+
+  it('reinserting refuses an ambiguous multiply occurring anchor', () => {
+    const fresh = ['anchor', 'middle', 'anchor'].join('\n');
+    expect(() => reinsertInlineLocalBlocksForTest(fresh, [{ anchor: 'anchor', lines: 'repo-owned' }])).toThrow(
+      /matches 2 lines/,
     );
   });
 
@@ -136,8 +144,7 @@ describe('managed-file inline local blocks', () => {
     // Lines that can serve as anchors: non-empty, not a marker, and each drawn
     // from a small alphabet so uniqueness is checkable — the round-trip only
     // holds when an anchor line occurs exactly once in the managed section
-    // (reinsert finds the FIRST occurrence by design, same as the real file
-    // shape: comments/patterns are unique in practice).
+    // because ambiguous anchors are rejected rather than selecting one.
     const linePool = fc.constantFrom('alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta');
     fc.assert(
       fc.property(
@@ -205,6 +212,20 @@ describe('nx graph project helpers', () => {
     );
   });
 
+  it('detects browser and deployment E2E targets by exact name only', () => {
+    const exact = targetNamesFromProjects({
+      app: { targets: { 'test-browser': {}, 'e2e-deployment': {} } },
+    });
+    const nearMisses = targetNamesFromProjects({
+      app: { targets: { 'test-browser-extra': {}, 'e2e-deployments': {}, 'pre-e2e-deployment': {} } },
+    });
+
+    expect(hasExactTargetForTest(exact, 'test-browser')).toBe(true);
+    expect(hasExactTargetForTest(exact, 'e2e-deployment')).toBe(true);
+    expect(hasExactTargetForTest(nearMisses, 'test-browser')).toBe(false);
+    expect(hasExactTargetForTest(nearMisses, 'e2e-deployment')).toBe(false);
+  });
+
   it('detects deploy configurations and cloudflare provider from graph nodes', () => {
     expect(deployTargetInfoFromProjects(sampleProjects, 'staging')).toEqual({
       exists: true,
@@ -217,12 +238,12 @@ describe('nx graph project helpers', () => {
     expect(deployTargetInfoFromProjects(sampleProjects, 'preview')).toEqual({ exists: false });
   });
 
-  it('recognizes convention-driven deploy-environment targets without per-environment configurations', () => {
+  it('recognizes convention-driven deploy-stage targets without per-stage configurations', () => {
     const projects: NxProjects = {
       app: {
         targets: {
           deploy: {
-            options: { command: 'smoo wrangler deploy-environment --environment {args.environment}' },
+            options: { command: 'smoo wrangler deploy-stage --stage {args.stage}' },
           },
         },
       },

package/src/monorepo/managed-files.ts

@@ -105,13 +105,15 @@ function reinsertInlineLocalBlocks(content: string, blocks: InlineLocalBlock[]):
   if (blocks.length === 0) return content;
   const lines = content.split('\n');
   for (const block of blocks) {
-    const index = lines.indexOf(block.anchor);
-    if (index === -1) {
+    const matches = lines.flatMap((line, index) => (line === block.anchor ? [index] : []));
+    if (matches.length !== 1) {
+      const reason = matches.length === 0 ? 'no line' : `${matches.length} lines`;
       throw new Error(
-        `${INLINE_LOCAL_BEGIN} block anchored on "${block.anchor}" no longer matches any line in the updated ` +
+        `${INLINE_LOCAL_BEGIN} block anchored on "${block.anchor}" matches ${reason} in the updated ` +
           'template — reconcile the repo-owned block manually',
       );
     }
+    const index = matches[0] as number;
     const markerIndent = block.markerIndent ?? '';
     lines.splice(
       index + 1,
@@ -136,6 +138,8 @@ interface ManagedFileContext {
   hasReleasePackages: boolean;
   hasStagingDeployTargets: boolean;
   hasProductionDeployTargets: boolean;
+  hasBrowserTestTargets: boolean;
+  hasE2eDeploymentTargets: boolean;
   stagingDeployProvider?: 'cloudflare';
   productionDeployProvider?: 'cloudflare';
   ciPushBranches: string[];
@@ -320,6 +324,8 @@ function getManagedContent(file: ManagedFile, context: ManagedFileContext): stri
       return renderCiWorkflowYaml({
         deploy: context.hasStagingDeployTargets,
         deployProvider: context.stagingDeployProvider,
+        browserTests: context.hasBrowserTestTargets,
+        e2eDeployment: context.hasStagingDeployTargets && context.hasE2eDeploymentTargets,
         pushBranches: context.ciPushBranches,
         runsOn: context.ciRunsOn,
       });
@@ -356,7 +362,8 @@ async function getManagedFileContext(root: string): Promise<ManagedFileContext>
   const nxProjects = await loadNxProjects(root);
   const stagingDeploy = deployTargetInfoFromProjects(nxProjects, 'staging');
   const productionDeploy = deployTargetInfoFromProjects(nxProjects, 'production');
-  const platformTargetGlobs = platformTargetGlobsForTest(targetNamesFromProjects(nxProjects));
+  const targetNames = targetNamesFromProjects(nxProjects);
+  const platformTargetGlobs = platformTargetGlobsForTest(targetNames);
   const nodeModulesCacheKey = existsSync(join(root, 'bun.lock'))
     ? `$${"{{ hashFiles('bun.lock', 'package.json', 'packages/*/package.json') }}"}`
     : `$${"{{ hashFiles('bun.lockb', 'package.json', 'packages/*/package.json') }}"}`;
@@ -364,6 +371,8 @@ async function getManagedFileContext(root: string): Promise<ManagedFileContext>
     hasReleasePackages: listReleasePackages(root, packageJson).length > 0,
     hasStagingDeployTargets: stagingDeploy.exists,
     hasProductionDeployTargets: productionDeploy.exists,
+    hasBrowserTestTargets: hasExactTargetForTest(targetNames, 'test-browser'),
+    hasE2eDeploymentTargets: hasExactTargetForTest(targetNames, 'e2e-deployment'),
     stagingDeployProvider: stagingDeploy.provider,
     productionDeployProvider: productionDeploy.provider,
     ciPushBranches,
@@ -374,6 +383,10 @@ async function getManagedFileContext(root: string): Promise<ManagedFileContext>
   };
 }
 
+export function hasExactTargetForTest(targetNames: Iterable<string>, target: string): boolean {
+  return [...targetNames].includes(target);
+}
+
 export function platformTargetGlobsForTest(targetNames: Iterable<string>): string[] {
   const names = [...targetNames];
   return PLATFORM_TARGET_GLOBS.filter((glob) => {
@@ -404,7 +417,7 @@ function deployTargetInfoFromTargets(targets: Record<string, NxTargetConfig>, co
   }
   const baseCommandValue = deploy.options?.command ?? deploy.command;
   const baseCommand = typeof baseCommandValue === 'string' ? baseCommandValue : '';
-  if (baseCommand.includes('smoo wrangler deploy-environment')) {
+  if (baseCommand.includes('smoo wrangler deploy-stage')) {
     return { exists: true, provider: 'cloudflare' };
   }
   const config = deploy.configurations?.[configuration];

package/src/monorepo/publish-workflow.ts

@@ -18,7 +18,7 @@ const PUBLISH_WORKFLOW_FORMAT_OPTIONS = Object.freeze({
 export type PublishWorkflowBump = 'auto' | 'patch' | 'minor' | 'major' | 'prerelease';
 export type PublishWorkflowCondition = 'version-mode-not-none' | 'deploy-production' | 'failure' | 'always';
 export type PublishWorkflowNxTarget = 'build' | 'lint' | 'test';
-export type PublishWorkflowDeployEnvironment = 'none' | 'production';
+export type PublishWorkflowDeployStage = 'none' | 'production';
 
 export enum PublishWorkflowStepKind {
   Checkout = 'checkout',
@@ -62,7 +62,7 @@ export interface PublishWorkflowDefinitionOptions {
 
 export interface PublishWorkflowInputs {
   bump: PublishWorkflowBump;
-  deployEnvironment: PublishWorkflowDeployEnvironment;
+  deployStage: PublishWorkflowDeployStage;
   dryRun: boolean;
 }
 
@@ -263,7 +263,7 @@ function shouldRunStep(
     return version.mode !== 'none';
   }
   if (step.condition === 'deploy-production') {
-    return version.mode !== 'none' && inputs.deployEnvironment === 'production' && !inputs.dryRun;
+    return version.mode !== 'none' && inputs.deployStage === 'production' && !inputs.dryRun;
   }
   if (step.condition === 'failure') {
     return failed;
@@ -291,7 +291,7 @@ function renderPublishWorkflowHeader(options: PublishWorkflowDefinitionOptions):
   const deployInput =
     options.deploy === true
       ? `
-      deploy_environment:
+      deploy_stage:
         type: choice
         description: Deploy live systems after a successful publish.
         options: [none, production]
@@ -483,10 +483,10 @@ function deployProductionStep(step: PublishWorkflowStep, options: PublishWorkflo
   return [
     `      - name: ${step.name}`,
     '        if:',
-    "          ${{ steps.version.outputs.mode != 'none' && inputs.deploy_environment == 'production' && inputs.dry_run !=",
+    "          ${{ steps.version.outputs.mode != 'none' && inputs.deploy_stage == 'production' && inputs.dry_run !=",
     "          'true' }}",
     ...deployEnvLines(options),
-    '        run: smoo github-ci nx-deploy --environment production --mode run-many --verify --name "Deploy Production"',
+    '        run: smoo github-ci nx-deploy --stage production --mode run-many --verify --name "Deploy Production"',
   ];
 }
 
@@ -534,7 +534,7 @@ function renderPlatformPublishWorkflowYaml(options: PublishWorkflowDefinitionOpt
   const deployInput =
     options.deploy === true
       ? `
-      deploy_environment:
+      deploy_stage:
         type: choice
         description: Deploy live systems after a successful publish.
         options: [none, 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',
@@ -937,10 +940,10 @@ function renderFinalLinuxPublishSteps(options: PublishWorkflowDefinitionOptions)
       `      # Step ${stepNumber++}`,
       '      - name: 🚀 Deploy production',
       '        if:',
-      "          ${{ needs.linux-release-candidate.outputs.mode != 'none' && inputs.deploy_environment == 'production' &&",
+      "          ${{ needs.linux-release-candidate.outputs.mode != 'none' && inputs.deploy_stage == 'production' &&",
       "          inputs.dry_run != 'true' }}",
       ...deployEnvLines(options),
-      '        run: smoo github-ci nx-deploy --environment production --mode run-many --verify --name "Deploy Production"',
+      '        run: smoo github-ci nx-deploy --stage production --mode run-many --verify --name "Deploy Production"',
     );
   }
   lines.push(

package/src/release/index.ts

@@ -80,6 +80,7 @@ export interface ReleaseRepairPendingOptions {
 
 export interface ReleasePlatformOutputsOptions {
   bump: string;
+  githubOutput?: string;
   output: string;
   ref?: string;
   targets: string;
@@ -221,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'),
@@ -236,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> {
@@ -966,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),
-      }),
+      });
+    },
   };
 }
 

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],
+      });
+    }
+  });
+});

package/src/wrangler/cloudflare.ts

@@ -1,5 +1,5 @@
 import typia from 'typia';
-import type { LiveKvNamespace } from './environment.js';
+import type { LiveKvNamespace } from './stage.js';
 
 export interface R2Bucket {
   name: string;
@@ -60,7 +60,8 @@ export interface CloudflareClient {
 interface CloudflareEnvelope {
   success: boolean;
   result?: unknown;
-  errors?: Array<{ code?: number; message?: string }>;
+  errors?: Array<{ code?: number; message?: string }> | null;
+  messages?: Array<{ code?: number; message?: string }> | null;
   result_info?: {
     page?: number;
     total_pages?: number;
@@ -92,13 +93,15 @@ export class CloudflareApiError extends Error {
   }
 }
 
+type CloudflareFetcher = (input: string, init?: RequestInit) => Promise<Response>;
+
 export class CloudflareRestClient implements CloudflareClient {
   private readonly accountPath: string;
 
   constructor(
     accountId: string,
     private readonly apiToken: string,
-    private readonly fetcher: typeof fetch = fetch,
+    private readonly fetcher: CloudflareFetcher = fetch,
   ) {
     if (!accountId || !apiToken) {
       throw new Error('CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN are required.');

package/src/wrangler/{deploy-environment.test.ts → deploy-stage.test.ts}

@@ -12,8 +12,8 @@ import type {
   WorkerRoute,
   WorkerScript,
 } from './cloudflare.js';
-import { cleanupPullRequest, deployEnvironment, type ProcessResult, type ProcessRunner } from './deploy-environment.js';
-import type { LiveKvNamespace } from './environment.js';
+import { cleanupPullRequest, deployStage, type ProcessResult, type ProcessRunner } from './deploy-stage.js';
+import type { LiveKvNamespace } from './stage.js';
 
 const HASH = '16577780061662788004';
 const FIXTURE = `[env.staging]
@@ -154,14 +154,14 @@ class FakeCloudflare implements CloudflareClient {
   }
 }
 
-describe('deploy-environment remote version fallback', () => {
+describe('deploy-stage remote version fallback', () => {
   it('returns a remote cache hit for the active tagged 100% version', async () => {
     const root = await fixtureRoot();
     const runner = new FakeRunner([{ id: 'version-1', annotations: { 'workers/tag': `nx-${HASH}` } }], {
       versions: [{ version_id: 'version-1', percentage: 100 }],
     });
 
-    const result = await deployEnvironment(root, 'pr123', dependencies(runner, new FakeCloudflare()));
+    const result = await deployStage(root, 'pr123', dependencies(runner, new FakeCloudflare()));
 
     expect(result.action).toBe('remote-cache-hit');
     expect(runner.calls.map((args) => args.slice(0, 2))).toEqual([
@@ -176,7 +176,7 @@ describe('deploy-environment remote version fallback', () => {
       versions: [{ version_id: 'version-2', percentage: 100 }],
     });
 
-    const result = await deployEnvironment(root, 'pr123', dependencies(runner, new FakeCloudflare()));
+    const result = await deployStage(root, 'pr123', dependencies(runner, new FakeCloudflare()));
 
     expect(result.action).toBe('activated');
     expect(runner.calls.at(-1)?.slice(0, 3)).toEqual(['versions', 'deploy', '--version-tag']);
@@ -189,7 +189,7 @@ describe('deploy-environment remote version fallback', () => {
     await writeFile(join(root, '.dev.vars.example'), 'OAUTH_STATE_SIGNING_KEY=""\nTOKEN_ENCRYPTION_KEY=""\n');
     const runner = new FakeRunner([], { versions: [{ version_id: 'version-2', percentage: 100 }] });
 
-    const result = await deployEnvironment(root, 'pr123', {
+    const result = await deployStage(root, 'pr123', {
       ...dependencies(runner, new FakeCloudflare()),
       processEnv: {
         CLOUDFLARE_ACCOUNT_ID: 'account-1',
@@ -214,13 +214,13 @@ describe('deploy-environment remote version fallback', () => {
     expect(existsSync(requiredTestValue(runner.secretsPathSeen, 'secrets path'))).toBe(false);
   });
 
-  it('passes only present manifest values for fixed environments and preserves absent remote secrets', async () => {
+  it('passes only present manifest values for fixed stages and preserves absent remote secrets', async () => {
     const root = await fixtureRoot();
     await writeFile(join(root, '.dev.vars.example'), 'OAUTH_STATE_SIGNING_KEY=""\nTOKEN_ENCRYPTION_KEY=""\n');
     const runner = new FakeRunner([], {});
     const cloudflare = new FakeCloudflare();
 
-    const result = await deployEnvironment(root, 'staging', {
+    const result = await deployStage(root, 'staging', {
       runner,
       cloudflare,
       processEnv: {
@@ -244,7 +244,7 @@ describe('deploy-environment remote version fallback', () => {
     cloudflare.scripts = [];
 
     await expect(
-      deployEnvironment(root, 'pr123', {
+      deployStage(root, 'pr123', {
         ...dependencies(new FakeRunner([], {}), cloudflare),
         processEnv: {
           CLOUDFLARE_ACCOUNT_ID: 'account-1',
@@ -268,7 +268,7 @@ describe('deploy-environment remote version fallback', () => {
       throw new Error('record already exists');
     };
 
-    const result = await deployEnvironment(root, 'pr123', dependencies(new FakeRunner([], {}), cloudflare));
+    const result = await deployStage(root, 'pr123', dependencies(new FakeRunner([], {}), cloudflare));
 
     expect(result.action).toBe('deployed');
     expect(createAttempts).toBe(1);
@@ -276,7 +276,7 @@ describe('deploy-environment remote version fallback', () => {
   });
 });
 
-describe('cleanup-pr exact environment matching', () => {
+describe('cleanup-pr exact stage matching', () => {
   it('rejects an invalid PR before touching the client', async () => {
     const cloudflare = new FakeCloudflare();
     let calls = 0;