@wyxos/zephyr 0.2.27 → 0.3.0

package/src/application/configuration/service.mjs

@@ -0,0 +1,109 @@
+import {
+    ensureSshDetails as ensureSshDetailsBase,
+    promptSshDetails as promptSshDetailsBase
+} from '../../ssh/keys.mjs'
+import {saveProjectConfig} from '../../config/project.mjs'
+import {saveServers} from '../../config/servers.mjs'
+import {generateId} from '../../utils/id.mjs'
+import {defaultProjectPath, listGitBranches, promptAppDetails} from './app-details.mjs'
+import {selectApp} from './app-selection.mjs'
+import {selectPreset} from './preset-selection.mjs'
+import {promptServerDetails, selectServer} from './server-selection.mjs'
+
+export {
+    defaultProjectPath,
+    listGitBranches,
+    promptAppDetails,
+    promptServerDetails,
+    selectServer,
+    selectApp,
+    selectPreset
+}
+
+function assertConfigurationDeps({
+                                     runPrompt,
+                                     runCommandCapture,
+                                     logProcessing,
+                                     logSuccess,
+                                     logWarning
+                                 } = {}) {
+    if (!runPrompt || !runCommandCapture || !logProcessing || !logSuccess || !logWarning) {
+        throw new Error('createConfigurationService requires prompt, command, and logger dependencies.')
+    }
+}
+
+export function createConfigurationService(deps = {}) {
+    assertConfigurationDeps(deps)
+
+    const {
+        runPrompt,
+        runCommandCapture,
+        logProcessing,
+        logSuccess,
+        logWarning
+    } = deps
+
+    const listBranches = (currentDir) => listGitBranches({
+        currentDir,
+        runCommandCapture,
+        logWarning
+    })
+
+    const promptSshDetails = (currentDir, existing = {}) => promptSshDetailsBase(currentDir, existing, {
+        runPrompt
+    })
+
+    const promptServerDetailsBound = (existingServers = []) => promptServerDetails({
+        existingServers,
+        runPrompt
+    })
+
+    const promptAppDetailsBound = (currentDir, existing = {}) => promptAppDetails({
+        currentDir,
+        existing,
+        runPrompt,
+        listGitBranches: listBranches,
+        resolveDefaultProjectPath: defaultProjectPath,
+        promptSshDetails
+    })
+
+    return {
+        ensureSshDetails(config, currentDir) {
+            return ensureSshDetailsBase(config, currentDir, {runPrompt, logProcessing})
+        },
+
+        selectServer(servers) {
+            return selectServer({
+                servers,
+                runPrompt,
+                logProcessing,
+                logSuccess,
+                persistServers: saveServers,
+                promptServerDetails: promptServerDetailsBound
+            })
+        },
+
+        selectApp(projectConfig, server, currentDir) {
+            return selectApp({
+                projectConfig,
+                server,
+                currentDir,
+                runPrompt,
+                logWarning,
+                logProcessing,
+                logSuccess,
+                persistProjectConfig: saveProjectConfig,
+                createId: generateId,
+                promptAppDetails: promptAppDetailsBound
+            })
+        },
+
+        selectPreset(projectConfig, servers) {
+            return selectPreset({
+                projectConfig,
+                servers,
+                runPrompt
+            })
+        }
+    }
+}

package/src/application/deploy/build-remote-deployment-plan.mjs

