@wyxos/zephyr 0.8.0 → 0.8.1

package/README.md

@@ -70,6 +70,9 @@ zephyr --type node
 # Release a Node/Vue package with an explicit bump
 zephyr --type node minor
 
+# Release a Node/Vue package, update a local consumer app, then deploy that app
+zephyr --type node --then-deploy ../php/atlas --consumer-preset wyxos-release --consumer-package @wyxos/vibe
+
 # Release a Packagist package
 zephyr --type packagist patch
 
@@ -111,10 +114,12 @@ For Laravel app deployments, `--maintenance on|off` overrides both the saved pre
 
 `--setup` is Laravel-only. It first verifies that the current project is a local Laravel app, then runs the normal local configuration prompts, tests SSH authentication to the selected server, and exits before local deploy preparation, pending snapshot handling, maintenance-mode decisions, locks, or remote deployment commands. On non-Laravel projects it fails before local setup changes are written.
 
-`--auto-commit` is available for app deployments and tells Zephyr to let local Codex inspect the repo and generate the dirty-tree commit message instead of prompting for one.
+`--auto-commit` is available for app deployments and package releases. It tells Zephyr to let local Codex inspect the repo and generate the dirty-tree commit message instead of prompting for one.
 
 `--skip-versioning` keeps Zephyr from mutating `package.json` or `composer.json`. On app deploys it skips the local npm version bump step. On package release workflows it releases the version already present in the manifest and creates the release tag from the current `HEAD`.
 
+`--then-deploy <path>` is available for `--type node` and `--type vue` package releases. After the package release succeeds and the published version is visible on npm, Zephyr updates the local consumer repository, commits the consumer dependency change, and deploys that consumer through its normal Zephyr app-deploy preset. Use `--consumer-preset <name>` to choose the app preset and `--consumer-package <name>` when the consumer dependency name differs from the released package name. Consumer lockfiles are refreshed only when the consumer repository already tracks an npm lockfile; Zephyr does not create or commit server-side lockfiles.
+
 ## AI Agents and Automation
 
 Zephyr can be used safely by Codex, CI jobs, or other automation once configuration is already in place.
@@ -132,6 +137,14 @@ zephyr --type node --non-interactive --json minor
 zephyr --type packagist --non-interactive --json patch
 ```
 
+Recommended pattern for releasing a package and immediately deploying a consumer app:
+
+```bash
+zephyr --type node --non-interactive --json --then-deploy ../php/atlas --consumer-preset wyxos-release --consumer-package @wyxos/vibe minor
+```
+
+The consumer update happens in the local consumer repository before deployment. Production receives the committed consumer state through the normal deployment path.
+
 In `--json` mode Zephyr emits NDJSON events on `stdout` with a stable shape:
 
 - `run_started`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A streamlined deployment tool for web applications with intelligent Laravel project detection",
   "type": "module",
   "main": "./src/index.mjs",

package/src/application/consumer/npm-publish-wait.mjs

@@ -0,0 +1,72 @@
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000
+const DEFAULT_INTERVAL_MS = 10 * 1000
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function npmPackageMetadataUrl(packageName) {
+  return `https://registry.npmjs.org/${encodeURIComponent(packageName)}`
+}
+
+export async function waitForNpmPackageVersion({
+  packageName,
+  version,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  intervalMs = DEFAULT_INTERVAL_MS,
+  fetchImpl = globalThis.fetch,
+  delayImpl = sleep,
+  nowImpl = Date.now,
+  logProcessing,
+  logSuccess,
+  logWarning
+} = {}) {
+  if (!packageName) {
+    throw new Error('Package name is required before waiting for npm publication.')
+  }
+
+  if (!version) {
+    throw new Error('Package version is required before waiting for npm publication.')
+  }
+
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch is not available, so Zephyr cannot verify npm publication.')
+  }
+
+  const deadline = nowImpl() + timeoutMs
+  const url = npmPackageMetadataUrl(packageName)
+  let attempts = 0
+  let lastError = null
+
+  logProcessing?.(`Waiting for ${packageName}@${version} to be visible on npm...`)
+
+  while (nowImpl() <= deadline) {
+    attempts += 1
+
+    try {
+      const response = await fetchImpl(url)
+
+      if (response.ok) {
+        const metadata = await response.json()
+        if (metadata?.versions?.[version]) {
+          logSuccess?.(`${packageName}@${version} is visible on npm.`)
+          return {packageName, version, attempts}
+        }
+      } else {
+        lastError = new Error(`npm registry responded with ${response.status}`)
+      }
+    } catch (error) {
+      lastError = error
+      logWarning?.(`npm visibility check failed: ${error.message}`)
+    }
+
+    if (nowImpl() + intervalMs > deadline) {
+      break
+    }
+
+    await delayImpl(intervalMs)
+  }
+
+  const suffix = lastError ? ` Last error: ${lastError.message}` : ''
+  throw new Error(`Timed out waiting for ${packageName}@${version} to be visible on npm.${suffix}`)
+}

package/src/application/consumer/release-package-then-deploy-consumer.mjs

