bulk-release 3.0.5 → 3.1.1

package/src/main/js/post/courier/index.js

@@ -1,6 +1,10 @@
 import {$, tempy, within, path, semver, fs} from 'zx-extra'
 import {unpackTar} from '../tar.js'
 import {log} from '../log.js'
+import {pool} from '../../util.js'
+import {scanDirectives, invalidateOrphans} from '../parcel/directive.js'
+import {tryLock, unlock, signalRebuild} from './semaphore.js'
+import gitTag from './channels/git-tag.js'
 import meta from './channels/meta.js'
 import npm from './channels/npm.js'
 import ghRelease from './channels/gh-release.js'
@@ -8,10 +12,15 @@ import ghPages from './channels/gh-pages.js'
 import changelog from './channels/changelog.js'
 import cmd from './channels/cmd.js'
 
-export {buildParcels} from './parcel.js'
 
-export const channels = {meta, npm, 'gh-release': ghRelease, 'gh-pages': ghPages, changelog, cmd}
-export const defaultOrder = ['meta', 'npm', 'gh-release', 'gh-pages', 'changelog', 'cmd']
+export const channels = {'git-tag': gitTag, meta, npm, 'gh-release': ghRelease, 'gh-pages': ghPages, changelog, cmd}
+export const defaultOrder = ['git-tag', 'meta', 'npm', 'gh-release', 'gh-pages', 'changelog', 'cmd']
+
+export const getActiveChannels = (pkg, channelNames, snapshot) =>
+  channelNames.filter(n => {
+    const ch = channels[n]
+    return ch && ch.transport !== false && (!snapshot || ch.snapshot) && ch.when(pkg)
+  })
 
 export const prepare = async (names, pkg) => {
   for (const n of names) await channels[n]?.prepare?.(pkg)
@@ -38,9 +47,11 @@ export const resolveManifest = (manifest, env = process.env) => {
   return resolved
 }
 
+const MARKERS = new Set(['released', 'skip', 'conflict', 'orphan'])
+
 const openParcel = async (tarPath, env) => {
   const content = await fs.readFile(tarPath, 'utf8').catch(() => null)
-  if (content === 'released' || content === 'skip') return null
+  if (MARKERS.has(content)) return null
 
   const destDir = tempy.temporaryDirectory()
   const {manifest} = await unpackTar(tarPath, destDir)
@@ -56,24 +67,6 @@ const openParcel = async (tarPath, env) => {
   return {ch, resolved, destDir, tarPath}
 }
 
-const pool = async (tasks, concurrency, fn) => {
-  const active = new Set()
-  let i = 0
-  await new Promise((resolve, reject) => {
-    const next = () => {
-      if (i >= tasks.length && active.size === 0) return resolve()
-      while (active.size < concurrency && i < tasks.length) {
-        const t = tasks[i++]
-        const p = fn(t).then(() => { active.delete(p); next() }, reject)
-        active.add(p)
-      }
-    }
-    next()
-  })
-}
-
-// Parcels grouped by package, sorted by semver asc (latest last).
-// Groups run in parallel (concurrency-limited), entries within a group — sequential.
 export const inspect = async (tars, env = process.env) => {
   const parcels = []
   const skipped = []
@@ -93,7 +86,6 @@ export const inspect = async (tars, env = process.env) => {
     }
   }
 
-  // group by package, sort by semver asc within each group
   const groups = new Map()
   for (const p of parcels) {
     const key = p.resolved.name || p.resolved.channel
@@ -106,7 +98,9 @@ export const inspect = async (tars, env = process.env) => {
   return {groups, skipped, total: tars.length, pending: parcels.length}
 }
 
-export const deliver = async (tars, env = process.env, {concurrency = 4, dryRun = false} = {}) => {
+// --- Legacy deliver (no directive) ---
+
+const deliverLegacy = async (tars, env, {concurrency, dryRun}) => {
   const {groups, skipped, total, pending} = await inspect(tars, env)
 
   for (const {file, reason, tarPath} of skipped) {
@@ -129,6 +123,7 @@ export const deliver = async (tars, env = process.env, {concurrency = 4, dryRun
       await within(async () => {
         $.scope = resolved.name || resolved.channel
         await ch.run(resolved, destDir)
+        log.info(`${resolved.channel} ${resolved.version}`)
       })
       await fs.writeFile(tarPath, 'released')
       entries.push(toEntry({resolved}))
@@ -137,3 +132,121 @@ export const deliver = async (tars, env = process.env, {concurrency = 4, dryRun
 
   return {total, pending, delivered: entries.length, skipped: skipped.length, entries}
 }
+
+// --- Directive-aware deliver ---
+
+const deliverParcel = async (tarPath, channelName, pkgName, version, env, {dryRun}) => {
+  const p = await openParcel(tarPath, env)
+  if (!p) return 'already'
+  if (p.warn) {
+    log.warn(`skipping ${p.warn}`)
+    return 'skip'
+  }
+
+  if (dryRun) return 'dryrun'
+
+  const {ch, resolved, destDir} = p
+  const res = await within(async () => {
+    $.scope = pkgName
+    const r = await ch.run(resolved, destDir)
+    log.info(`${channelName} ${version}`)
+    return r
+  })
+
+  if (res === 'conflict') return 'conflict'
+
+  await fs.writeFile(tarPath, 'released')
+  return res === 'duplicate' ? 'duplicate' : 'ok'
+}
+
+const deliverDirective = async (directive, tarMap, env, {dryRun}) => {
+  const entries = []
+  const conflicts = []
+  const skipped = []
+
+  for (const pkgName of directive.queue) {
+    const pkg = directive.packages[pkgName]
+    if (!pkg) continue
+
+    let pkgConflict = false
+
+    for (const step of pkg.deliver) {
+      if (pkgConflict) break
+
+      const results = await Promise.all(step.map(async (channelName) => {
+        const parcelName = (pkg.parcels || []).find(p => p.includes(`.${channelName}.`))
+        const tarPath = parcelName && tarMap.get(parcelName)
+        if (!tarPath) return 'missing'
+
+        return deliverParcel(tarPath, channelName, pkgName, pkg.version, env, {dryRun})
+      }))
+
+      for (let i = 0; i < step.length; i++) {
+        const r = results[i]
+        if (r === 'skip') skipped.push({channelName: step[i], pkg: pkgName})
+        else if (r !== 'missing' && r !== 'already') entries.push({channel: step[i], name: pkgName, version: pkg.version})
+      }
+
+      if (results.includes('conflict')) {
+        pkgConflict = true
+        conflicts.push(pkgName)
+        for (const p of pkg.parcels || []) {
+          const tp = tarMap.get(p)
+          if (!tp) continue
+          const c = await fs.readFile(tp, 'utf8').catch(() => null)
+          if (c !== 'released') await fs.writeFile(tp, 'conflict')
+        }
+      }
+    }
+  }
+
+  return {entries, conflicts, skipped}
+}
+
+// --- Main entry point ---
+
+export const deliver = async (tars, env = process.env, {concurrency = 4, dryRun = false, cwd} = {}) => {
+  const dir = tars.length ? path.dirname(tars[0]) : null
+  const directives = dir ? await scanDirectives(dir) : []
+
+  if (!directives.length) return deliverLegacy(tars, env, {concurrency, dryRun})
+
+  const tarMap = new Map(tars.map(t => [path.basename(t), t]))
+  const allEntries = []
+  const allConflicts = []
+  const allSkipped = []
+
+  for (const directive of directives) {
+    const gitRoot = cwd || dir
+    if (!await tryLock(gitRoot, directive)) {
+      log.info(`directive ${directive.sha.slice(0, 7)} locked, skipping`)
+      continue
+    }
+
+    try {
+      await invalidateOrphans(dir, directive)
+      const {entries, conflicts, skipped} = await deliverDirective(directive, tarMap, env, {dryRun})
+      allEntries.push(...entries)
+      allConflicts.push(...conflicts)
+      allSkipped.push(...skipped)
+
+      if (conflicts.length) {
+        await fs.writeFile(directive.tarPath, 'conflict')
+        await signalRebuild(gitRoot, directive.sha)
+      } else if (!skipped.length) {
+        await fs.writeFile(directive.tarPath, 'released')
+      }
+    } finally {
+      await unlock(gitRoot, directive)
+    }
+  }
+
+  return {
+    total: tars.length,
+    pending: allEntries.length,
+    delivered: allEntries.length,
+    skipped: allSkipped.length,
+    entries: allEntries,
+    conflicts: allConflicts,
+  }
+}

package/src/main/js/post/courier/semaphore.js

@@ -0,0 +1,31 @@
+import {pushAnnotatedTag, deleteRemoteTag} from '../api/git.js'
+
+const tagName = ({sha}) =>
+  `zbr-deliver.${sha.slice(0, 7)}`
+
+export const tryLock = async (cwd, directive) => {
+  const tag = tagName(directive)
+  const body = JSON.stringify({
+    ts:       directive.timestamp,
+    sha:      directive.sha,
+    packages: directive.queue,
+  })
+  try {
+    await pushAnnotatedTag(cwd, tag, body)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const unlock = async (cwd, directive) => {
+  await deleteRemoteTag(cwd, tagName(directive))
+}
+
+export const signalRebuild = async (cwd, sha) => {
+  const tag = `zbr-rebuild.${sha.slice(0, 7)}`
+  try { await pushAnnotatedTag(cwd, tag, 'rebuild') } catch { /* already signaled */ }
+}
+
+export const consumeRebuildSignal = async (cwd, sha) =>
+  deleteRemoteTag(cwd, `zbr-rebuild.${sha.slice(0, 7)}`)

package/src/main/js/post/courier/seniority.js

@@ -0,0 +1,19 @@
+import {$, semver} from 'zx-extra'
+import {parseTag} from '../depot/generators/tag.js'
+
+export const hasHigherVersion = async (cwd, name, version) => {
+  const output = (await $({cwd, nothrow: true})`git ls-remote --tags origin`).toString()
+  if (!output) return false
+
+  for (const line of output.split('\n')) {
+    const ref = line.split('\t')[1]?.replace('refs/tags/', '')
+    if (!ref) continue
+    const parsed = parseTag(ref)
+    if (!parsed || parsed.name !== name) continue
+    try {
+      if (semver.gt(parsed.version, version)) return true
+    } catch { /* unparseable version, skip */ }
+  }
+
+  return false
+}

package/src/main/js/post/depot/context.js

@@ -0,0 +1,46 @@
+import {fs, path} from 'zx-extra'
+
+export const CONTEXT_FILE = '.zbr-context.json'
+
+export const writeContext = async (cwd, context) => {
+  const filePath = path.resolve(cwd, CONTEXT_FILE)
+  await fs.writeJson(filePath, context, {spaces: 2})
+  return filePath
+}
+
+export const readContext = async (filePath) => {
+  let data
+  try { data = await fs.readJson(filePath) } catch {
+    throw new Error(`context not found: ${filePath}`)
+  }
+
+  if (!data || typeof data !== 'object') throw new Error(`context is not an object: ${filePath}`)
+  if (!data.status)                      throw new Error(`context missing status: ${filePath}`)
+  if (data.status === 'proceed') {
+    if (!data.sha || !data.sha7)         throw new Error(`context missing sha: ${filePath}`)
+    if (!data.packages || typeof data.packages !== 'object')
+      throw new Error(`context missing packages: ${filePath}`)
+  }
+
+  return data
+}
+
+export const buildContext = (packages, queue, sha, {getChannels} = {}) => {
+  const pkgs = {}
+  for (const name of queue) {
+    const pkg = packages[name]
+    if (!pkg.releaseType || pkg.skipped) continue
+    pkgs[name] = {
+      version:  pkg.version,
+      tag:      pkg.tag,
+      channels: getChannels ? getChannels(pkg) : [],
+    }
+  }
+
+  return {
+    status: 'proceed',
+    sha,
+    sha7: sha.slice(0, 7),
+    packages: pkgs,
+  }
+}

package/src/main/js/post/depot/reconcile.js

@@ -0,0 +1,47 @@
+import {$} from 'zx-extra'
+import {log} from '../log.js'
+import {getRemoteTagSha, clearTagsCache} from '../api/git.js'
+import {formatTag} from './generators/tag.js'
+import {resolvePkgVersion} from './steps/analyze.js'
+
+export const preflight = async (pkg, ctx) => {
+  if (!pkg.tag) return 'ok'
+
+  const cwd = ctx.git.root
+  const remoteSha = await getRemoteTagSha(cwd, pkg.tag)
+  if (!remoteSha) return 'ok'
+
+  // tag exists on remote
+  if (remoteSha === ctx.git.sha) {
+    log.info(`preflight: ${pkg.tag} already exists for our commit, skipping`)
+    return 'skip'
+  }
+
+  // need history for merge-base
+  await $({cwd, nothrow: true})`git fetch --deepen=100`
+
+  const isOursOlder = await $({cwd, nothrow: true})`git merge-base --is-ancestor ${ctx.git.sha} ${remoteSha}`
+  if (isOursOlder.exitCode === 0) {
+    log.info(`preflight: ${pkg.tag} — we are older, skipping`)
+    return 'skip'
+  }
+
+  const isRemoteOlder = await $({cwd, nothrow: true})`git merge-base --is-ancestor ${remoteSha} ${ctx.git.sha}`
+  if (isRemoteOlder.exitCode === 0) {
+    log.info(`preflight: ${pkg.tag} — we are newer, re-resolving version`)
+    await $({cwd})`git fetch origin --tags --force`
+    clearTagsCache()
+
+    const pre = ctx.flags.snapshot ? `-snap.${ctx.git.sha.slice(0, 7)}` : undefined
+    // re-resolve: the fetched tags will give us a new latest version
+    const latestVersion = pkg.latest.tag?.version || pkg.manifest.version
+    pkg.version = resolvePkgVersion(pkg.releaseType, latestVersion, pkg.manifest.version, pre)
+    pkg.manifest.version = pkg.version
+    pkg.tag = formatTag({name: pkg.name, version: pkg.version, format: pkg.config.tagFormat})
+    return 'ok'
+  }
+
+  // diverged — anomaly
+  log.warn(`preflight: ${pkg.tag} — diverged commits, skipping`)
+  return 'skip'
+}

package/src/main/js/post/depot/steps/contextify.js

@@ -1,6 +1,6 @@
 import {getPkgConfig} from '../../../config.js'
 import {getLatest} from '../generators/meta.js'
-import {getRoot, getSha} from '../../api/git.js'
+import {getRoot, getSha, getCommitTimestamp} from '../../api/git.js'
 
 /**
  * Global release context — one per `run()` invocation.
@@ -44,6 +44,7 @@ export const contextify = async (pkg, ctx) => {
     git: {
       sha: await getSha(pkg.absPath),
       root: await getRoot(pkg.absPath),
+      timestamp: await getCommitTimestamp(pkg.absPath),
     },
   }
 }

package/src/main/js/post/depot/steps/pack.js

@@ -1,27 +1,22 @@
 import {$, tempy, fs, path} from 'zx-extra'
 import {memoizeBy, asTuple} from '../../../util.js'
-import {channels, prepare, buildParcels} from '../../courier/index.js'
+import {prepare, getActiveChannels} from '../../courier/index.js'
+import {buildParcels, PARCELS_DIR} from '../../parcel/index.js'
 import {npmPersist} from '../../api/npm.js'
 import {getRepo} from '../../api/git.js'
 import {formatReleaseNotes} from '../generators/notes.js'
 import {ghPrepareAssets} from '../../api/gh.js'
 import {packTar, hashFile} from '../../tar.js'
 
-const filterActive = (names, pkg, {snapshot = false} = {}) =>
-  names.filter(n => {
-    const ch = channels[n]
-    return ch && ch.transport !== false && (!snapshot || ch.snapshot) && ch.when(pkg)
-  })
-
 export const pack = memoizeBy(async (pkg, ctx = pkg.ctx) => {
   const {channels: channelNames = [], flags} = ctx
   const snapshot = !!flags.snapshot
-  const active = filterActive(channelNames, pkg, {snapshot})
+  const active = getActiveChannels(pkg, channelNames, snapshot)
 
   await prepare(active, pkg)
   await npmPersist(pkg)
 
-  const outputDir = flags.pack ? path.resolve(ctx.git.root, typeof flags.pack === 'string' ? flags.pack : 'parcels') : null
+  const outputDir = flags.pack ? path.resolve(ctx.git.root, typeof flags.pack === 'string' ? flags.pack : PARCELS_DIR) : null
   const stageDir = outputDir || tempy.temporaryDirectory()
   if (outputDir) await fs.ensureDir(outputDir)
   const {repoName, repoHost, originUrl} = await getRepo(pkg.absPath, {basicAuth: pkg.config.ghBasicAuth})
@@ -49,7 +44,8 @@ export const pack = memoizeBy(async (pkg, ctx = pkg.ctx) => {
     const tmpPath = path.join(stageDir, `_tmp.${channel}.tar`)
     await packTar(tmpPath, manifest, files)
     const hash = await hashFile(tmpPath)
-    const finalPath = path.join(stageDir, `parcel.${pkg.tag}.${channel}.${hash}.tar`)
+    const sha7 = ctx.git.sha.slice(0, 7)
+    const finalPath = path.join(stageDir, `parcel.${sha7}.${channel}.${pkg.tag}.${hash}.tar`)
     await fs.rename(tmpPath, finalPath)
     tars.push(finalPath)
   }

package/src/main/js/post/depot/steps/publish.js

@@ -1,28 +1,18 @@
 import {memoizeBy} from '../../../util.js'
 import {exec} from '../exec.js'
-import {log} from '../../log.js'
 import {deliver, channels, runChannel} from '../../courier/index.js'
-import {pushTag} from '../../api/git.js'
 
 export const publish = memoizeBy(async (pkg, ctx = pkg.ctx) => {
   if (pkg.version !== pkg.manifest.version)
     throw new Error('package.json version not synced')
 
   const {run = exec, channels: channelNames = [], flags} = ctx
-  const snapshot = !!flags.snapshot
   const {tars = []} = pkg
 
-  if (!snapshot) {
-    const {tag, config: {gitCommitterEmail, gitCommitterName}} = pkg
-    ctx.git.tag = tag
-    log.info(`push release tag ${tag}`)
-    await pushTag({cwd: ctx.git.root, tag, gitCommitterEmail, gitCommitterName})
-  }
-
   await deliver(tars, ctx.env)
 
   const cmd = channels.cmd
-  if (channelNames.includes('cmd') && cmd?.when(pkg) && (!snapshot || cmd.snapshot))
+  if (channelNames.includes('cmd') && cmd?.when(pkg) && (!flags.snapshot || cmd.snapshot))
     await runChannel('cmd', pkg, run)
 
   pkg.published = true

package/src/main/js/post/modes/deliver.js

@@ -0,0 +1,23 @@
+import {$, glob, path} from 'zx-extra'
+import {createReport, log} from '../log.js'
+import {deliver} from '../courier/index.js'
+import {PARCELS_DIR} from '../parcel/index.js'
+
+export const runDeliver = async ({env, flags}) => {
+  const dir = typeof flags.deliver === 'string' ? flags.deliver : PARCELS_DIR
+  const report = createReport({flags})
+
+  $.memo = new Map()
+  $.report = report
+
+  report.setStatus('inspecting')
+
+  const tars = await glob(path.join(dir, 'parcel.*.tar'))
+  if (!tars.length) return report.setStatus('success').log(`no parcels in ${dir}`)
+
+  report.setStatus('delivering').log(`parcels: ${tars.length}`)
+  const result = await deliver(tars, env, {dryRun: flags.dryRun})
+  report.set('delivery', result).setStatus('success')
+
+  log.info(`done: ${result.delivered} delivered, ${result.skipped} skipped`)
+}

package/src/main/js/post/modes/pack.js

@@ -0,0 +1,69 @@
+import {$, within, path} from 'zx-extra'
+
+import {log} from '../log.js'
+import {traverseQueue} from '../depot/deps.js'
+import {contextify} from '../depot/steps/contextify.js'
+import {analyze} from '../depot/steps/analyze.js'
+import {build} from '../depot/steps/build.js'
+import {pack} from '../depot/steps/pack.js'
+import {publish} from '../depot/steps/publish.js'
+import {clean} from '../depot/steps/clean.js'
+import {test} from '../depot/steps/test.js'
+import {preflight} from '../depot/reconcile.js'
+import {buildDirective, PARCELS_DIR} from '../parcel/index.js'
+
+export const runPack = async ({cwd, env, flags}, ctx) => {
+  const {report, packages, queue, prev} = ctx
+
+  const forEachPkg = (cb) => traverseQueue({queue, prev, cb: (name) => within(async () => {
+    $.scope = name
+    await contextify(packages[name], ctx)
+    return cb(packages[name])
+  })})
+
+  report
+    .log('queue:', queue)
+    .log('graphs', ctx.graphs)
+
+  try {
+    await forEachPkg(async (pkg) => {
+      report.setStatus('analyzing', pkg.name)
+      await analyze(pkg)
+      report.set({
+        config:      pkg.config,
+        version:     pkg.version,
+        prevVersion: pkg.latest.tag?.version || pkg.manifest.version,
+        releaseType: pkg.releaseType,
+        tag:         pkg.tag,
+      }, pkg.name)
+    })
+
+    report.setStatus('pending')
+
+    const packed = []
+    await forEachPkg(async (pkg) => {
+      if (!pkg.releaseType) { pkg.skipped = true; return report.setStatus('skipped', pkg.name) }
+      if (await preflight(pkg, pkg.ctx) === 'skip') { pkg.skipped = true; return report.setStatus('skipped', pkg.name) }
+      if (flags.build !== false) { report.setStatus('building',  pkg.name); await build(pkg) }
+      if (flags.test  !== false) { report.setStatus('testing',   pkg.name); await test(pkg)  }
+      if (flags.dryRun || flags.publish === false) return report.setStatus('success', pkg.name)
+
+      report.setStatus('packing',    pkg.name); await pack(pkg)
+      if (flags.pack) { packed.push(pkg); return report.setStatus('packed', pkg.name) }
+
+      report.setStatus('publishing', pkg.name); await publish(pkg)
+      report.setStatus('success',    pkg.name)
+    })
+
+    if (flags.pack && packed.length) {
+      const outputDir = path.resolve(ctx.cwd, typeof flags.pack === 'string' ? flags.pack : PARCELS_DIR)
+      await buildDirective(ctx, packed, outputDir)
+    }
+  } catch (e) {
+    report.error(e, e.stack).set('error', e).setStatus('failure')
+    throw e
+  } finally {
+    await clean(ctx)
+  }
+  report.setStatus('success').log('Great success!')
+}

package/src/main/js/post/modes/receive.js

@@ -0,0 +1,72 @@
+import {$, within} from 'zx-extra'
+
+import {log} from '../log.js'
+import {traverseQueue} from '../depot/deps.js'
+import {contextify} from '../depot/steps/contextify.js'
+import {analyze} from '../depot/steps/analyze.js'
+import {clean} from '../depot/steps/clean.js'
+import {preflight} from '../depot/reconcile.js'
+import {consumeRebuildSignal} from '../courier/semaphore.js'
+import {getActiveChannels} from '../courier/index.js'
+import {writeContext, buildContext} from '../depot/context.js'
+import {getSha} from '../api/git.js'
+import {setOutput, isRebuildTrigger} from '../api/gh.js'
+
+export const runReceive = async ({cwd, env, flags}, ctx) => {
+  const {report, packages, queue, prev} = ctx
+
+  const sha = await getSha(cwd)
+  const sha7 = sha.slice(0, 7)
+
+  if (isRebuildTrigger(env) && !flags.dryRun) {
+    const result = await consumeRebuildSignal(cwd, sha)
+    if (result?.exitCode !== 0 && result?.stderr?.includes('remote ref does not exist')) {
+      log.info(`rebuild signal already consumed by another process`)
+      await writeContext(cwd, {status: 'skip', reason: 'rebuild claimed by another process'})
+      setOutput('status', 'skip')
+      return report.setStatus('success')
+    }
+    log.info(`consumed rebuild signal for ${sha7}`)
+  }
+
+  const forEachPkg = (cb) => traverseQueue({queue, prev, cb: (name) => within(async () => {
+    $.scope = name
+    await contextify(packages[name], ctx)
+    return cb(packages[name])
+  })})
+
+  try {
+    await forEachPkg(async (pkg) => {
+      report.setStatus('analyzing', pkg.name)
+      await analyze(pkg)
+    })
+
+    await forEachPkg(async (pkg) => {
+      if (!pkg.releaseType) { pkg.skipped = true; return }
+      if (await preflight(pkg, pkg.ctx) === 'skip') { pkg.skipped = true; return }
+    })
+
+    const snapshot = !!flags.snapshot
+    const context = buildContext(packages, queue, sha, {
+      getChannels: (pkg) => getActiveChannels(pkg, ctx.channels, snapshot),
+    })
+    await writeContext(cwd, context)
+
+    const count = Object.keys(context.packages).length
+    if (count === 0) {
+      log.info('nothing to release')
+      await writeContext(cwd, {status: 'skip', reason: 'nothing to release'})
+      setOutput('status', 'skip')
+    } else {
+      log.info(`${count} package(s) to release`)
+      setOutput('status', 'proceed')
+    }
+  } catch (e) {
+    report.error(e, e.stack).setStatus('failure')
+    throw e
+  } finally {
+    await clean(ctx)
+  }
+
+  report.setStatus('success')
+}

package/src/main/js/post/modes/verify.js

@@ -0,0 +1,41 @@
+import {glob, path, fs} from 'zx-extra'
+import {log} from '../log.js'
+import {PARCELS_DIR, verifyParcels} from '../parcel/index.js'
+import {CONTEXT_FILE, readContext} from '../depot/context.js'
+
+export const runVerify = async ({cwd, flags}) => {
+  const inputDir = typeof flags.verify === 'string' ? flags.verify : PARCELS_DIR
+  const contextPath = typeof flags.context === 'string' ? flags.context : path.resolve(cwd, CONTEXT_FILE)
+  const outputDir = path.resolve(cwd, PARCELS_DIR)
+
+  log.info(`verifying parcels in ${inputDir} against ${contextPath}`)
+
+  const context = await readContext(contextPath)
+  if (context.status !== 'proceed') {
+    log.info(`context status is '${context.status}', nothing to verify`)
+    return
+  }
+
+  const tars = await glob(path.join(inputDir, 'parcel.*.tar'))
+  if (!tars.length) {
+    log.info('no parcels to verify')
+    return
+  }
+
+  const {verified, errors} = verifyParcels(tars, context)
+
+  if (errors.length) {
+    for (const e of errors) log.error(`verify: ${e}`)
+    throw new Error(`parcel verification failed: ${errors.length} error(s)`)
+  }
+
+  if (path.resolve(inputDir) !== outputDir) {
+    await fs.ensureDir(outputDir)
+    for (const tarPath of verified) {
+      await fs.copy(tarPath, path.join(outputDir, path.basename(tarPath)))
+    }
+    log.info(`${verified.length} parcel(s) verified and copied to ${outputDir}`)
+  } else {
+    log.info(`${verified.length} parcel(s) verified in place`)
+  }
+}