@smoothbricks/cli 0.1.1 → 0.3.0

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:
@@ -345,15 +341,12 @@ function yamlLinesForStep(step: PublishWorkflowStep): string[] {
     case PublishWorkflowStepKind.BuildSelfHostedCli:
       return [
         `      - 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',
+        '        # SmoothBricks self-hosts smoo from source for release commands.',
+        '        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:
@@ -385,7 +378,7 @@ function yamlLinesForStep(step: PublishWorkflowStep): string[] {
       return [
         `      - name: ${step.name}`,
         `        if: ${githubExpression('failure()')}`,
-        '        uses: actions/upload-artifact@v4',
+        '        uses: actions/upload-artifact@v7.0.1',
         '        with:',
         `          name: trace-results-${githubExpression('github.run_id')}`,
         '          path: packages/*/.trace-results.db',
@@ -399,10 +392,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,
+  };
+}

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

@@ -0,0 +1,261 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import {
+  applyRootDevDependencyDefaults,
+  applyToolConfigDefaults,
+  applyToolingPackageDefaults,
+  readToolContext,
+  validateToolConfig,
+} from './tool-validation.js';
+
+const registryVersions: Record<string, string[]> = {
+  '@biomejs/biome': ['2.3.5'],
+  '@nx/js': ['22.5.4'],
+  '@smoothbricks/nx-plugin': ['0.0.1'],
+  eslint: ['9.39.1'],
+  'eslint-stdout': ['1.1.1', '1.1.2'],
+  nx: ['22.5.4'],
+  prettier: ['3.6.1'],
+  typescript: ['5.9.3'],
+};
+
+const realFetch = globalThis.fetch;
+
+describe('tool configuration validation', () => {
+  beforeEach(() => {
+    globalThis.fetch = mockRegistryFetch as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = realFetch;
+  });
+
+  it('fixes root, tooling, and devenv tool declarations', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      await writeJson(join(root, 'package.json'), {
+        name: '@smoothbricks/codebase',
+        version: '0.0.0',
+        private: true,
+        devDependencies: {
+          '@smoothbricks/cli': 'workspace:*',
+        },
+      });
+      const devenvPath = join(root, 'tooling/direnv/devenv.nix');
+      await mkdir(dirname(devenvPath), { recursive: true });
+      await writeFile(
+        devenvPath,
+        `{
+  pkgs,
+  ...
+}: {
+  packages = with pkgs; [
+  ];
+}
+`,
+      );
+
+      expect(validateToolConfig(root)).toBeGreaterThan(0);
+      await applyToolConfigDefaults(root);
+      expect(validateToolConfig(root)).toBe(0);
+
+      const rootPackage = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+      const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
+      const devenv = await readFile(join(root, 'tooling/direnv/devenv.nix'), 'utf8');
+      expect(rootPackage.devDependencies['@smoothbricks/cli']).toBeUndefined();
+      expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe('workspace:*');
+      expect(rootPackage.devDependencies['eslint-stdout']).toBe('workspace:*');
+      expect(rootPackage.devDependencies.nx).toBe('22.5.4');
+      expect(rootPackage.workspaces).toContain('tooling');
+      expect(toolingPackage.name).toBe('@smoothbricks/tooling');
+      expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe('workspace:*');
+      expect(devenv).toContain('nodejs_latest');
+      expect(devenv).toContain('coreutils');
+      expect(devenv).toContain('git-format-staged');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('accepts newer dependency versions above the policy floor', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      await writeJson(join(root, 'package.json'), {
+        name: '@fixture/app',
+        version: '0.0.0',
+        private: true,
+        workspaces: ['packages/*', 'tooling'],
+        devDependencies: {
+          '@biomejs/biome': '^3.0.0',
+          '@nx/js': '22.6.0',
+          '@smoothbricks/nx-plugin': '^0.1.0',
+          '@types/bun': '1.3.99',
+          eslint: '^10.0.0',
+          'eslint-stdout': await currentEslintStdoutRange(),
+          nx: '23.0.0',
+          prettier: '^3.7.0',
+          typescript: '^6.0.0',
+        },
+      });
+      await writeJson(join(root, 'tooling/package.json'), {
+        name: '@fixture/tooling',
+        private: true,
+        dependencies: { '@smoothbricks/cli': await currentCliRange() },
+      });
+      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(validateToolConfig(root)).toBe(0);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('uses workspace smoo in the SmoothBricks codebase repo', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      await writeJson(join(root, 'package.json'), {
+        name: '@smoothbricks/codebase',
+        version: '0.0.0',
+        private: true,
+        workspaces: ['packages/*', 'tooling'],
+      });
+      applyToolingPackageDefaults(root, readToolContext(root).policy);
+
+      const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
+      expect(toolingPackage.name).toBe('@smoothbricks/tooling');
+      expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe('workspace:*');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('uses published smoo and eslint formatter ranges in user repos', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      await writeJson(join(root, 'package.json'), {
+        name: '@fixture/app',
+        version: '0.0.0',
+        private: true,
+        workspaces: ['packages/*', 'tooling'],
+        devDependencies: {
+          '@biomejs/biome': '^3.0.0',
+          '@nx/js': '22.6.0',
+          eslint: '^10.0.0',
+          nx: '23.0.0',
+          prettier: '^3.7.0',
+          typescript: '^6.0.0',
+        },
+      });
+
+      const context = readToolContext(root);
+      await applyRootDevDependencyDefaults(root, context);
+      applyToolingPackageDefaults(root, context.policy);
+
+      const rootPackage = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+      const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
+      expect(rootPackage.devDependencies['eslint-stdout']).toBe(await currentEslintStdoutRange());
+      expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe(await currentNxPluginRange());
+      expect(toolingPackage.name).toBe('@fixture/tooling');
+      expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe(await currentCliRange());
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});
+
+async function currentCliRange(): Promise<string> {
+  const pkg = JSON.parse(await readFile(new URL('../../package.json', import.meta.url), 'utf8'));
+  return `^${pkg.version}`;
+}
+
+async function currentEslintStdoutRange(): Promise<string> {
+  const pkg = JSON.parse(await readFile(new URL('../../../eslint-stdout/package.json', import.meta.url), 'utf8'));
+  return `^${latestPatchVersion('eslint-stdout', pkg.version) ?? pkg.version}`;
+}
+
+function mockRegistryFetch(input: Parameters<typeof fetch>[0]): Promise<Response> {
+  const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+  const packageName = decodeURIComponent(new URL(url).pathname.slice(1));
+  const versions = registryVersions[packageName];
+  if (!versions) {
+    return Promise.resolve(new Response('{}', { status: 404 }));
+  }
+  return Promise.resolve(
+    new Response(JSON.stringify({ versions: Object.fromEntries(versions.map((version) => [version, {}])) }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    }),
+  );
+}
+
+function latestPatchVersion(packageName: string, version: string): string | null {
+  const [major, minor] = version.split('.');
+  if (!major || !minor) {
+    return null;
+  }
+  return (
+    (registryVersions[packageName] ?? [])
+      .filter((candidate) => candidate.startsWith(`${major}.${minor}.`))
+      .sort((left, right) => compareDotVersions(right, left))[0] ?? null
+  );
+}
+
+function compareDotVersions(left: string, right: string): number {
+  const leftParts = left.split('.').map(Number);
+  const rightParts = right.split('.').map(Number);
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const diff = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+
+async function currentNxPluginRange(): Promise<string> {
+  return `^${latestRegistryVersion('@smoothbricks/nx-plugin')}`;
+}
+
+function latestRegistryVersion(packageName: string): string {
+  const versions = registryVersions[packageName];
+  if (!versions) {
+    throw new Error(`missing mocked registry versions for ${packageName}`);
+  }
+  let latest = versions[0];
+  for (const version of versions) {
+    if (!latest || compareDotVersions(version, latest) > 0) {
+      latest = version;
+    }
+  }
+  if (!latest) {
+    throw new Error(`empty mocked registry versions for ${packageName}`);
+  }
+  return latest;
+}
+
+async function writeJson(path: string, value: Record<string, unknown>): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}