@@ -0,0 +1,245 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import {validateLocalDependencies} from '../../dependency-scanner.mjs'
+import * as bootstrap from '../../project/bootstrap.mjs'
+import {createAppContext} from '../../runtime/app-context.mjs'
+import {mergeDeployOptions} from '../../config/preset-options.mjs'
+import {createConfigurationService} from '../configuration/service.mjs'
+import {selectDeploymentTarget} from '../configuration/select-deployment-target.mjs'
+import {resolvePendingSnapshot} from '../deploy/resolve-pending-snapshot.mjs'
+import {runDeployment} from '../deploy/run-deployment.mjs'
+import {waitForNpmPackageVersion} from './npm-publish-wait.mjs'
+import {
+  assertCleanConsumerRepo,
+  updateConsumerDependency
+} from './update-consumer-dependency.mjs'
+
+function resolveConsumerRootDir(producerRootDir, consumerRootDir) {
+  if (!consumerRootDir) {
+    throw new Error('--then-deploy requires a consumer repository path.')
+  }
+
+  return path.isAbsolute(consumerRootDir)
+    ? path.resolve(consumerRootDir)
+    : path.resolve(producerRootDir, consumerRootDir)
+}
+
+async function fileExists(filePath) {
+  return fs.access(filePath).then(() => true).catch(() => false)
+}
+
+function createConsumerExecutionMode({
+  presetName,
+  maintenanceMode,
+  skipChecks = false,
+  skipTests = false,
+  skipLint = false,
+  skipVersioning = false,
+  skipGitHooks = false,
+  autoCommit = false,
+  json = false,
+  explicitMaintenanceMode = false,
+  explicitSkipChecks = false,
+  explicitSkipTests = false,
+  explicitSkipLint = false,
+  explicitSkipVersioning = false,
+  explicitSkipGitHooks = false,
+  explicitAutoCommit = false
+} = {}) {
+  return {
+    interactive: false,
+    json: json === true,
+    workflow: 'deploy',
+    setup: false,
+    presetName,
+    maintenanceMode,
+    skipChecks: skipChecks === true,
+    skipTests: skipTests === true || skipChecks === true,
+    skipLint: skipLint === true || skipChecks === true,
+    skipVersioning: skipVersioning === true,
+    skipGitHooks: skipGitHooks === true,
+    autoCommit: autoCommit === true,
+    resumePending: false,
+    discardPending: false,
+    explicitMaintenanceMode: explicitMaintenanceMode === true,
+    explicitSkipChecks: explicitSkipChecks === true,
+    explicitSkipTests: explicitSkipTests === true || explicitSkipChecks === true,
+    explicitSkipLint: explicitSkipLint === true || explicitSkipChecks === true,
+    explicitSkipVersioning: explicitSkipVersioning === true,
+    explicitSkipGitHooks: explicitSkipGitHooks === true,
+    explicitAutoCommit: explicitAutoCommit === true
+  }
+}
+
+function resolvePackageDetails({releasedPackage, packageName, version}) {
+  const resolvedPackageName = packageName ?? releasedPackage?.name
+  const resolvedVersion = version ?? releasedPackage?.version
+
+  if (!resolvedPackageName) {
+    throw new Error('Unable to determine the package name to update in the consumer app. Pass --consumer-package <name>.')
+  }
+
+  if (!resolvedVersion) {
+    throw new Error('Unable to determine the released package version for the consumer app update.')
+  }
+
+  return {packageName: resolvedPackageName, version: resolvedVersion}
+}
+
+export async function releasePackageThenDeployConsumer({
+  producerRootDir,
+  consumerRootDir,
+  releasedPackage,
+  packageName = null,
+  version = null,
+  presetName,
+  maintenanceMode = null,
+  skipChecks = false,
+  skipTests = false,
+  skipLint = false,
+  skipVersioning = false,
+  skipGitHooks = false,
+  autoCommit = false,
+  json = false,
+  explicitMaintenanceMode = false,
+  explicitSkipChecks = false,
+  explicitSkipTests = false,
+  explicitSkipLint = false,
+  explicitSkipVersioning = false,
+  explicitSkipGitHooks = false,
+  explicitAutoCommit = false,
+  createAppContextImpl = createAppContext,
+  waitForNpmPackageVersionImpl = waitForNpmPackageVersion,
+  updateConsumerDependencyImpl = updateConsumerDependency,
+  assertCleanConsumerRepoImpl = assertCleanConsumerRepo,
+  validateLocalDependenciesImpl = validateLocalDependencies,
+  selectDeploymentTargetImpl = selectDeploymentTarget,
+  resolvePendingSnapshotImpl = resolvePendingSnapshot,
+  runDeploymentImpl = runDeployment,
+  bootstrapImpl = bootstrap
+} = {}) {
+  if (!presetName) {
+    throw new Error('--then-deploy requires --consumer-preset <name>.')
+  }
+
+  const resolvedProducerRootDir = producerRootDir ?? process.cwd()
+  const resolvedConsumerRootDir = resolveConsumerRootDir(resolvedProducerRootDir, consumerRootDir)
+  const details = resolvePackageDetails({releasedPackage, packageName, version})
+  const executionMode = createConsumerExecutionMode({
+    presetName,
+    maintenanceMode,
+    skipChecks,
+    skipTests,
+    skipLint,
+    skipVersioning,
+    skipGitHooks,
+    autoCommit,
+    json,
+    explicitMaintenanceMode,
+    explicitSkipChecks,
+    explicitSkipTests,
+    explicitSkipLint,
+    explicitSkipVersioning,
+    explicitSkipGitHooks,
+    explicitAutoCommit
+  })
+  const context = createAppContextImpl({executionMode})
+  const {
+    logProcessing,
+    logSuccess,
+    logWarning,
+    runPrompt,
+    runCommand,
+    runCommandCapture,
+    emitEvent
+  } = context
+  const configurationService = createConfigurationService(context)
+
+  logProcessing?.(`Preparing consumer app at ${resolvedConsumerRootDir}...`)
+  await assertCleanConsumerRepoImpl(resolvedConsumerRootDir, {runCommandCapture})
+
+  await bootstrapImpl.ensureGitignoreEntry(resolvedConsumerRootDir, {
+    runCommand,
+    logSuccess,
+    logWarning,
+    skipGitHooks: executionMode.skipGitHooks
+  })
+  await bootstrapImpl.ensureProjectReleaseScript(resolvedConsumerRootDir, {
+    runPrompt,
+    runCommand,
+    logSuccess,
+    logWarning,
+    skipGitHooks: executionMode.skipGitHooks,
+    interactive: executionMode.interactive
+  })
+
+  const hasPackageJson = await fileExists(path.join(resolvedConsumerRootDir, 'package.json'))
+  const hasComposerJson = await fileExists(path.join(resolvedConsumerRootDir, 'composer.json'))
+
+  if (hasPackageJson || hasComposerJson) {
+    logProcessing?.('Validating consumer dependencies...')
+    await validateLocalDependenciesImpl(resolvedConsumerRootDir, runPrompt, logSuccess, {
+      interactive: executionMode.interactive,
+      skipGitHooks: executionMode.skipGitHooks
+    })
+  }
+
+  const {deploymentConfig, presetState} = await selectDeploymentTargetImpl(resolvedConsumerRootDir, {
+    configurationService,
+    runPrompt,
+    logProcessing,
+    logSuccess,
+    logWarning,
+    emitEvent,
+    executionMode,
+    promptPresetOptions: true
+  })
+
+  if (presetState) {
+    const effectiveDeployOptions = mergeDeployOptions(executionMode, presetState.options)
+    Object.assign(executionMode, {
+      presetName: presetState.name,
+      ...effectiveDeployOptions,
+      skipChecks: executionMode.skipChecks === true ||
+        (effectiveDeployOptions.skipTests === true && effectiveDeployOptions.skipLint === true)
+    })
+    context.executionMode = executionMode
+    await presetState.applyExecutionMode(executionMode)
+  }
+
+  await waitForNpmPackageVersionImpl({
+    packageName: details.packageName,
+    version: details.version,
+    logProcessing,
+    logSuccess,
+    logWarning
+  })
+
+  await updateConsumerDependencyImpl({
+    rootDir: resolvedConsumerRootDir,
+    packageName: details.packageName,
+    version: details.version,
+    runCommand,
+    runCommandCapture,
+    logProcessing,
+    logSuccess,
+    logWarning,
+    skipGitHooks: executionMode.skipGitHooks
+  })
+
+  const snapshotToUse = await resolvePendingSnapshotImpl(resolvedConsumerRootDir, deploymentConfig, {
+    runPrompt,
+    logProcessing,
+    logWarning,
+    executionMode
+  })
+
+  await runDeploymentImpl(deploymentConfig, {
+    rootDir: resolvedConsumerRootDir,
+    snapshot: snapshotToUse,
+    context,
+    presetState
+  })
+}

