@smoothbricks/cli 0.1.0 → 0.2.0

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

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'bun:test';
+import type { ReleasePackageInfo } from '../core.js';
+import {
+  type NpmPublishDiagnosticShell,
+  npmPublishAuthFailureMarkdown,
+  npmPublishAuthFailureMessage,
+  publishWithAuthDiagnostics,
+} from '../npm-auth.js';
+
+const pkg: Pick<ReleasePackageInfo, 'name' | 'version'> = { name: '@scope/pkg', version: '1.2.3' };
+
+describe('npm publish auth diagnostics', () => {
+  it('explains trusted publishing setup when an existing package publish is unauthenticated', () => {
+    const message = npmPublishAuthFailureMessage(pkg, {
+      tokenPresent: true,
+      repository: 'smoothbricks/codebase',
+    });
+    const markdown = npmPublishAuthFailureMarkdown(pkg, {
+      tokenPresent: true,
+      repository: 'smoothbricks/codebase',
+    });
+
+    expect(message).toContain('🚨 npm publish authentication failed for @scope/pkg@1.2.3');
+    expect(message).toContain('smoo release trust-publisher');
+    expect(message).toContain('NODE_AUTH_TOKEN/NPM_TOKEN is set but unused');
+    expect(message).toContain('repository: smoothbricks/codebase');
+    expect(message).toContain('workflow: publish.yml');
+    expect(markdown).toContain('## 🚨 npm Publish Authentication Failed');
+    expect(markdown).toContain('Run locally: `smoo release trust-publisher`');
+    expect(markdown).toContain('repository `smoothbricks/codebase` and workflow `publish.yml`');
+  });
+
+  it('points first package publishes to local placeholder bootstrap', () => {
+    const message = npmPublishAuthFailureMessage(pkg, { tokenPresent: false });
+    const markdown = npmPublishAuthFailureMarkdown(pkg, { tokenPresent: false });
+
+    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 () => {
+    const shell = new RecordingPublishShell({ publishFails: true });
+
+    await expect(
+      publishWithAuthDiagnostics(pkg, shell, {
+        tokenPresent: true,
+        repository: 'smoothbricks/codebase',
+      }),
+    ).rejects.toThrow('@scope/pkg@1.2.3: npm publish authentication failed');
+
+    expect(shell.errors).toHaveLength(1);
+    expect(shell.errors[0]).toContain('🚨 npm publish authentication failed for @scope/pkg@1.2.3');
+    expect(shell.errors[0]).toContain('NODE_AUTH_TOKEN/NPM_TOKEN is set but unused');
+    expect(shell.errors[0]).toContain('smoo release trust-publisher');
+    expect(shell.errors[0]).toContain('repository: smoothbricks/codebase');
+    expect(shell.summaries).toHaveLength(1);
+    expect(shell.summaries[0]).toContain('## 🚨 npm Publish Authentication Failed');
+    expect(shell.summaries[0]).toContain('Run locally: `smoo release trust-publisher`');
+    expect(shell.logs).toEqual([]);
+  });
+
+  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, { tokenPresent: false })).rejects.toThrow(
+      '@scope/pkg@1.2.3: npm publish authentication failed',
+    );
+
+    expect(shell.errors).toHaveLength(1);
+    expect(shell.errors[0]).toContain('smoo release trust-publisher --bootstrap');
+    expect(shell.summaries).toHaveLength(1);
+    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, { tokenPresent: true });
+
+    expect(shell.errors).toEqual([]);
+    expect(shell.summaries).toEqual([]);
+    expect(shell.logs).toEqual(['@scope/pkg@1.2.3: publish result already visible on npm; continuing.']);
+  });
+});
+
+class RecordingPublishShell implements NpmPublishDiagnosticShell {
+  readonly logs: string[] = [];
+  readonly errors: string[] = [];
+  readonly summaries: string[] = [];
+  private readonly publishFails: boolean;
+  private readonly versionVisibleAfterFailure: boolean;
+
+  constructor(options: { publishFails: boolean; versionVisibleAfterFailure?: boolean }) {
+    this.publishFails = options.publishFails;
+    this.versionVisibleAfterFailure = options.versionVisibleAfterFailure === true;
+  }
+
+  async publish(): Promise<void> {
+    if (this.publishFails) {
+      throw new Error('ENEEDAUTH');
+    }
+  }
+
+  async versionExists(): Promise<boolean> {
+    return this.versionVisibleAfterFailure;
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+
+  error(message: string): void {
+    this.errors.push(message);
+  }
+
+  async appendSummary(markdown: string): Promise<void> {
+    this.summaries.push(markdown);
+  }
+}

package/src/release/__tests__/orchestration.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, it } from 'bun:test';
+import type { ReleasePackageInfo, ReleaseTarget } from '../core.js';
+import {
+  completeReleaseAtHead,
+  type ReleaseRepairShell,
+  type ReleaseVersionShell,
+  repairPendingTargets,
+  runReleaseVersion,
+} from '../orchestration.js';
+
+const stable: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.0.0',
+};
+const prerelease: ReleasePackageInfo = {
+  name: '@scope/prerelease',
+  projectName: 'prerelease',
+  path: 'packages/prerelease',
+  version: '2.0.0-beta.1',
+};
+
+describe('release orchestration', () => {
+  it('repairs an older target with one checkout, one devenv load, npm-only build, and GitHub create calls', async () => {
+    const target = releaseTarget('older-release', [stable, prerelease], [stable], [prerelease]);
+    const shell = new RecordingRepairShell();
+
+    const summaries = await repairPendingTargets(shell, [target], 'restore-ref', false);
+
+    expect(shell.checkouts).toEqual(['older-release', 'restore-ref']);
+    expect(shell.devenvLoads).toBe(1);
+    expect(shell.builds).toEqual([['@scope/stable']]);
+    expect(shell.publishes).toEqual([{ name: '@scope/stable', distTag: 'latest', dryRun: false }]);
+    expect(shell.githubCreates).toEqual([{ name: '@scope/prerelease', dryRun: false }]);
+    expect(shell.pushes).toEqual([['@scope/stable', '@scope/prerelease']]);
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0]?.published.map((pkg) => pkg.name)).toEqual(['@scope/stable']);
+    expect(summaries[0]?.githubReleases.map((pkg) => pkg.name)).toEqual(['@scope/prerelease']);
+  });
+
+  it('skips build and publish for GitHub-only repair targets', async () => {
+    const target = releaseTarget('github-only', [prerelease], [], [prerelease]);
+    const shell = new RecordingRepairShell();
+
+    await repairPendingTargets(shell, [target], 'restore-ref', false);
+
+    expect(shell.builds).toEqual([]);
+    expect(shell.publishes).toEqual([]);
+    expect(shell.githubCreates).toEqual([{ name: '@scope/prerelease', dryRun: false }]);
+  });
+
+  it('publishes a partial HEAD release by building npm-missing packages and creating missing GitHub Releases', async () => {
+    const shell = new RecordingRepairShell({ npmMissing: ['@scope/stable'], githubMissing: ['@scope/prerelease'] });
+
+    const summary = await completeReleaseAtHead(shell, [stable, prerelease], false, true);
+
+    expect(shell.checkouts).toEqual([]);
+    expect(shell.devenvLoads).toBe(0);
+    expect(shell.builds).toEqual([['@scope/stable']]);
+    expect(shell.publishes).toEqual([{ name: '@scope/stable', distTag: 'latest', dryRun: false }]);
+    expect(shell.githubCreates).toEqual([{ name: '@scope/prerelease', dryRun: false }]);
+    expect(summary.published.map((pkg) => pkg.name)).toEqual(['@scope/stable']);
+    expect(summary.alreadyPublished.map((pkg) => pkg.name)).toEqual(['@scope/prerelease']);
+    expect(summary.githubReleases.map((pkg) => pkg.name)).toEqual(['@scope/prerelease']);
+    expect(summary.rerunRequired).toBe(true);
+  });
+
+  it('leaves a complete HEAD release idempotent', async () => {
+    const shell = new RecordingRepairShell();
+
+    const summary = await completeReleaseAtHead(shell, [stable, prerelease], false, false);
+
+    expect(shell.builds).toEqual([]);
+    expect(shell.publishes).toEqual([]);
+    expect(shell.githubCreates).toEqual([]);
+    expect(summary.published).toEqual([]);
+    expect(summary.alreadyPublished.map((pkg) => pkg.name)).toEqual(['@scope/stable', '@scope/prerelease']);
+    expect(summary.githubReleases).toEqual([]);
+  });
+
+  it('does not run Nx versioning when HEAD is already a release target', async () => {
+    const shell = new RecordingVersionShell({ releasePackagesAtHead: [[stable]] });
+
+    const result = await runReleaseVersion(shell, { bump: 'patch', dryRun: false });
+
+    expect(result).toEqual({ mode: 'none', packages: [stable], status: 'already-release-target' });
+    expect(shell.nxRuns).toEqual([]);
+    expect(shell.ensureCalls).toEqual([['@scope/stable']]);
+  });
+
+  it('runs forced Nx versioning for an untagged HEAD and reports a new release commit', async () => {
+    const shell = new RecordingVersionShell({
+      releasePackagesAtHead: [[], [stable]],
+      releaseVersionPackages: [stable, prerelease],
+      heads: ['before', 'after'],
+    });
+
+    const result = await runReleaseVersion(shell, { bump: 'patch', dryRun: false });
+
+    expect(result).toEqual({ mode: 'new', packages: [stable], status: 'new-release' });
+    expect(shell.nxRuns).toEqual([{ packages: ['@scope/stable', '@scope/prerelease'], bump: 'patch', dryRun: false }]);
+    expect(shell.cleanChecks).toBe(1);
+    expect(shell.ensureCalls).toEqual([['@scope/stable']]);
+  });
+
+  it('skips auto Nx versioning when no package-local candidates exist', async () => {
+    const shell = new RecordingVersionShell({ releasePackagesAtHead: [[]], releaseVersionPackages: [] });
+
+    const result = await runReleaseVersion(shell, { bump: 'auto', dryRun: false });
+
+    expect(result).toEqual({ mode: 'none', packages: [], status: 'no-release-needed' });
+    expect(shell.nxRuns).toEqual([]);
+    expect(shell.cleanChecks).toBe(0);
+    expect(shell.ensureCalls).toEqual([]);
+  });
+
+  it('runs auto Nx versioning only for selected package-local candidates', async () => {
+    const shell = new RecordingVersionShell({
+      releasePackagesAtHead: [[], [stable]],
+      releaseVersionPackages: [stable],
+      heads: ['before', 'after'],
+    });
+
+    const result = await runReleaseVersion(shell, { bump: 'auto', dryRun: false });
+
+    expect(result).toEqual({ mode: 'new', packages: [stable], status: 'new-release' });
+    expect(shell.nxRuns).toEqual([{ packages: ['@scope/stable'], bump: 'auto', dryRun: false }]);
+  });
+});
+
+function releaseTarget(
+  sha: string,
+  packages: ReleasePackageInfo[],
+  npmPackages: ReleasePackageInfo[],
+  githubPackages: ReleasePackageInfo[],
+): ReleaseTarget<ReleasePackageInfo> {
+  return { sha, timestamp: 1, packages, npmPackages, githubPackages };
+}
+
+class RecordingRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
+  readonly checkouts: string[] = [];
+  readonly pushes: string[][] = [];
+  readonly builds: string[][] = [];
+  readonly publishes: Array<{ name: string; distTag: string; dryRun: boolean }> = [];
+  readonly githubCreates: Array<{ name: string; dryRun: boolean }> = [];
+  readonly npmQueries: string[][] = [];
+  readonly githubQueries: string[][] = [];
+  devenvLoads = 0;
+  currentRef = 'head';
+  private readonly npmMissing: Set<string>;
+  private readonly githubMissing: Set<string>;
+
+  constructor(options: { npmMissing?: string[]; githubMissing?: string[] } = {}) {
+    this.npmMissing = new Set(options.npmMissing ?? []);
+    this.githubMissing = new Set(options.githubMissing ?? []);
+  }
+
+  async gitHead(): Promise<string> {
+    return this.currentRef;
+  }
+
+  async pushReleaseRefs(packages: ReleasePackageInfo[]): Promise<boolean> {
+    this.pushes.push(packageNames(packages));
+    return true;
+  }
+
+  async listNpmMissingPackages(packages: ReleasePackageInfo[]): Promise<ReleasePackageInfo[]> {
+    this.npmQueries.push(packageNames(packages));
+    return packages.filter((pkg) => this.npmMissing.has(pkg.name));
+  }
+
+  async buildReleaseCandidate(packages: ReleasePackageInfo[]): Promise<void> {
+    this.builds.push(packageNames(packages));
+  }
+
+  async publishPackage(pkg: ReleasePackageInfo, distTag: string, dryRun: boolean): Promise<void> {
+    this.publishes.push({ name: pkg.name, distTag, dryRun });
+  }
+
+  async listGithubMissingPackages(packages: ReleasePackageInfo[]): Promise<ReleasePackageInfo[]> {
+    this.githubQueries.push(packageNames(packages));
+    return packages.filter((pkg) => this.githubMissing.has(pkg.name));
+  }
+
+  async createGithubRelease(pkg: ReleasePackageInfo, dryRun: boolean): Promise<void> {
+    this.githubCreates.push({ name: pkg.name, dryRun });
+  }
+
+  async checkout(ref: string): Promise<void> {
+    this.currentRef = ref;
+    this.checkouts.push(ref);
+  }
+
+  async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
+    this.devenvLoads += 1;
+    return runWithEnv();
+  }
+}
+
+class RecordingVersionShell implements ReleaseVersionShell<ReleasePackageInfo> {
+  readonly ensureCalls: string[][] = [];
+  readonly nxRuns: Array<{ packages: string[]; bump: string; dryRun: boolean }> = [];
+  cleanChecks = 0;
+  private readonly releaseBatches: ReleasePackageInfo[][];
+  private readonly versionPackages: ReleasePackageInfo[];
+  private readonly heads: string[];
+
+  constructor(options: {
+    releasePackagesAtHead: ReleasePackageInfo[][];
+    releaseVersionPackages?: ReleasePackageInfo[];
+    heads?: string[];
+  }) {
+    this.releaseBatches = [...options.releasePackagesAtHead];
+    this.versionPackages = options.releaseVersionPackages ?? [stable, prerelease];
+    this.heads = [...(options.heads ?? [])];
+  }
+
+  async releasePackagesAtHead(): Promise<ReleasePackageInfo[]> {
+    return this.releaseBatches.shift() ?? [];
+  }
+
+  async releaseVersionPackages(): Promise<ReleasePackageInfo[]> {
+    return this.versionPackages;
+  }
+
+  async ensureLocalReleaseTags(packages: ReleasePackageInfo[]): Promise<void> {
+    this.ensureCalls.push(packageNames(packages));
+  }
+
+  async gitHead(): Promise<string> {
+    return this.heads.shift() ?? 'head';
+  }
+
+  async runNxReleaseVersion(packages: ReleasePackageInfo[], bump: string, dryRun: boolean): Promise<void> {
+    this.nxRuns.push({ packages: packageNames(packages), bump, dryRun });
+  }
+
+  async assertCleanGitTree(): Promise<void> {
+    this.cleanChecks += 1;
+  }
+}
+
+function packageNames(packages: ReleasePackageInfo[]): string[] {
+  return packages.map((pkg) => pkg.name);
+}