@@ -0,0 +1,174 @@
+import {findPhpBinary} from '../../infrastructure/php/version.mjs'
+import {planLaravelDeploymentTasks} from './plan-laravel-deployment-tasks.mjs'
+
+async function detectRemoteLaravelProject(ssh, remoteCwd) {
+    const laravelCheck = await ssh.execCommand(
+        'if [ -f artisan ] && [ -f composer.json ] && grep -q "laravel/framework" composer.json; then echo "yes"; else echo "no"; fi',
+        {cwd: remoteCwd}
+    )
+
+    return laravelCheck.stdout.trim() === 'yes'
+}
+
+async function collectChangedFiles({
+                                       config,
+                                       snapshot,
+                                       remoteIsLaravel,
+                                       executeRemote,
+                                       logProcessing
+                                   } = {}) {
+    if (snapshot?.changedFiles) {
+        logProcessing?.('Resuming deployment with saved task snapshot.')
+        return snapshot.changedFiles
+    }
+
+    if (!remoteIsLaravel) {
+        return []
+    }
+
+    await executeRemote(`Fetch latest changes for ${config.branch}`, `git fetch origin ${config.branch}`)
+
+    const diffResult = await executeRemote(
+        'Inspect pending changes',
+        `git diff --name-only HEAD..origin/${config.branch}`,
+        {printStdout: false}
+    )
+
+    const changedFiles = diffResult.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+
+    if (changedFiles.length > 0) {
+        const preview = changedFiles
+            .slice(0, 20)
+            .map((file) => ` - ${file}`)
+            .join('\n')
+
+        logProcessing?.(
+            `Detected ${changedFiles.length} changed file(s):\n${preview}${changedFiles.length > 20 ? '\n - ...' : ''}`
+        )
+    } else {
+        logProcessing?.('No upstream file changes detected.')
+    }
+
+    return changedFiles
+}
+
+async function detectHorizonConfiguration({
+                                              ssh,
+                                              remoteCwd,
+                                              remoteIsLaravel,
+                                              changedFiles
+                                          } = {}) {
+    const hasPhpChanges = remoteIsLaravel && changedFiles.some((file) => file.endsWith('.php'))
+
+    if (!hasPhpChanges) {
+        return false
+    }
+
+    const horizonCheck = await ssh.execCommand(
+        'if [ -f config/horizon.php ]; then echo "yes"; else echo "no"; fi',
+        {cwd: remoteCwd}
+    )
+
+    return horizonCheck.stdout.trim() === 'yes'
+}
+
+async function resolvePhpCommand({
+                                     requiredPhpVersion,
+                                     ssh,
+                                     remoteCwd,
+                                     logProcessing,
+                                     logWarning
+                                 } = {}) {
+    if (!requiredPhpVersion) {
+        return 'php'
+    }
+
+    try {
+        const phpCommand = await findPhpBinary(ssh, remoteCwd, requiredPhpVersion)
+        if (phpCommand !== 'php') {
+            logProcessing?.(`Detected PHP requirement: ${requiredPhpVersion}, using ${phpCommand}`)
+        }
+
+        return phpCommand
+    } catch (error) {
+        logWarning?.(`Could not find PHP binary for version ${requiredPhpVersion}: ${error.message}`)
+        return 'php'
+    }
+}
+
+export async function buildRemoteDeploymentPlan({
+                                                    config,
+                                                    snapshot = null,
+                                                    requiredPhpVersion = null,
+                                                    ssh,
+                                                    remoteCwd,
+                                                    executeRemote,
+                                                    logProcessing,
+                                                    logSuccess,
+                                                    logWarning
+                                                } = {}) {
+    const remoteIsLaravel = await detectRemoteLaravelProject(ssh, remoteCwd)
+
+    if (remoteIsLaravel) {
+        logSuccess?.('Laravel project detected.')
+    } else {
+        logWarning?.('Laravel project not detected; skipping Laravel-specific maintenance tasks.')
+    }
+
+    const changedFiles = await collectChangedFiles({
+        config,
+        snapshot,
+        remoteIsLaravel,
+        executeRemote,
+        logProcessing
+    })
+
+    const horizonConfigured = await detectHorizonConfiguration({
+        ssh,
+        remoteCwd,
+        remoteIsLaravel,
+        changedFiles
+    })
+
+    const phpCommand = await resolvePhpCommand({
+        requiredPhpVersion,
+        ssh,
+        remoteCwd,
+        logProcessing,
+        logWarning
+    })
+
+    const steps = planLaravelDeploymentTasks({
+        branch: config.branch,
+        isLaravel: remoteIsLaravel,
+        changedFiles,
+        horizonConfigured,
+        phpCommand
+    })
+
+    const usefulSteps = steps.length > 1
+    const pendingSnapshot = !usefulSteps
+        ? null
+        : snapshot ?? {
+        serverName: config.serverName,
+        branch: config.branch,
+        projectPath: config.projectPath,
+        sshUser: config.sshUser,
+        createdAt: new Date().toISOString(),
+        changedFiles,
+        taskLabels: steps.map((step) => step.label)
+    }
+
+    return {
+        remoteIsLaravel,
+        changedFiles,
+        horizonConfigured,
+        phpCommand,
+        steps,
+        usefulSteps,
+        pendingSnapshot
+    }
+}

package/src/application/deploy/bump-local-package-version.mjs

