@smoothbricks/cli 0.1.1 → 0.2.0

package/src/monorepo/packs/index.ts

@@ -1,35 +1,66 @@
 import { chmodSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { validateBunLockfileVersions } from '../lockfile.js';
+import { runStatus } from '../../lib/run.js';
+import { readProjectTargets } from '../../nx/index.js';
+import { syncBunLockfileVersions, validateBunLockfileVersions } from '../lockfile.js';
 import { validateManagedFiles } from '../managed-files.js';
-import { validateNxSync } from '../nx-sync.js';
+import { fixNxSync, validateNxSync } from '../nx-sync.js';
 import { fixPackageHygiene, validatePackageHygiene } from '../package-hygiene.js';
 import {
+  applyFixableMonorepoDefaults,
   applyNxReleaseDefaults,
   applyPublicPackageDefaults,
   applyWorkspaceDependencyDefaults,
+  type ResolvedProjectTargets,
+  validateNxProjectNames,
   validateNxReleaseConfig,
   validatePublicPackageMetadata,
   validatePublicTags,
   validateRootPackagePolicy,
   validateWorkspaceDependencies,
 } from '../package-policy.js';
-import { validatePackedPublicPackages } from '../packed-package.js';
+import {
+  validatePackedPublicPackageManifest,
+  validatePackedPublicPackagePublint,
+  validatePackedPublicPackageTypes,
+} from '../packed-package.js';
 import { syncRootRuntimeVersions } from '../runtime.js';
+import { applyToolConfigDefaults, validateToolConfig } from '../tool-validation.js';
 
 export interface MonorepoContext {
   root: string;
   syncRuntime: boolean;
+  verbose?: boolean;
 }
 
 export interface ValidatePackOptions {
   failFast?: boolean;
+  fix?: boolean;
+  verbose?: boolean;
 }
 
-interface MonorepoPack {
+export interface MonorepoPack {
   name: string;
   init?(ctx: MonorepoContext): Promise<void> | void;
-  validate?(ctx: MonorepoContext): Promise<number> | number;
+  fixPreBuild?(ctx: MonorepoContext): Promise<void> | void;
+  fixPostBuild?(ctx: MonorepoContext): Promise<void> | void;
+  validatePreBuild?(ctx: MonorepoContext): Promise<number> | number;
+  validatePostBuild?(ctx: MonorepoContext): Promise<number> | number;
+}
+
+export interface ValidatePackRunHooks {
+  packs?: readonly MonorepoPack[];
+  runBuild?: (ctx: MonorepoContext, options?: ValidatePackOptions) => Promise<number> | number;
+}
+
+export interface ValidatePackResult {
+  failures: number;
+  failedChecks: number;
+}
+
+interface CapturedOutput {
+  logs: string[];
+  errors: string[];
 }
 
 const packs: MonorepoPack[] = [
@@ -44,13 +75,22 @@ const packs: MonorepoPack[] = [
         console.log('skip           root runtime versions (outside devenv; pass --sync-runtime to force)');
       }
     },
-    async validate(ctx) {
+    async fixPreBuild(ctx) {
+      applyFixableMonorepoDefaults(ctx.root);
+      await applyToolConfigDefaults(ctx.root);
+      syncBunLockfileVersions(ctx.root);
+      await fixNxSync(ctx.root, ctx.verbose === true);
+      applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
+    },
+    async validatePreBuild(ctx) {
       return (
         validateManagedFiles(ctx.root) +
         validateRootPackagePolicy(ctx.root) +
+        validateToolConfig(ctx.root) +
+        validateNxProjectNames(ctx.root) +
         validateNxReleaseConfig(ctx.root) +
         validateBunLockfileVersions(ctx.root) +
-        (await validateNxSync(ctx.root))
+        (await validateNxSync(ctx.root, ctx.verbose === true))
       );
     },
   },
@@ -59,24 +99,55 @@ const packs: MonorepoPack[] = [
     init(ctx) {
       applyPublicPackageDefaults(ctx.root);
     },
-    validate(ctx) {
+    fixPreBuild(ctx) {
+      applyPublicPackageDefaults(ctx.root);
+    },
+    validatePreBuild(ctx) {
       return validatePublicTags(ctx.root) + validatePublicPackageMetadata(ctx.root);
     },
   },
   {
     name: 'workspace-dependencies',
-    async init(ctx) {
+    init(ctx) {
       applyWorkspaceDependencyDefaults(ctx.root);
+    },
+    async fixPostBuild(ctx) {
+      applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
+    },
+    async validatePostBuild(ctx) {
+      return validateWorkspaceDependencies(ctx.root, {
+        resolvedTargetsByProject: await readResolvedTargetsByProject(ctx),
+      });
+    },
+  },
+  {
+    name: 'package-hygiene',
+    async init(ctx) {
+      await fixPackageHygiene(ctx.root, ctx.verbose === true);
+    },
+    async fixPostBuild(ctx) {
       await fixPackageHygiene(ctx.root);
     },
-    async validate(ctx) {
-      return validateWorkspaceDependencies(ctx.root) + (await validatePackageHygiene(ctx.root));
+    async validatePostBuild(ctx) {
+      return validatePackageHygiene(ctx.root, ctx.verbose === true);
+    },
+  },
+  {
+    name: 'packed-package-publint',
+    validatePostBuild(ctx) {
+      return validatePackedPublicPackagePublint(ctx.root);
+    },
+  },
+  {
+    name: 'packed-package-manifest',
+    validatePostBuild(ctx) {
+      return validatePackedPublicPackageManifest(ctx.root);
     },
   },
   {
-    name: 'packed-packages',
-    validate(ctx) {
-      return validatePackedPublicPackages(ctx.root);
+    name: 'packed-package-types',
+    validatePostBuild(ctx) {
+      return validatePackedPublicPackageTypes(ctx.root);
     },
   },
 ];
@@ -87,22 +158,242 @@ export async function runInitPacks(ctx: MonorepoContext): Promise<void> {
   }
 }
 
-export async function runValidatePacks(ctx: MonorepoContext, options: ValidatePackOptions = {}): Promise<number> {
+export async function runValidatePacks(
+  ctx: MonorepoContext,
+  options: ValidatePackOptions = {},
+  hooks: ValidatePackRunHooks = {},
+): Promise<ValidatePackResult> {
+  const selectedPacks = hooks.packs ?? packs;
+  const build = hooks.runBuild ?? runBuild;
+
+  if (options.fix) {
+    await runFixPhase(ctx, selectedPacks, 'pre-build', 'fixPreBuild');
+    const buildFailures = await build(ctx, options);
+    if (buildFailures > 0) {
+      return { failures: buildFailures, failedChecks: 1 };
+    }
+    await runFixPhase(ctx, selectedPacks, 'post-build', 'fixPostBuild');
+    return runValidationPhases(ctx, selectedPacks, options, false);
+  }
+
+  const preBuild = await runValidationPhase(ctx, selectedPacks, options, 'pre-build', 'validatePreBuild', false);
+  if (preBuild.failures > 0 && options.failFast) {
+    return preBuild;
+  }
+  const buildFailures = await build(ctx, options);
+  if (buildFailures > 0) {
+    return { failures: preBuild.failures + buildFailures, failedChecks: preBuild.failedChecks + 1 };
+  }
+  return sumResults(
+    preBuild,
+    await runValidationPhase(ctx, selectedPacks, options, 'post-build', 'validatePostBuild', true),
+  );
+}
+
+async function runValidationPhases(
+  ctx: MonorepoContext,
+  selectedPacks: readonly MonorepoPack[],
+  options: ValidatePackOptions,
+  printedBefore: boolean,
+): Promise<ValidatePackResult> {
+  const preBuild = await runValidationPhase(
+    ctx,
+    selectedPacks,
+    options,
+    'pre-build',
+    'validatePreBuild',
+    printedBefore,
+  );
+  if (preBuild.failures > 0 && options.failFast) {
+    return preBuild;
+  }
+  return sumResults(
+    preBuild,
+    await runValidationPhase(ctx, selectedPacks, options, 'post-build', 'validatePostBuild', true),
+  );
+}
+
+async function runValidationPhase(
+  ctx: MonorepoContext,
+  selectedPacks: readonly MonorepoPack[],
+  options: ValidatePackOptions,
+  phase: 'pre-build' | 'post-build',
+  method: 'validatePreBuild' | 'validatePostBuild',
+  printedBefore: boolean,
+): Promise<ValidatePackResult> {
   let failures = 0;
+  let failedChecks = 0;
   let checkedPacks = 0;
-  for (const pack of packs) {
-    if (!pack.validate) {
+  let hasPrinted = printedBefore;
+  for (const pack of selectedPacks) {
+    const validate = pack[method];
+    if (!validate) {
       continue;
     }
-    console.log(`${checkedPacks === 0 ? '' : '\n'}== ${pack.name} ==`);
+    const label = `${pack.name} (${phase})`;
+    if (options.verbose) {
+      printCheckHeading(label, hasPrinted || checkedPacks > 0);
+    }
+    hasPrinted = true;
     checkedPacks++;
-    const packFailures = await pack.validate(ctx);
+    let packFailures: number;
+    let output = emptyCapturedOutput();
+    try {
+      if (options.verbose) {
+        packFailures = await validate(ctx);
+      } else {
+        const captured = await captureConsoleOutput(() => validate(ctx));
+        packFailures = captured.result;
+        output = captured.output;
+      }
+    } catch (error) {
+      if (!options.verbose) {
+        printCheckHeading(label, true);
+        if (error instanceof CapturedConsoleError) {
+          output = error.output;
+        }
+        printCapturedOutput(output);
+      }
+      throw error instanceof CapturedConsoleError ? error.cause : error;
+    }
     failures += packFailures;
+    if (packFailures > 0) {
+      failedChecks++;
+    }
+    if (!options.verbose && packFailures > 0) {
+      printCheckHeading(label, true);
+      printCapturedOutput(output);
+    }
+    printCheckStatus(label, packFailures);
     if (packFailures > 0 && options.failFast) {
       break;
     }
   }
-  return failures;
+  return { failures, failedChecks };
+}
+
+function sumResults(left: ValidatePackResult, right: ValidatePackResult): ValidatePackResult {
+  return { failures: left.failures + right.failures, failedChecks: left.failedChecks + right.failedChecks };
+}
+
+async function runFixPhase(
+  ctx: MonorepoContext,
+  selectedPacks: readonly MonorepoPack[],
+  phase: 'pre-build' | 'post-build',
+  method: 'fixPreBuild' | 'fixPostBuild',
+): Promise<void> {
+  let checkedPacks = 0;
+  for (const pack of selectedPacks) {
+    const fix = pack[method];
+    if (!fix) {
+      continue;
+    }
+    const label = `${pack.name} (${phase} fix)`;
+    if (ctx.verbose) {
+      printCheckHeading(label, checkedPacks > 0);
+    }
+    checkedPacks++;
+    if (ctx.verbose) {
+      await fix(ctx);
+      continue;
+    }
+    let output = emptyCapturedOutput();
+    try {
+      output = (await captureConsoleOutput(() => fix(ctx))).output;
+    } catch (error) {
+      if (error instanceof CapturedConsoleError) {
+        output = error.output;
+      }
+      printCheckHeading(label, true);
+      printCapturedOutput(output);
+      throw error instanceof CapturedConsoleError ? error.cause : error;
+    }
+  }
+}
+
+async function runBuild(ctx: MonorepoContext, options: ValidatePackOptions = {}): Promise<number> {
+  if (options.verbose) {
+    printCheckHeading('build', true);
+  }
+  const status = await runStatus('nx', ['run-many', '-t', 'build'], ctx.root, options.verbose !== true);
+  if (status !== 0) {
+    if (!options.verbose) {
+      printCheckHeading('build', true);
+    }
+    console.error('nx run-many -t build failed');
+    printCheckStatus('build', 1);
+    return 1;
+  }
+  printCheckStatus('build', 0);
+  return 0;
+}
+
+function printCheckStatus(label: string, failures: number): void {
+  if (failures === 0) {
+    console.log(`🆗 ${label}`);
+    return;
+  }
+  const noun = failures === 1 ? 'problem' : 'problems';
+  console.log(`👎 ${label} (${failures} ${noun})\n`);
+}
+
+function printCheckHeading(label: string, separate: boolean): void {
+  console.log(`${separate ? '\n' : ''}== ${label} ==`);
+}
+
+function emptyCapturedOutput(): CapturedOutput {
+  return { logs: [], errors: [] };
+}
+
+async function captureConsoleOutput<T>(fn: () => Promise<T> | T): Promise<{ result: T; output: CapturedOutput }> {
+  const output = emptyCapturedOutput();
+  const originalLog = console.log;
+  const originalError = console.error;
+  console.log = (...args: unknown[]) => {
+    output.logs.push(args.join(' '));
+  };
+  console.error = (...args: unknown[]) => {
+    output.errors.push(args.join(' '));
+  };
+  try {
+    return { result: await fn(), output };
+  } catch (error) {
+    throw new CapturedConsoleError(error, output);
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+  }
+}
+
+class CapturedConsoleError extends Error {
+  constructor(
+    public override readonly cause: unknown,
+    public readonly output: CapturedOutput,
+  ) {
+    super(cause instanceof Error ? cause.message : String(cause));
+  }
+}
+
+function printCapturedOutput(output: CapturedOutput): void {
+  for (const line of output.logs) {
+    console.log(line);
+  }
+  for (const line of output.errors) {
+    console.log(line);
+  }
+}
+
+async function readResolvedTargetsByProject(ctx: MonorepoContext): Promise<Map<string, ResolvedProjectTargets>> {
+  const projects = await readProjectTargets(ctx.root);
+  return new Map(
+    projects.map((project) => [
+      project.project,
+      {
+        targets: new Set(project.targets),
+        ...(project.buildDependsOn ? { buildDependsOn: project.buildDependsOn } : {}),
+      },
+    ]),
+  );
 }
 
 function ensureLocalSmooShim(root: string): void {

package/src/monorepo/publish-workflow.ts

@@ -1,3 +1,5 @@
+import { isSmoothBricksCodebasePackageName } from '../lib/cli-package.js';
+
 export type PublishWorkflowBump = 'auto' | 'patch' | 'minor' | 'major' | 'prerelease';
 export type PublishWorkflowCondition = 'version-mode-not-none' | 'failure' | 'always';
 export type PublishWorkflowNxTarget = 'build' | 'lint' | 'test';
@@ -26,7 +28,6 @@ export interface PublishWorkflowStep {
   id?: string;
   condition?: PublishWorkflowCondition;
   nxTarget?: PublishWorkflowNxTarget;
-  needsNodeAuthToken?: boolean;
 }
 
 export interface PublishWorkflowDefinition {
@@ -57,19 +58,18 @@ export interface PublishWorkflowCallbacks {
   setupDevenv(): Promise<PublishWorkflowSetupOutputs>;
   configureReleaseAuthor(): Promise<void>;
   buildSelfHostedCli(): Promise<void>;
-  repairPendingReleases(input: { dryRun: boolean; nodeAuthToken: boolean }): Promise<void>;
+  repairPendingReleases(input: { dryRun: boolean }): Promise<void>;
   versionRelease(input: { bump: PublishWorkflowBump; dryRun: boolean }): Promise<PublishWorkflowVersionOutputs>;
   checkManagedMonorepoFiles(): Promise<void>;
   nxRunMany(input: { target: PublishWorkflowNxTarget; projects: string[] }): Promise<void>;
   uploadTraceDbs(): Promise<void>;
   validateMonorepoConfig(): Promise<void>;
-  publishRelease(input: { bump: PublishWorkflowBump; dryRun: boolean; nodeAuthToken: boolean }): Promise<void>;
+  publishRelease(input: { bump: PublishWorkflowBump; dryRun: boolean }): Promise<void>;
   saveNixDevenv(input: PublishWorkflowSetupOutputs): Promise<void>;
 }
 
 export interface PublishWorkflowRunContext {
   inputs: PublishWorkflowInputs;
-  nodeAuthToken: boolean;
   callbacks: PublishWorkflowCallbacks;
 }
 
@@ -87,7 +87,7 @@ export function definePublishWorkflow(options: PublishWorkflowDefinitionOptions
     { kind: PublishWorkflowStepKind.SetupDevenv, name: '🧱 Setup Nix/devenv', id: 'setup' },
     { kind: PublishWorkflowStepKind.ConfigureReleaseAuthor, name: '🤖 Configure release author' },
   ];
-  if (options.repoName === '@smoothbricks/codebase') {
+  if (isSmoothBricksCodebasePackageName(options.repoName)) {
     setupSteps.push({ kind: PublishWorkflowStepKind.BuildSelfHostedCli, name: '🏗️ Build self-hosted smoo' });
   }
   return {
@@ -96,7 +96,6 @@ export function definePublishWorkflow(options: PublishWorkflowDefinitionOptions
       {
         kind: PublishWorkflowStepKind.RepairPendingReleases,
         name: '🧯 Repair pending releases',
-        needsNodeAuthToken: true,
       },
       { kind: PublishWorkflowStepKind.VersionRelease, name: '🏷️ Version release', id: 'version' },
       {
@@ -131,7 +130,6 @@ export function definePublishWorkflow(options: PublishWorkflowDefinitionOptions
       {
         kind: PublishWorkflowStepKind.PublishRelease,
         name: `📦 Publish release (${versionMode})`,
-        needsNodeAuthToken: true,
       },
       {
         kind: PublishWorkflowStepKind.SaveNixDevenv,
@@ -175,7 +173,6 @@ export async function runPublishWorkflow(
         case PublishWorkflowStepKind.RepairPendingReleases:
           await context.callbacks.repairPendingReleases({
             dryRun: context.inputs.dryRun,
-            nodeAuthToken: context.nodeAuthToken,
           });
           break;
         case PublishWorkflowStepKind.VersionRelease:
@@ -202,7 +199,6 @@ export async function runPublishWorkflow(
           await context.callbacks.publishRelease({
             bump: context.inputs.bump,
             dryRun: context.inputs.dryRun,
-            nodeAuthToken: context.nodeAuthToken,
           });
           break;
         case PublishWorkflowStepKind.SaveNixDevenv:
@@ -347,13 +343,11 @@ function yamlLinesForStep(step: PublishWorkflowStep): string[] {
         `      - name: ${step.name}`,
         '        # SmoothBricks self-hosts smoo from source, but Nx release loads',
         '        # @smoothbricks/cli/nx-version-actions through the built package export.',
-        '        run: nx build @smoothbricks/cli',
+        '        run: nx build cli',
       ];
     case PublishWorkflowStepKind.RepairPendingReleases:
       return [
         `      - name: ${step.name}`,
-        '        env:',
-        `          NODE_AUTH_TOKEN: ${githubExpression('secrets.NPM_TOKEN')}`,
         `        run: smoo release repair-pending --dry-run "${githubExpression('inputs.dry_run')}"`,
       ];
     case PublishWorkflowStepKind.VersionRelease:
@@ -399,10 +393,8 @@ function yamlLinesForStep(step: PublishWorkflowStep): string[] {
       return [
         `      - name: ${step.name}`,
         '        # smoo packs with Bun, then publishes tarballs with npm. Existing',
-        '        # packages use trusted publishing/OIDC; first publishes use NODE_AUTH_TOKEN',
-        '        # because npm trust can only be configured after a package exists.',
-        '        env:',
-        `          NODE_AUTH_TOKEN: ${githubExpression('secrets.NPM_TOKEN')}`,
+        '        # packages must already exist on npm and use trusted publishing/OIDC.',
+        '        # Missing package names are bootstrapped locally before trust setup.',
         `        run: smoo release publish --bump "${githubExpression('inputs.bump')}" --dry-run "${githubExpression('inputs.dry_run')}"`,
       ];
     case PublishWorkflowStepKind.SaveNixDevenv:

package/src/monorepo/setup-test-tracing.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'bun:test';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { type SetupTestTracingShell, setupTestTracing } from './index.js';
+
+describe('LMAO test tracing setup', () => {
+  it('runs the Bun test tracing generator for every workspace package', async () => {
+    await withWorkspace(async (root) => {
+      await writeWorkspacePackage(root, 'packages/a', '@scope/a', 'a');
+      await writeWorkspacePackage(root, 'packages/b', '@scope/b', 'b');
+      const shell = new RecordingSetupShell();
+
+      await setupTestTracing(root, { all: true }, shell);
+
+      expect(shell.runs).toEqual([generatorRun(root, 'a', '@scope/a'), generatorRun(root, 'b', '@scope/b')]);
+    });
+  });
+
+  it('selects packages by project name, package name, or package root', async () => {
+    await withWorkspace(async (root) => {
+      await writeWorkspacePackage(root, 'packages/a', '@scope/a', 'a');
+      await writeWorkspacePackage(root, 'packages/b', '@scope/b', 'b');
+      await writeWorkspacePackage(root, 'packages/c', '@scope/c', 'c');
+      const shell = new RecordingSetupShell();
+
+      await setupTestTracing(root, { projects: 'a,@scope/b,packages/c', opContextExport: 'customContext' }, shell);
+
+      expect(shell.runs).toEqual([
+        generatorRun(root, 'a', '@scope/a', 'customContext'),
+        generatorRun(root, 'b', '@scope/b', 'customContext'),
+        generatorRun(root, 'c', '@scope/c', 'customContext'),
+      ]);
+    });
+  });
+
+  it('prints generator invocations in dry-run mode without running Nx', async () => {
+    await withWorkspace(async (root) => {
+      await writeWorkspacePackage(root, 'packages/a', '@scope/a', 'a');
+      const shell = new RecordingSetupShell();
+
+      await setupTestTracing(root, { all: true, dryRun: true }, shell);
+
+      expect(shell.runs).toEqual([]);
+      expect(shell.logs).toEqual([
+        'would run      nx g @smoothbricks/nx-plugin:bun-test-tracing --project a --opContextModule @scope/a --opContextExport opContext --tracerModule @smoothbricks/lmao/testing/bun',
+      ]);
+    });
+  });
+});
+
+class RecordingSetupShell implements SetupTestTracingShell {
+  readonly runs: { command: string; args: string[]; cwd: string }[] = [];
+  readonly logs: string[] = [];
+
+  async run(command: string, args: string[], cwd: string): Promise<void> {
+    this.runs.push({ command, args, cwd });
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+}
+
+async function withWorkspace(run: (root: string) => Promise<void>): Promise<void> {
+  const root = await mkdtemp(join(tmpdir(), 'smoo-test-tracing-'));
+  try {
+    await writeJson(join(root, 'package.json'), {
+      name: '@scope/workspace',
+      version: '0.0.0',
+      private: true,
+      workspaces: ['packages/*'],
+    });
+    await run(root);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+
+async function writeWorkspacePackage(
+  root: string,
+  packagePath: string,
+  name: string,
+  projectName: string,
+): Promise<void> {
+  await mkdir(join(root, packagePath), { recursive: true });
+  await writeJson(join(root, packagePath, 'package.json'), {
+    name,
+    version: '1.0.0',
+    nx: { name: projectName },
+  });
+}
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function generatorRun(
+  root: string,
+  project: string,
+  opContextModule: string,
+  opContextExport = 'opContext',
+): { command: string; args: string[]; cwd: string } {
+  return {
+    command: 'nx',
+    args: [
+      'g',
+      '@smoothbricks/nx-plugin:bun-test-tracing',
+      '--project',
+      project,
+      '--opContextModule',
+      opContextModule,
+      '--opContextExport',
+      opContextExport,
+      '--tracerModule',
+      '@smoothbricks/lmao/testing/bun',
+    ],
+    cwd: root,
+  };
+}