package/src/release/__tests__/publish-plan.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'bun:test';
+import type { ReleasePackageInfo } from '../core.js';
+import { planPublishActions } from '../publish-plan.js';
+
+const stable: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.0.0',
+};
+const prerelease: ReleasePackageInfo = {
+  name: '@scope/prerelease',
+  projectName: 'prerelease',
+  path: 'packages/prerelease',
+  version: '2.0.0-beta.1',
+};
+
+describe('publish plan', () => {
+  it('returns empty actions when durable release state is complete', () => {
+    expect(
+      planPublishActions({
+        releasePackages: [stable, prerelease],
+        npmMissingPackages: [],
+        githubMissingPackages: [],
+      }),
+    ).toEqual({ buildProjects: [], publishPackages: [], githubReleasePackages: [] });
+  });
+
+  it('builds and publishes exactly npm-missing packages', () => {
+    const plan = planPublishActions({
+      releasePackages: [stable, prerelease],
+      npmMissingPackages: [stable],
+      githubMissingPackages: [],
+    });
+
+    expect(plan.buildProjects).toEqual(['stable']);
+    expect(plan.publishPackages).toEqual([{ pkg: stable, distTag: 'latest' }]);
+    expect(plan.githubReleasePackages).toEqual([]);
+  });
+
+  it('does not build for GitHub-only repair actions', () => {
+    const plan = planPublishActions({
+      releasePackages: [stable, prerelease],
+      npmMissingPackages: [],
+      githubMissingPackages: [prerelease],
+    });
+
+    expect(plan.buildProjects).toEqual([]);
+    expect(plan.publishPackages).toEqual([]);
+    expect(plan.githubReleasePackages).toEqual([prerelease]);
+  });
+
+  it('uses latest for stable packages and next for prerelease packages', () => {
+    const plan = planPublishActions({
+      releasePackages: [stable, prerelease],
+      npmMissingPackages: [stable, prerelease],
+      githubMissingPackages: [],
+    });
+
+    expect(plan.buildProjects).toEqual(['stable', 'prerelease']);
+    expect(plan.publishPackages).toEqual([
+      { pkg: stable, distTag: 'latest' },
+      { pkg: prerelease, distTag: 'next' },
+    ]);
+    expect(plan.githubReleasePackages).toEqual([]);
+  });
+});