@@ -0,0 +1,81 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import {commandExists} from '../../utils/command.mjs'
+
+async function readPackageJson(rootDir) {
+    const packageJsonPath = path.join(rootDir, 'package.json')
+    const raw = await fs.readFile(packageJsonPath, 'utf8')
+    return JSON.parse(raw)
+}
+
+async function isGitIgnored(rootDir, filePath, {runCommand} = {}) {
+    try {
+        await runCommand('git', ['check-ignore', '-q', filePath], {cwd: rootDir})
+        return true
+    } catch {
+        return false
+    }
+}
+
+export async function bumpLocalPackageVersion(rootDir, {
+    versionArg = null,
+    runCommand,
+    logProcessing,
+    logSuccess,
+    logWarning
+} = {}) {
+    if (!commandExists('npm')) {
+        logWarning?.('npm is not available in PATH. Skipping npm version bump.')
+        return null
+    }
+
+    let pkg
+    try {
+        pkg = await readPackageJson(rootDir)
+    } catch {
+        return null
+    }
+
+    if (!pkg?.version) {
+        return null
+    }
+
+    const releaseValue = (versionArg && String(versionArg).trim().length > 0)
+        ? String(versionArg).trim()
+        : 'patch'
+
+    logProcessing?.(`Bumping npm package version (${releaseValue})...`)
+    await runCommand('npm', ['version', releaseValue, '--no-git-tag-version', '--force'], {cwd: rootDir})
+
+    const updatedPkg = await readPackageJson(rootDir)
+    const nextVersion = updatedPkg?.version ?? pkg.version
+    const didVersionChange = nextVersion !== pkg.version
+
+    const filesToStage = ['package.json']
+    const packageLockPath = path.join(rootDir, 'package-lock.json')
+
+    try {
+        await fs.access(packageLockPath)
+        const ignored = await isGitIgnored(rootDir, 'package-lock.json', {runCommand})
+        if (!ignored) {
+            filesToStage.push('package-lock.json')
+        }
+    } catch {
+        // package-lock.json does not exist
+    }
+
+    await runCommand('git', ['add', ...filesToStage], {cwd: rootDir})
+
+    if (!didVersionChange) {
+        logWarning?.('Version did not change after npm version. Skipping version commit.')
+        return updatedPkg
+    }
+
+    await runCommand('git', ['commit', '-m', `chore: bump version to ${nextVersion}`, '--', ...filesToStage], {
+        cwd: rootDir
+    })
+    logSuccess?.(`Version updated to ${nextVersion}.`)
+
+    return updatedPkg
+}

package/src/application/deploy/execute-remote-deployment-plan.mjs

@@ -0,0 +1,61 @@
+import {clearPendingTasksSnapshot, savePendingTasksSnapshot} from '../../deploy/snapshots.mjs'
+import {PENDING_TASKS_FILE} from '../../utils/paths.mjs'
+
+async function persistPendingSnapshot(rootDir, pendingSnapshot, executeRemote) {
+    await savePendingTasksSnapshot(rootDir, pendingSnapshot)
+
+    const payload = Buffer.from(JSON.stringify(pendingSnapshot)).toString('base64')
+    await executeRemote(
+        'Record pending deployment tasks',
+        `mkdir -p .zephyr && echo '${payload}' | base64 --decode > .zephyr/${PENDING_TASKS_FILE}`,
+        {printStdout: false}
+    )
+}
+
+function logScheduledTasks(steps, {logProcessing} = {}) {
+    if (steps.length === 1) {
+        logProcessing?.('No additional maintenance tasks scheduled beyond git pull.')
+        return
+    }
+
+    const extraTasks = steps
+        .slice(1)
+        .map((step) => step.label)
+        .join(', ')
+
+    logProcessing?.(`Additional tasks scheduled: ${extraTasks}`)
+}
+
+export async function executeRemoteDeploymentPlan({
+                                                      rootDir,
+                                                      executeRemote,
+                                                      steps,
+                                                      usefulSteps,
+                                                      pendingSnapshot = null,
+                                                      logProcessing
+                                                  } = {}) {
+    if (usefulSteps && pendingSnapshot) {
+        await persistPendingSnapshot(rootDir, pendingSnapshot, executeRemote)
+    }
+
+    logScheduledTasks(steps, {logProcessing})
+
+    let completed = false
+
+    try {
+        for (const step of steps) {
+            await executeRemote(step.label, step.command)
+        }
+
+        completed = true
+    } finally {
+        if (usefulSteps && completed) {
+            await executeRemote(
+                'Clear pending deployment snapshot',
+                `rm -f .zephyr/${PENDING_TASKS_FILE}`,
+                {printStdout: false, allowFailure: true}
+            )
+            await clearPendingTasksSnapshot(rootDir)
+        }
+    }
+}

package/src/{utils/task-planner.mjs → application/deploy/plan-laravel-deployment-tasks.mjs}

