@wyxos/zephyr 0.9.12 → 0.9.14

package/README.md

@@ -52,6 +52,9 @@ zephyr minor --skip-checks
 # Deploy a configured app non-interactively
 zephyr --non-interactive --preset wyxos-release --maintenance off
 
+# Deploy several configured app presets as one grouped release
+zephyr --non-interactive --group "Development v1-v4" --maintenance off --skip-versioning
+
 # Configure a Laravel app target and verify SSH without deploying
 zephyr --setup
 
@@ -95,7 +98,7 @@ For app deployments, interactive mode now requires a real interactive terminal.
 Non-interactive mode is strict and is intended for already-configured projects:
 
 - `--non-interactive` fails instead of prompting
-- app deployments require `--preset <name>`
+- app deployments require `--preset <name>` or `--group <name>`
 - Laravel app deployments require either a saved preset maintenance preference, `--maintenance on|off`, or a resumable snapshot that already contains the choice
 - pending deployment snapshots require either `--resume-pending` or `--discard-pending`
 - stale remote locks are never auto-removed in non-interactive mode
@@ -133,6 +136,12 @@ Recommended pattern for app deployments:
 zephyr --non-interactive --json --preset wyxos-release --maintenance off
 ```
 
+Recommended pattern for grouped app deployments:
+
+```bash
+zephyr --non-interactive --json --group "Development v1-v4" --maintenance off --skip-versioning
+```
+
 Recommended pattern for package releases:
 
 ```bash
@@ -270,12 +279,22 @@ Deployment targets are stored per-project at `.zephyr/config.json`:
       "sshUser": "forge",
       "sshKey": "~/.ssh/id_rsa"
     }