package/src/application/consumer/update-consumer-dependency.mjs

@@ -0,0 +1,159 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import {gitCommitArgs} from '../../utils/git-hooks.mjs'
+
+const DEPENDENCY_FIELDS = [
+  'dependencies',
+  'devDependencies',
+  'peerDependencies',
+  'optionalDependencies'
+]
+const TRACKED_NPM_LOCK_FILES = ['package-lock.json', 'npm-shrinkwrap.json']
+
+async function readPackageJson(rootDir) {
+  const packageJsonPath = path.join(rootDir, 'package.json')
+  const raw = await fs.readFile(packageJsonPath, 'utf8')
+  return JSON.parse(raw)
+}
+
+async function writePackageJson(rootDir, pkg) {
+  const packageJsonPath = path.join(rootDir, 'package.json')
+  await fs.writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8')
+}
+
+function findDependencyField(pkg, packageName) {
+  return DEPENDENCY_FIELDS.find((field) => Object.hasOwn(pkg?.[field] ?? {}, packageName)) ?? null
+}
+
+function formatDependencyVersion(currentValue, version) {
+  if (typeof currentValue !== 'string' || currentValue.length === 0) {
+    return `^${version}`
+  }
+
+  if (currentValue.startsWith('~')) {
+    return `~${version}`
+  }
+
+  if (currentValue.startsWith('^')) {
+    return `^${version}`
+  }
+
+  if (/^\d/.test(currentValue)) {
+    return version
+  }
+
+  return `^${version}`
+}
+
+export async function assertCleanConsumerRepo(rootDir, {runCommandCapture} = {}) {
+  const status = await runCommandCapture('git', ['status', '--porcelain'], {cwd: rootDir})
+  const normalizedStatus = typeof status === 'string' ? status : status?.stdout ?? ''
+
+  if (normalizedStatus.trim().length > 0) {
+    throw new Error('Consumer repository has uncommitted changes. Commit, stash, or clean them before running a package-to-consumer release.')
+  }
+}
+
+async function isTracked(rootDir, filePath, {runCommandCapture} = {}) {
+  try {
+    await runCommandCapture('git', ['ls-files', '--error-unmatch', filePath], {cwd: rootDir})
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function getChangedFiles(rootDir, files, {runCommandCapture} = {}) {
+  const status = await runCommandCapture('git', ['status', '--porcelain', '--', ...files], {cwd: rootDir})
+  const normalizedStatus = typeof status === 'string' ? status : status?.stdout ?? ''
+  return normalizedStatus
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+}
+
+async function trackedNpmLockFiles(rootDir, {runCommandCapture} = {}) {
+  const tracked = []
+
+  for (const filePath of TRACKED_NPM_LOCK_FILES) {
+    if (await isTracked(rootDir, filePath, {runCommandCapture})) {
+      tracked.push(filePath)
+    }
+  }
+
+  return tracked
+}
+
+export async function updateConsumerDependency({
+  rootDir,
+  packageName,
+  version,
+  runCommand,
+  runCommandCapture,
+  logProcessing,
+  logSuccess,
+  logWarning,
+  skipGitHooks = false
+} = {}) {
+  if (!rootDir) {
+    throw new Error('Consumer root directory is required.')
+  }
+
+  if (!packageName) {
+    throw new Error('Consumer package name is required.')
+  }
+
+  if (!version) {
+    throw new Error('Consumer package version is required.')
+  }
+
+  if (typeof runCommand !== 'function' || typeof runCommandCapture !== 'function') {
+    throw new Error('Consumer dependency updates require command runners.')
+  }
+
+  await assertCleanConsumerRepo(rootDir, {runCommandCapture})
+
+  const pkg = await readPackageJson(rootDir)
+  const dependencyField = findDependencyField(pkg, packageName)
+
+  if (!dependencyField) {
+    throw new Error(`Consumer package.json does not depend on ${packageName}. Add it before running --then-deploy.`)
+  }
+
+  const currentValue = pkg[dependencyField][packageName]
+  const nextValue = formatDependencyVersion(currentValue, version)
+  const lockFiles = await trackedNpmLockFiles(rootDir, {runCommandCapture})
+
+  if (currentValue !== nextValue) {
+    logProcessing?.(`Updating ${packageName} in consumer package.json from ${currentValue} to ${nextValue}...`)
+    pkg[dependencyField][packageName] = nextValue
+    await writePackageJson(rootDir, pkg)
+  } else {
+    logProcessing?.(`Consumer package.json already references ${packageName}@${nextValue}.`)
+  }
+
+  if (lockFiles.length > 0) {
+    logProcessing?.(`Refreshing tracked npm lock file${lockFiles.length === 1 ? '' : 's'}: ${lockFiles.join(', ')}...`)
+    await runCommand('npm', ['install', '--package-lock-only', '--ignore-scripts'], {cwd: rootDir})
+  } else {
+    logWarning?.('No tracked npm lock file found in consumer repo; committing manifest update only.')
+  }
+
+  const filesToCommit = ['package.json', ...lockFiles]
+  const changedFiles = await getChangedFiles(rootDir, filesToCommit, {runCommandCapture})
+
+  if (changedFiles.length === 0) {
+    logSuccess?.(`Consumer already uses ${packageName}@${version}.`)
+    return {committed: false, files: []}
+  }
+
+  const commitMessage = `chore: update ${packageName} to ${version}`
+
+  await runCommand('git', ['add', '--', ...filesToCommit], {cwd: rootDir})
+  await runCommand('git', gitCommitArgs(['-m', commitMessage, '--', ...filesToCommit], {skipGitHooks}), {cwd: rootDir})
+
+  logSuccess?.(`Committed consumer dependency update with "${commitMessage}".`)
+
+  return {committed: true, files: filesToCommit, message: commitMessage}
+}

package/src/application/release/release-node-package.mjs

@@ -391,6 +391,7 @@ async function deployGHPages(skipDeploy, pkg, rootDir = process.cwd(), {
 export async function releaseNodePackage({
                                              releaseType,
                                              skipGitHooks = false,
+                                             autoCommit = false,
                                              skipTests = false,
                                              skipLint = false,
                                              skipVersioning = false,
@@ -431,6 +432,7 @@ export async function releaseNodePackage({
         logSuccess,
         logWarning,
         interactive,
+        autoCommit,
         skipGitHooks
     })
     await ensureReleaseBranchReady({rootDir, branchMethod: 'show-current', logStep, logWarning})
@@ -472,4 +474,5 @@ export async function releaseNodePackage({
 
     logStep?.('Publishing will be handled by GitHub Actions via trusted publishing.')
     logSuccess?.(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
+    return updatedPkg
 }

package/src/application/release/release-packagist-package.mjs

@@ -240,6 +240,7 @@ async function pushChanges(rootDir = process.cwd(), {
 export async function releasePackagistPackage({
                                                   releaseType,
                                                   skipGitHooks = false,
+                                                  autoCommit = false,
                                                   skipTests = false,
                                                   skipLint = false,
                                                   skipVersioning = false,
@@ -286,6 +287,7 @@ export async function releasePackagistPackage({
         logSuccess,
         logWarning,
         interactive,
+        autoCommit,
         skipGitHooks
     })
     await ensureReleaseBranchReady({rootDir, branchMethod: 'show-current', logStep, logWarning})
@@ -324,4 +326,5 @@ export async function releasePackagistPackage({
 
     logSuccess?.(`Release workflow completed for ${composer.name}@${updatedComposer.version}.`)
     logStep?.('Note: Packagist will automatically detect the new git tag and update the package.')
+    return updatedComposer
 }

package/src/cli/options.mjs

@@ -35,13 +35,17 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         .exitOverride()
         .option('--type <type>', 'Workflow type (node|vue|packagist). Omit for normal app deployments.')
         .option('--non-interactive', 'Fail instead of prompting when Zephyr needs user input.')
+        .option('--then-deploy <path>', 'After a node/vue package release, update and deploy a local consumer app repo.')
+        .option('--consumer-package <name>', 'Package name to update in the --then-deploy consumer. Defaults to the released package name.')
+        .option('--consumer-preset <name>', 'Preset name to use for the --then-deploy consumer app deployment.')
+        .option('--consumer-maintenance <mode>', 'Laravel maintenance mode policy for the --then-deploy consumer app deployment (on|off).')
         .option('--json', 'Emit NDJSON events to stdout. Requires --non-interactive.')
         .option('--setup', 'Configure an app deployment target and verify SSH connectivity without deploying.')
         .option('--preset <name>', 'Preset name to use for non-interactive app deployments.')
         .option('--resume-pending', 'Resume a saved pending deployment snapshot without prompting.')
         .option('--discard-pending', 'Discard a saved pending deployment snapshot without prompting.')
         .option('--maintenance <mode>', 'Laravel maintenance mode policy for app deployments (on|off).')
-        .option('--auto-commit', 'Automatically commit dirty deploy changes with a Codex-generated message.')
+        .option('--auto-commit', 'Automatically commit dirty changes with a Codex-generated message.')
         .option('--skip-versioning', 'Skip updating package/composer version files before continuing.')
         .option('--skip-git-hooks', 'Bypass local git hooks for any commits and pushes Zephyr performs.')
         .option('--skip-checks', 'Skip Zephyr local lint and test execution.')
@@ -49,6 +53,12 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         .option('--skip-lint', 'Skip Zephyr local lint execution in package release and app deployment workflows.')
         .option('--skip-build', 'Skip build execution in node/vue release workflows.')
         .option('--skip-deploy', 'Skip GitHub Pages deployment in node/vue release workflows.')
+        .option('--consumer-skip-checks', 'Skip Zephyr local lint and test execution in the --then-deploy consumer deployment.')
+        .option('--consumer-skip-tests', 'Skip Zephyr local test execution in the --then-deploy consumer deployment.')
+        .option('--consumer-skip-lint', 'Skip Zephyr local lint execution in the --then-deploy consumer deployment.')
+        .option('--consumer-skip-versioning', 'Skip local version bumping in the --then-deploy consumer deployment.')
+        .option('--consumer-skip-git-hooks', 'Bypass local git hooks for commits and pushes in the --then-deploy consumer repo.')
+        .option('--consumer-auto-commit', 'Automatically commit dirty deploy changes in the --then-deploy consumer repo.')
         .argument(
             '[version]',
             'Version or npm bump type for deployments (e.g. 1.2.3, patch, minor, major).'
@@ -63,6 +73,7 @@ export function parseCliOptions(args = process.argv.slice(2)) {
     const options = program.opts()
     const workflowType = options.type ?? null
     const explicitSkipChecks = hasFlag(args, '--skip-checks')
+    const explicitConsumerSkipChecks = hasFlag(args, '--consumer-skip-checks')
 
     if (workflowType && !WORKFLOW_TYPES.has(workflowType)) {
         throw new InvalidCliOptionsError('Invalid value for --type. Use one of: node, vue, packagist.')
@@ -72,6 +83,7 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         workflowType,
         versionArg: program.args[0] ?? null,
         nonInteractive: Boolean(options.nonInteractive),
+        thenDeploy: options.thenDeploy ?? null,
         json: Boolean(options.json),
         setup: Boolean(options.setup),
         presetName: options.preset ?? null,
@@ -86,13 +98,29 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         skipLint: Boolean(options.skipLint || options.skipChecks),
         skipBuild: Boolean(options.skipBuild),
         skipDeploy: Boolean(options.skipDeploy),
+        consumerPackage: options.consumerPackage ?? null,
+        consumerPresetName: options.consumerPreset ?? null,
+        consumerMaintenanceMode: normalizeMaintenanceMode(options.consumerMaintenance),
+        consumerSkipChecks: Boolean(options.consumerSkipChecks),
+        consumerSkipTests: Boolean(options.consumerSkipTests || options.consumerSkipChecks),
+        consumerSkipLint: Boolean(options.consumerSkipLint || options.consumerSkipChecks),
+        consumerSkipVersioning: Boolean(options.consumerSkipVersioning),
+        consumerSkipGitHooks: Boolean(options.consumerSkipGitHooks),
+        consumerAutoCommit: Boolean(options.consumerAutoCommit),
         explicitMaintenanceMode: hasFlag(args, '--maintenance'),
         explicitAutoCommit: hasFlag(args, '--auto-commit'),
         explicitSkipVersioning: hasFlag(args, '--skip-versioning'),
         explicitSkipGitHooks: hasFlag(args, '--skip-git-hooks'),
         explicitSkipChecks,
         explicitSkipTests: hasFlag(args, '--skip-tests') || explicitSkipChecks,
-        explicitSkipLint: hasFlag(args, '--skip-lint') || explicitSkipChecks
+        explicitSkipLint: hasFlag(args, '--skip-lint') || explicitSkipChecks,
+        explicitConsumerMaintenanceMode: hasFlag(args, '--consumer-maintenance'),
+        explicitConsumerSkipChecks,
+        explicitConsumerSkipTests: hasFlag(args, '--consumer-skip-tests') || explicitConsumerSkipChecks,
+        explicitConsumerSkipLint: hasFlag(args, '--consumer-skip-lint') || explicitConsumerSkipChecks,
+        explicitConsumerSkipVersioning: hasFlag(args, '--consumer-skip-versioning'),
+        explicitConsumerSkipGitHooks: hasFlag(args, '--consumer-skip-git-hooks'),
+        explicitConsumerAutoCommit: hasFlag(args, '--consumer-auto-commit')
     }
 }
 
@@ -102,6 +130,7 @@ export function validateCliOptions(options = {}) {
         nonInteractive = false,
         json = false,
         setup = false,
+        thenDeploy = null,
         presetName = null,
         resumePending = false,
         discardPending = false,
@@ -113,7 +142,16 @@ export function validateCliOptions(options = {}) {
         skipLint = false,
         skipBuild = false,
         skipDeploy = false,
-        versionArg = null
+        versionArg = null,
+        consumerPackage = null,
+        consumerPresetName = null,
+        consumerMaintenanceMode = null,
+        consumerSkipChecks = false,
+        consumerSkipTests = false,
+        consumerSkipLint = false,
+        consumerSkipVersioning = false,
+        consumerSkipGitHooks = false,
+        consumerAutoCommit = false
     } = options
 
     if (json && !nonInteractive) {
@@ -125,6 +163,31 @@ export function validateCliOptions(options = {}) {
     }
 
     const isPackageRelease = workflowType === 'node' || workflowType === 'vue' || workflowType === 'packagist'
+    const isNodePackageRelease = workflowType === 'node' || workflowType === 'vue'
+    const hasConsumerOptions = Boolean(
+        thenDeploy ||
+        consumerPackage ||
+        consumerPresetName ||
+        consumerMaintenanceMode !== null ||
+        consumerSkipChecks ||
+        consumerSkipTests ||
+        consumerSkipLint ||
+        consumerSkipVersioning ||
+        consumerSkipGitHooks ||
+        consumerAutoCommit
+    )
+
+    if (hasConsumerOptions && !thenDeploy) {
+        throw new InvalidCliOptionsError('--consumer-* options require --then-deploy <path>.')
+    }
+
+    if (thenDeploy && !isNodePackageRelease) {
+        throw new InvalidCliOptionsError('--then-deploy is only valid for node/vue package release workflows.')
+    }
+
+    if (thenDeploy && !consumerPresetName) {
+        throw new InvalidCliOptionsError('--then-deploy requires --consumer-preset <name>.')
+    }
 
     if (isPackageRelease) {
         if (setup) {
@@ -142,10 +205,6 @@ export function validateCliOptions(options = {}) {
         if (maintenanceMode !== null) {
             throw new InvalidCliOptionsError('--maintenance is only valid for app deployments.')
         }
-
-        if (autoCommit) {
-            throw new InvalidCliOptionsError('--auto-commit is only valid for app deployments.')
-        }
     } else {
         if (skipBuild || skipDeploy) {
             throw new InvalidCliOptionsError('--skip-build and --skip-deploy are only valid for node/vue release workflows.')

package/src/main.mjs

@@ -18,6 +18,7 @@ import {selectDeploymentTarget} from './application/configuration/select-deploym
 import {resolvePendingSnapshot} from './application/deploy/resolve-pending-snapshot.mjs'
 import {runDeployment} from './application/deploy/run-deployment.mjs'
 import {assertLaravelSetupProject} from './application/deploy/verify-laravel-setup.mjs'
+import {releasePackageThenDeployConsumer} from './application/consumer/release-package-then-deploy-consumer.mjs'
 import {SKIP_GIT_HOOKS_WARNING} from './utils/git-hooks.mjs'
 import {notifyWorkflowResult} from './utils/notifications.mjs'
 
@@ -32,6 +33,7 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
             workflowType: firstArg.workflowType ?? firstArg.type ?? null,
             versionArg: firstArg.versionArg ?? null,
             nonInteractive: firstArg.nonInteractive === true,
+            thenDeploy: firstArg.thenDeploy ?? null,
             json: firstArg.json === true,
             setup: firstArg.setup === true,
             presetName: firstArg.presetName ?? null,
@@ -46,6 +48,22 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
             skipLint: firstArg.skipLint === true || firstArg.skipChecks === true,
             skipBuild: firstArg.skipBuild === true,
             skipDeploy: firstArg.skipDeploy === true,
+            consumerPackage: firstArg.consumerPackage ?? null,
+            consumerPresetName: firstArg.consumerPresetName ?? null,
+            consumerMaintenanceMode: firstArg.consumerMaintenanceMode ?? null,
+            consumerSkipChecks: firstArg.consumerSkipChecks === true,
+            consumerSkipTests: firstArg.consumerSkipTests === true || firstArg.consumerSkipChecks === true,
+            consumerSkipLint: firstArg.consumerSkipLint === true || firstArg.consumerSkipChecks === true,
+            consumerSkipVersioning: firstArg.consumerSkipVersioning === true,
+            consumerSkipGitHooks: firstArg.consumerSkipGitHooks === true,
+            consumerAutoCommit: firstArg.consumerAutoCommit === true,
+            explicitConsumerMaintenanceMode: firstArg.explicitConsumerMaintenanceMode === true || 'consumerMaintenanceMode' in firstArg,
+            explicitConsumerSkipChecks: firstArg.explicitConsumerSkipChecks === true || 'consumerSkipChecks' in firstArg,
+            explicitConsumerSkipTests: firstArg.explicitConsumerSkipTests === true || 'consumerSkipTests' in firstArg || 'consumerSkipChecks' in firstArg,
+            explicitConsumerSkipLint: firstArg.explicitConsumerSkipLint === true || 'consumerSkipLint' in firstArg || 'consumerSkipChecks' in firstArg,
+            explicitConsumerSkipVersioning: firstArg.explicitConsumerSkipVersioning === true || 'consumerSkipVersioning' in firstArg,
+            explicitConsumerSkipGitHooks: firstArg.explicitConsumerSkipGitHooks === true || 'consumerSkipGitHooks' in firstArg,
+            explicitConsumerAutoCommit: firstArg.explicitConsumerAutoCommit === true || 'consumerAutoCommit' in firstArg,
             explicitMaintenanceMode: firstArg.explicitMaintenanceMode === true || 'maintenanceMode' in firstArg,
             explicitAutoCommit: firstArg.explicitAutoCommit === true || 'autoCommit' in firstArg,
             explicitSkipVersioning: firstArg.explicitSkipVersioning === true || 'skipVersioning' in firstArg,
@@ -61,6 +79,7 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
         workflowType: firstArg ?? null,
         versionArg: secondArg ?? null,
         nonInteractive: false,
+        thenDeploy: null,
         json: false,
         setup: false,
         presetName: null,
@@ -75,6 +94,22 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
         skipLint: false,
         skipBuild: false,
         skipDeploy: false,
+        consumerPackage: null,
+        consumerPresetName: null,
+        consumerMaintenanceMode: null,
+        consumerSkipChecks: false,
+        consumerSkipTests: false,
+        consumerSkipLint: false,
+        consumerSkipVersioning: false,
+        consumerSkipGitHooks: false,
+        consumerAutoCommit: false,
+        explicitConsumerMaintenanceMode: false,
+        explicitConsumerSkipChecks: false,
+        explicitConsumerSkipTests: false,
+        explicitConsumerSkipLint: false,
+        explicitConsumerSkipVersioning: false,
+        explicitConsumerSkipGitHooks: false,
+        explicitConsumerAutoCommit: false,
         explicitMaintenanceMode: false,
         explicitAutoCommit: false,
         explicitSkipVersioning: false,
@@ -209,8 +244,9 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         }
 
         if (options.workflowType === 'node' || options.workflowType === 'vue') {
-            await releaseNode({
+            const releasedPackage = await releaseNode({
                 releaseType: options.versionArg,
+                autoCommit: options.autoCommit,
                 skipGitHooks: options.skipGitHooks,
                 skipTests: options.skipTests,
                 skipLint: options.skipLint,
@@ -219,6 +255,32 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                 skipDeploy: options.skipDeploy,
                 context: appContext
             })
+
+            if (options.thenDeploy) {
+                await releasePackageThenDeployConsumer({
+                    producerRootDir: rootDir,
+                    consumerRootDir: options.thenDeploy,
+                    releasedPackage,
+                    packageName: options.consumerPackage,
+                    presetName: options.consumerPresetName,
+                    maintenanceMode: options.consumerMaintenanceMode,
+                    skipChecks: options.consumerSkipChecks,
+                    skipTests: options.consumerSkipTests,
+                    skipLint: options.consumerSkipLint,
+                    skipVersioning: options.consumerSkipVersioning,
+                    skipGitHooks: options.consumerSkipGitHooks,
+                    autoCommit: options.consumerAutoCommit,
+                    explicitMaintenanceMode: options.explicitConsumerMaintenanceMode,
+                    explicitSkipChecks: options.explicitConsumerSkipChecks,
+                    explicitSkipTests: options.explicitConsumerSkipTests,
+                    explicitSkipLint: options.explicitConsumerSkipLint,
+                    explicitSkipVersioning: options.explicitConsumerSkipVersioning,
+                    explicitSkipGitHooks: options.explicitConsumerSkipGitHooks,
+                    explicitAutoCommit: options.explicitConsumerAutoCommit,
+                    json: currentExecutionMode.json
+                })
+            }
+
             emitEvent?.('run_completed', {
                 message: 'Zephyr workflow completed successfully.',
                 data: {
@@ -240,12 +302,14 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         if (options.workflowType === 'packagist') {
             await releasePackagist({
                 releaseType: options.versionArg,
+                autoCommit: options.autoCommit,
                 skipGitHooks: options.skipGitHooks,
                 skipTests: options.skipTests,
                 skipLint: options.skipLint,
                 skipVersioning: options.skipVersioning,
                 context: appContext
             })
+
             emitEvent?.('run_completed', {
                 message: 'Zephyr workflow completed successfully.',
                 data: {

package/src/release/shared.mjs

@@ -94,6 +94,7 @@ export async function ensureCleanWorkingTree(rootDir = process.cwd(), {
   logSuccess,
   logWarning,
   interactive = true,
+  autoCommit = false,
   skipGitHooks = false,
   suggestCommitMessage = suggestReleaseCommitMessage
 } = {}) {
@@ -107,7 +108,7 @@ export async function ensureCleanWorkingTree(rootDir = process.cwd(), {
     return
   }
 
-  if (!interactive || typeof runPrompt !== 'function') {
+  if (!autoCommit && (!interactive || typeof runPrompt !== 'function')) {
     throw new Error(DIRTY_WORKING_TREE_MESSAGE)
   }
 
@@ -117,24 +118,34 @@ export async function ensureCleanWorkingTree(rootDir = process.cwd(), {
     logWarning,
     statusEntries
   })
-  const {commitMessage} = await runPrompt([
-    {
-      type: 'input',
-      name: 'commitMessage',
-      message:
-        'Pending changes detected before release:\n\n' +
-        `${formatWorkingTreePreview(statusEntries)}\n\n` +
-        'Enter a commit message to stage and commit all current changes before continuing.\n' +
-        'Leave blank to cancel.',
-      default: suggestedCommitMessage ?? ''
+  let message = suggestedCommitMessage?.trim() ?? ''
+
+  if (autoCommit) {
+    if (!message) {
+      throw new Error('Release auto-commit failed because Codex could not determine a usable commit message.')
     }
-  ])
 
-  if (!commitMessage || commitMessage.trim().length === 0) {
-    throw new Error(DIRTY_WORKING_TREE_CANCELLED_MESSAGE)
-  }
+    logStep?.(`Auto-commit enabled. Using Codex-generated commit message "${message}".`)
+  } else {
+    const {commitMessage} = await runPrompt([
+      {
+        type: 'input',
+        name: 'commitMessage',
+        message:
+          'Pending changes detected before release:\n\n' +
+          `${formatWorkingTreePreview(statusEntries)}\n\n` +
+          'Enter a commit message to stage and commit all current changes before continuing.\n' +
+          'Leave blank to cancel.',
+        default: message
+      }
+    ])
+
+    if (!commitMessage || commitMessage.trim().length === 0) {
+      throw new Error(DIRTY_WORKING_TREE_CANCELLED_MESSAGE)
+    }
 
-  const message = commitMessage.trim()
+    message = commitMessage.trim()
+  }
 
   logStep?.('Staging all pending changes before release...')
   await runCommand('git', ['add', '-A'], {

package/src/release-node.mjs

@@ -10,6 +10,7 @@ function hasExplicitReleaseOptions(options = {}) {
         'skipTests',
         'skipLint',
         'skipVersioning',
+        'autoCommit',
         'skipBuild',
         'skipDeploy'
     ].some((key) => key in options)
@@ -23,11 +24,12 @@ export async function releaseNode(options = {}) {
             skipTests: options.skipTests === true,
             skipLint: options.skipLint === true,
             skipVersioning: options.skipVersioning === true,
+            autoCommit: options.autoCommit === true,
             skipBuild: options.skipBuild === true,
             skipDeploy: options.skipDeploy === true
         }
         : parseReleaseArgs({
-            booleanFlags: ['--skip-git-hooks', '--skip-tests', '--skip-lint', '--skip-versioning', '--skip-build', '--skip-deploy']
+            booleanFlags: ['--skip-git-hooks', '--auto-commit', '--skip-tests', '--skip-lint', '--skip-versioning', '--skip-build', '--skip-deploy']
         })
 
     if (parsed.skipVersioning && parsed.releaseType) {
@@ -43,10 +45,11 @@ export async function releaseNode(options = {}) {
     })
     const {logProcessing: logStep, logSuccess, logWarning, runPrompt, runCommand, runCommandCapture, executionMode} = context
 
-    await releaseNodePackage({
+    return await releaseNodePackage({
         releaseType: parsed.releaseType,
         skipGitHooks: parsed.skipGitHooks === true || executionMode?.skipGitHooks === true,
         skipTests: parsed.skipTests === true,
+        autoCommit: parsed.autoCommit === true,
         skipLint: parsed.skipLint === true,
         skipVersioning: parsed.skipVersioning === true,
         skipBuild: parsed.skipBuild === true,

package/src/release-packagist.mjs

@@ -9,6 +9,7 @@ function hasExplicitReleaseOptions(options = {}) {
         'skipGitHooks',
         'skipTests',
         'skipLint',
+        'autoCommit',
         'skipVersioning'
     ].some((key) => key in options)
 }
@@ -20,10 +21,11 @@ export async function releasePackagist(options = {}) {
             skipGitHooks: options.skipGitHooks === true,
             skipTests: options.skipTests === true,
             skipLint: options.skipLint === true,
+            autoCommit: options.autoCommit === true,
             skipVersioning: options.skipVersioning === true
         }
         : parseReleaseArgs({
-            booleanFlags: ['--skip-git-hooks', '--skip-tests', '--skip-lint', '--skip-versioning']
+            booleanFlags: ['--skip-git-hooks', '--auto-commit', '--skip-tests', '--skip-lint', '--skip-versioning']
         })
 
     if (parsed.skipVersioning && parsed.releaseType) {
@@ -39,9 +41,10 @@ export async function releasePackagist(options = {}) {
     })
     const {logProcessing: logStep, logSuccess, logWarning, runPrompt, runCommand, runCommandCapture, executionMode} = context
 
-    await releasePackagistPackage({
+    return await releasePackagistPackage({
         releaseType: parsed.releaseType,
         skipGitHooks: parsed.skipGitHooks === true || executionMode?.skipGitHooks === true,
+        autoCommit: parsed.autoCommit === true,
         skipTests: parsed.skipTests === true,
         skipLint: parsed.skipLint === true,
         skipVersioning: parsed.skipVersioning === true,