@wyxos/zephyr 0.2.31 → 0.3.0

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

@@ -0,0 +1,147 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import process from 'node:process'
+
+import {
+    acquireRemoteLock,
+    compareLocksAndPrompt,
+    releaseLocalLock,
+    releaseRemoteLock
+} from '../../deploy/locks.mjs'
+import {createRemoteExecutor} from '../../deploy/remote-exec.mjs'
+import {resolveSshKeyPath} from '../../ssh/keys.mjs'
+import {cleanupOldLogs, closeLogFile, getLogFilePath, writeToLogFile} from '../../utils/log-file.mjs'
+import {resolveRemotePath} from '../../utils/remote-path.mjs'
+import {buildRemoteDeploymentPlan} from './build-remote-deployment-plan.mjs'
+import {executeRemoteDeploymentPlan} from './execute-remote-deployment-plan.mjs'
+import {prepareLocalDeployment} from './prepare-local-deployment.mjs'
+
+async function resolveRemoteHome(ssh, sshUser) {
+    const remoteHomeResult = await ssh.execCommand('printf "%s" "$HOME"')
+    return remoteHomeResult.stdout.trim() || `/home/${sshUser}`
+}
+
+export async function runDeployment(config, options = {}) {
+    const {
+        snapshot = null,
+        rootDir = process.cwd(),
+        versionArg = null,
+        context
+    } = options
+
+    const {
+        logProcessing,
+        logSuccess,
+        logWarning,
+        logError,
+        runPrompt,
+        createSshClient,
+        runCommand
+    } = context
+
+    await cleanupOldLogs(rootDir)
+
+    const {requiredPhpVersion} = await prepareLocalDeployment(config, {
+        snapshot,
+        rootDir,
+        versionArg,
+        runPrompt,
+        runCommand,
+        runCommandCapture: context.runCommandCapture,
+        logProcessing,
+        logSuccess,
+        logWarning
+    })
+
+    const ssh = createSshClient()
+    const sshUser = config.sshUser || os.userInfo().username
+    const privateKeyPath = await resolveSshKeyPath(config.sshKey)
+    const privateKey = await fs.readFile(privateKeyPath, 'utf8')
+    let remoteCwd = null
+
+    logProcessing(`\nConnecting to ${config.serverIp} as ${sshUser}...`)
+
+    let lockAcquired = false
+
+    try {
+        await ssh.connect({
+            host: config.serverIp,
+            username: sshUser,
+            privateKey
+        })
+
+        const remoteHome = await resolveRemoteHome(ssh, sshUser)
+        remoteCwd = resolveRemotePath(config.projectPath, remoteHome)
+
+        logProcessing('Connection established. Acquiring deployment lock on server...')
+        await acquireRemoteLock(ssh, remoteCwd, rootDir, {runPrompt, logWarning})
+        lockAcquired = true
+        logProcessing(`Lock acquired. Running deployment commands in ${remoteCwd}...`)
+
+        const executeRemote = createRemoteExecutor({
+            ssh,
+            rootDir,
+            remoteCwd,
+            writeToLogFile,
+            logProcessing,
+            logSuccess,
+            logError
+        })
+
+        const remotePlan = await buildRemoteDeploymentPlan({
+            config,
+            snapshot,
+            rootDir,
+            requiredPhpVersion,
+            ssh,
+            remoteCwd,
+            executeRemote,
+            logProcessing,
+            logSuccess,
+            logWarning
+        })
+
+        await executeRemoteDeploymentPlan({
+            rootDir,
+            executeRemote,
+            steps: remotePlan.steps,
+            usefulSteps: remotePlan.usefulSteps,
+            pendingSnapshot: remotePlan.pendingSnapshot,
+            logProcessing
+        })
+
+        logSuccess('\nDeployment commands completed successfully.')
+
+        const logPath = await getLogFilePath(rootDir)
+        logSuccess(`\nAll task output has been logged to: ${logPath}`)
+    } catch (error) {
+        const logPath = await getLogFilePath(rootDir).catch(() => null)
+        if (logPath) {
+            logError(`\nTask output has been logged to: ${logPath}`)
+        }
+
+        if (lockAcquired && ssh && remoteCwd) {
+            try {
+                await compareLocksAndPrompt(rootDir, ssh, remoteCwd, {runPrompt, logWarning})
+            } catch {
+                // Ignore lock comparison errors during error handling
+            }
+        }
+
+        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()
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+import * as localRepo from '../../deploy/local-repo.mjs'
+import * as preflight from '../../deploy/preflight.mjs'
+import {commandExists} from '../../utils/command.mjs'
+
+async function getGitStatus(rootDir, {runCommandCapture} = {}) {
+    return await localRepo.getGitStatus(rootDir, {runCommandCapture})
+}
+
+async function hasUncommittedChanges(rootDir, {runCommandCapture} = {}) {
+    return await localRepo.hasUncommittedChanges(rootDir, {
+        getGitStatus: (dir) => getGitStatus(dir, {runCommandCapture})
+    })
+}
+
+async function runLocalLaravelTests(rootDir, {runCommand, logProcessing, logSuccess, logWarning} = {}) {
+    if (!commandExists('php')) {
+        logWarning?.(
+            'PHP is not available in PATH. Skipping local Laravel tests.\n' +
+            '  To run tests locally, ensure PHP is installed and added to your PATH.\n' +
+            '  On Windows with Laravel Herd, you may need to add Herd\'s PHP to your system PATH.'
+        )
+        return
+    }
+
+    logProcessing?.('Running Laravel tests locally...')
+
+    try {
+        await runCommand('php', ['artisan', 'test', '--compact'], {cwd: rootDir})
+        logSuccess?.('Local tests passed.')
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(
+                'Failed to run Laravel tests: PHP executable not found.\n' +
+                'Make sure PHP is installed and available in your PATH.'
+            )
+        }
+
+        throw new Error(`Local tests failed. Fix test failures before deploying.\n${error.message}`)
+    }
+}
+
+export async function runLocalDeploymentChecks({
+    rootDir,
+    isLaravel,
+    hasHook,
+    runCommand,
+    runCommandCapture,
+    logProcessing,
+    logSuccess,
+    logWarning
+} = {}) {
+    if (hasHook) {
+        logProcessing?.('Pre-push git hook detected. Skipping local linting and test execution.')
+        return
+    }
+
+    const lintRan = await preflight.runLinting(rootDir, {
+        runCommand,
+        logProcessing,
+        logSuccess,
+        logWarning,
+        commandExists
+    })
+
+    if (lintRan) {
+        const hasChanges = await hasUncommittedChanges(rootDir, {runCommandCapture})
+        if (hasChanges) {
+            await preflight.commitLintingChanges(rootDir, {
+                getGitStatus: (dir) => getGitStatus(dir, {runCommandCapture}),
+                runCommand,
+                logProcessing,
+                logSuccess
+            })
+        }
+    }
+
+    if (isLaravel) {
+        await runLocalLaravelTests(rootDir, {runCommand, logProcessing, logSuccess, logWarning})
+    }
+}

package/src/application/release/release-node-package.mjs

@@ -0,0 +1,340 @@
+import {join} from 'node:path'
+import {readFile} from 'node:fs/promises'
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+
+import {writeStderr} from '../../utils/output.mjs'
+import {
+    ensureCleanWorkingTree,
+    ensureReleaseBranchReady,
+    runReleaseCommand as runCommand,
+    validateReleaseDependencies
+} from '../../release/shared.mjs'
+
+async function readPackage(rootDir = process.cwd()) {
+    const packagePath = join(rootDir, 'package.json')
+    const raw = await readFile(packagePath, 'utf8')
+    return JSON.parse(raw)
+}
+
+function hasScript(pkg, scriptName) {
+    return pkg?.scripts?.[scriptName] !== undefined
+}
+
+async function runLint(skipLint, pkg, rootDir = process.cwd(), {logStep, logSuccess, logWarning} = {}) {
+    if (skipLint) {
+        logWarning?.('Skipping lint because --skip-lint flag was provided.')
+        return
+    }
+
+    if (!hasScript(pkg, 'lint')) {
+        logStep?.('Skipping lint (no lint script found in package.json).')
+        return
+    }
+
+    logStep?.('Running lint...')
+
+    try {
+        await runCommand('npm', ['run', 'lint'], {cwd: rootDir})
+        logSuccess?.('Lint passed.')
+    } catch (error) {
+        if (error.stdout) {
+            writeStderr(error.stdout)
+        }
+        if (error.stderr) {
+            writeStderr(error.stderr)
+        }
+        throw error
+    }
+}
+
+async function runTests(skipTests, pkg, rootDir = process.cwd(), {logStep, logSuccess, logWarning} = {}) {
+    if (skipTests) {
+        logWarning?.('Skipping tests because --skip-tests flag was provided.')
+        return
+    }
+
+    if (!hasScript(pkg, 'test:run') && !hasScript(pkg, 'test')) {
+        logStep?.('Skipping tests (no test or test:run script found in package.json).')
+        return
+    }
+
+    logStep?.('Running test suite...')
+
+    try {
+        const testRunScript = pkg?.scripts?.['test:run'] ?? ''
+        const testScript = pkg?.scripts?.test ?? ''
+        const usesNodeTest = (script) => /\bnode\b.*\s--test\b/.test(script)
+
+        if (hasScript(pkg, 'test:run')) {
+            if (usesNodeTest(testRunScript)) {
+                await runCommand('npm', ['run', 'test:run'], {cwd: rootDir})
+            } else {
+                await runCommand('npm', ['run', 'test:run', '--', '--reporter=dot'], {cwd: rootDir})
+            }
+        } else if (usesNodeTest(testScript)) {
+            await runCommand('npm', ['test'], {cwd: rootDir})
+        } else {
+            await runCommand('npm', ['test', '--', '--run', '--reporter=dot'], {cwd: rootDir})
+        }
+
+        logSuccess?.('Tests passed.')
+    } catch (error) {
+        if (error.stdout) {
+            writeStderr(error.stdout)
+        }
+        if (error.stderr) {
+            writeStderr(error.stderr)
+        }
+        throw error
+    }
+}
+
+async function runBuild(skipBuild, pkg, rootDir = process.cwd(), {logStep, logSuccess, logWarning} = {}) {
+    if (skipBuild) {
+        logWarning?.('Skipping build because --skip-build flag was provided.')
+        return
+    }
+
+    if (!hasScript(pkg, 'build')) {
+        logStep?.('Skipping build (no build script found in package.json).')
+        return
+    }
+
+    logStep?.('Building project...')
+
+    try {
+        await runCommand('npm', ['run', 'build'], {cwd: rootDir})
+        logSuccess?.('Build completed.')
+    } catch (error) {
+        if (error.stdout) {
+            writeStderr(error.stdout)
+        }
+        if (error.stderr) {
+            writeStderr(error.stderr)
+        }
+        throw error
+    }
+}
+
+async function runLibBuild(skipBuild, pkg, rootDir = process.cwd(), {logStep, logSuccess, logWarning} = {}) {
+    if (skipBuild) {
+        logWarning?.('Skipping library build because --skip-build flag was provided.')
+        return false
+    }
+
+    if (!hasScript(pkg, 'build:lib')) {
+        logStep?.('Skipping library build (no build:lib script found in package.json).')
+        return false
+    }
+
+    logStep?.('Building library...')
+
+    try {
+        await runCommand('npm', ['run', 'build:lib'], {cwd: rootDir})
+        logSuccess?.('Library built.')
+    } catch (error) {
+        if (error.stdout) {
+            writeStderr(error.stdout)
+        }
+        if (error.stderr) {
+            writeStderr(error.stderr)
+        }
+        throw error
+    }
+
+    const {stdout: statusAfterBuild} = await runCommand('git', ['status', '--porcelain'], {capture: true, cwd: rootDir})
+    const hasLibChanges = statusAfterBuild.split('\n').some((line) => {
+        const trimmed = line.trim()
+        return trimmed.includes('lib/') && (trimmed.startsWith('M') || trimmed.startsWith('??') || trimmed.startsWith('A') || trimmed.startsWith('D'))
+    })
+
+    if (hasLibChanges) {
+        logStep?.('Committing lib build artifacts...')
+        await runCommand('git', ['add', 'lib/'], {capture: true, cwd: rootDir})
+        await runCommand('git', ['commit', '-m', 'chore: build lib artifacts'], {capture: true, cwd: rootDir})
+        logSuccess?.('Lib build artifacts committed.')
+    }
+
+    return hasLibChanges
+}
+
+async function bumpVersion(releaseType, rootDir = process.cwd(), {logStep, logSuccess} = {}) {
+    logStep?.('Bumping package version...')
+
+    const {stdout: statusBefore} = await runCommand('git', ['status', '--porcelain'], {capture: true, cwd: rootDir})
+    const hasLibChanges = statusBefore.split('\n').some((line) => {
+        const trimmed = line.trim()
+        return trimmed.includes('lib/') && (trimmed.startsWith('M') || trimmed.startsWith('??') || trimmed.startsWith('A') || trimmed.startsWith('D'))
+    })
+
+    if (hasLibChanges) {
+        logStep?.('Stashing lib build artifacts...')
+        await runCommand('git', ['stash', 'push', '-u', '-m', 'temp: lib build artifacts', 'lib/'], {capture: true, cwd: rootDir})
+    }
+
+    try {
+        await runCommand('npm', ['version', releaseType], {capture: true, cwd: rootDir})
+    } finally {
+        if (hasLibChanges) {
+            logStep?.('Restoring lib build artifacts...')
+            await runCommand('git', ['stash', 'pop'], {capture: true, cwd: rootDir})
+            await runCommand('git', ['add', 'lib/'], {capture: true, cwd: rootDir})
+            const {stdout: statusAfter} = await runCommand('git', ['status', '--porcelain'], {capture: true, cwd: rootDir})
+            if (statusAfter.includes('lib/')) {
+                await runCommand('git', ['commit', '--amend', '--no-edit'], {capture: true, cwd: rootDir})
+            }
+        }
+    }
+
+    const pkg = await readPackage(rootDir)
+    const commitMessage = `chore: release ${pkg.version}`
+    await runCommand('git', ['commit', '--amend', '-m', commitMessage], {capture: true, cwd: rootDir})
+
+    logSuccess?.(`Version updated to ${pkg.version}.`)
+    return pkg
+}
+
+async function pushChanges(rootDir = process.cwd(), {logStep, logSuccess} = {}) {
+    logStep?.('Pushing commits and tags to origin...')
+    try {
+        await runCommand('git', ['push', '--follow-tags'], {capture: true, cwd: rootDir})
+        logSuccess?.('Git push completed.')
+    } catch (error) {
+        if (error.stdout) {
+            writeStderr(error.stdout)
+        }
+        if (error.stderr) {
+            writeStderr(error.stderr)
+        }
+        throw error
+    }
+}
+
+function extractDomainFromHomepage(homepage) {
+    if (!homepage) return null
+    try {
+        const url = new URL(homepage)
+        return url.hostname
+    } catch {
+        const match = homepage.match(/(?:https?:\/\/)?([^/]+)/)
+        return match ? match[1] : null
+    }
+}
+
+async function deployGHPages(skipDeploy, pkg, rootDir = process.cwd(), {logStep, logSuccess, logWarning} = {}) {
+    if (skipDeploy) {
+        logWarning?.('Skipping GitHub Pages deployment because --skip-deploy flag was provided.')
+        return
+    }
+
+    const distPath = path.join(rootDir, 'dist')
+    const distExists = await fs.promises
+        .stat(distPath)
+        .then((stats) => stats.isDirectory())
+        .catch(() => false)
+
+    if (!distExists) {
+        logStep?.('Skipping GitHub Pages deployment (no dist directory found).')
+        return
+    }
+
+    logStep?.('Deploying to GitHub Pages...')
+
+    const cnamePath = path.join(distPath, 'CNAME')
+    const homepage =
+        pkg &&
+        typeof pkg === 'object' &&
+        'homepage' in pkg &&
+        typeof pkg.homepage === 'string'
+            ? pkg.homepage
+            : null
+
+    if (homepage) {
+        const domain = extractDomainFromHomepage(homepage)
+        if (domain) {
+            try {
+                await fs.promises.mkdir(distPath, {recursive: true})
+                await fs.promises.writeFile(cnamePath, domain)
+            } catch (error) {
+                logWarning?.(`Could not write CNAME file: ${error.message}`)
+            }
+        }
+    }
+
+    const worktreeDir = path.resolve(rootDir, '.gh-pages')
+
+    try {
+        try {
+            await runCommand('git', ['worktree', 'remove', worktreeDir, '-f'], {capture: true, cwd: rootDir})
+        } catch (_error) {
+            // Ignore if worktree doesn't exist
+        }
+
+        try {
+            await runCommand('git', ['worktree', 'add', worktreeDir, 'gh-pages'], {capture: true, cwd: rootDir})
+        } catch {
+            await runCommand('git', ['worktree', 'add', worktreeDir, '-b', 'gh-pages'], {capture: true, cwd: rootDir})
+        }
+
+        await runCommand('git', ['-C', worktreeDir, 'config', 'user.name', 'wyxos'], {capture: true})
+        await runCommand('git', ['-C', worktreeDir, 'config', 'user.email', 'github@wyxos.com'], {capture: true})
+
+        for (const entry of fs.readdirSync(worktreeDir)) {
+            if (entry === '.git') continue
+            const target = path.join(worktreeDir, entry)
+            fs.rmSync(target, {recursive: true, force: true})
+        }
+
+        fs.cpSync(distPath, worktreeDir, {recursive: true})
+
+        await runCommand('git', ['-C', worktreeDir, 'add', '-A'], {capture: true})
+        await runCommand('git', ['-C', worktreeDir, 'commit', '-m', `deploy: demo ${new Date().toISOString()}`, '--allow-empty'], {capture: true})
+        await runCommand('git', ['-C', worktreeDir, 'push', '-f', 'origin', 'gh-pages'], {capture: true})
+
+        logSuccess?.('GitHub Pages deployment completed.')
+    } catch (error) {
+        if (error.stdout) {
+            writeStderr(error.stdout)
+        }
+        if (error.stderr) {
+            writeStderr(error.stderr)
+        }
+        throw error
+    }
+}
+
+export async function releaseNodePackage({
+                                             releaseType,
+                                             skipTests = false,
+                                             skipLint = false,
+                                             skipBuild = false,
+                                             skipDeploy = false,
+                                             rootDir = process.cwd(),
+                                             logStep,
+                                             logSuccess,
+                                             logWarning
+                                         } = {}) {
+    logStep?.('Reading package metadata...')
+    const pkg = await readPackage(rootDir)
+
+    logStep?.('Validating dependencies...')
+    await validateReleaseDependencies(rootDir, {logSuccess})
+
+    logStep?.('Checking working tree status...')
+    await ensureCleanWorkingTree(rootDir, {runCommand})
+    await ensureReleaseBranchReady({rootDir, branchMethod: 'show-current', logStep, logWarning})
+
+    await runLint(skipLint, pkg, rootDir, {logStep, logSuccess, logWarning})
+    await runTests(skipTests, pkg, rootDir, {logStep, logSuccess, logWarning})
+    await runLibBuild(skipBuild, pkg, rootDir, {logStep, logSuccess, logWarning})
+
+    const updatedPkg = await bumpVersion(releaseType, rootDir, {logStep, logSuccess})
+    await runBuild(skipBuild, updatedPkg, rootDir, {logStep, logSuccess, logWarning})
+    await pushChanges(rootDir, {logStep, logSuccess})
+    await deployGHPages(skipDeploy, updatedPkg, rootDir, {logStep, logSuccess, logWarning})
+
+    logStep?.('Publishing will be handled by GitHub Actions via trusted publishing.')
+    logSuccess?.(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
+}