release-it 20.0.1 → 20.2.0

package/config/release-it.json

@@ -1,4 +1,5 @@
 {
+  "quiet": false,
   "hooks": {},
   "git": {
     "changelog": "git log --pretty=format:\"* %s (%h)\" ${from}...${to}",
@@ -29,6 +30,7 @@
     "publishArgs": [],
     "publishPackageManager": "npm",
     "tag": null,
+    "stage": false,
     "otp": null,
     "ignoreVersion": false,
     "allowSameVersion": false,

package/lib/args.js

@@ -12,6 +12,7 @@ const aliases = {
 const booleanOptions = [
   'dry-run',
   'ci',
+  'quiet',
   'git',
   'npm',
   'github',

package/lib/cli.js

@@ -18,6 +18,7 @@ const helpText = `Release It! v${pkg.version}
   -v --version           Print release-it version number
      --release-version   Print version number to be released
      --changelog         Print changelog for the version to be released
+     --quiet             Suppress preview output during release
   -V --verbose           Verbose output (user hooks output)
   -VV                    Extra verbose output (also internal commands output)
 

package/lib/config.js

@@ -70,6 +70,10 @@ class Config {
     return debug.enabled;
   }
 
+  get isQuiet() {
+    return Boolean(this.options.quiet);
+  }
+
   get isCI() {
     return Boolean(this.options.ci) || this.isReleaseVersion || this.isChangelog;
   }

package/lib/index.js

@@ -15,9 +15,9 @@ const runTasks = async (opts, di) => {
     await container.config.init();
 
     const { config } = container;
-    const { isCI, isVerbose, verbosityLevel, isDryRun, isChangelog, isReleaseVersion } = config;
+    const { isCI, isVerbose, verbosityLevel, isDryRun, isChangelog, isReleaseVersion, isQuiet } = config;
 
-    container.log = container.log || new Logger({ isCI, isVerbose, verbosityLevel, isDryRun });
+    container.log = container.log || new Logger({ isCI, isVerbose, verbosityLevel, isDryRun, isQuiet });
     container.spinner = container.spinner || new Spinner({ container, config });
     container.prompt = container.prompt || new Prompt({ container: { config } });
     container.shell = container.shell || new Shell({ container });
@@ -94,6 +94,7 @@ const runTasks = async (opts, di) => {
       const action = config.isIncrement ? 'release' : 'update';
       const suffix = version && config.isIncrement ? `${latestVersion}...${version}` : `currently at ${latestVersion}`;
       log.obtrusive(`🚀 Let's ${action} ${name} (${suffix})`);
+      if (isQuiet) log.info('Preview output hidden (--quiet).');
       log.preview({ title: 'changelog', text: changelog });
     }
 

package/lib/log.js

@@ -4,11 +4,12 @@ import { isObjectLoose } from '@phun-ky/typeof';
 import { upperFirst } from './util.js';
 
 class Logger {
-  constructor({ isCI = true, isVerbose = false, verbosityLevel = 0, isDryRun = false } = {}) {
+  constructor({ isCI = true, isVerbose = false, verbosityLevel = 0, isDryRun = false, isQuiet = false } = {}) {
     this.isCI = isCI;
     this.isVerbose = isVerbose;
     this.verbosityLevel = verbosityLevel;
     this.isDryRun = isDryRun;
+    this.isQuiet = isQuiet;
   }
 
   shouldLog(isExternal) {
@@ -57,6 +58,7 @@ class Logger {
   }
 
   preview({ title, text }) {
+    if (this.isQuiet) return;
     if (text) {
       const header = styleText('bold', upperFirst(title));
       const body = text.replace(new RegExp(EOL + EOL, 'g'), EOL);

package/lib/plugin/github/GitHub.js

@@ -129,27 +129,41 @@ class GitHub extends Release {
   }
 
   async release() {
-    const { assets } = this.options;
+    const { assets, draft } = this.options;
     const { isWeb, isUpdate } = this.getContext();
     const { isCI } = this.config;
 
     const type = isUpdate ? 'update' : 'create';
     const publishMethod = `${type}Release`;
 
+    const useDraftFlow = !isUpdate && assets;
+
     if (isWeb) {
       const task = () => this.createWebRelease();
       return this.step({ task, label: 'Generating link to GitHub Release web interface', prompt: 'release' });
     } else if (isCI) {
-      await this.step({ task: () => this[publishMethod](), label: `GitHub ${type} release` });
-      await this.step({ enabled: assets, task: () => this.uploadAssets(), label: 'GitHub upload assets' });
+      if (useDraftFlow) {
+        await this.step({ task: () => this.createRelease({ draft: true }), label: 'GitHub create release' });
+        await this.step({ task: () => this.uploadAssets(), label: 'GitHub upload assets' });
+        if (!draft) await this.step({ task: () => this.publishRelease(), label: 'GitHub publish release' });
+      } else {
+        await this.step({ task: () => this[publishMethod](), label: `GitHub ${type} release` });
+        await this.step({ enabled: assets, task: () => this.uploadAssets(), label: 'GitHub upload assets' });
+      }
       return this.step({
         task: () => (isUpdate ? Promise.resolve() : this.commentOnResolvedItems()),
         label: 'GitHub comment on resolved items'
       });
     } else {
       const release = async () => {
-        await this[publishMethod]();
-        await this.uploadAssets();
+        if (useDraftFlow) {
+          await this.createRelease({ draft: true });
+          await this.uploadAssets();
+          if (!draft) await this.publishRelease();
+        } else {
+          await this[publishMethod]();
+          await this.uploadAssets();
+        }
         return isUpdate ? Promise.resolve(true) : this.commentOnResolvedItems();
       };
       return this.step({ task: release, label: `GitHub ${type} release`, prompt: 'release' });
@@ -218,16 +232,14 @@ class GitHub extends Release {
       discussionCategoryName = undefined
     } = this.options;
     const { tagName } = this.config.getContext();
-    const { version, releaseNotes, isUpdate } = this.getContext();
+    const { version, releaseNotes } = this.getContext();
     const { isPreRelease } = parseVersion(version);
     const name = format(releaseName, this.config.getContext());
     const releaseNotesObject = this.options.releaseNotes;
 
-    const body = autoGenerate
-      ? isUpdate
-        ? null
-        : ''
-      : truncateBody(releaseNotesObject?.commit ? await this.renderReleaseNotes(releaseNotesObject) : releaseNotes);
+    const resolvedReleaseNotes =
+      (releaseNotesObject?.commit ? await this.renderReleaseNotes(releaseNotesObject) : releaseNotes) ?? '';
+    const body = !autoGenerate ? truncateBody(resolvedReleaseNotes) : '';
 
     /**
      * @type {CreateReleaseOptions}
@@ -255,10 +267,12 @@ class GitHub extends Release {
     });
   }
 
-  async createRelease() {
+  async createRelease({ draft } = {}) {
     const options = await this.getOctokitReleaseOptions();
     const { isDryRun } = this.config;
 
+    if (draft === true) options.draft = true;
+
     this.log.exec(`octokit repos.createRelease "${options.name}" (${options.tag_name})`, { isDryRun });
 
     if (isDryRun) {
@@ -405,6 +419,34 @@ class GitHub extends Release {
     });
   }
 
+  async publishRelease() {
+    const { isDryRun } = this.config;
+    const { owner, project: repo } = this.getContext('repo');
+    const release_id = this.getContext('releaseId');
+    const { tagName } = this.config.getContext();
+
+    const options = { owner, repo, release_id, draft: false };
+
+    this.log.exec(`octokit repos.updateRelease (publish ${tagName})`, { isDryRun });
+
+    if (isDryRun) return true;
+
+    return this.retry(async bail => {
+      try {
+        this.debug(options);
+        const response = await this.client.repos.updateRelease(options);
+        const { html_url, discussion_url } = response.data;
+        this.setContext({ releaseUrl: html_url, discussionUrl: discussion_url });
+        this.config.setContext({ releaseUrl: html_url, discussionUrl: discussion_url });
+        this.debug(response.data);
+        this.log.verbose(`octokit repos.updateRelease: done (${response.headers.location})`);
+        return true;
+      } catch (err) {
+        return this.handleError(err, bail);
+      }
+    });
+  }
+
   async commentOnResolvedItems() {
     const { isDryRun } = this.config;
     const { host, owner, project: repo } = this.getContext('repo');

package/lib/plugin/gitlab/GitLab.js

@@ -171,6 +171,7 @@ class GitLab extends Release {
     const url = `${baseUrl}/${endpoint}${options.searchParams ? `?${new URLSearchParams(options.searchParams)}` : ''}`;
     const headers = {
       'user-agent': 'webpro/release-it',
+      'Accept-Encoding': 'identity',
       [tokenHeader]: this.token
     };
     // When using fetch() with FormData bodies, we should not set the Content-Type header.

package/lib/plugin/npm/npm.js

@@ -98,10 +98,13 @@ class npm extends Plugin {
   release() {
     if (this.options.publish === false) return false;
     if (this.getContext('private')) return false;
+    const { stage } = this.options;
     const publish = () => this.publish({ otpCallback });
     const otpCallback =
-      this.config.isCI && !this.config.isPromptOnlyVersion ? null : task => this.step({ prompt: 'otp', task });
-    return this.step({ task: publish, label: 'npm publish', prompt: 'publish' });
+      stage || (this.config.isCI && !this.config.isPromptOnlyVersion)
+        ? null
+        : task => this.step({ prompt: 'otp', task });
+    return this.step({ task: publish, label: stage ? 'npm stage publish' : 'npm publish', prompt: 'publish' });
   }
 
   isRegistryUp() {
@@ -212,6 +215,16 @@ class npm extends Plugin {
     return urlJoin(baseUrl, publicPath, this.getName());
   }
 
+  getStagedPackagesUrl() {
+    const name = this.getName();
+    const entity = name.startsWith('@') ? name.slice(1).split('/')[0] : this.getContext('username');
+    return entity ? `https://www.npmjs.com/settings/${entity}/staged-packages` : 'https://www.npmjs.com';
+  }
+
+  logWouldStage() {
+    this.log.log(`📦 Would stage (dry-run). Approve at ${this.getStagedPackagesUrl()} after a real run.`);
+  }
+
   getRegistry() {
     const { publishConfig } = this.getContext();
     const registries = publishConfig
@@ -254,9 +267,9 @@ class npm extends Plugin {
 
   async publish({ otp = this.options.otp, otpCallback } = {}) {
     const publishPackageManager = this.options.publishPackageManager || 'npm';
-    const { publishPath = '.', publishArgs } = this.options;
+    const { publishPath = '.', publishArgs, stage } = this.options;
     const { private: isPrivate, tag = DEFAULT_TAG } = this.getContext();
-    const otpArgs = otp ? ['--otp', otp] : [];
+    const otpArgs = otp && !stage ? ['--otp', otp] : [];
     const dryRunArg = this.config.isDryRun ? '--dry-run' : '';
     const registry = this.getRegistry();
     const registryArg = registry ? `--registry ${registry}` : '';
@@ -274,17 +287,29 @@ class npm extends Plugin {
       registryArg,
       ...fixArgs(publishArgs)
     ].filter(Boolean);
-    const isInteractive = !this.config.isCI;
-    return this.exec([publishPackageManager, 'publish', ...args], {
+    const publishCommand = stage ? ['stage', 'publish'] : ['publish'];
+    const isInteractive = !stage && (!this.config.isCI || Boolean(this.config.isPromptOnlyVersion));
+    return this.exec([publishPackageManager, ...publishCommand, ...args], {
       options: { ...getOptions(), interactive: isInteractive }
     })
-      .then(() => {
-        this.setContext({ isReleased: true });
-        this.config.setContext({ isReleased: true });
+      .then(output => {
+        if (stage) {
+          if (this.config.isDryRun) {
+            this.logWouldStage();
+          } else {
+            const id = output?.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0];
+            const approve = `${publishPackageManager} stage approve${id ? ` ${id}` : ''}`;
+            this.log.log(`📦 Staged, not yet published. Approve at ${this.getStagedPackagesUrl()} (or \`${approve}\`).`);
+          }
+        } else {
+          this.setContext({ isReleased: true });
+          this.config.setContext({ isReleased: true });
+        }
       })
       .catch(err => {
         this.debug(err);
         if (this.config.isDryRun && /publish over the previously published version/.test(err)) {
+          if (stage) this.logWouldStage();
           return Promise.resolve();
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-it",
-  "version": "20.0.1",
+  "version": "20.2.0",
   "description": "Generic CLI tool to automate versioning and package publishing-related tasks.",
   "keywords": [
     "build",

package/schema/npm.json

@@ -29,6 +29,10 @@
       "type": "string",
       "default": null
     },
+    "stage": {
+      "type": "boolean",
+      "default": false
+    },
     "otp": {
       "type": "string",
       "default": null

package/schema/release-it.json

@@ -88,6 +88,11 @@
         "type": "boolean",
         "default": false
       }
+    },
+    "quiet": {
+      "type": "boolean",
+      "default": false,
+      "description": "Suppress preview output (changelog, changeset, release notes) during the release flow. Does not affect the --changelog mode."
     }
   }
 }

package/test/github.js

@@ -10,6 +10,7 @@ import {
   interceptListReleases,
   interceptCreate,
   interceptUpdate,
+  interceptPublish,
   interceptAsset
 } from './stub/github.js';
 import { mockFetch } from './util/mock.js';
@@ -88,8 +89,9 @@ describe('github', () => {
 
     interceptAuthentication(api);
     interceptCollaborator(api);
-    interceptCreate(api, { body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes' } });
+    interceptCreate(api, { body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes', draft: true } });
     interceptAsset(assets, { body: '*' });
+    interceptPublish(api, { body: { tag_name: '2.0.2' } });
 
     await runTasks(github);
 
@@ -98,6 +100,78 @@ describe('github', () => {
     assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
   });
 
+  test('should keep release as draft when draft:true with assets', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo Custom notes',
+        draft: true,
+        assets: 'test/resources/file-v${version}.txt'
+      }
+    };
+    const github = await factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, {
+      body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes', draft: true }
+    });
+    interceptAsset(assets, { body: '*' });
+
+    await runTasks(github);
+
+    const execLabels = github.log.exec.mock.calls.map(c => c.arguments[0]);
+    assert(!execLabels.some(label => /updateRelease \(publish/.test(label)));
+    const { isReleased } = github.getContext();
+    assert(isReleased);
+  });
+
+  test('should create release without draft flow when no assets', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo Custom notes'
+      }
+    };
+    const github = await factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, {
+      body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes', draft: false }
+    });
+
+    await runTasks(github);
+
+    const execLabels = github.log.exec.mock.calls.map(c => c.arguments[0]);
+    assert(!execLabels.some(label => /updateRelease \(publish/.test(label)));
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
+  });
+
   test('should create a pre-release and draft release notes', async t => {
     const options = {
       git,
@@ -463,7 +537,8 @@ describe('github', () => {
 
     assert.equal(get.mock.callCount(), 0);
     assert.equal(github.log.exec.mock.calls[1].arguments[0], 'octokit repos.createRelease "R 1.0.1" (v1.0.1)');
-    assert.equal(github.log.exec.mock.calls.at(-1).arguments[0], 'octokit repos.uploadReleaseAssets');
+    assert.equal(github.log.exec.mock.calls.at(-2).arguments[0], 'octokit repos.uploadReleaseAssets');
+    assert.equal(github.log.exec.mock.calls.at(-1).arguments[0], 'octokit repos.updateRelease (publish v1.0.1)');
     const { isReleased, releaseUrl } = github.getContext();
     assert(isReleased);
     assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/v1.0.1');
@@ -615,7 +690,7 @@ describe('github', () => {
         tag_name: '2.0.2',
         name: 'Release 2.0.2',
         generate_release_notes: false,
-        body: null,
+        body: '',
         discussion_category_name: 'Announcement'
       }
     });

package/test/log.js

@@ -151,4 +151,22 @@ describe('log', () => {
     const { stdout } = mockStdIo.end();
     assert.equal(stripVTControlCharacters(stdout), `Title:${EOL}changelog\n`);
   });
+
+  test('should print preview when not quiet', () => {
+    const log = new Log({ isQuiet: false });
+    mockStdIo.start();
+    log.preview({ title: 'changelog', text: 'x' });
+    const { stdout } = mockStdIo.end();
+    assert.notEqual(stdout, '');
+  });
+
+  test('should suppress every preview when quiet', () => {
+    const log = new Log({ isQuiet: true });
+    mockStdIo.start();
+    log.preview({ title: 'changelog', text: 'x' });
+    log.preview({ title: 'changeset', text: 'y' });
+    log.preview({ title: 'release notes', text: 'z' });
+    const { stdout } = mockStdIo.end();
+    assert.equal(stdout, '');
+  });
 });

package/test/npm.js

@@ -288,6 +288,20 @@ describe('npm', async () => {
     assert.equal(npmClient.log.warn.mock.calls[0].arguments[0], 'The provided OTP is incorrect or has expired.');
   });
 
+  test('should let npm own the terminal under --only-version so passkey 2FA works (#1234)', async t => {
+    const onlyVersion = await factory(npm, { options: { 'only-version': true } });
+    onlyVersion.setContext({ name: 'pkg' });
+    const exec = t.mock.method(onlyVersion.shell, 'exec', () => Promise.resolve());
+    await onlyVersion.publish();
+    assert.equal(exec.mock.calls.at(-1).arguments[1].interactive, true);
+
+    const ci = await factory(npm);
+    ci.setContext({ name: 'pkg' });
+    const exec2 = t.mock.method(ci.shell, 'exec', () => Promise.resolve());
+    await ci.publish();
+    assert.equal(exec2.mock.calls.at(-1).arguments[1].interactive, false);
+  });
+
   test('should publish', async t => {
     const npmClient = await factory(npm);
     const exec = t.mock.method(npmClient.shell, 'exec', command => {
@@ -323,6 +337,87 @@ describe('npm', async () => {
     ]);
   });
 
+  test('should publish to the staging area when `stage` is enabled', async t => {
+    const options = { npm: { skipChecks: true, stage: true } };
+    const npmClient = await factory(npm, { options });
+    const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
+    await runTasks(npmClient);
+    assert.deepEqual(exec.mock.calls.at(-1).arguments[0], [
+      'npm',
+      'stage',
+      'publish',
+      '.',
+      '--tag',
+      'latest',
+      '--workspaces=false'
+    ]);
+  });
+
+  test('should not pass --otp when staging (2FA happens at approval)', async t => {
+    const npmClient = await factory(npm, { options: { npm: { stage: true } } });
+    npmClient.setContext({ name: 'pkg' });
+    const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
+    await npmClient.publish({ otp: '123456' });
+    assert.deepEqual(exec.mock.calls.at(-1).arguments[0], [
+      'npm',
+      'stage',
+      'publish',
+      '.',
+      '--tag',
+      'latest',
+      '--workspaces=false'
+    ]);
+  });
+
+  test('should stage publish with pnpm', async t => {
+    const npmClient = await factory(npm, { options: { npm: { stage: true, publishPackageManager: 'pnpm' } } });
+    npmClient.setContext({ name: 'pkg' });
+    const exec = t.mock.method(npmClient.shell, 'exec', () => Promise.resolve());
+    await npmClient.publish();
+    assert.deepEqual(exec.mock.calls.at(-1).arguments[0], ['pnpm', 'stage', 'publish', '.', '--tag', 'latest']);
+  });
+
+  test('should print the staged-packages approval URL after stage publish', async t => {
+    const unscoped = await factory(npm, { options: { npm: { stage: true } } });
+    unscoped.setContext({ name: 'pkg', username: 'webpro' });
+    t.mock.method(unscoped.shell, 'exec', () => Promise.resolve());
+    await unscoped.publish();
+    assert.match(unscoped.log.log.mock.calls.map(c => c.arguments[0]).join('\n'), /settings\/webpro\/staged-packages/);
+
+    const scoped = await factory(npm, { options: { npm: { stage: true } } });
+    scoped.setContext({ name: '@release-it/x', username: 'webpro' });
+    t.mock.method(scoped.shell, 'exec', () => Promise.resolve());
+    await scoped.publish();
+    assert.match(scoped.log.log.mock.calls.map(c => c.arguments[0]).join('\n'), /settings\/release-it\/staged-packages/);
+  });
+
+  test('should surface the stage id from publish output in the approval message', async t => {
+    const npmClient = await factory(npm, { options: { npm: { stage: true } } });
+    npmClient.setContext({ name: 'pkg', username: 'webpro' });
+    const id = '71289309-c232-432b-a2d4-32a14fa08177';
+    t.mock.method(npmClient.shell, 'exec', () => Promise.resolve(`+ pkg@1.0.0 (staged with id ${id})`));
+    await npmClient.publish();
+    const logged = npmClient.log.log.mock.calls.map(c => c.arguments[0]).join('\n');
+    assert.match(logged, new RegExp(`npm stage approve ${id}`));
+  });
+
+  test('should describe a staged dry-run, whether npm resolves or rejects the un-bumped version', async t => {
+    const execs = [
+      () => Promise.resolve('staged with id 71289309-c232-432b-a2d4-32a14fa08177'),
+      () => Promise.reject(new Error('npm error You cannot publish over the previously published versions: 1.0.0.'))
+    ];
+    for (const exec of execs) {
+      const npmClient = await factory(npm, { options: { 'dry-run': true, npm: { stage: true } } });
+      npmClient.setContext({ name: 'pkg', username: 'webpro' });
+      t.mock.method(npmClient.shell, 'exec', exec);
+      await npmClient.publish();
+      const logged = npmClient.log.log.mock.calls.map(c => c.arguments[0]).join('\n');
+      assert.match(logged, /Would stage \(dry-run\)/);
+      assert.match(logged, /settings\/webpro\/staged-packages/);
+      assert.doesNotMatch(logged, /stage approve 71289309/);
+    }
+  });
+
   test('should skip checks', async () => {
     const options = { npm: { skipChecks: true } };
     const npmClient = await factory(npm, { options });

package/test/stub/github.js

@@ -38,7 +38,7 @@ export const interceptCreate = (
     body: {
       tag_name,
       name = '',
-      body = null,
+      body = '',
       prerelease = false,
       draft = false,
       generate_release_notes = false,
@@ -81,7 +81,7 @@ export const interceptUpdate = (
     body: {
       tag_name,
       name = '',
-      body = null,
+      body = '',
       prerelease = false,
       draft = false,
       generate_release_notes = false,
@@ -121,6 +121,27 @@ export const interceptUpdate = (
   );
 };
 
+export const interceptPublish = (
+  server,
+  { host = 'github.com', owner = 'user', project = 'repo', body: { tag_name } = {} } = {}
+) => {
+  server.patch(
+    {
+      url: `/repos/${owner}/${project}/releases/1`,
+      body: { draft: false }
+    },
+    {
+      status: 200,
+      body: {
+        id: 1,
+        tag_name,
+        draft: false,
+        html_url: `https://${host}/${owner}/${project}/releases/tag/${tag_name}`
+      }
+    }
+  );
+};
+
 export const interceptAsset = (
   server,
   { api = 'https://api.github.com', host = 'github.com', owner = 'user', project = 'repo', tagName } = {}

package/test/tasks.js

@@ -20,6 +20,7 @@ import {
   interceptAuthentication as interceptGitHubAuthentication,
   interceptCollaborator as interceptGitHubCollaborator,
   interceptCreate as interceptGitHubCreate,
+  interceptPublish as interceptGitHubPublish,
   interceptAsset as interceptGitHubAsset
 } from './stub/github.js';
 import { factory, LogStub, SpinnerStub } from './util/index.js';
@@ -256,9 +257,11 @@ describe('tasks', () => {
         tag_name: 'v1.1.0-alpha.0',
         name: 'Release 1.1.0-alpha.0',
         body: `Notes for ${pkgName} [v1.1.0-alpha.0]: ${sha}`,
-        prerelease: true
+        prerelease: true,
+        draft: true
       }
     });
+    interceptGitHubPublish(github, { owner, project, body: { tag_name: 'v1.1.0-alpha.0' } });
 
     interceptGitLabUser(gitlab, { owner });
     interceptGitLabCollaborator(gitlab, { owner, project });
@@ -575,4 +578,49 @@ describe('tasks', () => {
       'echo after:afterRelease'
     ]);
   });
+
+  test('should show changelog preview by default', async () => {
+    gitAdd('{"name":"my-package","version":"1.2.3"}', 'package.json', 'Add package.json');
+    childProcess.execSync('git tag 1.2.3', execOpts);
+    gitAdd('line', 'file', 'Add file');
+    await runTasks(
+      {},
+      getContainer({
+        increment: 'patch'
+      })
+    );
+    const changelogCalls = log.preview.mock.calls.filter(call => call.arguments[0].title === 'changelog');
+    assert.equal(changelogCalls.length, 1);
+    assert(changelogCalls[0].arguments[0].text.includes('Add file'));
+  });
+
+  test('should show changelog preview when quiet is false', async () => {
+    gitAdd('{"name":"my-package","version":"1.2.3"}', 'package.json', 'Add package.json');
+    childProcess.execSync('git tag 1.2.3', execOpts);
+    gitAdd('line', 'file', 'Add file');
+    await runTasks(
+      {},
+      getContainer({
+        increment: 'patch',
+        quiet: false
+      })
+    );
+    const changelogCalls = log.preview.mock.calls.filter(call => call.arguments[0].title === 'changelog');
+    assert.equal(changelogCalls.length, 1);
+  });
+
+  test('should announce hidden preview when quiet is true', async () => {
+    gitAdd('{"name":"my-package","version":"1.2.3"}', 'package.json', 'Add package.json');
+    childProcess.execSync('git tag 1.2.3', execOpts);
+    gitAdd('line', 'file', 'Add file');
+    await runTasks(
+      {},
+      getContainer({
+        increment: 'patch',
+        quiet: true
+      })
+    );
+    assert(log.obtrusive.mock.calls[0].arguments[0].includes('release my-package'));
+    assert(log.info.mock.calls.some(call => call.arguments[0] === 'Preview output hidden (--quiet).'));
+  });
 });

package/types/config.d.ts

@@ -83,6 +83,9 @@ export interface Config {
     /** @default null */
     tag?: any;
 
+    /** @default false */
+    stage?: boolean;
+
     /** @default null */
     otp?: any;
 
@@ -205,4 +208,7 @@ export interface Config {
     /** @default false */
     skipChecks?: boolean;
   };
+
+  /** @default false */
+  quiet?: boolean;
 }