package/src/release/__tests__/retag-unpublished.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'bun:test';
+import type { ReleasePackageInfo } from '../core.js';
+import {
+  type RetagUnpublishedOptions,
+  type RetagUnpublishedShell,
+  type RetagUnpublishedTagUpdate,
+  retagUnpublished,
+} from '../retag-unpublished.js';
+
+const pkg: ReleasePackageInfo = { name: '@scope/pkg', projectName: 'pkg', path: 'packages/pkg', version: '1.2.3' };
+
+describe('retag unpublished releases', () => {
+  it('moves unpublished owned tags, pushes with a remote lease, and dispatches publish auto', async () => {
+    const shell = new RecordingRetagShell({
+      versionAtRef: '1.2.3',
+      remoteTagObjects: new Map([['@scope/pkg@1.2.3', 'old-tag-object']]),
+      dispatchSha: 'target-sha',
+    });
+
+    const updates = await retagUnpublished(shell, retagOptions({ push: true, dispatch: true }));
+
+    expect(updates).toEqual([{ tag: '@scope/pkg@1.2.3', pkg, expectedRemoteObject: 'old-tag-object' }]);
+    expect(shell.movedTags).toEqual([{ tag: '@scope/pkg@1.2.3', ref: 'HEAD' }]);
+    expect(shell.pushed).toEqual([[{ tag: '@scope/pkg@1.2.3', expectedRemoteObject: 'old-tag-object' }]]);
+    expect(shell.dispatched).toEqual([{ workflow: 'publish.yml', branch: 'main' }]);
+    expect(shell.dispatchRefLookups).toEqual(['main']);
+    expect(shell.remoteTagLookups).toEqual(['@scope/pkg@1.2.3']);
+  });
+
+  it('rejects tags whose package version already exists on npm', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.3', npmPublished: true });
+
+    await expect(retagUnpublished(shell, retagOptions())).rejects.toThrow(
+      'Cannot retag @scope/pkg@1.2.3: @scope/pkg@1.2.3 already exists on npm.',
+    );
+
+    expect(shell.movedTags).toEqual([]);
+    expect(shell.pushed).toEqual([]);
+  });
+
+  it('rejects tags whose version does not match the target ref package manifest', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.4' });
+
+    await expect(retagUnpublished(shell, retagOptions())).rejects.toThrow(
+      'Release tag @scope/pkg@1.2.3 cannot move to HEAD: packages/pkg/package.json has version 1.2.4, expected 1.2.3.',
+    );
+  });
+
+  it('rejects workflow dispatch when the target ref is not the remote branch head', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.3', dispatchSha: 'other-sha' });
+
+    await expect(retagUnpublished(shell, retagOptions({ push: true, dispatch: true }))).rejects.toThrow(
+      'Cannot dispatch publish.yml: HEAD resolves to target-sha, but main resolves to other-sha.',
+    );
+
+    expect(shell.movedTags).toEqual([]);
+    expect(shell.pushed).toEqual([]);
+    expect(shell.dispatched).toEqual([]);
+  });
+
+  it('dry-runs without moving, pushing, or dispatching tags', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.3', dispatchSha: 'target-sha' });
+
+    await retagUnpublished(shell, retagOptions({ push: true, dispatch: true, dryRun: true }));
+
+    expect(shell.movedTags).toEqual([]);
+    expect(shell.pushed).toEqual([]);
+    expect(shell.dispatched).toEqual([]);
+    expect(shell.logs).toContain('Would move @scope/pkg@1.2.3 to HEAD (target-sha).');
+    expect(shell.logs).toContain('Would push 1 retagged release tag.');
+    expect(shell.logs).toContain('Would dispatch publish.yml on main with bump=auto.');
+  });
+});
+
+function retagOptions(overrides: Partial<RetagUnpublishedOptions> = {}): RetagUnpublishedOptions {
+  return {
+    tags: ['@scope/pkg@1.2.3'],
+    toRef: 'HEAD',
+    push: false,
+    dispatch: false,
+    dryRun: false,
+    branch: 'main',
+    workflow: 'publish.yml',
+    ...overrides,
+  };
+}
+
+class RecordingRetagShell implements RetagUnpublishedShell<ReleasePackageInfo> {
+  readonly movedTags: Array<{ tag: string; ref: string }> = [];
+  readonly pushed: Array<Array<{ tag: string; expectedRemoteObject: string | null }>> = [];
+  readonly dispatched: Array<{ workflow: string; branch: string }> = [];
+  readonly dispatchRefLookups: string[] = [];
+  readonly remoteTagLookups: string[] = [];
+  readonly logs: string[] = [];
+  private readonly versionAtRef: string | null;
+  private readonly npmPublished: boolean;
+  private readonly githubReleaseCreated: boolean;
+  private readonly remoteTagObjects: Map<string, string>;
+  private readonly dispatchSha: string | null;
+
+  constructor(options: {
+    versionAtRef: string | null;
+    npmPublished?: boolean;
+    githubReleaseCreated?: boolean;
+    remoteTagObjects?: Map<string, string>;
+    dispatchSha?: string | null;
+  }) {
+    this.versionAtRef = options.versionAtRef;
+    this.npmPublished = options.npmPublished === true;
+    this.githubReleaseCreated = options.githubReleaseCreated === true;
+    this.remoteTagObjects = options.remoteTagObjects ?? new Map();
+    this.dispatchSha = options.dispatchSha ?? null;
+  }
+
+  listReleasePackages(): ReleasePackageInfo[] {
+    return [pkg];
+  }
+
+  async resolveRef(): Promise<string> {
+    return 'target-sha';
+  }
+
+  async resolveDispatchRef(branch: string): Promise<string | null> {
+    this.dispatchRefLookups.push(branch);
+    return this.dispatchSha;
+  }
+
+  async packageVersionAtRef(): Promise<string | null> {
+    return this.versionAtRef;
+  }
+
+  async npmVersionExists(): Promise<boolean> {
+    return this.npmPublished;
+  }
+
+  async githubReleaseExists(): Promise<boolean> {
+    return this.githubReleaseCreated;
+  }
+
+  async remoteTagObject(tag: string): Promise<string | null> {
+    this.remoteTagLookups.push(tag);
+    return this.remoteTagObjects.get(tag) ?? null;
+  }
+
+  async createOrMoveTag(tag: string, ref: string): Promise<void> {
+    this.movedTags.push({ tag, ref });
+  }
+
+  async pushTags(updates: Array<RetagUnpublishedTagUpdate<ReleasePackageInfo>>): Promise<void> {
+    this.pushed.push(updates.map((update) => ({ tag: update.tag, expectedRemoteObject: update.expectedRemoteObject })));
+  }
+
+  async dispatchPublishWorkflow(workflow: string, branch: string): Promise<void> {
+    this.dispatched.push({ workflow, branch });
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+}