@wyxos/zephyr 0.7.5 → 0.8.1

package/README.md

@@ -49,6 +49,9 @@ zephyr minor --skip-checks
 # Deploy a configured app non-interactively
 zephyr --non-interactive --preset wyxos-release --maintenance off
 
+# Configure a Laravel app target and verify SSH without deploying
+zephyr --setup
+
 # Deploy a configured app non-interactively and auto-commit dirty changes
 zephyr --non-interactive --preset wyxos-release --auto-commit
 
@@ -67,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
 
@@ -106,10 +112,14 @@ then non-interactive mode stops immediately with a clear error instead.
 
 For Laravel app deployments, `--maintenance on|off` overrides both the saved preset preference and the maintenance prompt when you want an explicit choice for the current run.
 
-`--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.
+`--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 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.
@@ -127,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.7.5",
+  "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/deploy/run-deployment.mjs

@@ -15,6 +15,7 @@ import {resolveRemotePath} from '../../utils/remote-path.mjs'
 import {buildRemoteDeploymentPlan, resolveRemoteDeploymentState} from './build-remote-deployment-plan.mjs'
 import {executeRemoteDeploymentPlan} from './execute-remote-deployment-plan.mjs'
 import {prepareLocalDeployment} from './prepare-local-deployment.mjs'
+import {verifyLaravelSetup} from './verify-laravel-setup.mjs'
 
 async function resolveRemoteHome(ssh, sshUser) {
     const remoteHomeResult = await ssh.execCommand('printf "%s" "$HOME"')
@@ -263,9 +264,22 @@ export async function runDeployment(config, options = {}) {
         executionMode
     } = context
 
+    const sshUser = config.sshUser || os.userInfo().username
+
+    if (executionMode?.setup === true) {
+        await verifyLaravelSetup({
+            config,
+            rootDir,
+            createSshClient,
+            sshUser,
+            logProcessing,
+            logSuccess
+        })
+        return
+    }
+
     await cleanupOldLogs(rootDir)
 
-    const sshUser = config.sshUser || os.userInfo().username
     const privateKeyPath = await resolveSshKeyPath(config.sshKey)
     const privateKey = await fs.readFile(privateKeyPath, 'utf8')
     let ssh = null

package/src/application/deploy/verify-laravel-setup.mjs

@@ -0,0 +1,43 @@
+import fs from 'node:fs/promises'
+
+import {isLocalLaravelProject} from '../../deploy/preflight.mjs'
+import {ZephyrError} from '../../runtime/errors.mjs'
+import {resolveSshKeyPath} from '../../ssh/keys.mjs'
+
+export async function assertLaravelSetupProject(rootDir) {
+    const isLaravel = await isLocalLaravelProject(rootDir)
+
+    if (!isLaravel) {
+        throw new ZephyrError(
+            'Zephyr setup is only supported for Laravel app projects.',
+            {code: 'ZEPHYR_SETUP_REQUIRES_LARAVEL'}
+        )
+    }
+}
+
+export async function verifyLaravelSetup({
+    config,
+    rootDir,
+    createSshClient,
+    sshUser,
+    logProcessing,
+    logSuccess
+} = {}) {
+    await assertLaravelSetupProject(rootDir)
+
+    const privateKeyPath = await resolveSshKeyPath(config.sshKey)
+    const privateKey = await fs.readFile(privateKeyPath, 'utf8')
+    const ssh = createSshClient()
+
+    try {
+        logProcessing?.(`\nConnecting to ${config.serverIp} as ${sshUser} to verify SSH setup...`)
+        await ssh.connect({
+            host: config.serverIp,
+            username: sshUser,
+            privateKey
+        })
+        logSuccess?.('Setup verified. SSH connection succeeded for this Laravel app.')
+    } finally {
+        ssh.dispose()
+    }
+}

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,12 +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.')
@@ -48,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).'
@@ -62,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.')
@@ -71,7 +83,9 @@ 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,
         resumePending: Boolean(options.resumePending),
         discardPending: Boolean(options.discardPending),
@@ -84,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')
     }
 }
 
@@ -99,14 +129,29 @@ export function validateCliOptions(options = {}) {
         workflowType = null,
         nonInteractive = false,
         json = false,
+        setup = false,
+        thenDeploy = null,
         presetName = null,
         resumePending = false,
         discardPending = false,
         maintenanceMode = null,
         autoCommit = false,
         skipVersioning = false,
+        skipChecks = false,
+        skipTests = false,
+        skipLint = false,
         skipBuild = false,
-        skipDeploy = false
+        skipDeploy = false,
+        versionArg = null,
+        consumerPackage = null,
+        consumerPresetName = null,
+        consumerMaintenanceMode = null,
+        consumerSkipChecks = false,
+        consumerSkipTests = false,
+        consumerSkipLint = false,
+        consumerSkipVersioning = false,
+        consumerSkipGitHooks = false,
+        consumerAutoCommit = false
     } = options
 
     if (json && !nonInteractive) {
@@ -118,8 +163,37 @@ 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) {
+            throw new InvalidCliOptionsError('--setup is only valid for app deployments.')
+        }
+
         if (presetName) {
             throw new InvalidCliOptionsError('--preset is only valid for app deployments.')
         }
