@smoothbricks/cli 0.1.1 → 0.3.0

package/src/release/__tests__/fixture-repo.test.ts

@@ -25,14 +25,14 @@ describe('release planning with fixture git repositories', () => {
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial release']);
       const first = await gitOutput(root, ['rev-parse', 'HEAD']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
-      await tag(root, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'b@1.0.0', '2025-01-01T00:00:01Z');
 
       await writePackage(root, '@scope/a', 'packages/a', '1.1.0');
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'second release']);
       const second = await gitOutput(root, ['rev-parse', 'HEAD']);
-      await tag(root, '@scope/a@1.1.0', '2025-01-02T00:00:00Z');
+      await tag(root, 'a@1.1.0', '2025-01-02T00:00:00Z');
 
       await writeFile(join(root, 'readme.md'), 'not a release\n');
       await git(root, ['add', '.']);
@@ -41,11 +41,11 @@ describe('release planning with fixture git repositories', () => {
       await tag(root, 'not-owned@9.9.9', '2025-01-03T00:00:00Z');
 
       const npmPublished = new Set(['@scope/a@1.0.0', '@scope/b@1.0.0']);
-      const githubReleases = new Set(['@scope/a@1.0.0']);
+      const githubReleases = new Set(['a@1.0.0']);
       const records = await collectOwnedReleaseTagRecords(
         [
-          { name: '@scope/a', path: 'packages/a' },
-          { name: '@scope/b', path: 'packages/b' },
+          { name: '@scope/a', projectName: 'a', path: 'packages/a' },
+          { name: '@scope/b', projectName: 'b', path: 'packages/b' },
         ],
         head,
         {
@@ -59,7 +59,7 @@ describe('release planning with fixture git repositories', () => {
         },
       );
 
-      expect(records.map((record) => record.tag)).toEqual(['@scope/a@1.1.0', '@scope/b@1.0.0', '@scope/a@1.0.0']);
+      expect(records.map((record) => record.tag)).toEqual(['a@1.1.0', 'b@1.0.0', 'a@1.0.0']);
       const pending = pendingReleaseTargets(records, head);
       expect(pending.map((target) => target.sha)).toEqual([first, second]);
       expect(pending[0]?.packages.map((pkg) => pkg.name)).toEqual(['@scope/b']);
@@ -74,7 +74,7 @@ describe('release planning with fixture git repositories', () => {
       await writePackage(root, '@scope/a', 'packages/a', '1.0.0');
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'release a']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
       await git(root, ['init', '--bare', 'remote.git']);
       await git(root, ['remote', 'add', 'origin', join(root, 'remote.git')]);
       await git(root, ['push', 'origin', 'main', '--tags']);
@@ -83,14 +83,18 @@ describe('release planning with fixture git repositories', () => {
       await git(checkout, ['fetch', '--tags', 'origin', 'main']);
       const head = await gitOutput(checkout, ['rev-parse', 'HEAD']);
 
-      const records = await collectOwnedReleaseTagRecords([{ name: '@scope/a', path: 'packages/a' }], head, {
-        listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(checkout),
-        isAncestor: (ancestor, descendant) => gitIsAncestor(checkout, ancestor, descendant),
-        packageVersionAtRef: (packagePath, ref) => packageVersionAtRef(checkout, packagePath, ref),
-        durableTagState: async () => ({ npmPublished: false, githubReleaseExists: false }),
-      });
+      const records = await collectOwnedReleaseTagRecords(
+        [{ name: '@scope/a', projectName: 'a', path: 'packages/a' }],
+        head,
+        {
+          listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(checkout),
+          isAncestor: (ancestor, descendant) => gitIsAncestor(checkout, ancestor, descendant),
+          packageVersionAtRef: (packagePath, ref) => packageVersionAtRef(checkout, packagePath, ref),
+          durableTagState: async () => ({ npmPublished: false, githubReleaseExists: false }),
+        },
+      );
 
-      expect(records.map((record) => record.tag)).toEqual(['@scope/a@1.0.0']);
+      expect(records.map((record) => record.tag)).toEqual(['a@1.0.0']);
       expect(pendingReleaseTargets(records, 'not-head').map((target) => target.sha)).toEqual([head]);
     });
   });
@@ -101,7 +105,7 @@ describe('release planning with fixture git repositories', () => {
       await writeBuildablePackage(root, '@scope/a', 'packages/a');
       await writeBuildablePackage(root, '@scope/b', 'packages/b');
 
-      await $`nx run-many -t build --projects=${'@scope/a,@scope/b'}`.cwd(root).quiet();
+      await $`nx run-many -t build --projects=${'a,b'}`.cwd(root).quiet();
 
       await expect(readFile(join(root, 'packages/a/dist/index.js'), 'utf8')).resolves.toBe('{}\n');
       await expect(readFile(join(root, 'packages/b/dist/index.js'), 'utf8')).resolves.toBe('{}\n');
@@ -115,26 +119,26 @@ describe('release planning with fixture git repositories', () => {
       await writeBuildablePackage(author, '@scope/b', 'packages/b', '1.0.0');
       await git(author, ['add', '.']);
       await git(author, ['commit', '-m', 'initial release']);
-      await tag(author, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
-      await tag(author, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+      await tag(author, 'a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(author, 'b@1.0.0', '2025-01-01T00:00:01Z');
 
       await writeBuildablePackage(author, '@scope/a', 'packages/a', '1.1.0');
       await git(author, ['add', 'packages/a/package.json']);
       await git(author, ['commit', '-m', 'release a 1.1.0']);
       const githubOnlySha = await gitOutput(author, ['rev-parse', 'HEAD']);
-      await tag(author, '@scope/a@1.1.0', '2025-01-02T00:00:00Z');
+      await tag(author, 'a@1.1.0', '2025-01-02T00:00:00Z');
 
       await writeBuildablePackage(author, '@scope/b', 'packages/b', '2.0.0-beta.1');
       await git(author, ['add', 'packages/b/package.json']);
       await git(author, ['commit', '-m', 'release b prerelease']);
       const npmAndGithubSha = await gitOutput(author, ['rev-parse', 'HEAD']);
-      await tag(author, '@scope/b@2.0.0-beta.1', '2025-01-03T00:00:00Z');
+      await tag(author, 'b@2.0.0-beta.1', '2025-01-03T00:00:00Z');
 
       await writeBuildablePackage(author, '@scope/a', 'packages/a', '1.2.0');
       await git(author, ['add', 'packages/a/package.json']);
       await git(author, ['commit', '-m', 'head release a 1.2.0']);
       const headSha = await gitOutput(author, ['rev-parse', 'HEAD']);
-      await tag(author, '@scope/a@1.2.0', '2025-01-04T00:00:00Z');
+      await tag(author, 'a@1.2.0', '2025-01-04T00:00:00Z');
 
       await git(author, ['init', '--bare', 'remote.git']);
       await git(author, ['remote', 'add', 'origin', join(author, 'remote.git')]);
@@ -147,7 +151,7 @@ describe('release planning with fixture git repositories', () => {
       const restoreRef = 'origin/main';
       const packages = releaseFixturePackages();
       const npmPublished = new Set(['@scope/a@1.0.0', '@scope/b@1.0.0', '@scope/a@1.1.0']);
-      const githubReleases = new Set(['@scope/a@1.0.0', '@scope/b@1.0.0']);
+      const githubReleases = new Set(['a@1.0.0', 'b@1.0.0']);
 
       const records = await collectOwnedReleaseTagRecords(packages, restoreRef, {
         listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(runner),
@@ -177,7 +181,7 @@ describe('release planning with fixture git repositories', () => {
         { name: '@scope/a', version: '1.1.0', dryRun: false },
         { name: '@scope/b', version: '2.0.0-beta.1', dryRun: false },
       ]);
-      expect(shell.pushes).toEqual([['@scope/a@1.1.0'], ['@scope/b@2.0.0-beta.1']]);
+      expect(shell.pushes).toEqual([['a@1.1.0'], ['b@2.0.0-beta.1']]);
       expect(summaries.map((summary) => summary.sha)).toEqual([githubOnlySha, npmAndGithubSha]);
       await expect(readFile(join(runner, 'packages/b/dist/index.js'), 'utf8')).resolves.toBe('{}\n');
       await expect(readFile(join(runner, 'packages/a/dist/index.js'), 'utf8')).rejects.toThrow();
@@ -197,27 +201,81 @@ describe('release planning with fixture git repositories', () => {
       const runner = join(author, 'runner');
       await git(runner, ['config', 'user.name', 'Test User']);
       await git(runner, ['config', 'user.email', 'test@example.com']);
-      const pkg: ReleasePackageInfo = { name: '@scope/pushed', path: 'packages/pushed', version: '1.0.0' };
+      const pkg: ReleasePackageInfo = {
+        name: '@scope/pushed',
+        projectName: 'pushed',
+        path: 'packages/pushed',
+        version: '1.0.0',
+      };
       const shell = new LocalGitRepairShell(runner);
 
       const summary = await completeReleaseAtHead(shell, [pkg], false, false);
 
       expect(summary.pushed).toBe(true);
-      expect(shell.pushes).toEqual([['@scope/pushed@1.0.0']]);
+      expect(shell.pushes).toEqual([['pushed@1.0.0']]);
       await $`git clone --branch main ${join(author, 'remote.git')} auditor`.cwd(author).quiet();
       const auditor = join(author, 'auditor');
       await git(auditor, ['fetch', '--tags', 'origin', 'main']);
-      await expect(gitOutput(auditor, ['rev-parse', 'refs/tags/@scope/pushed@1.0.0^{}'])).resolves.toBe(
+      await expect(gitOutput(auditor, ['rev-parse', 'refs/tags/pushed@1.0.0^{}'])).resolves.toBe(
         await gitOutput(runner, ['rev-parse', 'HEAD']),
       );
+      await expect(gitSucceeds(auditor, ['rev-parse', '--verify', 'refs/tags/@scope/pushed@1.0.0'])).resolves.toBe(
+        false,
+      );
+    });
+  });
+
+  it('repairs a scoped package from its project-name release tag without creating a package-name tag', async () => {
+    await withFixtureRepo(async (author) => {
+      await writeWorkspace(author);
+      await writeBuildablePackage(author, '@scope/cli', 'packages/cli', '0.2.0');
+      await git(author, ['add', '.']);
+      await git(author, ['commit', '-m', 'release cli 0.2.0']);
+      const releaseSha = await gitOutput(author, ['rev-parse', 'HEAD']);
+      await tag(author, 'cli@0.2.0', '2025-01-01T00:00:00Z');
+
+      await git(author, ['init', '--bare', 'remote.git']);
+      await git(author, ['remote', 'add', 'origin', join(author, 'remote.git')]);
+      await git(author, ['push', 'origin', 'main', '--tags']);
+      await $`git clone --branch main ${join(author, 'remote.git')} runner`.cwd(author).quiet();
+      const runner = join(author, 'runner');
+      await git(runner, ['config', 'user.name', 'Test User']);
+      await git(runner, ['config', 'user.email', 'test@example.com']);
+      await git(runner, ['fetch', '--tags', 'origin', 'main']);
+
+      const pkg: ReleasePackageInfo = {
+        name: '@scope/cli',
+        projectName: 'cli',
+        path: 'packages/cli',
+        version: '0.0.0',
+      };
+      const records = await collectOwnedReleaseTagRecords([pkg], 'origin/main', {
+        listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(runner),
+        isAncestor: (ancestor, descendant) => gitIsAncestor(runner, ancestor, descendant),
+        packageVersionAtRef: (packagePath, ref) => packageVersionAtRef(runner, packagePath, ref),
+        durableTagState: async () => ({ npmPublished: false, githubReleaseExists: false }),
+      });
+      const pending = pendingReleaseTargets(records, 'not-head');
+
+      const shell = new LocalGitRepairShell(runner);
+      const summaries = await repairPendingTargets(shell, pending, 'origin/main', false);
+
+      expect(records.map((record) => record.tag)).toEqual(['cli@0.2.0']);
+      expect(pending.map((target) => target.sha)).toEqual([releaseSha]);
+      expect(shell.pushes).toEqual([['cli@0.2.0']]);
+      expect(shell.publishes).toEqual([{ name: '@scope/cli', version: '0.2.0', distTag: 'latest', dryRun: false }]);
+      expect(shell.githubCreates).toEqual([{ name: '@scope/cli', version: '0.2.0', dryRun: false }]);
+      expect(summaries[0]?.packages.map((releasePackage) => releasePackage.name)).toEqual(['@scope/cli']);
+      await expect(gitSucceeds(runner, ['rev-parse', '--verify', 'refs/tags/cli@0.2.0'])).resolves.toBe(true);
+      await expect(gitSucceeds(runner, ['rev-parse', '--verify', 'refs/tags/@scope/cli@0.2.0'])).resolves.toBe(false);
     });
   });
 });
 
 function releaseFixturePackages(): ReleasePackageInfo[] {
   return [
-    { name: '@scope/a', path: 'packages/a', version: '0.0.0' },
-    { name: '@scope/b', path: 'packages/b', version: '0.0.0' },
+    { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '0.0.0' },
+    { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '0.0.0' },
   ];
 }
 
@@ -236,7 +294,7 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
   }
 
   async pushReleaseRefs(packages: ReleasePackageInfo[]): Promise<boolean> {
-    this.pushes.push(packages.map((pkg) => `${pkg.name}@${pkg.version}`));
+    this.pushes.push(packages.map((pkg) => releaseTag(pkg)));
     await git(this.root, ['fetch', '--tags', 'origin', 'main']);
     for (const pkg of packages) {
       await this.ensureLocalReleaseTag(pkg);
@@ -265,7 +323,7 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
   async buildReleaseCandidate(packages: ReleasePackageInfo[]): Promise<void> {
     this.builds.push(packages.map((pkg) => pkg.name));
-    await $`nx run-many -t build --projects=${packages.map((pkg) => pkg.name).join(',')}`.cwd(this.root).quiet();
+    await $`nx run-many -t build --projects=${packages.map((pkg) => pkg.projectName).join(',')}`.cwd(this.root).quiet();
   }
 
   async publishPackage(pkg: ReleasePackageInfo, distTag: string, dryRun: boolean): Promise<void> {
@@ -276,8 +334,9 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
     return [];
   }
 
-  async createGithubRelease(pkg: ReleasePackageInfo, dryRun: boolean): Promise<void> {
+  async createGithubRelease(pkg: ReleasePackageInfo, dryRun: boolean): Promise<string | null> {
     this.githubCreates.push({ name: pkg.name, version: pkg.version, dryRun });
+    return dryRun ? null : `https://github.test/${releaseTag(pkg)}`;
   }
 
   async checkout(ref: string): Promise<void> {

package/src/release/__tests__/github-release.test.ts

@@ -8,14 +8,19 @@ import {
   projectChangelogContents,
 } from '../github-release.js';
 
-const stable: ReleasePackageInfo = { name: '@scope/pkg', path: 'packages/pkg', version: '1.2.3' };
-const prerelease: ReleasePackageInfo = { name: '@scope/pkg', path: 'packages/pkg', version: '2.0.0-beta.1' };
+const stable: ReleasePackageInfo = { name: '@scope/pkg', projectName: 'pkg', path: 'packages/pkg', version: '1.2.3' };
+const prerelease: ReleasePackageInfo = {
+  name: '@scope/pkg',
+  projectName: 'pkg',
+  path: 'packages/pkg',
+  version: '2.0.0-beta.1',
+};
 
 describe('GitHub release helpers', () => {
   it('configures the Nx changelog API for render-only project changelogs', () => {
-    expect(nxProjectChangelogArgs(stable, '@scope/pkg@1.2.2', false)).toEqual({
+    expect(nxProjectChangelogArgs(stable, 'pkg@1.2.2', false)).toEqual({
       version: '1.2.3',
-      projects: ['@scope/pkg'],
+      projects: ['pkg'],
       gitCommit: false,
       gitTag: false,
       gitPush: false,
@@ -23,14 +28,14 @@ describe('GitHub release helpers', () => {
       createRelease: false,
       deleteVersionPlans: false,
       dryRun: false,
-      from: '@scope/pkg@1.2.2',
+      from: 'pkg@1.2.2',
     });
   });
 
   it('marks the Nx changelog request as a first release when there is no previous tag', () => {
     expect(nxProjectChangelogArgs(stable, null, true)).toEqual({
       version: '1.2.3',
-      projects: ['@scope/pkg'],
+      projects: ['pkg'],
       gitCommit: false,
       gitTag: false,
       gitPush: false,
@@ -47,17 +52,17 @@ describe('GitHub release helpers', () => {
       projectChangelogContents(
         {
           projectChangelogs: {
-            '@scope/pkg': { contents: 'generated release notes' },
+            pkg: { contents: 'generated release notes' },
           },
         },
-        '@scope/pkg',
+        'pkg',
       ),
     ).toBe('generated release notes');
   });
 
   it('fails when Nx omits the requested project changelog', () => {
-    expect(() => projectChangelogContents({ projectChangelogs: {} }, '@scope/pkg')).toThrow(
-      'Nx did not generate a project changelog for @scope/pkg.',
+    expect(() => projectChangelogContents({ projectChangelogs: {} }, 'pkg')).toThrow(
+      'Nx did not generate a project changelog for pkg.',
     );
   });
 
@@ -66,18 +71,11 @@ describe('GitHub release helpers', () => {
 
     await createOrUpdateGithubRelease(stable, 'stable notes', shell);
 
-    expect(shell.existsQueries).toEqual(['@scope/pkg@1.2.3']);
+    expect(shell.existsQueries).toEqual(['pkg@1.2.3']);
     expect(shell.notes).toEqual(['stable notes']);
-    expect(shell.logs).toEqual(['@scope/pkg@1.2.3: creating GitHub Release for @scope/pkg@1.2.3.']);
+    expect(shell.logs).toEqual(['@scope/pkg@1.2.3: creating GitHub Release for pkg@1.2.3.']);
     const command = onlyCommand(shell.commands);
-    expect(command.slice(0, 6)).toEqual([
-      'release',
-      'create',
-      '@scope/pkg@1.2.3',
-      '--title',
-      '@scope/pkg@1.2.3',
-      '--notes-file',
-    ]);
+    expect(command.slice(0, 6)).toEqual(['release', 'create', 'pkg@1.2.3', '--title', 'pkg@1.2.3', '--notes-file']);
     expect(command).toContain('--verify-tag');
     expect(command).toContain('--latest=true');
     expect(command).not.toContain('--prerelease');
@@ -88,16 +86,16 @@ describe('GitHub release helpers', () => {
 
     await createOrUpdateGithubRelease(prerelease, 'prerelease notes', shell);
 
-    expect(shell.existsQueries).toEqual(['@scope/pkg@2.0.0-beta.1']);
+    expect(shell.existsQueries).toEqual(['pkg@2.0.0-beta.1']);
     expect(shell.notes).toEqual(['prerelease notes']);
-    expect(shell.logs).toEqual(['@scope/pkg@2.0.0-beta.1: updating GitHub Release for @scope/pkg@2.0.0-beta.1.']);
+    expect(shell.logs).toEqual(['@scope/pkg@2.0.0-beta.1: updating GitHub Release for pkg@2.0.0-beta.1.']);
     const command = onlyCommand(shell.commands);
     expect(command.slice(0, 6)).toEqual([
       'release',
       'edit',
-      '@scope/pkg@2.0.0-beta.1',
+      'pkg@2.0.0-beta.1',
       '--title',
-      '@scope/pkg@2.0.0-beta.1',
+      'pkg@2.0.0-beta.1',
       '--notes-file',
     ]);
     expect(command).toContain('--verify-tag');

package/src/release/__tests__/helpers/fixture-repo.ts

@@ -47,6 +47,7 @@ export async function writeBuildablePackage(
         name,
         version,
         nx: {
+          name: name.startsWith('@') ? name.slice(name.indexOf('/') + 1) : name,
           targets: {
             build: {
               executor: 'nx:run-commands',

package/src/release/__tests__/npm-auth.test.ts

@@ -12,12 +12,10 @@ const pkg: Pick<ReleasePackageInfo, 'name' | 'version'> = { name: '@scope/pkg',
 describe('npm publish auth diagnostics', () => {
   it('explains trusted publishing setup when an existing package publish is unauthenticated', () => {
     const message = npmPublishAuthFailureMessage(pkg, {
-      useBootstrapToken: false,
       tokenPresent: true,
       repository: 'smoothbricks/codebase',
     });
     const markdown = npmPublishAuthFailureMarkdown(pkg, {
-      useBootstrapToken: false,
       tokenPresent: true,
       repository: 'smoothbricks/codebase',
     });
@@ -32,16 +30,12 @@ describe('npm publish auth diagnostics', () => {
     expect(markdown).toContain('repository `smoothbricks/codebase` and workflow `publish.yml`');
   });
 
-  it('explains the bootstrap token path for first package publishes', () => {
-    const message = npmPublishAuthFailureMessage(pkg, { useBootstrapToken: true, tokenPresent: false });
-    const markdown = npmPublishAuthFailureMarkdown(pkg, { useBootstrapToken: true, tokenPresent: false });
+  it('points first package publishes to local placeholder bootstrap', () => {
+    const message = npmPublishAuthFailureMessage(pkg, { tokenPresent: false });
+    const markdown = npmPublishAuthFailureMarkdown(pkg, { tokenPresent: false });
 
-    expect(message).toContain('temporary npm automation token');
-    expect(message).toContain('NODE_AUTH_TOKEN/NPM_TOKEN is not set');
-    expect(message).toContain('After the first successful publish, run:');
-    expect(message).toContain('smoo release trust-publisher');
-    expect(markdown).toContain('Add a temporary `NPM_TOKEN` repository secret');
-    expect(markdown).toContain('After the first successful publish, run `smoo release trust-publisher`');
+    expect(message).toContain('smoo release trust-publisher --bootstrap');
+    expect(markdown).toContain('smoo release trust-publisher --bootstrap');
   });
 
   it('reports trusted-publishing guidance and writes it to the publish summary after existing package auth failure', async () => {
@@ -49,7 +43,6 @@ describe('npm publish auth diagnostics', () => {
 
     await expect(
       publishWithAuthDiagnostics(pkg, shell, {
-        useBootstrapToken: false,
         tokenPresent: true,
         repository: 'smoothbricks/codebase',
       }),
@@ -66,26 +59,24 @@ describe('npm publish auth diagnostics', () => {
     expect(shell.logs).toEqual([]);
   });
 
-  it('reports bootstrap token guidance and writes it to the publish summary after first-publish auth failure', async () => {
+  it('reports bootstrap command guidance and writes it to the publish summary after first-publish auth failure', async () => {
     const shell = new RecordingPublishShell({ publishFails: true });
 
-    await expect(
-      publishWithAuthDiagnostics(pkg, shell, { useBootstrapToken: true, tokenPresent: false }),
-    ).rejects.toThrow('@scope/pkg@1.2.3: npm publish authentication failed');
+    await expect(publishWithAuthDiagnostics(pkg, shell, { tokenPresent: false })).rejects.toThrow(
+      '@scope/pkg@1.2.3: npm publish authentication failed',
+    );
 
     expect(shell.errors).toHaveLength(1);
-    expect(shell.errors[0]).toContain('temporary npm automation token');
-    expect(shell.errors[0]).toContain('NODE_AUTH_TOKEN/NPM_TOKEN is not set');
-    expect(shell.errors[0]).toContain('smoo release trust-publisher');
+    expect(shell.errors[0]).toContain('smoo release trust-publisher --bootstrap');
     expect(shell.summaries).toHaveLength(1);
-    expect(shell.summaries[0]).toContain('Add a temporary `NPM_TOKEN` repository secret');
+    expect(shell.summaries[0]).toContain('smoo release trust-publisher --bootstrap');
     expect(shell.logs).toEqual([]);
   });
 
   it('continues without auth warning when the package version appears on npm after publish failure', async () => {
     const shell = new RecordingPublishShell({ publishFails: true, versionVisibleAfterFailure: true });
 
-    await publishWithAuthDiagnostics(pkg, shell, { useBootstrapToken: false, tokenPresent: true });
+    await publishWithAuthDiagnostics(pkg, shell, { tokenPresent: true });
 
     expect(shell.errors).toEqual([]);
     expect(shell.summaries).toEqual([]);