@@ -52,10 +52,12 @@ export function planLaravelDeploymentTasks({
 
   if (shouldRunComposer) {
     // Composer is a PHP script, so we need to run it with the correct PHP version
-    // Try composer.phar first, then system composer, ensuring it uses the correct PHP
+    // Deployments should be lockfile-based and reproducible.
+    // `composer update --no-dev` still resolves require-dev and can fail on production PHP versions.
+    // Prefer `composer install --no-dev` and fail loudly if composer.lock is missing.
     steps.push({
-      label: 'Update Composer dependencies',
-      command: `if [ -f composer.phar ]; then ${phpCommand} composer.phar update --no-dev --no-interaction --prefer-dist; elif command -v composer >/dev/null 2>&1; then ${phpCommand} $(command -v composer) update --no-dev --no-interaction --prefer-dist; else ${phpCommand} composer update --no-dev --no-interaction --prefer-dist; fi`
+      label: 'Install Composer dependencies',
+      command: `if [ ! -f composer.lock ]; then echo "composer.lock is missing; commit composer.lock for reproducible deploys." >&2; exit 1; fi; if [ -f composer.phar ]; then ${phpCommand} composer.phar install --no-dev --no-interaction --prefer-dist --optimize-autoloader; elif command -v composer >/dev/null 2>&1; then ${phpCommand} $(command -v composer) install --no-dev --no-interaction --prefer-dist --optimize-autoloader; else ${phpCommand} composer install --no-dev --no-interaction --prefer-dist --optimize-autoloader; fi`
     })
   }
 
@@ -96,4 +98,3 @@ export function planLaravelDeploymentTasks({
 
   return steps
 }
-

package/src/application/deploy/prepare-local-deployment.mjs

@@ -0,0 +1,52 @@
+import process from 'node:process'
+
+import {ensureLocalRepositoryState} from '../../deploy/local-repo.mjs'
+import {bumpLocalPackageVersion} from './bump-local-package-version.mjs'
+import {resolveLocalDeploymentContext} from './resolve-local-deployment-context.mjs'
+import {runLocalDeploymentChecks} from './run-local-deployment-checks.mjs'
+
+export async function prepareLocalDeployment(config, {
+    snapshot = null,
+    rootDir = process.cwd(),
+    versionArg = null,
+    runPrompt,
+    runCommand,
+    runCommandCapture,
+    logProcessing,
+    logSuccess,
+    logWarning
+} = {}) {
+    const context = await resolveLocalDeploymentContext(rootDir)
+
+    if (!snapshot && context.isLaravel) {
+        await bumpLocalPackageVersion(rootDir, {
+            versionArg,
+            runCommand,
+            logProcessing,
+            logSuccess,
+            logWarning
+        })
+    }
+
+    await ensureLocalRepositoryState(config.branch, rootDir, {
+        runPrompt,
+        runCommand,
+        runCommandCapture,
+        logProcessing,
+        logSuccess,
+        logWarning
+    })
+
+    await runLocalDeploymentChecks({
+        rootDir,
+        isLaravel: context.isLaravel,
+        hasHook: context.hasHook,
+        runCommand,
+        runCommandCapture,
+        logProcessing,
+        logSuccess,
+        logWarning
+    })
+
+    return context
+}

package/src/application/deploy/resolve-local-deployment-context.mjs

@@ -0,0 +1,17 @@
+import * as preflight from '../../deploy/preflight.mjs'
+import {getPhpVersionRequirement} from '../../infrastructure/php/version.mjs'
+
+export async function resolveLocalDeploymentContext(rootDir) {
+    let requiredPhpVersion = null
+
+    try {
+        requiredPhpVersion = await getPhpVersionRequirement(rootDir)
+    } catch {
+        // composer.json might not exist or be unreadable
+    }
+
+    const isLaravel = await preflight.isLocalLaravelProject(rootDir)
+    const hasHook = await preflight.hasPrePushHook(rootDir)
+
+    return {requiredPhpVersion, isLaravel, hasHook}
+}

package/src/application/deploy/resolve-pending-snapshot.mjs

@@ -0,0 +1,45 @@
+import {clearPendingTasksSnapshot, loadPendingTasksSnapshot} from '../../deploy/snapshots.mjs'
+
+export async function resolvePendingSnapshot(rootDir, deploymentConfig, {
+    runPrompt,
+    logProcessing,
+    logWarning
+} = {}) {
+    const existingSnapshot = await loadPendingTasksSnapshot(rootDir)
+
+    if (!existingSnapshot) {
+        return null
+    }
+
+    const matchesSelection =
+        existingSnapshot.serverName === deploymentConfig.serverName &&
+        existingSnapshot.branch === deploymentConfig.branch
+
+    const messageLines = [
+        'Pending deployment tasks were detected from a previous run.',
+        `Server: ${existingSnapshot.serverName}`,
+        `Branch: ${existingSnapshot.branch}`
+    ]
+
+    if (existingSnapshot.taskLabels && existingSnapshot.taskLabels.length > 0) {
+        messageLines.push(`Tasks: ${existingSnapshot.taskLabels.join(', ')}`)
+    }
+
+    const {resumePendingTasks} = await runPrompt([
+        {
+            type: 'confirm',
+            name: 'resumePendingTasks',
+            message: `${messageLines.join(' | ')}. Resume using this plan?`,
+            default: matchesSelection
+        }
+    ])
+
+    if (resumePendingTasks) {
+        logProcessing?.('Resuming deployment using saved task snapshot...')
+        return existingSnapshot
+    }
+
+    await clearPendingTasksSnapshot(rootDir)
+    logWarning?.('Discarded pending deployment snapshot.')
+    return null
+}