bulk-release 3.0.4 → 3.1.0

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

@@ -1,6 +1,9 @@
 import {$, tempy, within, path, semver, fs} from 'zx-extra'
 import {unpackTar} from '../tar.js'
 import {log} from '../log.js'
+import {scanDirectives, invalidateOrphans} from './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'
@@ -10,8 +13,8 @@ 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 prepare = async (names, pkg) => {
   for (const n of names) await channels[n]?.prepare?.(pkg)
@@ -38,9 +41,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)
@@ -72,10 +77,9 @@ const pool = async (tasks, concurrency, fn) => {
   })
 }
 
-// Parcels grouped by package, sorted by semver asc (latest last).
-// Groups run in parallel (concurrency-limited), entries within a group — sequential.
-export const deliver = async (tars, env = process.env, {concurrency = 4} = {}) => {
-  const groups = new Map()
+export const inspect = async (tars, env = process.env) => {
+  const parcels = []
+  const skipped = []
 
   for (const tarPath of tars) {
     const fname = path.basename(tarPath)
@@ -83,32 +87,176 @@ export const deliver = async (tars, env = process.env, {concurrency = 4} = {}) =
       const p = await openParcel(tarPath, env)
       if (!p) continue
       if (p.warn) {
-        log.warn(`skipping ${fname}: ${p.warn}`)
-        if (p.tarPath) await fs.writeFile(tarPath, 'skip')
+        skipped.push({file: fname, reason: p.warn, tarPath: p.tarPath})
         continue
       }
-      const key = p.resolved.name || p.resolved.channel
-      if (!groups.has(key)) groups.set(key, [])
-      groups.get(key).push(p)
+      parcels.push(p)
     } catch (e) {
-      log.warn(`skipping ${fname}: ${e.message}`)
+      skipped.push({file: fname, reason: e.message})
     }
   }
 
+  const groups = new Map()
+  for (const p of parcels) {
+    const key = p.resolved.name || p.resolved.channel
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key).push(p)
+  }
   for (const g of groups.values())
     g.sort((a, b) => semver.compare(a.resolved.version || '0.0.0', b.resolved.version || '0.0.0'))
 
-  let delivered = 0
+  return {groups, skipped, total: tars.length, pending: parcels.length}
+}
+
+// --- 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) {
+    log.warn(`skipping ${file}: ${reason}`)
+    if (!dryRun && tarPath) await fs.writeFile(tarPath, 'skip')
+  }
+
+  const entries = []
+  const toEntry = ({resolved}) => ({channel: resolved.channel, name: resolved.name, version: resolved.version})
+
+  if (dryRun) {
+    for (const group of groups.values())
+      for (const p of group)
+        entries.push(toEntry(p))
+    return {total, pending: entries.length, delivered: 0, skipped: skipped.length, entries}
+  }
+
   await pool([...groups.values()], concurrency, async (group) => {
     for (const {ch, resolved, destDir, tarPath} of group) {
       await within(async () => {
         $.scope = resolved.name || resolved.channel
         await ch.run(resolved, destDir)
+        log.info(`${resolved.channel} ${resolved.version}`)
       })
       await fs.writeFile(tarPath, 'released')
-      delivered++
+      entries.push(toEntry({resolved}))
     }
   })
 
-  return delivered
+  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/parcel.js

@@ -9,6 +9,18 @@ const gitFields = (a, pkg) => ({
 })
 
 const entry = {
+  'git-tag': (pkg, ctx) => ({
+    channel: 'git-tag',
+    manifest: {
+      channel: 'git-tag',
+      name: pkg.name, version: pkg.version, tag: pkg.tag,
+      cwd: ctx.git.root,
+      gitCommitterName: '${{GIT_COMMITTER_NAME}}',
+      gitCommitterEmail: '${{GIT_COMMITTER_EMAIL}}',
+    },
+    files: [],
+  }),
+
   npm: (pkg, ctx, a) => ({
     channel: 'npm',
     manifest: {
@@ -24,6 +36,7 @@ const entry = {
     channel: 'gh-release',
     manifest: {
       channel: 'gh-release',
+      name: pkg.name, version: pkg.version,
       tag: pkg.tag, repoHost: a.repoHost, repoName: a.repoName, releaseNotes: a.releaseNotes,
       token: '${{GH_TOKEN}}', apiUrl: pkg.config.ghApiUrl,
       assets: pkg.config.ghAssets ? [...pkg.config.ghAssets] : undefined,
@@ -35,7 +48,7 @@ const entry = {
     const [branch = 'gh-pages', , to = '.', ..._msg] = asTuple(pkg.config.ghPages, ['branch', 'from', 'to', 'msg'])
     return {
       channel: 'gh-pages',
-      manifest: {channel: 'gh-pages', branch, to, msg: msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}'), ...gitFields(a, pkg)},
+      manifest: {channel: 'gh-pages', name: pkg.name, version: pkg.version, branch, to, msg: msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}'), ...gitFields(a, pkg)},
       files: a.docsDir ? [{name: 'docs', source: a.docsDir}] : [],
     }
   },
@@ -44,7 +57,7 @@ const entry = {
     const [branch = 'changelog', file = `${pkg.name.replace(/[^a-z0-9-]/ig, '')}-changelog.md`, ..._msg] = asTuple(pkg.config.changelog, ['branch', 'file', 'msg'])
     return {
       channel: 'changelog',
-      manifest: {channel: 'changelog', releaseNotes: a.releaseNotes, branch, file, msg: msgJoin(_msg, pkg, 'chore: update changelog ${{name}}'), ...gitFields(a, pkg)},
+      manifest: {channel: 'changelog', name: pkg.name, version: pkg.version, releaseNotes: a.releaseNotes, branch, file, msg: msgJoin(_msg, pkg, 'chore: update changelog ${{name}}'), ...gitFields(a, pkg)},
       files: [],
     }
   },

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,45 @@
+import {fs, path} from 'zx-extra'
+import {channels as channelRegistry} from '../courier/index.js'
+
+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 (cwd) => {
+  const filePath = path.resolve(cwd, CONTEXT_FILE)
+  try {
+    return await fs.readJson(filePath)
+  } catch {
+    return null
+  }
+}
+
+const getActiveChannels = (pkg, channelNames, snapshot) =>
+  channelNames.filter(n => {
+    const ch = channelRegistry[n]
+    return ch && ch.transport !== false && (!snapshot || ch.snapshot) && ch.when(pkg)
+  })
+
+export const buildContext = (packages, queue, sha, {channelNames = [], snapshot = false} = {}) => {
+  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: getActiveChannels(pkg, channelNames, snapshot),
+    }
+  }
+
+  return {
+    status: 'proceed',
+    sha,
+    sha7: sha.slice(0, 7),
+    packages: pkgs,
+  }
+}

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

@@ -0,0 +1,50 @@
+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 isTagConflict = (e) =>
+  /already exists|updates were rejected|failed to push/i.test(e?.message || e?.stderr || '')
+
+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

@@ -7,6 +7,7 @@ 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]
@@ -49,7 +50,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,24 @@
+import {$, glob, path} from 'zx-extra'
+import {createReport, log} from '../log.js'
+import {deliver} from '../courier/index.js'
+
+const PARCELS_DIR = 'parcels'
+
+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,71 @@
+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} from '../courier/directive.js'
+
+const PARCELS_DIR = 'parcels'
+
+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,71 @@
+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 {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)) {
+    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 context = buildContext(packages, queue, sha, {
+      channelNames: ctx.channels,
+      snapshot: !!flags.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')
+}