@wyxos/zephyr 0.4.5 → 0.4.6

package/README.md

@@ -68,6 +68,8 @@ When `--type node` or `--type vue` is used without a bump argument, Zephyr defau
 
 Interactive mode remains the default and is the best fit for first-time setup, config repair, and one-off deployments.
 
+For app deployments, interactive mode now requires a real interactive terminal. If stdin/stdout are not attached to a TTY, Zephyr refuses to continue in interactive mode and tells you to rerun with --non-interactive --preset <name> --maintenance on|off.
+
 Non-interactive mode is strict and is intended for already-configured projects:
 
 - `--non-interactive` fails instead of prompting
@@ -77,6 +79,8 @@ Non-interactive mode is strict and is intended for already-configured projects:
 - stale remote locks are never auto-removed in non-interactive mode
 - `--json` is only supported together with `--non-interactive`
 
+If Laravel maintenance mode has already been enabled and Zephyr then exits abnormally because of a signal such as `SIGINT`, `SIGTERM`, or `SIGHUP`, it now makes a best-effort attempt to run `artisan up` automatically before exiting.
+
 If Zephyr would normally prompt to:
 
 - create or repair config

package/package.json

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

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

@@ -59,7 +59,9 @@ async function maybeRecoverLaravelMaintenanceMode({
     runPrompt,
     logProcessing,
     logWarning,
-    executionMode = {}
+    executionMode = {},
+    forceAutoRecovery = false,
+    reason = null
 } = {}) {
     if (!remotePlan?.remoteIsLaravel || !remotePlan?.maintenanceModeEnabled) {
         return
@@ -75,8 +77,11 @@ async function maybeRecoverLaravelMaintenanceMode({
     }
 
     try {
-        if (executionMode?.interactive === false) {
-            logProcessing?.('Deployment failed after Laravel maintenance mode was enabled. Running `artisan up` automatically...')
+        if (forceAutoRecovery || executionMode?.interactive === false) {
+            const reasonSuffix = typeof reason === 'string' && reason.length > 0
+                ? ` because of ${reason}`
+                : ''
+            logProcessing?.(`Deployment interrupted${reasonSuffix} after Laravel maintenance mode was enabled. Running \`artisan up\` automatically...`)
             await executeRemote(
                 'Disable Laravel maintenance mode',
                 remotePlan.maintenanceUpCommand ?? `${remotePlan.phpCommand} artisan up`
@@ -115,6 +120,129 @@ async function maybeRecoverLaravelMaintenanceMode({
     }
 }
 
+function signalToExitCode(signal) {
+    const signalNumbers = {
+        SIGHUP: 1,
+        SIGINT: 2,
+        SIGTERM: 15
+    }
+
+    if (!signalNumbers[signal]) {
+        return null
+    }
+
+    return 128 + signalNumbers[signal]
+}
+
+export function createAbnormalExitGuard({
+    processRef = process,
+    cleanup = async () => {},
+    terminate = null,
+    logWarning
+} = {}) {
+    const listeners = new Map()
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP']
+    let active = true
+    let cleanupPromise = null
+
+    const terminateProcess = typeof terminate === 'function'
+        ? terminate
+        : async (signal) => {
+            const exitCode = signalToExitCode(signal)
+
+            if (typeof exitCode === 'number') {
+                processRef.exitCode = exitCode
+            }
+
+            if (typeof processRef.kill === 'function' && typeof processRef.pid === 'number') {
+                processRef.kill(processRef.pid, signal)
+            }
+        }
+
+    const unregister = () => {
+        if (!active) {
+            return
+        }
+
+        active = false
+
+        for (const [signal, handler] of listeners.entries()) {
+            if (typeof processRef.off === 'function') {
+                processRef.off(signal, handler)
+                continue
+            }
+
+            if (typeof processRef.removeListener === 'function') {
+                processRef.removeListener(signal, handler)
+            }
+        }
+
+        listeners.clear()
+    }
+
+    const run = async (signal) => {
+        if (!active) {
+            return cleanupPromise
+        }
+
+        if (cleanupPromise) {
+            return cleanupPromise
+        }
+
+        unregister()
+        cleanupPromise = (async () => {
+            try {
+                await cleanup(signal)
+            } catch (error) {
+                logWarning?.(`Best-effort deploy recovery after ${signal} failed: ${error.message}`)
+            } finally {
+                await terminateProcess(signal)
+            }
+        })()
+
+        return cleanupPromise
+    }
+
+    for (const signal of signals) {
+        const handler = () => {
+            void run(signal)
+        }
+
+        listeners.set(signal, handler)
+        processRef.once(signal, handler)
+    }
+
+    return {
+        unregister,
+        run
+    }
+}
+
+async function cleanupDeploymentResources({
+    rootDir,
+    ssh,
+    remoteCwd,
+    lockAcquired,
+    logWarning
+} = {}) {
+    if (lockAcquired && ssh && remoteCwd) {
+        try {
+            await releaseRemoteLock(ssh, remoteCwd, {logWarning})
+            await releaseLocalLock(rootDir, {logWarning})
+        } catch (error) {
+            logWarning?.(`Failed to release lock: ${error.message}`)
+        }
+    }
+
+    await closeLogFile()
+
+    if (ssh) {
+        ssh.dispose()
+    }
+}
+
+export {maybeRecoverLaravelMaintenanceMode}
+
 export async function runDeployment(config, options = {}) {
     const {
         snapshot = null,
@@ -150,6 +278,64 @@ export async function runDeployment(config, options = {}) {
     }
 
     let lockAcquired = false
+    const abnormalExitGuard = createAbnormalExitGuard({
+        logWarning,
+        cleanup: async (signal) => {
+            let recoverySsh = null
+            let recoveryExecutor = executeRemote
+
+            try {
+                if (remoteCwd) {
+                    ({ssh: recoverySsh} = await connectToRemoteDeploymentTarget({
+                        config,
+                        createSshClient,
+                        sshUser,
+                        privateKey,
+                        remoteCwd,
+                        logProcessing,
+                        message: `Reconnecting to ${config.serverIp} as ${sshUser} for abnormal-exit recovery...`
+                    }))
+
+                    recoveryExecutor = createRemoteExecutor({
+                        ssh: recoverySsh,
+                        rootDir,
+                        remoteCwd,
+                        writeToLogFile,
+                        logProcessing,
+                        logSuccess,
+                        logError
+                    })
+                }
+
+                await maybeRecoverLaravelMaintenanceMode({
+                    remotePlan,
+                    executionState,
+                    executeRemote: recoveryExecutor,
+                    runPrompt,
+                    logProcessing,
+                    logWarning,
+                    executionMode,
+                    forceAutoRecovery: true,
+                    reason: signal
+                })
+            } finally {
+                await cleanupDeploymentResources({
+                    rootDir,
+                    ssh: recoverySsh ?? ssh,
+                    remoteCwd,
+                    lockAcquired,
+                    logWarning
+                })
+                lockAcquired = false
+
+                if (recoverySsh && ssh && recoverySsh !== ssh) {
+                    ssh.dispose()
+                }
+
+                ssh = null
+            }
+        }
+    })
 
     try {
         ({ssh, remoteCwd} = await connectToRemoteDeploymentTarget({
@@ -280,18 +466,13 @@ export async function runDeployment(config, options = {}) {
 
         throw new Error(`Deployment failed: ${error.message}`)
     } finally {
-        if (lockAcquired && ssh && remoteCwd) {
-            try {
-                await releaseRemoteLock(ssh, remoteCwd, {logWarning})
-                await releaseLocalLock(rootDir, {logWarning})
-            } catch (error) {
-                logWarning(`Failed to release lock: ${error.message}`)
-            }
-        }
-
-        await closeLogFile()
-        if (ssh) {
-            ssh.dispose()
-        }
+        abnormalExitGuard.unregister()
+        await cleanupDeploymentResources({
+            rootDir,
+            ssh,
+            remoteCwd,
+            lockAcquired,
+            logWarning
+        })
     }
 }

package/src/main.mjs

@@ -8,7 +8,7 @@ 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 {getErrorCode, ZephyrError} 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'
@@ -73,6 +73,23 @@ function resolveWorkflowName(workflowType = null) {
     return 'deploy'
 }
 
+function assertInteractiveAppDeploySession({workflowType = null, executionMode = {}, appContext = {}} = {}) {
+    const isAppDeploy = workflowType !== 'node' && workflowType !== 'vue' && workflowType !== 'packagist'
+
+    if (!isAppDeploy || executionMode?.interactive === false) {
+        return
+    }
+
+    if (appContext?.hasInteractiveTerminal !== false) {
+        return
+    }
+
+    throw new ZephyrError(
+        'Zephyr refuses interactive app deployments without a real interactive terminal. Rerun in a TTY, or use --non-interactive --preset <name> --maintenance on|off.',
+        {code: 'ZEPHYR_INTERACTIVE_SESSION_REQUIRED'}
+    )
+}
+
 async function runRemoteTasks(config, options = {}) {
     return await runDeployment(config, {
         ...options,
@@ -131,6 +148,12 @@ async function main(optionsOrWorkflowType = null, versionArg = null) {
             logWarning(SKIP_GIT_HOOKS_WARNING)
         }
 
+        assertInteractiveAppDeploySession({
+            workflowType: options.workflowType,
+            executionMode: currentExecutionMode,
+            appContext
+        })
+
         if (options.workflowType === 'node' || options.workflowType === 'vue') {
             await releaseNode({
                 releaseType: options.versionArg,

package/src/runtime/app-context.mjs

@@ -1,3 +1,4 @@
+import process from 'node:process'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
 import {NodeSSH} from 'node-ssh'
@@ -12,6 +13,7 @@ export function createAppContext({
                                      chalkInstance = chalk,
                                      inquirerInstance = inquirer,
                                      NodeSSHClass = NodeSSH,
+                                     processInstance = process,
                                      runCommandImpl = runCommandBase,
                                      runCommandCaptureImpl = runCommandCaptureBase,
                                      executionMode = {}
@@ -38,6 +40,7 @@ export function createAppContext({
         emitEvent,
         workflow: normalizedExecutionMode.workflow
     })
+    const hasInteractiveTerminal = Boolean(processInstance?.stdin?.isTTY && processInstance?.stdout?.isTTY)
     const createSshClient = createSshClientFactory({NodeSSH: NodeSSHClass})
     const {runCommand, runCommandCapture} = createLocalCommandRunners({
         runCommandBase: runCommandImpl,
@@ -59,6 +62,7 @@ export function createAppContext({
         runCommand: runCommandWithMode,
         runCommandCapture,
         emitEvent,
+        hasInteractiveTerminal,
         executionMode: normalizedExecutionMode
     }
 }