+  ],
+  "groups": [
+    {
+      "name": "Production targets",
+      "presets": [
+        "prod-main"
+      ]
+    }
   ]
 }
 ```
 
 Preset `options` capture repeatable deploy behavior so Zephyr can reuse the same maintenance, dirty-tree, and deploy-check preferences on later runs.
 
+Deployment `groups` run the named presets in order. Zephyr performs local dependency validation once before the group starts, and after the first successful target for a branch it skips local checks and versioning for later targets on that same branch. Targets on a different branch are prepared separately.
+
 ### Project Directory Structure
 
 Zephyr creates a `.zephyr/` directory in your project with:

package/package.json

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

package/src/application/configuration/deployment-groups.mjs

@@ -0,0 +1,68 @@
+import {loadProjectConfig} from '../../config/project.mjs'
+import {loadServers} from '../../config/servers.mjs'
+import {ZephyrError} from '../../runtime/errors.mjs'
+
+export function findDeploymentGroupByName(projectConfig, groupName) {
+    const groups = projectConfig?.groups ?? []
+    return groups.find((group) => group?.name === groupName) ?? null
+}
+
+export function resolveDeploymentGroupPresetNames(projectConfig, groupName) {
+    const group = findDeploymentGroupByName(projectConfig, groupName)
+
+    if (!group) {
+        throw new ZephyrError(
+            `Zephyr cannot run deployment group "${groupName}" because it was not found in .zephyr/config.json.`,
+            {code: 'ZEPHYR_DEPLOYMENT_GROUP_NOT_FOUND'}
+        )
+    }
+
+    const presetNames = Array.isArray(group.presets)
+        ? group.presets.filter((presetName) => typeof presetName === 'string' && presetName.trim().length > 0)
+        : []
+
+    if (presetNames.length === 0) {
+        throw new ZephyrError(
+            `Zephyr cannot run deployment group "${groupName}" because it has no presets.`,
+            {code: 'ZEPHYR_DEPLOYMENT_GROUP_INVALID'}
+        )
+    }
+
+    const configuredPresetNames = new Set((projectConfig?.presets ?? []).map((preset) => preset?.name).filter(Boolean))
+    const missingPresetName = presetNames.find((presetName) => !configuredPresetNames.has(presetName))
+
+    if (missingPresetName) {
+        throw new ZephyrError(
+            `Zephyr cannot run deployment group "${groupName}" because preset "${missingPresetName}" was not found in .zephyr/config.json.`,
+            {code: 'ZEPHYR_DEPLOYMENT_GROUP_INVALID'}
+        )
+    }
+
+    return presetNames
+}
+
+export async function resolveDeploymentGroup(rootDir, {
+    groupName,
+    logSuccess,
+    logWarning,
+    strict = true,
+    allowMigration = false
+} = {}) {
+    const servers = await loadServers({
+        logSuccess,
+        logWarning,
+        strict,
+        allowMigration
+    })
+    const projectConfig = await loadProjectConfig(rootDir, servers, {
+        logSuccess,
+        logWarning,
+        strict,
+        allowMigration
+    })
+
+    return {
+        name: groupName,
+        presetNames: resolveDeploymentGroupPresetNames(projectConfig, groupName)
+    }
+}

package/src/application/deploy/run-local-deployment-checks.mjs

@@ -1,6 +1,6 @@
 import * as localRepo from '../../deploy/local-repo.mjs'
 import * as preflight from '../../deploy/preflight.mjs'
-import {commandExists} from '../../utils/command.mjs'
+import {commandExists, formatCommandError} from '../../utils/command.mjs'
 
 async function getGitStatus(rootDir, {runCommandCapture} = {}) {
     return await localRepo.getGitStatus(rootDir, {runCommandCapture})
@@ -98,7 +98,7 @@ async function runLocalLaravelBuild(rootDir, {runCommand, logProcessing, logSucc
             )
         }
 
-        throw new Error(`Local frontend build failed. Fix build failures before deploying.\n${error.message}`)
+        throw new Error(`Local frontend build failed. Fix build failures before deploying.\n${formatCommandError(error)}`)
     }
 }
 
@@ -106,7 +106,7 @@ async function runLocalLaravelTests(rootDir, {runCommand, logProcessing, logSucc
     logProcessing?.('Running Laravel tests locally...')
 
     try {
-        await runCommand(testCommand.command, testCommand.args, {cwd: rootDir})
+        await runCommand(testCommand.command, testCommand.args, {cwd: rootDir, capture: true})
         logSuccess?.('Local tests passed.')
     } catch (error) {
         if (error.code === 'ENOENT') {
@@ -116,7 +116,7 @@ async function runLocalLaravelTests(rootDir, {runCommand, logProcessing, logSucc
             )
         }
 
-        throw new Error(`Local tests failed. Fix test failures before deploying.\n${error.message}`)
+        throw new Error(`Local tests failed. Fix test failures before deploying.\n${formatCommandError(error)}`)
     }
 }
 

package/src/application/deploy/run-preset-deployment.mjs

@@ -0,0 +1,118 @@
+import {mergeDeployOptions} from '../../config/preset-options.mjs'
+import {selectDeploymentTarget} from '../configuration/select-deployment-target.mjs'
+import {resolvePendingSnapshot} from './resolve-pending-snapshot.mjs'
+import {runDeployment} from './run-deployment.mjs'
+
+async function runRemoteTasks(config, options = {}) {
+    return await runDeployment(config, {
+        ...options,
+        context: options.context
+    })
+}
+
+function mergePresetExecutionMode(executionMode, presetState) {
+    if (!presetState) {
+        return executionMode
+    }
+
+    const effectiveDeployOptions = mergeDeployOptions(executionMode, presetState.options)
+
+    return {
+        ...executionMode,
+        presetName: presetState.name,
+        ...effectiveDeployOptions,
+        skipChecks: executionMode.skipChecks === true ||
+            (effectiveDeployOptions.skipTests === true && effectiveDeployOptions.skipLint === true)
+    }
+}
+
+function reusePreparedBranchExecutionMode(executionMode, deploymentConfig, preparedBranches, logProcessing) {
+    if (!preparedBranches?.has(deploymentConfig.branch)) {
+        return executionMode
+    }
+
+    logProcessing?.(
+        `Reusing completed local preparation for branch ${deploymentConfig.branch}; skipping local checks and versioning for this target.`
+    )
+
+    return {
+        ...executionMode,
+        skipChecks: true,
+        skipTests: true,
+        skipLint: true,
+        skipVersioning: true
+    }
+}
+
+export async function runPresetDeployment({
+    rootDir,
+    configurationService,
+    appContext,
+    runPrompt,
+    logProcessing,
+    logSuccess,
+    logWarning,
+    emitEvent,
+    baseExecutionMode,
+    presetName,
+    versionArg,
+    preparedBranches = null
+} = {}) {
+    let targetExecutionMode = {
+        ...baseExecutionMode,
+        presetName
+    }
+    appContext.executionMode = targetExecutionMode
+
+    const {deploymentConfig, presetState} = await selectDeploymentTarget(rootDir, {
+        configurationService,
+        runPrompt,
+        logProcessing,
+        logSuccess,
+        logWarning,
+        emitEvent,
+        executionMode: targetExecutionMode,
+        promptPresetOptions: targetExecutionMode.setup !== true
+    })
+
+    targetExecutionMode = mergePresetExecutionMode(targetExecutionMode, presetState)
+    appContext.executionMode = targetExecutionMode
+
+    if (presetState) {
+        await presetState.applyExecutionMode(targetExecutionMode)
+    }
+
+    targetExecutionMode = reusePreparedBranchExecutionMode(
+        targetExecutionMode,
+        deploymentConfig,
+        preparedBranches,
+        logProcessing
+    )
+    appContext.executionMode = targetExecutionMode
+
+    const snapshotToUse = targetExecutionMode.setup
+        ? null
+        : await resolvePendingSnapshot(rootDir, deploymentConfig, {
+            runPrompt,
+            logProcessing,
+            logWarning,
+            executionMode: targetExecutionMode
+        })
+
+    const deploymentOptions = {
+        rootDir,
+        snapshot: snapshotToUse,
+        versionArg,
+        context: appContext
+    }
+
+    if (presetState !== undefined) {
+        deploymentOptions.presetState = presetState
+    }
+
+    await runRemoteTasks(deploymentConfig, deploymentOptions)
+
+    preparedBranches?.add(deploymentConfig.branch)
+
+    return targetExecutionMode
+}

package/src/cli/options.mjs

@@ -42,6 +42,7 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         .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('--group <name>', 'Deployment group name to run multiple app deployment presets in sequence.')
         .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).')
@@ -87,6 +88,7 @@ export function parseCliOptions(args = process.argv.slice(2)) {
         json: Boolean(options.json),
         setup: Boolean(options.setup),
         presetName: options.preset ?? null,
+        groupName: options.group ?? null,
         resumePending: Boolean(options.resumePending),
         discardPending: Boolean(options.discardPending),
         maintenanceMode: normalizeMaintenanceMode(options.maintenance),
@@ -132,6 +134,7 @@ export function validateCliOptions(options = {}) {
         setup = false,
         thenDeploy = null,
         presetName = null,
+        groupName = null,
         resumePending = false,
         discardPending = false,
         maintenanceMode = null,
@@ -198,6 +201,10 @@ export function validateCliOptions(options = {}) {
             throw new InvalidCliOptionsError('--preset is only valid for app deployments.')
         }
 
+        if (groupName) {
+            throw new InvalidCliOptionsError('--group is only valid for app deployments.')
+        }
+
         if (resumePending || discardPending) {
             throw new InvalidCliOptionsError('--resume-pending and --discard-pending are only valid for app deployments.')
         }
@@ -210,11 +217,19 @@ export function validateCliOptions(options = {}) {
             throw new InvalidCliOptionsError('--skip-build and --skip-deploy are only valid for node/vue release workflows.')
         }
 
+        if (presetName && groupName) {
+            throw new InvalidCliOptionsError('Use either --preset <name> or --group <name>, not both.')
+        }
+
         if (setup) {
             if (versionArg) {
                 throw new InvalidCliOptionsError('--setup cannot be used with a version or bump argument.')
             }
 
+            if (groupName) {
+                throw new InvalidCliOptionsError('--setup cannot be used with --group.')
+            }
+
             if (resumePending || discardPending) {
                 throw new InvalidCliOptionsError('--setup cannot be used with pending deployment snapshot flags.')
             }
@@ -232,8 +247,8 @@ export function validateCliOptions(options = {}) {
             }
         }
 
-        if (nonInteractive && !presetName) {
-            throw new InvalidCliOptionsError('--non-interactive app deployments require --preset <name>.')
+        if (nonInteractive && !presetName && !groupName) {
+            throw new InvalidCliOptionsError('--non-interactive app deployments require --preset <name> or --group <name>.')
         }
     }
 

package/src/config/project.mjs

@@ -105,6 +105,43 @@ export function migratePresets(presets, apps) {
   return { presets: migrated, needsMigration }
 }
 
+export function migrateGroups(groups) {
+  if (!Array.isArray(groups)) {
+    return { groups: [], needsMigration: false }
+  }
+
+  let needsMigration = false
+  const migrated = groups.flatMap((group) => {
+    if (!group || typeof group !== 'object') {
+      needsMigration = true
+      return []
+    }
+
+    const name = typeof group.name === 'string' ? group.name.trim() : ''
+    const rawPresets = Array.isArray(group.presets)
+      ? group.presets
+      : Array.isArray(group.presetNames)
+        ? group.presetNames
+        : []
+    const presets = rawPresets
+      .map((presetName) => typeof presetName === 'string' ? presetName.trim() : '')
+      .filter((presetName) => presetName.length > 0)
+
+    if (!name || presets.length === 0) {
+      needsMigration = true
+      return []
+    }
+
+    if (name !== group.name || !Array.isArray(group.presets) || presets.length !== rawPresets.length) {
+      needsMigration = true
+    }
+
+    return [{ name, presets }]
+  })
+
+  return { groups: migrated, needsMigration }
+}
+
 export async function loadProjectConfig(rootDir, servers = [], {
   logSuccess,
   logWarning,
@@ -118,11 +155,13 @@ export async function loadProjectConfig(rootDir, servers = [], {
     const data = JSON.parse(raw)
     const apps = Array.isArray(data?.apps) ? data.apps : []
     const presets = Array.isArray(data?.presets) ? data.presets : []
+    const groups = Array.isArray(data?.groups) ? data.groups : []
 
     const { apps: migratedApps, needsMigration: appsNeedMigration } = migrateApps(apps, servers)
     const { presets: migratedPresets, needsMigration: presetsNeedMigration } = migratePresets(presets, migratedApps)
+    const { groups: migratedGroups, needsMigration: groupsNeedMigration } = migrateGroups(groups)
 
-    if (appsNeedMigration || presetsNeedMigration) {
+    if (appsNeedMigration || presetsNeedMigration || groupsNeedMigration) {
       if (!allowMigration) {
         throw new ZephyrError(
           'Zephyr cannot run non-interactively because .zephyr/config.json needs migration. Rerun interactively once to update the config.',
@@ -132,12 +171,13 @@ export async function loadProjectConfig(rootDir, servers = [], {
 
       await saveProjectConfig(rootDir, {
         apps: migratedApps,
-        presets: migratedPresets
+        presets: migratedPresets,
+        groups: migratedGroups
       })
       logSuccess?.('Migrated project configuration to use unique IDs.')
     }
 
-    return { apps: migratedApps, presets: migratedPresets }
+    return { apps: migratedApps, presets: migratedPresets, groups: migratedGroups }
   } catch (error) {
     if (error.code === 'ENOENT') {
       if (strict) {
@@ -147,7 +187,7 @@ export async function loadProjectConfig(rootDir, servers = [], {
         )
       }
 
-      return { apps: [], presets: [] }
+      return { apps: [], presets: [], groups: [] }
     }
 
     if (error instanceof ZephyrError) {
@@ -162,19 +202,24 @@ export async function loadProjectConfig(rootDir, servers = [], {
     }
 
     logWarning?.('Failed to read .zephyr/config.json, starting with an empty list of apps.')
-    return { apps: [], presets: [] }
+    return { apps: [], presets: [], groups: [] }
   }
 }
 
 export async function saveProjectConfig(rootDir, config) {
   const configDir = getProjectConfigDir(rootDir)
   await ensureDirectory(configDir)
+  const payloadData = {
+    apps: config.apps ?? [],
+    presets: config.presets ?? []
+  }
+
+  if (Array.isArray(config.groups) && config.groups.length > 0) {
+    payloadData.groups = config.groups
+  }
 
   const payload = JSON.stringify(
-    {
-      apps: config.apps ?? [],
-      presets: config.presets ?? []
-    },
+    payloadData,
     null,
     2
   )

package/src/deploy/local-repo.mjs

@@ -1,6 +1,7 @@
 import { getCurrentBranch as getCurrentBranchImpl, getUpstreamRef as getUpstreamRefImpl } from '../utils/git.mjs'
 import {hasPrePushHook} from './preflight.mjs'
 import {gitCommitArgs, gitPushArgs} from '../utils/git-hooks.mjs'
+import {formatCommandError} from '../utils/command.mjs'
 import {
   formatWorkingTreePreview,
   parseWorkingTreeEntries,
@@ -207,6 +208,13 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
     await runCommand(command, args, { cwd })
     return undefined
   }
+  const runCapturedCommand = async (command, args) => {
+    try {
+      await runCommand(command, args, {cwd: rootDir, capture: true})
+    } catch (error) {
+      throw new Error(formatCommandError(error))
+    }
+  }
 
   const suggestedCommitMessage = await suggestCommitMessage(rootDir, {
     runCommand: captureAwareRunCommand,
@@ -244,10 +252,10 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
   }
 
   logProcessing?.('Staging all pending changes before deployment...')
-  await runCommand('git', ['add', '-A'], { cwd: rootDir })
+  await runCapturedCommand('git', ['add', '-A'])
 
   logProcessing?.('Committing pending changes before deployment...')
-  await runCommand('git', gitCommitArgs(['-m', message], {skipGitHooks}), { cwd: rootDir })
+  await runCapturedCommand('git', gitCommitArgs(['-m', message], {skipGitHooks}))
 
   const prePushHookPresent = await hasPrePushHook(rootDir)
   if (prePushHookPresent) {
@@ -259,10 +267,10 @@ async function commitAndPushPendingChanges(targetBranch, rootDir, {
   }
 
   try {
-    await runCommand('git', gitPushArgs(['origin', targetBranch], {skipGitHooks}), { cwd: rootDir })
+    await runCapturedCommand('git', gitPushArgs(['origin', targetBranch], {skipGitHooks}))
   } catch (error) {
     if (prePushHookPresent) {
-      throw new Error(`Git push failed while the pre-push hook was running. See hook output above.\n${error.message}`)
+      throw new Error(`Git push failed while the pre-push hook was running.\n${error.message}`)
     }
 
     throw error

package/src/deploy/preflight.mjs

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import {gitCommitArgs} from '../utils/git-hooks.mjs'
+import {formatCommandError} from '../utils/command.mjs'
 
 export async function hasPrePushHook(rootDir) {
   const hookPaths = [
@@ -137,14 +138,22 @@ export async function runLinting(rootDir, {
 
   if (selectedLintCommand.type === 'npm') {
     logProcessing?.('Running npm lint...')
-    await runCommand(selectedLintCommand.command, selectedLintCommand.args, { cwd: rootDir })
+    try {
+      await runCommand(selectedLintCommand.command, selectedLintCommand.args, {cwd: rootDir, capture: true})
+    } catch (error) {
+      throw new Error(`Linting failed. Fix lint failures before deploying.\n${formatCommandError(error)}`)
+    }
     logSuccess?.('Linting completed.')
     return true
   }
 
   if (selectedLintCommand.type === 'pint') {
     logProcessing?.('Running Laravel Pint...')
-    await runCommand(selectedLintCommand.command, selectedLintCommand.args, { cwd: rootDir })
+    try {
+      await runCommand(selectedLintCommand.command, selectedLintCommand.args, {cwd: rootDir, capture: true})
+    } catch (error) {
+      throw new Error(`Laravel Pint failed. Fix formatting failures before deploying.\n${formatCommandError(error)}`)
+    }
     logSuccess?.('Linting completed.')
     return true
   }
@@ -166,7 +175,7 @@ export async function runBuild(rootDir, {
   }
 
   logProcessing?.('Running local frontend build...')
-  await runCommand(selectedBuildCommand.command, selectedBuildCommand.args, {cwd: rootDir})
+  await runCommand(selectedBuildCommand.command, selectedBuildCommand.args, {cwd: rootDir, capture: true})
   logSuccess?.('Local frontend build completed.')
   return true
 }

package/src/main.mjs

@@ -11,12 +11,10 @@ import * as bootstrap from './project/bootstrap.mjs'
 import {getErrorCode, ZephyrError} from './runtime/errors.mjs'
 import {PROJECT_CONFIG_DIR} from './utils/paths.mjs'
 import {writeStderrLine} from './utils/output.mjs'
-import {mergeDeployOptions} from './config/preset-options.mjs'
 import {createAppContext} from './runtime/app-context.mjs'
 import {createConfigurationService} from './application/configuration/service.mjs'
-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 {resolveDeploymentGroup} from './application/configuration/deployment-groups.mjs'
+import {runPresetDeployment} from './application/deploy/run-preset-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'
@@ -49,6 +47,7 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
             json: firstArg.json === true,
             setup: firstArg.setup === true,
             presetName: firstArg.presetName ?? null,
+            groupName: firstArg.groupName ?? null,
             resumePending: firstArg.resumePending === true,
             discardPending: firstArg.discardPending === true,
             maintenanceMode: firstArg.maintenanceMode ?? null,
@@ -95,6 +94,7 @@ function normalizeMainOptions(firstArg = null, secondArg = null) {
         json: false,
         setup: false,
         presetName: null,
+        groupName: null,
         resumePending: false,
         discardPending: false,
         maintenanceMode: null,
@@ -162,13 +162,6 @@ function assertInteractiveAppDeploySession({workflowType = null, executionMode =
     )
 }
 
-async function runRemoteTasks(config, options = {}) {
-    return await runDeployment(config, {
-        ...options,
-        context: options.context
-    })
-}
-
 async function main(optionsOrWorkflowType = null, versionArg = null) {
     const options = normalizeMainOptions(optionsOrWorkflowType, versionArg)
     const rootDir = process.cwd()
@@ -179,6 +172,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
         workflow: resolveWorkflowName(options.workflowType),
         setup: options.setup === true,
         presetName: options.presetName,
+        groupName: options.groupName,
         maintenanceMode: options.maintenanceMode,
         autoCommit: options.autoCommit === true,
         skipVersioning: options.skipVersioning === true,
@@ -226,6 +220,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
                     setup: currentExecutionMode.setup === true,
                     nonInteractive: currentExecutionMode.interactive === false,
                     presetName: currentExecutionMode.presetName,
+                    groupName: currentExecutionMode.groupName,
                     maintenanceMode: currentExecutionMode.maintenanceMode,
                     autoCommit: currentExecutionMode.autoCommit === true,
                     skipVersioning: currentExecutionMode.skipVersioning === true,
@@ -371,59 +366,65 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             })
         }
 
-        const {deploymentConfig, presetState} = await selectDeploymentTarget(rootDir, {
-            configurationService,
-            runPrompt,
-            logProcessing,
-            logSuccess,
-            logWarning,
-            emitEvent,
-            executionMode: currentExecutionMode,
-            promptPresetOptions: currentExecutionMode.setup !== true
-        })
-
-        if (presetState) {
-            const effectiveDeployOptions = mergeDeployOptions(currentExecutionMode, presetState.options)
-            currentExecutionMode = {
-                ...currentExecutionMode,
-                presetName: presetState.name,
-                ...effectiveDeployOptions,
-                skipChecks: currentExecutionMode.skipChecks === true ||
-                    (effectiveDeployOptions.skipTests === true && effectiveDeployOptions.skipLint === true)
+        if (currentExecutionMode.groupName) {
+            const deploymentGroup = await resolveDeploymentGroup(rootDir, {
+                groupName: currentExecutionMode.groupName,
+                logSuccess,
+                logWarning,
+                strict: currentExecutionMode.interactive === false,
+                allowMigration: currentExecutionMode.interactive !== false
+            })
+            const preparedBranches = new Set()
+            const baseGroupExecutionMode = {...currentExecutionMode}
+
+            logProcessing?.(`Running deployment group "${deploymentGroup.name}" with ${deploymentGroup.presetNames.length} presets.`)
+
+            for (const [index, presetName] of deploymentGroup.presetNames.entries()) {
+                logProcessing?.(`\nDeploying group target ${index + 1}/${deploymentGroup.presetNames.length}: ${presetName}`)
+                currentExecutionMode = await runPresetDeployment({
+                    rootDir,
+                    configurationService,
+                    appContext,
+                    runPrompt,
+                    logProcessing,
+                    logSuccess,
+                    logWarning,
+                    emitEvent,
+                    baseExecutionMode: baseGroupExecutionMode,
+                    presetName,
+                    versionArg: options.versionArg,
+                    preparedBranches
+                })
             }
-            appContext.executionMode = currentExecutionMode
-            await presetState.applyExecutionMode(currentExecutionMode)
-        }
-
-        const snapshotToUse = currentExecutionMode.setup
-            ? null
-            : await resolvePendingSnapshot(rootDir, deploymentConfig, {
+        } else {
+            currentExecutionMode = await runPresetDeployment({
+                rootDir,
+                configurationService,
+                appContext,
                 runPrompt,
                 logProcessing,
+                logSuccess,
                 logWarning,
-                executionMode: currentExecutionMode
+                emitEvent,
+                baseExecutionMode: currentExecutionMode,
+                presetName: currentExecutionMode.presetName,
+                versionArg: options.versionArg
             })
-
-        await runRemoteTasks(deploymentConfig, {
-            rootDir,
-            snapshot: snapshotToUse,
-            versionArg: options.versionArg,
-            context: appContext,
-            presetState
-        })
+        }
 
         emitEvent?.('run_completed', {
             message: 'Zephyr workflow completed successfully.',
             data: {
                 version: ZEPHYR_VERSION,
-                workflow: currentExecutionMode.workflow
+                workflow: currentExecutionMode.workflow,
+                groupName: currentExecutionMode.groupName
             }
         })
         if (!currentExecutionMode.json) {
             await notifyWorkflowResult({
                 status: 'success',
                 workflow: currentExecutionMode.workflow,
-                presetName: currentExecutionMode.presetName,
+                presetName: currentExecutionMode.groupName ?? currentExecutionMode.presetName,
                 rootDir
             })
         }
@@ -446,7 +447,7 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             await notifyWorkflowResult({
                 status: 'failure',
                 workflow: currentExecutionMode.workflow,
-                presetName: currentExecutionMode.presetName,
+                presetName: currentExecutionMode.groupName ?? currentExecutionMode.presetName,
                 rootDir,
                 message: error.message
             })
@@ -456,4 +457,4 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
     }
 }
 
-export {main, runRemoteTasks}
+export {main}

package/src/utils/command.mjs

@@ -12,12 +12,11 @@ export function commandExists(command) {
   const resolvedCommand = resolveCommandForPlatform(command)
 
   // On Windows, use 'where', on Unix use 'which'
-  const checker = DEFAULT_IS_WINDOWS ? 'where' : 'which'
+  const checker = DEFAULT_IS_WINDOWS ? 'where.exe' : 'which'
 
   try {
     const result = spawnSync(checker, [resolvedCommand], {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      shell: DEFAULT_IS_WINDOWS
+      stdio: ['ignore', 'pipe', 'ignore']
     })
     return result.status === 0
   } catch {
@@ -67,7 +66,11 @@ function quoteForCmd(arg) {
   return value
 }
 
-export async function runCommand(command, args, { cwd = process.cwd(), stdio = 'inherit' } = {}) {
+export async function runCommand(command, args, { cwd = process.cwd(), stdio = 'inherit', capture = false } = {}) {
+  if (capture) {
+    return runCommandCapture(command, args, {cwd})
+  }
+
   const resolvedCommand = resolveCommandForPlatform(command)
   const useShell = isWindowsShellShim(resolvedCommand) || shouldUseShellOnWindows(command)
 
@@ -152,3 +155,23 @@ export async function runCommandCapture(command, args, { cwd = process.cwd() } =
   })
 }
 
+export function formatCapturedCommandOutput(error) {
+  const sections = [
+    ['stdout', error?.stdout],
+    ['stderr', error?.stderr]
+  ]
+    .map(([label, value]) => {
+      const text = typeof value === 'string' ? value.trim() : ''
+      return text ? `[${label}]\n${text}` : null
+    })
+    .filter(Boolean)
+
+  return sections.join('\n')
+}
+
+export function formatCommandError(error) {
+  const message = error?.message ?? String(error)
+  const output = formatCapturedCommandOutput(error)
+
+  return output ? `${message}\n${output}` : message
+}