@wyxos/zephyr 0.2.18 → 0.2.20

package/README.md

@@ -22,6 +22,22 @@ Navigate to your project directory and run:
 zephyr
 ```
 
+See all flags:
+
+```bash
+zephyr --help
+```
+
+Common flags:
+
+```bash
+# Run a release workflow
+zephyr --type node
+
+# Skip the best-effort update check for this run
+zephyr --skip-version-check
+```
+
 Follow the interactive prompts to configure your deployment target:
 - Server name and IP address
 - Project path on the remote server
@@ -34,7 +50,9 @@ Configuration is saved automatically for future deployments.
 
 When run via `npx`, Zephyr can prompt to re-run itself using the latest published version.
 
-- **Skip update check**: set `ZEPHYR_SKIP_VERSION_CHECK=1`
+- **Skip update check**:
+  - Set `ZEPHYR_SKIP_VERSION_CHECK=1`, or
+  - Use `zephyr --skip-version-check`
 
 ## Features
 

package/bin/zephyr.mjs

@@ -1,14 +1,29 @@
 #!/usr/bin/env node
 import process from 'node:process'
-import { logError, main } from '../src/index.mjs'
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { main } from '../src/main.mjs'
+import { createChalkLogger } from '../src/utils/output.mjs'
 
-// Parse --type flag from command line arguments
-const args = process.argv.slice(2)
-const typeFlag = args.find(arg => arg.startsWith('--type='))
-const releaseType = typeFlag ? typeFlag.split('=')[1] : null
+const { logError } = createChalkLogger(chalk)
+
+const program = new Command()
+
+program
+  .name('zephyr')
+  .description('A streamlined deployment tool for web applications with intelligent Laravel project detection')
+  .option('--type <type>', 'Release type (node|vue|packagist)')
+  .option('--skip-version-check', 'Skip the version check for this run')
+
+program.parse(process.argv)
+const options = program.opts()
+
+if (options.skipVersionCheck) {
+  process.env.ZEPHYR_SKIP_VERSION_CHECK = '1'
+}
 
 try {
-  await main(releaseType)
+  await main(options.type ?? null)
 } catch (error) {
   logError(error?.message || String(error))
   process.exitCode = 1

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "description": "A streamlined deployment tool for web applications with intelligent Laravel project detection",
   "type": "module",
   "main": "./src/index.mjs",
   "exports": {
     ".": "./src/index.mjs",
-    "./ssh-utils": "./src/ssh-utils.mjs"
+    "./ssh": "./src/ssh/index.mjs"
   },
   "bin": {
     "zephyr": "bin/zephyr.mjs"
@@ -44,6 +44,7 @@
   ],
   "dependencies": {
     "chalk": "5.3.0",
+    "commander": "11.1.0",
     "inquirer": "^9.2.12",
     "node-ssh": "^13.1.0",
     "semver": "^7.6.3"

package/src/config/project.mjs

@@ -0,0 +1,118 @@
+import fs from 'node:fs/promises'
+
+import { ensureDirectory, getProjectConfigDir, getProjectConfigPath } from '../utils/paths.mjs'
+import { generateId } from '../utils/id.mjs'
+
+export function migrateApps(apps, servers) {
+  if (!Array.isArray(apps)) {
+    return { apps: [], needsMigration: false }
+  }
+
+  const serverNameToId = new Map()
+  servers.forEach((server) => {
+    if (server.id && server.serverName) {
+      serverNameToId.set(server.serverName, server.id)
+    }
+  })
+
+  let needsMigration = false
+  const migrated = apps.map((app) => {
+    const updated = { ...app }
+
+    if (!app.id) {
+      needsMigration = true
+      updated.id = generateId()
+    }
+
+    if (app.serverName && !app.serverId) {
+      const serverId = serverNameToId.get(app.serverName)
+      if (serverId) {
+        needsMigration = true
+        updated.serverId = serverId
+      }
+    }
+
+    return updated
+  })
+
+  return { apps: migrated, needsMigration }
+}
+
+export function migratePresets(presets, apps) {
+  if (!Array.isArray(presets)) {
+    return { presets: [], needsMigration: false }
+  }
+
+  const keyToAppId = new Map()
+  apps.forEach((app) => {
+    if (app.id && app.serverName && app.projectPath) {
+      const key = `${app.serverName}:${app.projectPath}`
+      keyToAppId.set(key, app.id)
+    }
+  })
+
+  let needsMigration = false
+  const migrated = presets.map((preset) => {
+    const updated = { ...preset }
+
+    if (preset.key && !preset.appId) {
+      const appId = keyToAppId.get(preset.key)
+      if (appId) {
+        needsMigration = true
+        updated.appId = appId
+      }
+    }
+
+    return updated
+  })
+
+  return { presets: migrated, needsMigration }
+}
+
+export async function loadProjectConfig(rootDir, servers = [], { logSuccess, logWarning } = {}) {
+  const configPath = getProjectConfigPath(rootDir)
+
+  try {
+    const raw = await fs.readFile(configPath, 'utf8')
+    const data = JSON.parse(raw)
+    const apps = Array.isArray(data?.apps) ? data.apps : []
+    const presets = Array.isArray(data?.presets) ? data.presets : []
+
+    const { apps: migratedApps, needsMigration: appsNeedMigration } = migrateApps(apps, servers)
+    const { presets: migratedPresets, needsMigration: presetsNeedMigration } = migratePresets(presets, migratedApps)
+
+    if (appsNeedMigration || presetsNeedMigration) {
+      await saveProjectConfig(rootDir, {
+        apps: migratedApps,
+        presets: migratedPresets
+      })
+      logSuccess?.('Migrated project configuration to use unique IDs.')
+    }
+
+    return { apps: migratedApps, presets: migratedPresets }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return { apps: [], presets: [] }
+    }
+
+    logWarning?.('Failed to read .zephyr/config.json, starting with an empty list of apps.')
+    return { apps: [], presets: [] }
+  }
+}
+
+export async function saveProjectConfig(rootDir, config) {
+  const configDir = getProjectConfigDir(rootDir)
+  await ensureDirectory(configDir)
+
+  const payload = JSON.stringify(
+    {
+      apps: config.apps ?? [],
+      presets: config.presets ?? []
+    },
+    null,
+    2
+  )
+
+  await fs.writeFile(getProjectConfigPath(rootDir), `${payload}\n`)
+}
+

package/src/config/servers.mjs

@@ -0,0 +1,57 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import { ensureDirectory } from '../utils/paths.mjs'
+import { generateId } from '../utils/id.mjs'
+
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.config', 'zephyr')
+const SERVERS_FILE = path.join(GLOBAL_CONFIG_DIR, 'servers.json')
+
+export function migrateServers(servers) {
+  if (!Array.isArray(servers)) {
+    return { servers: [], needsMigration: false }
+  }
+
+  let needsMigration = false
+  const migrated = servers.map((server) => {
+    if (!server.id) {
+      needsMigration = true
+      return { ...server, id: generateId() }
+    }
+    return server
+  })
+
+  return { servers: migrated, needsMigration }
+}
+
+export async function loadServers({ logSuccess, logWarning } = {}) {
+  try {
+    const raw = await fs.readFile(SERVERS_FILE, 'utf8')
+    const data = JSON.parse(raw)
+    const servers = Array.isArray(data) ? data : []
+
+    const { servers: migrated, needsMigration } = migrateServers(servers)
+
+    if (needsMigration) {
+      await saveServers(migrated)
+      logSuccess?.('Migrated servers configuration to use unique IDs.')
+    }
+
+    return migrated
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return []
+    }
+
+    logWarning?.('Failed to read servers.json, starting with an empty list.')
+    return []
+  }
+}
+
+export async function saveServers(servers) {
+  await ensureDirectory(GLOBAL_CONFIG_DIR)
+  const payload = JSON.stringify(servers, null, 2)
+  await fs.writeFile(SERVERS_FILE, `${payload}\n`)
+}
+

package/src/dependency-scanner.mjs

@@ -1,10 +1,8 @@
 import { readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { spawn } from 'node:child_process'
 import process from 'node:process'
 import chalk from 'chalk'
-
-const IS_WINDOWS = process.platform === 'win32'
+import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
 
 function isLocalPathOutsideRepo(depPath, rootDir) {
   if (!depPath || typeof depPath !== 'string') {
@@ -218,45 +216,13 @@ async function updateComposerJsonDependency(rootDir, packageName, newVersion, fi
 }
 
 async function runCommand(command, args, { cwd = process.cwd(), capture = false } = {}) {
-  return new Promise((resolve, reject) => {
-    const resolvedCommand = IS_WINDOWS && (command === 'npm' || command === 'npx' || command === 'pnpm' || command === 'yarn')
-      ? `${command}.cmd`
-      : command
-
-    const spawnOptions = {
-      stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
-      cwd
-    }
-
-    const child = spawn(resolvedCommand, args, spawnOptions)
-    let stdout = ''
-    let stderr = ''
-
-    if (capture) {
-      child.stdout.on('data', (chunk) => {
-        stdout += chunk
-      })
-
-      child.stderr.on('data', (chunk) => {
-        stderr += chunk
-      })
-    }
+  if (capture) {
+    const { stdout, stderr } = await runCommandCaptureBase(command, args, { cwd })
+    return { stdout: stdout.trim(), stderr: stderr.trim() }
+  }
 
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(capture ? { stdout: stdout.trim(), stderr: stderr.trim() } : undefined)
-      } else {
-        const error = new Error(`Command failed (${code}): ${resolvedCommand} ${args.join(' ')}`)
-        if (capture) {
-          error.stdout = stdout
-          error.stderr = stderr
-        }
-        error.exitCode = code
-        reject(error)
-      }
-    })
-  })
+  await runCommandBase(command, args, { cwd })
+  return undefined
 }
 
 async function getGitStatus(rootDir) {

package/src/deploy/local-repo.mjs

@@ -0,0 +1,215 @@
+import { getCurrentBranch as getCurrentBranchImpl, getUpstreamRef as getUpstreamRefImpl } from '../utils/git.mjs'
+
+export async function getCurrentBranch(rootDir) {
+  const branch = await getCurrentBranchImpl(rootDir)
+  return branch ?? ''
+}
+
+export async function getGitStatus(rootDir, { runCommandCapture } = {}) {
+  const output = await runCommandCapture('git', ['status', '--porcelain'], { cwd: rootDir })
+  return output.trim()
+}
+
+export function hasStagedChanges(statusOutput) {
+  if (!statusOutput || statusOutput.length === 0) {
+    return false
+  }
+
+  const lines = statusOutput.split('\n').filter((line) => line.trim().length > 0)
+
+  return lines.some((line) => {
+    const firstChar = line[0]
+    return firstChar && firstChar !== ' ' && firstChar !== '?'
+  })
+}
+
+export async function hasUncommittedChanges(rootDir, { getGitStatus: getGitStatusFn } = {}) {
+  const status = await getGitStatusFn(rootDir)
+  return status.length > 0
+}
+
+export async function getUpstreamRef(rootDir) {
+  return await getUpstreamRefImpl(rootDir)
+}
+
+export async function ensureCommittedChangesPushed(targetBranch, rootDir, {
+  runCommand,
+  runCommandCapture,
+  logProcessing,
+  logSuccess,
+  logWarning,
+  getUpstreamRef: getUpstreamRefFn = getUpstreamRef
+} = {}) {
+  const upstreamRef = await getUpstreamRefFn(rootDir)
+
+  if (!upstreamRef) {
+    logWarning?.(`Branch ${targetBranch} does not track a remote upstream; skipping automatic push of committed changes.`)
+    return { pushed: false, upstreamRef: null }
+  }
+
+  const [remoteName, ...upstreamParts] = upstreamRef.split('/')
+  const upstreamBranch = upstreamParts.join('/')
+
+  if (!remoteName || !upstreamBranch) {
+    logWarning?.(`Unable to determine remote destination for ${targetBranch}. Skipping automatic push.`)
+    return { pushed: false, upstreamRef }
+  }
+
+  try {
+    await runCommand('git', ['fetch', remoteName], { cwd: rootDir, silent: true })
+  } catch (error) {
+    logWarning?.(`Unable to fetch from ${remoteName} before push: ${error.message}`)
+  }
+
+  let remoteExists = true
+
+  try {
+    await runCommand('git', ['show-ref', '--verify', '--quiet', `refs/remotes/${upstreamRef}`], {
+      cwd: rootDir,
+      silent: true
+    })
+  } catch {
+    remoteExists = false
+  }
+
+  let aheadCount = 0
+  let behindCount = 0
+
+  if (remoteExists) {
+    const aheadOutput = await runCommandCapture('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], { cwd: rootDir })
+    aheadCount = parseInt(aheadOutput.trim() || '0', 10)
+
+    const behindOutput = await runCommandCapture('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], { cwd: rootDir })
+    behindCount = parseInt(behindOutput.trim() || '0', 10)
+  } else {
+    aheadCount = 1
+  }
+
+  if (Number.isFinite(behindCount) && behindCount > 0) {
+    throw new Error(
+      `Local branch ${targetBranch} is behind ${upstreamRef} by ${behindCount} commit${behindCount === 1 ? '' : 's'}. Pull or rebase before deployment.`
+    )
+  }
+
+  if (!Number.isFinite(aheadCount) || aheadCount <= 0) {
+    return { pushed: false, upstreamRef }
+  }
+
+  const commitLabel = aheadCount === 1 ? 'commit' : 'commits'
+  logProcessing?.(`Found ${aheadCount} ${commitLabel} not yet pushed to ${upstreamRef}. Pushing before deployment...`)
+
+  await runCommandCapture('git', ['push', remoteName, `${targetBranch}:${upstreamBranch}`], { cwd: rootDir })
+  logSuccess?.(`Pushed committed changes to ${upstreamRef}.`)
+
+  return { pushed: true, upstreamRef }
+}
+
+export async function ensureLocalRepositoryState(targetBranch, rootDir = process.cwd(), {
+  runPrompt,
+  runCommand,
+  runCommandCapture,
+  logProcessing,
+  logSuccess,
+  logWarning,
+  getCurrentBranch: getCurrentBranchFn = getCurrentBranch,
+  getGitStatus: getGitStatusFn = (dir) => getGitStatus(dir, { runCommandCapture }),
+  ensureCommittedChangesPushed: ensureCommittedChangesPushedFn = (branch, dir) =>
+    ensureCommittedChangesPushed(branch, dir, {
+      runCommand,
+      runCommandCapture,
+      logProcessing,
+      logSuccess,
+      logWarning
+    })
+} = {}) {
+  if (!targetBranch) {
+    throw new Error('Deployment branch is not defined in the release configuration.')
+  }
+
+  const currentBranch = await getCurrentBranchFn(rootDir)
+
+  if (!currentBranch) {
+    throw new Error('Unable to determine the current git branch. Ensure this is a git repository.')
+  }
+
+  const initialStatus = await getGitStatusFn(rootDir)
+  const hasPendingChanges = initialStatus.length > 0
+
+  const statusReport = await runCommandCapture('git', ['status', '--short', '--branch'], { cwd: rootDir })
+  const lines = statusReport.split(/\r?\n/)
+  const branchLine = lines[0] || ''
+  const aheadMatch = branchLine.match(/ahead (\d+)/)
+  const behindMatch = branchLine.match(/behind (\d+)/)
+  const aheadCount = aheadMatch ? parseInt(aheadMatch[1], 10) : 0
+  const behindCount = behindMatch ? parseInt(behindMatch[1], 10) : 0
+
+  if (aheadCount > 0) {
+    logWarning?.(`Local branch ${currentBranch} is ahead of upstream by ${aheadCount} commit${aheadCount === 1 ? '' : 's'}.`)
+  }
+
+  if (behindCount > 0) {
+    logProcessing?.(`Synchronizing local branch ${currentBranch} with its upstream...`)
+    try {
+      await runCommand('git', ['pull', '--ff-only'], { cwd: rootDir })
+      logSuccess?.('Local branch fast-forwarded with upstream changes.')
+    } catch (error) {
+      throw new Error(
+        `Unable to fast-forward ${currentBranch} with upstream changes. Resolve conflicts manually, then rerun the deployment.\n${error.message}`
+      )
+    }
+  }
+
+  if (currentBranch !== targetBranch) {
+    if (hasPendingChanges) {
+      throw new Error(
+        `Local repository has uncommitted changes on ${currentBranch}. Commit or stash them before switching to ${targetBranch}.`
+      )
+    }
+
+    logProcessing?.(`Switching local repository from ${currentBranch} to ${targetBranch}...`)
+    await runCommand('git', ['checkout', targetBranch], { cwd: rootDir })
+    logSuccess?.(`Checked out ${targetBranch} locally.`)
+  }
+
+  const statusAfterCheckout = currentBranch === targetBranch ? initialStatus : await getGitStatusFn(rootDir)
+
+  if (statusAfterCheckout.length === 0) {
+    await ensureCommittedChangesPushedFn(targetBranch, rootDir)
+    logProcessing?.('Local repository is clean. Proceeding with deployment.')
+    return
+  }
+
+  if (!hasStagedChanges(statusAfterCheckout)) {
+    await ensureCommittedChangesPushedFn(targetBranch, rootDir)
+    logProcessing?.('No staged changes detected. Unstaged or untracked files will not affect deployment. Proceeding with deployment.')
+    return
+  }
+
+  logWarning?.(`Staged changes detected on ${targetBranch}. A commit is required before deployment.`)
+
+  const { commitMessage } = await runPrompt([
+    {
+      type: 'input',
+      name: 'commitMessage',
+      message: 'Enter a commit message for pending changes before deployment',
+      validate: (value) => (value && value.trim().length > 0 ? true : 'Commit message cannot be empty.')
+    }
+  ])
+
+  const message = commitMessage.trim()
+
+  logProcessing?.('Committing staged changes before deployment...')
+  await runCommand('git', ['commit', '-m', message], { cwd: rootDir })
+  await runCommand('git', ['push', 'origin', targetBranch], { cwd: rootDir })
+  logSuccess?.(`Committed and pushed changes to origin/${targetBranch}.`)
+
+  const finalStatus = await getGitStatusFn(rootDir)
+
+  if (finalStatus.length > 0) {
+    throw new Error('Local repository still has uncommitted changes after commit. Aborting deployment.')
+  }
+
+  await ensureCommittedChangesPushedFn(targetBranch, rootDir)
+  logProcessing?.('Local repository is clean after committing pending changes.')
+}
+