@wyxos/zephyr 0.3.4 → 0.4.1

package/src/config/project.mjs

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises'
 
+import {ZephyrError} from '../runtime/errors.mjs'
 import { ensureDirectory, getProjectConfigDir, getProjectConfigPath } from '../utils/paths.mjs'
 import { generateId } from '../utils/id.mjs'
 
@@ -69,7 +70,12 @@ export function migratePresets(presets, apps) {
   return { presets: migrated, needsMigration }
 }
 
-export async function loadProjectConfig(rootDir, servers = [], { logSuccess, logWarning } = {}) {
+export async function loadProjectConfig(rootDir, servers = [], {
+  logSuccess,
+  logWarning,
+  strict = false,
+  allowMigration = true
+} = {}) {
   const configPath = getProjectConfigPath(rootDir)
 
   try {
@@ -82,6 +88,13 @@ export async function loadProjectConfig(rootDir, servers = [], { logSuccess, log
     const { presets: migratedPresets, needsMigration: presetsNeedMigration } = migratePresets(presets, migratedApps)
 
     if (appsNeedMigration || presetsNeedMigration) {
+      if (!allowMigration) {
+        throw new ZephyrError(
+          'Zephyr cannot run non-interactively because .zephyr/config.json needs migration. Rerun interactively once to update the config.',
+          {code: 'ZEPHYR_PROJECT_CONFIG_MIGRATION_REQUIRED'}
+        )
+      }
+
       await saveProjectConfig(rootDir, {
         apps: migratedApps,
         presets: migratedPresets
@@ -92,9 +105,27 @@ export async function loadProjectConfig(rootDir, servers = [], { logSuccess, log
     return { apps: migratedApps, presets: migratedPresets }
   } catch (error) {
     if (error.code === 'ENOENT') {
+      if (strict) {
+        throw new ZephyrError(
+          'Zephyr cannot run non-interactively because .zephyr/config.json does not exist. Run an interactive deployment first to create it.',
+          {code: 'ZEPHYR_PROJECT_CONFIG_MISSING'}
+        )
+      }
+
       return { apps: [], presets: [] }
     }
 
+    if (error instanceof ZephyrError) {
+      throw error
+    }
+
+    if (strict) {
+      throw new ZephyrError(
+        'Zephyr cannot run non-interactively because .zephyr/config.json could not be read.',
+        {code: 'ZEPHYR_PROJECT_CONFIG_INVALID', cause: error}
+      )
+    }
+
     logWarning?.('Failed to read .zephyr/config.json, starting with an empty list of apps.')
     return { apps: [], presets: [] }
   }

package/src/config/servers.mjs

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
+import {ZephyrError} from '../runtime/errors.mjs'
 import { ensureDirectory } from '../utils/paths.mjs'
 import { generateId } from '../utils/id.mjs'
 
@@ -25,7 +26,12 @@ export function migrateServers(servers) {
   return { servers: migrated, needsMigration }
 }
 
-export async function loadServers({ logSuccess, logWarning } = {}) {
+export async function loadServers({
+  logSuccess,
+  logWarning,
+  strict = false,
+  allowMigration = true
+} = {}) {
   try {
     const raw = await fs.readFile(SERVERS_FILE, 'utf8')
     const data = JSON.parse(raw)
@@ -34,6 +40,13 @@ export async function loadServers({ logSuccess, logWarning } = {}) {
     const { servers: migrated, needsMigration } = migrateServers(servers)
 
     if (needsMigration) {
+      if (!allowMigration) {
+        throw new ZephyrError(
+          'Zephyr cannot run non-interactively because ~/.config/zephyr/servers.json needs migration. Rerun interactively once to update the config.',
+          {code: 'ZEPHYR_SERVERS_CONFIG_MIGRATION_REQUIRED'}
+        )
+      }
+
       await saveServers(migrated)
       logSuccess?.('Migrated servers configuration to use unique IDs.')
     }
@@ -41,9 +54,27 @@ export async function loadServers({ logSuccess, logWarning } = {}) {
     return migrated
   } catch (error) {
     if (error.code === 'ENOENT') {
+      if (strict) {
+        throw new ZephyrError(
+          'Zephyr cannot run non-interactively because ~/.config/zephyr/servers.json does not exist. Run an interactive deployment first to create it.',
+          {code: 'ZEPHYR_SERVERS_CONFIG_MISSING'}
+        )
+      }
+
       return []
     }
 
+    if (error instanceof ZephyrError) {
+      throw error
+    }
+
+    if (strict) {
+      throw new ZephyrError(
+        'Zephyr cannot run non-interactively because ~/.config/zephyr/servers.json could not be read.',
+        {code: 'ZEPHYR_SERVERS_CONFIG_INVALID', cause: error}
+      )
+    }
+
     logWarning?.('Failed to read servers.json, starting with an empty list.')
     return []
   }
@@ -54,4 +85,3 @@ export async function saveServers(servers) {
   const payload = JSON.stringify(servers, null, 2)
   await fs.writeFile(SERVERS_FILE, `${payload}\n`)
 }
-

package/src/dependency-scanner.mjs

@@ -2,6 +2,7 @@ import { readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import process from 'node:process'
 import chalk from 'chalk'
+import {ZephyrError} from './runtime/errors.mjs'
 import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
 
 function isLocalPathOutsideRepo(depPath, rootDir) {
@@ -262,7 +263,9 @@ async function commitDependencyUpdates(rootDir, updatedFiles, promptFn, logFn) {
   return true
 }
 
-async function validateLocalDependencies(rootDir, promptFn, logFn = null) {
+async function validateLocalDependencies(rootDir, promptFn, logFn = null, {
+  interactive = true
+} = {}) {
   const packageDeps = await scanPackageJsonDependencies(rootDir)
   const composerDeps = await scanComposerJsonDependencies(rootDir)
 
@@ -308,6 +311,13 @@ async function validateLocalDependencies(rootDir, promptFn, logFn = null) {
   const countText = allDeps.length === 1 ? 'dependency' : 'dependencies'
   const promptMessage = `Found ${countColored} local file ${countText} pointing outside the repository:\n\n${messages.join('\n\n')}\n\nUpdate to latest version?`
 
+  if (!interactive) {
+    throw new ZephyrError(
+      'Zephyr cannot run non-interactively because local file dependencies point outside the repository and require confirmation to update.',
+      {code: 'ZEPHYR_DEPENDENCY_UPDATE_REQUIRED'}
+    )
+  }
+
   // Prompt user
   const { shouldUpdate } = await promptFn([
     {

package/src/deploy/locks.mjs

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises'
 import os from 'node:os'
 import process from 'node:process'
 
+import {ZephyrError} from '../runtime/errors.mjs'
 import { PROJECT_LOCK_FILE, ensureDirectory, getLockFilePath, getProjectConfigDir } from '../utils/paths.mjs'
 
 function createLockPayload() {
@@ -67,7 +68,26 @@ export async function readRemoteLock(ssh, remoteCwd) {
   return null
 }
 
-export async function compareLocksAndPrompt(rootDir, ssh, remoteCwd, { runPrompt, logWarning } = {}) {
+function parseLockDetails(rawContent = '') {
+  try {
+    return JSON.parse(rawContent.trim())
+  } catch (_error) {
+    return { raw: rawContent.trim() }
+  }
+}
+
+function formatLockHolder(details = {}) {
+  const startedBy = details.user ? `${details.user}@${details.hostname ?? 'unknown'}` : 'unknown user'
+  const startedAt = details.startedAt ? ` at ${details.startedAt}` : ''
+
+  return { startedBy, startedAt }
+}
+
+export async function compareLocksAndPrompt(rootDir, ssh, remoteCwd, {
+  runPrompt,
+  logWarning,
+  interactive = true
+} = {}) {
   const localLock = await readLocalLock(rootDir)
   const remoteLock = await readRemoteLock(ssh, remoteCwd)
 
@@ -79,8 +99,15 @@ export async function compareLocksAndPrompt(rootDir, ssh, remoteCwd, { runPrompt
   const remoteKey = `${remoteLock.user}@${remoteLock.hostname}:${remoteLock.pid}:${remoteLock.startedAt}`
 
   if (localKey === remoteKey) {
-    const startedBy = remoteLock.user ? `${remoteLock.user}@${remoteLock.hostname ?? 'unknown'}` : 'unknown user'
-    const startedAt = remoteLock.startedAt ? ` at ${remoteLock.startedAt}` : ''
+    const { startedBy, startedAt } = formatLockHolder(remoteLock)
+
+    if (!interactive) {
+      throw new ZephyrError(
+        `Stale deployment lock detected on the server (started by ${startedBy}${startedAt}). Remove ${remoteCwd}/.zephyr/${PROJECT_LOCK_FILE} manually before rerunning with --non-interactive.`,
+        {code: 'ZEPHYR_STALE_REMOTE_LOCK'}
+      )
+    }
+
     const { shouldRemove } = await runPrompt([
       {
         type: 'confirm',
@@ -103,7 +130,11 @@ export async function compareLocksAndPrompt(rootDir, ssh, remoteCwd, { runPrompt
   return false
 }
 
-export async function acquireRemoteLock(ssh, remoteCwd, rootDir, { runPrompt, logWarning } = {}) {
+export async function acquireRemoteLock(ssh, remoteCwd, rootDir, {
+  runPrompt,
+  logWarning,
+  interactive = true
+} = {}) {
   const lockPath = `.zephyr/${PROJECT_LOCK_FILE}`
   const escapedLockPath = lockPath.replace(/'/g, "'\\''")
   const checkCommand = `mkdir -p .zephyr && if [ -f '${escapedLockPath}' ]; then cat '${escapedLockPath}'; else echo "LOCK_NOT_FOUND"; fi`
@@ -113,31 +144,17 @@ export async function acquireRemoteLock(ssh, remoteCwd, rootDir, { runPrompt, lo
   if (checkResult.stdout && checkResult.stdout.trim() !== 'LOCK_NOT_FOUND' && checkResult.stdout.trim() !== '') {
     const localLock = await readLocalLock(rootDir)
     if (localLock) {
-      const removed = await compareLocksAndPrompt(rootDir, ssh, remoteCwd, { runPrompt, logWarning })
+      const removed = await compareLocksAndPrompt(rootDir, ssh, remoteCwd, { runPrompt, logWarning, interactive })
       if (!removed) {
-        let details = {}
-        try {
-          details = JSON.parse(checkResult.stdout.trim())
-        } catch (_error) {
-          details = { raw: checkResult.stdout.trim() }
-        }
-
-        const startedBy = details.user ? `${details.user}@${details.hostname ?? 'unknown'}` : 'unknown user'
-        const startedAt = details.startedAt ? ` at ${details.startedAt}` : ''
+        const details = parseLockDetails(checkResult.stdout.trim())
+        const { startedBy, startedAt } = formatLockHolder(details)
         throw new Error(
           `Another deployment is currently in progress on the server (started by ${startedBy}${startedAt}). Remove ${remoteCwd}/${lockPath} if you are sure it is stale.`
         )
       }
     } else {
-      let details = {}
-      try {
-        details = JSON.parse(checkResult.stdout.trim())
-      } catch (_error) {
-        details = { raw: checkResult.stdout.trim() }
-      }
-
-      const startedBy = details.user ? `${details.user}@${details.hostname ?? 'unknown'}` : 'unknown user'
-      const startedAt = details.startedAt ? ` at ${details.startedAt}` : ''
+      const details = parseLockDetails(checkResult.stdout.trim())
+      const { startedBy, startedAt } = formatLockHolder(details)
       throw new Error(
         `Another deployment is currently in progress on the server (started by ${startedBy}${startedAt}). Remove ${remoteCwd}/${lockPath} if you are sure it is stale.`
       )
@@ -168,4 +185,3 @@ export async function releaseRemoteLock(ssh, remoteCwd, { logWarning } = {}) {
     logWarning?.(`Failed to remove lock file: ${result.stderr}`)
   }
 }
-

package/src/main.mjs

@@ -3,10 +3,12 @@ import {createRequire} from 'node:module'
 import path from 'node:path'
 import process from 'node:process'
 
+import {validateCliOptions} from './cli/options.mjs'
 import {releaseNode} from './release-node.mjs'
 import {releasePackagist} from './release-packagist.mjs'
 import {validateLocalDependencies} from './dependency-scanner.mjs'
 import * as bootstrap from './project/bootstrap.mjs'
+import {getErrorCode} from './runtime/errors.mjs'
 import {PROJECT_CONFIG_DIR} from './utils/paths.mjs'
 import {writeStderrLine} from './utils/output.mjs'
 import {createAppContext} from './runtime/app-context.mjs'
@@ -20,97 +22,223 @@ const RELEASE_SCRIPT_COMMAND = 'npx @wyxos/zephyr@latest'
 const require = createRequire(import.meta.url)
 const {version: ZEPHYR_VERSION} = require('../package.json')
 
-const appContext = createAppContext()
-const {
-    logProcessing,
-    logSuccess,
-    logWarning,
-    logError,
-    runPrompt,
-    runCommand
-} = appContext
-const configurationService = createConfigurationService(appContext)
+function normalizeMainOptions(firstArg = null, secondArg = null) {
+    if (firstArg && typeof firstArg === 'object' && !Array.isArray(firstArg)) {
+        return {
+            workflowType: firstArg.workflowType ?? firstArg.type ?? null,
+            versionArg: firstArg.versionArg ?? null,
+            nonInteractive: firstArg.nonInteractive === true,
+            json: firstArg.json === true,
+            presetName: firstArg.presetName ?? null,
+            resumePending: firstArg.resumePending === true,
+            discardPending: firstArg.discardPending === true,
+            maintenanceMode: firstArg.maintenanceMode ?? null,
+            skipTests: firstArg.skipTests === true,
+            skipLint: firstArg.skipLint === true,
+            skipBuild: firstArg.skipBuild === true,
+            skipDeploy: firstArg.skipDeploy === true,
+            context: firstArg.context ?? null
+        }
+    }
+
+    return {
+        workflowType: firstArg ?? null,
+        versionArg: secondArg ?? null,
+        nonInteractive: false,
+        json: false,
+        presetName: null,
+        resumePending: false,
+        discardPending: false,
+        maintenanceMode: null,
+        skipTests: false,
+        skipLint: false,
+        skipBuild: false,
+        skipDeploy: false,
+        context: null
+    }
+}
+
+function resolveWorkflowName(workflowType = null) {
+    if (workflowType === 'node' || workflowType === 'vue') {
+        return `release-${workflowType}`
+    }
+
+    if (workflowType === 'packagist') {
+        return 'release-packagist'
+    }
+
+    return 'deploy'
+}
 
 async function runRemoteTasks(config, options = {}) {
     return await runDeployment(config, {
         ...options,
-        context: options.context ?? appContext
+        context: options.context
     })
 }
 
-async function main(releaseType = null, versionArg = null) {
-    logProcessing(`Zephyr v${ZEPHYR_VERSION}`)
+async function main(optionsOrWorkflowType = null, versionArg = null) {
+    const options = normalizeMainOptions(optionsOrWorkflowType, versionArg)
+
+    const executionMode = {
+        interactive: !options.nonInteractive,
+        json: options.json === true && options.nonInteractive === true,
+        workflow: resolveWorkflowName(options.workflowType),
+        presetName: options.presetName,
+        maintenanceMode: options.maintenanceMode,
+        resumePending: options.resumePending,
+        discardPending: options.discardPending
+    }
+    const appContext = options.context ?? createAppContext({executionMode})
+    const {
+        logProcessing,
+        logSuccess,
+        logWarning,
+        logError,
+        runPrompt,
+        runCommand,
+        emitEvent
+    } = appContext
+    const currentExecutionMode = appContext.executionMode ?? executionMode
+    const configurationService = createConfigurationService(appContext)
+
+    try {
+        validateCliOptions(options)
+
+        if (currentExecutionMode.json) {
+            emitEvent?.('run_started', {
+                message: `Zephyr v${ZEPHYR_VERSION} starting`,
+                data: {
+                    version: ZEPHYR_VERSION,
+                    workflow: currentExecutionMode.workflow,
+                    nonInteractive: currentExecutionMode.interactive === false,
+                    presetName: currentExecutionMode.presetName,
+                    maintenanceMode: currentExecutionMode.maintenanceMode,
+                    resumePending: currentExecutionMode.resumePending,
+                    discardPending: currentExecutionMode.discardPending
+                }
+            })
+        } else {
+            logProcessing(`Zephyr v${ZEPHYR_VERSION}`)
+        }
 
-    if (releaseType === 'node' || releaseType === 'vue') {
-        try {
-            await releaseNode()
+        if (options.workflowType === 'node' || options.workflowType === 'vue') {
+            await releaseNode({
+                releaseType: options.versionArg,
+                skipTests: options.skipTests,
+                skipLint: options.skipLint,
+                skipBuild: options.skipBuild,
+                skipDeploy: options.skipDeploy,
+                context: appContext
+            })
+            emitEvent?.('run_completed', {
+                message: 'Zephyr workflow completed successfully.',
+                data: {
+                    version: ZEPHYR_VERSION,
+                    workflow: currentExecutionMode.workflow
+                }
+            })
             return
-        } catch (error) {
-            logError('\nRelease failed:')
-            logError(error.message)
-            if (error.stack) {
-                writeStderrLine(error.stack)
-            }
-            process.exit(1)
         }
-    }
 
-    if (releaseType === 'packagist') {
-        try {
-            await releasePackagist()
+        if (options.workflowType === 'packagist') {
+            await releasePackagist({
+                releaseType: options.versionArg,
+                skipTests: options.skipTests,
+                skipLint: options.skipLint,
+                context: appContext
+            })
+            emitEvent?.('run_completed', {
+                message: 'Zephyr workflow completed successfully.',
+                data: {
+                    version: ZEPHYR_VERSION,
+                    workflow: currentExecutionMode.workflow
+                }
+            })
             return
-        } catch (error) {
-            logError('\nRelease failed:')
-            logError(error.message)
-            if (error.stack) {
-                writeStderrLine(error.stack)
-            }
-            process.exit(1)
         }
-    }
 
-    const rootDir = process.cwd()
+        const rootDir = process.cwd()
 
-    await bootstrap.ensureGitignoreEntry(rootDir, {
-        projectConfigDir: PROJECT_CONFIG_DIR,
-        runCommand,
-        logSuccess,
-        logWarning
-    })
-    await bootstrap.ensureProjectReleaseScript(rootDir, {
-        runPrompt,
-        runCommand,
-        logSuccess,
-        logWarning,
-        releaseScriptName: RELEASE_SCRIPT_NAME,
-        releaseScriptCommand: RELEASE_SCRIPT_COMMAND
-    })
+        await bootstrap.ensureGitignoreEntry(rootDir, {
+            projectConfigDir: PROJECT_CONFIG_DIR,
+            runCommand,
+            logSuccess,
+            logWarning
+        })
+        await bootstrap.ensureProjectReleaseScript(rootDir, {
+            runPrompt,
+            runCommand,
+            logSuccess,
+            logWarning,
+            interactive: currentExecutionMode.interactive,
+            releaseScriptName: RELEASE_SCRIPT_NAME,
+            releaseScriptCommand: RELEASE_SCRIPT_COMMAND
+        })
 
-    const packageJsonPath = path.join(rootDir, 'package.json')
-    const composerJsonPath = path.join(rootDir, 'composer.json')
-    const hasPackageJson = await fs.access(packageJsonPath).then(() => true).catch(() => false)
-    const hasComposerJson = await fs.access(composerJsonPath).then(() => true).catch(() => false)
+        const packageJsonPath = path.join(rootDir, 'package.json')
+        const composerJsonPath = path.join(rootDir, 'composer.json')
+        const hasPackageJson = await fs.access(packageJsonPath).then(() => true).catch(() => false)
+        const hasComposerJson = await fs.access(composerJsonPath).then(() => true).catch(() => false)
 
-    if (hasPackageJson || hasComposerJson) {
-        logProcessing('Validating dependencies...')
-        await validateLocalDependencies(rootDir, runPrompt, logSuccess)
-    }
+        if (hasPackageJson || hasComposerJson) {
+            logProcessing('Validating dependencies...')
+            await validateLocalDependencies(rootDir, runPrompt, logSuccess, {
+                interactive: currentExecutionMode.interactive
+            })
+        }
 
-    const {deploymentConfig} = await selectDeploymentTarget(rootDir, {
-        configurationService,
-        runPrompt,
-        logProcessing,
-        logSuccess,
-        logWarning
-    })
+        const {deploymentConfig} = await selectDeploymentTarget(rootDir, {
+            configurationService,
+            runPrompt,
+            logProcessing,
+            logSuccess,
+            logWarning,
+            emitEvent,
+            executionMode: currentExecutionMode
+        })
 
-    const snapshotToUse = await resolvePendingSnapshot(rootDir, deploymentConfig, {
-        runPrompt,
-        logProcessing,
-        logWarning
-    })
+        const snapshotToUse = await resolvePendingSnapshot(rootDir, deploymentConfig, {
+            runPrompt,
+            logProcessing,
+            logWarning,
+            executionMode: currentExecutionMode
+        })
+
+        await runRemoteTasks(deploymentConfig, {
+            rootDir,
+            snapshot: snapshotToUse,
+            versionArg: options.versionArg,
+            context: appContext
+        })
+
+        emitEvent?.('run_completed', {
+            message: 'Zephyr workflow completed successfully.',
+            data: {
+                version: ZEPHYR_VERSION,
+                workflow: currentExecutionMode.workflow
+            }
+        })
+    } catch (error) {
+        const errorCode = getErrorCode(error)
+        emitEvent?.('run_failed', {
+            message: error.message,
+            code: errorCode,
+            data: {
+                version: ZEPHYR_VERSION,
+                workflow: currentExecutionMode.workflow
+            }
+        })
 
-    await runRemoteTasks(deploymentConfig, {rootDir, snapshot: snapshotToUse, versionArg})
+        if (!currentExecutionMode.json) {
+            logError(error.message)
+            if (errorCode === 'ZEPHYR_FAILURE' && error.stack) {
+                writeStderrLine(error.stack)
+            }
+        }
+
+        throw error
+    }
 }
 
 export {main, runRemoteTasks}

package/src/project/bootstrap.mjs

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
+import {ZephyrError} from '../runtime/errors.mjs'
+
 export async function ensureGitignoreEntry(rootDir, {
   projectConfigDir = '.zephyr',
   runCommand,
@@ -66,6 +68,7 @@ export async function ensureProjectReleaseScript(rootDir, {
   runCommand,
   logSuccess,
   logWarning,
+  interactive = true,
   releaseScriptName = 'release',
   releaseScriptCommand = 'npx @wyxos/zephyr@latest'
 } = {}) {
@@ -96,6 +99,13 @@ export async function ensureProjectReleaseScript(rootDir, {
     return false
   }
 
+  if (!interactive) {
+    throw new ZephyrError(
+      'Zephyr cannot run non-interactively because package.json is missing the Zephyr release script. Add `"release": "npx @wyxos/zephyr@latest"` and rerun.',
+      {code: 'ZEPHYR_RELEASE_SCRIPT_REQUIRED'}
+    )
+  }
+
   const { installReleaseScript } = await runPrompt([
     {
       type: 'confirm',
@@ -144,4 +154,3 @@ export async function ensureProjectReleaseScript(rootDir, {
 
   return true
 }
-

package/src/release/shared.mjs

@@ -65,14 +65,23 @@ export function parseReleaseArgs({
 
 export async function runReleaseCommand(command, args, {
   cwd = process.cwd(),
-  capture = false
+  capture = false,
+  runCommandImpl = runCommandBase,
+  runCommandCaptureImpl = runCommandCaptureBase
 } = {}) {
   if (capture) {
-    const { stdout, stderr } = await runCommandCaptureBase(command, args, { cwd })
+    const captured = await runCommandCaptureImpl(command, args, { cwd })
+
+    if (typeof captured === 'string') {
+      return { stdout: captured.trim(), stderr: '' }
+    }
+
+    const stdout = captured?.stdout ?? ''
+    const stderr = captured?.stderr ?? ''
     return { stdout: stdout.trim(), stderr: stderr.trim() }
   }
 
-  await runCommandBase(command, args, { cwd })
+  await runCommandImpl(command, args, { cwd })
   return undefined
 }
 
@@ -91,9 +100,10 @@ export async function ensureCleanWorkingTree(rootDir = process.cwd(), {
 
 export async function validateReleaseDependencies(rootDir = process.cwd(), {
   prompt = (questions) => inquirer.prompt(questions),
-  logSuccess
+  logSuccess,
+  interactive = true
 } = {}) {
-  await validateLocalDependencies(rootDir, prompt, logSuccess)
+  await validateLocalDependencies(rootDir, prompt, logSuccess, { interactive })
 }
 
 export async function ensureReleaseBranchReady({