@@ -131,21 +205,39 @@ 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.')
         }
 
+        if (setup) {
+            if (versionArg) {
+                throw new InvalidCliOptionsError('--setup cannot be used with a version or bump argument.')
+            }
+
+            if (resumePending || discardPending) {
+                throw new InvalidCliOptionsError('--setup cannot be used with pending deployment snapshot flags.')
+            }
+
+            if (maintenanceMode !== null) {
+                throw new InvalidCliOptionsError('--setup cannot be used with --maintenance.')
+            }
+
+            if (autoCommit) {
+                throw new InvalidCliOptionsError('--setup cannot be used with --auto-commit.')
+            }
+
+            if (skipVersioning || skipChecks || skipTests || skipLint) {
+                throw new InvalidCliOptionsError('--setup cannot be used with deployment skip flags.')
+            }
+        }
+
         if (nonInteractive && !presetName) {
             throw new InvalidCliOptionsError('--non-interactive app deployments require --preset <name>.')
         }
     }
 
-    if (skipVersioning && options.versionArg) {
+    if (skipVersioning && versionArg) {
         throw new InvalidCliOptionsError('--skip-versioning cannot be used together with an explicit version or bump argument.')
     }
 }

package/src/main.mjs

@@ -17,6 +17,8 @@ import {createConfigurationService} from './application/configuration/service.mj
 import {selectDeploymentTarget} from './application/configuration/select-deployment-target.mjs'
 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'
 
@@ -31,7 +33,9 @@ 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,
             resumePending: firstArg.resumePending === true,
             discardPending: firstArg.discardPending === true,
@@ -44,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,
@@ -59,7 +79,9 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
         workflowType: firstArg ?? null,
         versionArg: secondArg ?? null,
         nonInteractive: false,
+        thenDeploy: null,
         json: false,
+        setup: false,
         presetName: null,
         resumePending: false,
         discardPending: false,
@@ -72,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,
@@ -127,6 +165,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         interactive: !options.nonInteractive,
         json: options.json === true && options.nonInteractive === true,
         workflow: resolveWorkflowName(options.workflowType),
+        setup: options.setup === true,
         presetName: options.presetName,
         maintenanceMode: options.maintenanceMode,
         autoCommit: options.autoCommit === true,
@@ -157,7 +196,8 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
     } = appContext
     let currentExecutionMode = {
         ...executionMode,
-        ...(appContext.executionMode ?? {})
+        ...(appContext.executionMode ?? {}),
+        setup: executionMode.setup === true || appContext.executionMode?.setup === true
     }
     appContext.executionMode = currentExecutionMode
     const configurationService = createConfigurationService(appContext)
@@ -171,6 +211,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                 data: {
                     version: ZEPHYR_VERSION,
                     workflow: currentExecutionMode.workflow,
+                    setup: currentExecutionMode.setup === true,
                     nonInteractive: currentExecutionMode.interactive === false,
                     presetName: currentExecutionMode.presetName,
                     maintenanceMode: currentExecutionMode.maintenanceMode,
@@ -198,9 +239,14 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             appContext
         })
 
+        if (currentExecutionMode.setup) {
+            await assertLaravelSetupProject(rootDir)
+        }
+
         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,
@@ -209,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: {
@@ -230,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: {
@@ -277,7 +351,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         const hasPackageJson = await fs.access(packageJsonPath).then(() => true).catch(() => false)
         const hasComposerJson = await fs.access(composerJsonPath).then(() => true).catch(() => false)
 
-        if (hasPackageJson || hasComposerJson) {
+        if (!currentExecutionMode.setup && (hasPackageJson || hasComposerJson)) {
             logProcessing('Validating dependencies...')
             await validateLocalDependencies(rootDir, runPrompt, logSuccess, {
                 interactive: currentExecutionMode.interactive,
@@ -292,7 +366,8 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             logSuccess,
             logWarning,
             emitEvent,
-            executionMode: currentExecutionMode
+            executionMode: currentExecutionMode,
+            promptPresetOptions: currentExecutionMode.setup !== true
         })
 
         if (presetState) {
@@ -308,12 +383,14 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             await presetState.applyExecutionMode(currentExecutionMode)
         }
 
-        const snapshotToUse = await resolvePendingSnapshot(rootDir, deploymentConfig, {
-            runPrompt,
-            logProcessing,
-            logWarning,
-            executionMode: currentExecutionMode
-        })
+        const snapshotToUse = currentExecutionMode.setup
+            ? null
+            : await resolvePendingSnapshot(rootDir, deploymentConfig, {
+                runPrompt,
+                logProcessing,
+                logWarning,
+                executionMode: currentExecutionMode
+            })
 
         await runRemoteTasks(deploymentConfig, {
             rootDir,

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,

package/src/runtime/app-context.mjs

@@ -22,6 +22,7 @@ export function createAppContext({
         interactive: executionMode.interactive !== false,
         json: executionMode.json === true,
         workflow: executionMode.workflow ?? 'deploy',
+        setup: executionMode.setup === true,
         presetName: executionMode.presetName ?? null,
         maintenanceMode: executionMode.maintenanceMode ?? null,
         autoCommit: executionMode.autoCommit === true,