@wyxos/zephyr 0.1.3 → 0.1.5

package/package.json

@@ -1,14 +1,42 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.1.3",
+  "version": "0.1.5",
+  "description": "A streamlined deployment tool for web applications with intelligent Laravel project detection",
   "type": "module",
+  "main": "./src/index.mjs",
+  "bin": {
+    "zephyr": "bin/zephyr.mjs"
+  },
   "scripts": {
     "test": "vitest",
     "release": "node publish.mjs"
   },
-  "bin": {
-    "zephyr": "bin/zephyr.mjs"
+  "keywords": [
+    "deployment",
+    "laravel",
+    "ssh",
+    "automation",
+    "devops",
+    "git"
+  ],
+  "author": "wyxos",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wyxos/zephyr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wyxos/zephyr/issues"
+  },
+  "homepage": "https://github.com/wyxos/zephyr#readme",
+  "engines": {
+    "node": ">=16.0.0"
   },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
   "dependencies": {
     "chalk": "5.3.0",
     "inquirer": "^9.2.12",

package/src/index.mjs

@@ -10,6 +10,10 @@ const PROJECT_CONFIG_DIR = '.zephyr'
 const PROJECT_CONFIG_FILE = 'config.json'
 const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.config', 'zephyr')
 const SERVERS_FILE = path.join(GLOBAL_CONFIG_DIR, 'servers.json')
+const PROJECT_LOCK_FILE = 'deploy.lock'
+const PENDING_TASKS_FILE = 'pending-tasks.json'
+const RELEASE_SCRIPT_NAME = 'release'
+const RELEASE_SCRIPT_COMMAND = 'npx @wyxos/zephyr@release'
 
 const logProcessing = (message = '') => console.log(chalk.yellow(message))
 const logSuccess = (message = '') => console.log(chalk.green(message))
@@ -197,6 +201,33 @@ async function ensureLocalRepositoryState(targetBranch, rootDir = process.cwd())
   const initialStatus = await getGitStatus(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(
@@ -246,6 +277,151 @@ async function ensureLocalRepositoryState(targetBranch, rootDir = process.cwd())
   logProcessing('Local repository is clean after committing pending changes.')
 }
 
+async function ensureProjectReleaseScript(rootDir) {
+  const packageJsonPath = path.join(rootDir, 'package.json')
+
+  let raw
+  try {
+    raw = await fs.readFile(packageJsonPath, 'utf8')
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return false
+    }
+
+    throw error
+  }
+
+  let packageJson
+  try {
+    packageJson = JSON.parse(raw)
+  } catch (error) {
+    logWarning('Unable to parse package.json; skipping release script injection.')
+    return false
+  }
+
+  const currentCommand = packageJson?.scripts?.[RELEASE_SCRIPT_NAME]
+
+  if (currentCommand && currentCommand.includes('@wyxos/zephyr')) {
+    return false
+  }
+
+  const { installReleaseScript } = await runPrompt([
+    {
+      type: 'confirm',
+      name: 'installReleaseScript',
+      message: 'Add "release" script to package.json that runs "npx @wyxos/zephyr@release"?',
+      default: true
+    }
+  ])
+
+  if (!installReleaseScript) {
+    return false
+  }
+
+  if (!packageJson.scripts || typeof packageJson.scripts !== 'object') {
+    packageJson.scripts = {}
+  }
+
+  packageJson.scripts[RELEASE_SCRIPT_NAME] = RELEASE_SCRIPT_COMMAND
+
+  const updatedPayload = `${JSON.stringify(packageJson, null, 2)}\n`
+  await fs.writeFile(packageJsonPath, updatedPayload)
+  logSuccess('Added release script to package.json.')
+
+  return true
+}
+
+function getProjectConfigDir(rootDir) {
+  return path.join(rootDir, PROJECT_CONFIG_DIR)
+}
+
+function getPendingTasksPath(rootDir) {
+  return path.join(getProjectConfigDir(rootDir), PENDING_TASKS_FILE)
+}
+
+function getLockFilePath(rootDir) {
+  return path.join(getProjectConfigDir(rootDir), PROJECT_LOCK_FILE)
+}
+
+async function acquireProjectLock(rootDir) {
+  const lockDir = getProjectConfigDir(rootDir)
+  await ensureDirectory(lockDir)
+  const lockPath = getLockFilePath(rootDir)
+
+  try {
+    const existing = await fs.readFile(lockPath, 'utf8')
+    let details = {}
+    try {
+      details = JSON.parse(existing)
+    } catch (error) {
+      details = { raw: existing }
+    }
+
+    const startedBy = details.user ? `${details.user}@${details.hostname ?? 'unknown'}` : 'unknown user'
+    const startedAt = details.startedAt ? ` at ${details.startedAt}` : ''
+    throw new Error(
+      `Another deployment is currently in progress (started by ${startedBy}${startedAt}). Remove ${lockPath} if you are sure it is stale.`
+    )
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  const payload = {
+    user: os.userInfo().username,
+    pid: process.pid,
+    hostname: os.hostname(),
+    startedAt: new Date().toISOString()
+  }
+
+  await fs.writeFile(lockPath, `${JSON.stringify(payload, null, 2)}\n`)
+  return lockPath
+}
+
+async function releaseProjectLock(rootDir) {
+  const lockPath = getLockFilePath(rootDir)
+  try {
+    await fs.unlink(lockPath)
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+}
+
+async function loadPendingTasksSnapshot(rootDir) {
+  const snapshotPath = getPendingTasksPath(rootDir)
+
+  try {
+    const raw = await fs.readFile(snapshotPath, 'utf8')
+    return JSON.parse(raw)
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null
+    }
+
+    throw error
+  }
+}
+
+async function savePendingTasksSnapshot(rootDir, snapshot) {
+  const configDir = getProjectConfigDir(rootDir)
+  await ensureDirectory(configDir)
+  const payload = `${JSON.stringify(snapshot, null, 2)}\n`
+  await fs.writeFile(getPendingTasksPath(rootDir), payload)
+}
+
+async function clearPendingTasksSnapshot(rootDir) {
+  try {
+    await fs.unlink(getPendingTasksPath(rootDir))
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+}
+
 async function ensureGitignoreEntry(rootDir) {
   const gitignorePath = path.join(rootDir, '.gitignore')
   const targetEntry = `${PROJECT_CONFIG_DIR}/`
@@ -546,8 +722,10 @@ function resolveRemotePath(projectPath, remoteHome) {
   return `${sanitizedHome}/${projectPath}`
 }
 
-async function runRemoteTasks(config) {
-  await ensureLocalRepositoryState(config.branch, process.cwd())
+async function runRemoteTasks(config, options = {}) {
+  const { snapshot = null, rootDir = process.cwd() } = options
+
+  await ensureLocalRepositoryState(config.branch, rootDir)
 
   const ssh = createSshClient()
   const sshUser = config.sshUser || os.userInfo().username
@@ -607,7 +785,10 @@ async function runRemoteTasks(config) {
 
     let changedFiles = []
 
-    if (isLaravel) {
+    if (snapshot && snapshot.changedFiles) {
+      changedFiles = snapshot.changedFiles
+      logProcessing('Resuming deployment with saved task snapshot.')
+    } else if (isLaravel) {
       await executeRemote(`Fetch latest changes for ${config.branch}`, `git fetch origin ${config.branch}`)
 
       const diffResult = await executeRemote(
@@ -735,6 +916,31 @@ async function runRemoteTasks(config) {
       })
     }
 
+    const usefulSteps = steps.length > 1
+
+    let pendingSnapshot
+
+    if (usefulSteps) {
+      pendingSnapshot = snapshot ?? {
+        serverName: config.serverName,
+        branch: config.branch,
+        projectPath: config.projectPath,
+        sshUser: config.sshUser,
+        createdAt: new Date().toISOString(),
+        changedFiles,
+        taskLabels: steps.map((step) => step.label)
+      }
+
+      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 }
+      )
+    }
+
     if (steps.length === 1) {
       logProcessing('No additional maintenance tasks scheduled beyond git pull.')
     } else {
@@ -746,8 +952,23 @@ async function runRemoteTasks(config) {
       logProcessing(`Additional tasks scheduled: ${extraTasks}`)
     }
 
-    for (const step of steps) {
-      await executeRemote(step.label, step.command)
+    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)
+      }
     }
 
     logSuccess('\nDeployment commands completed successfully.')
@@ -937,6 +1158,7 @@ async function main() {
   const rootDir = process.cwd()
 
   await ensureGitignoreEntry(rootDir)
+  await ensureProjectReleaseScript(rootDir)
 
   const servers = await loadServers()
   const server = await selectServer(servers)
@@ -962,11 +1184,58 @@ async function main() {
   logProcessing('\nSelected deployment target:')
   console.log(JSON.stringify(deploymentConfig, null, 2))
 
-  await runRemoteTasks(deploymentConfig)
+  const existingSnapshot = await loadPendingTasksSnapshot(rootDir)
+  let snapshotToUse = null
+
+  if (existingSnapshot) {
+    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) {
+      snapshotToUse = existingSnapshot
+      logProcessing('Resuming deployment using saved task snapshot...')
+    } else {
+      await clearPendingTasksSnapshot(rootDir)
+      logWarning('Discarded pending deployment snapshot.')
+    }
+  }
+
+  let lockAcquired = false
+
+  try {
+    await acquireProjectLock(rootDir)
+    lockAcquired = true
+    await runRemoteTasks(deploymentConfig, { rootDir, snapshot: snapshotToUse })
+  } finally {
+    if (lockAcquired) {
+      await releaseProjectLock(rootDir)
+    }
+  }
 }
 
 export {
   ensureGitignoreEntry,
+  ensureProjectReleaseScript,
   listSshKeys,
   resolveRemotePath,
   isPrivateKeyFile,

package/publish.mjs

@@ -1,222 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-import { readFile } from 'node:fs/promises'
-
-const ROOT = dirname(fileURLToPath(import.meta.url))
-const PACKAGE_PATH = join(ROOT, 'package.json')
-
-const STEP_PREFIX = '→'
-const OK_PREFIX = '✔'
-const WARN_PREFIX = '⚠'
-
-function logStep(message) {
-  console.log(`${STEP_PREFIX} ${message}`)
-}
-
-function logSuccess(message) {
-  console.log(`${OK_PREFIX} ${message}`)
-}
-
-function logWarning(message) {
-  console.warn(`${WARN_PREFIX} ${message}`)
-}
-
-function runCommand(command, args, { cwd = ROOT, capture = false } = {}) {
-  return new Promise((resolve, reject) => {
-    const spawnOptions = {
-      cwd,
-      stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit'
-    }
-
-    const child = spawn(command, args, spawnOptions)
-    let stdout = ''
-    let stderr = ''
-
-    if (capture) {
-      child.stdout.on('data', (chunk) => {
-        stdout += chunk
-      })
-
-      child.stderr.on('data', (chunk) => {
-        stderr += chunk
-      })
-    }
-
-    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}): ${command} ${args.join(' ')}`)
-        if (capture) {
-          error.stdout = stdout
-          error.stderr = stderr
-        }
-        error.exitCode = code
-        reject(error)
-      }
-    })
-  })
-}
-
-async function readPackage() {
-  const raw = await readFile(PACKAGE_PATH, 'utf8')
-  return JSON.parse(raw)
-}
-
-async function ensureCleanWorkingTree() {
-  const { stdout } = await runCommand('git', ['status', '--porcelain'], { capture: true })
-
-  if (stdout.length > 0) {
-    throw new Error('Working tree has uncommitted changes. Commit or stash them before releasing.')
-  }
-}
-
-async function getCurrentBranch() {
-  const { stdout } = await runCommand('git', ['branch', '--show-current'], { capture: true })
-  return stdout || null
-}
-
-async function getUpstreamRef() {
-  try {
-    const { stdout } = await runCommand('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], {
-      capture: true
-    })
-
-    return stdout || null
-  } catch {
-    return null
-  }
-}
-
-async function ensureUpToDateWithUpstream(branch, upstreamRef) {
-  if (!upstreamRef) {
-    logWarning(`Branch ${branch} has no upstream configured; skipping ahead/behind checks.`)
-    return
-  }
-
-  const aheadResult = await runCommand('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], {
-    capture: true
-  })
-  const behindResult = await runCommand('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], {
-    capture: true
-  })
-
-  const ahead = Number.parseInt(aheadResult.stdout || '0', 10)
-  const behind = Number.parseInt(behindResult.stdout || '0', 10)
-
-  if (Number.isFinite(behind) && behind > 0) {
-    throw new Error(
-      `Branch ${branch} is behind ${upstreamRef} by ${behind} commit${behind === 1 ? '' : 's'}. Pull or rebase first.`
-    )
-  }
-
-  if (Number.isFinite(ahead) && ahead > 0) {
-    logWarning(`Branch ${branch} is ahead of ${upstreamRef} by ${ahead} commit${ahead === 1 ? '' : 's'}.`)
-  }
-}
-
-function parseArgs() {
-  const args = process.argv.slice(2)
-  const positionals = args.filter((arg) => !arg.startsWith('--'))
-  const flags = new Set(args.filter((arg) => arg.startsWith('--')))
-
-  const releaseType = positionals[0] ?? 'patch'
-  const skipTests = flags.has('--skip-tests')
-
-  const allowedTypes = new Set([
-    'major',
-    'minor',
-    'patch',
-    'premajor',
-    'preminor',
-    'prepatch',
-    'prerelease'
-  ])
-
-  if (!allowedTypes.has(releaseType)) {
-    throw new Error(
-      `Invalid release type "${releaseType}". Use one of: ${Array.from(allowedTypes).join(', ')}.`
-    )
-  }
-
-  return { releaseType, skipTests }
-}
-
-async function runTests(skipTests) {
-  if (skipTests) {
-    logWarning('Skipping tests because --skip-tests flag was provided.')
-    return
-  }
-
-  logStep('Running test suite (vitest run)...')
-  await runCommand('npx', ['vitest', 'run'])
-  logSuccess('Tests passed.')
-}
-
-async function ensureNpmAuth() {
-  logStep('Confirming npm authentication...')
-  await runCommand('npm', ['whoami'])
-}
-
-async function bumpVersion(releaseType) {
-  logStep(`Bumping package version with "npm version ${releaseType}"...`)
-  await runCommand('npm', ['version', releaseType, '--message', 'chore: release %s'])
-  const pkg = await readPackage()
-  logSuccess(`Version updated to ${pkg.version}.`)
-  return pkg
-}
-
-async function pushChanges() {
-  logStep('Pushing commits and tags to origin...')
-  await runCommand('git', ['push', '--follow-tags'])
-  logSuccess('Git push completed.')
-}
-
-async function publishPackage(pkg) {
-  const publishArgs = ['publish']
-
-  if (pkg.name.startsWith('@')) {
-    publishArgs.push('--access', 'public')
-  }
-
-  logStep(`Publishing ${pkg.name}@${pkg.version} to npm...`)
-  await runCommand('npm', publishArgs)
-  logSuccess('npm publish completed.')
-}
-
-async function main() {
-  const { releaseType, skipTests } = parseArgs()
-
-  logStep('Reading package metadata...')
-  const pkg = await readPackage()
-
-  logStep('Checking working tree status...')
-  await ensureCleanWorkingTree()
-
-  const branch = await getCurrentBranch()
-  if (!branch) {
-    throw new Error('Unable to determine current branch.')
-  }
-
-  logStep(`Current branch: ${branch}`)
-  const upstreamRef = await getUpstreamRef()
-  await ensureUpToDateWithUpstream(branch, upstreamRef)
-
-  await runTests(skipTests)
-  await ensureNpmAuth()
-
-  const updatedPkg = await bumpVersion(releaseType)
-  await pushChanges()
-  await publishPackage(updatedPkg)
-
-  logSuccess(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
-}
-
-main().catch((error) => {
-  console.error('\nRelease failed:')
-  console.error(error.message)
-  process.exit(1)
-})

package/tests/index.test.js

@@ -1,426 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-
-const mockReadFile = vi.fn()
-const mockReaddir = vi.fn()
-const mockAccess = vi.fn()
-const mockWriteFile = vi.fn()
-const mockMkdir = vi.fn()
-const mockExecCommand = vi.fn()
-const mockConnect = vi.fn()
-const mockDispose = vi.fn()
-const mockPrompt = vi.fn()
-
-vi.mock('node:fs/promises', () => ({
-  default: {
-    readFile: mockReadFile,
-    readdir: mockReaddir,
-    access: mockAccess,
-    writeFile: mockWriteFile,
-    mkdir: mockMkdir
-  },
-  readFile: mockReadFile,
-  readdir: mockReaddir,
-  access: mockAccess,
-  writeFile: mockWriteFile,
-  mkdir: mockMkdir
-}))
-
-const spawnQueue = []
-
-const queueSpawnResponse = (response = {}) => {
-  spawnQueue.push(response)
-}
-
-const mockSpawn = vi.fn((command, args) => {
-  const { stdout = '', stderr = '', exitCode = 0, error } =
-    spawnQueue.length > 0 ? spawnQueue.shift() : {}
-
-  const stdoutHandlers = []
-  const stderrHandlers = []
-  const closeHandlers = []
-  const errorHandlers = []
-
-  setImmediate(() => {
-    if (error) {
-      errorHandlers.forEach((handler) => handler(error))
-      return
-    }
-
-    if (stdout) {
-      const chunk = Buffer.from(stdout)
-      stdoutHandlers.forEach((handler) => handler(chunk))
-    }
-
-    if (stderr) {
-      const chunk = Buffer.from(stderr)
-      stderrHandlers.forEach((handler) => handler(chunk))
-    }
-
-    closeHandlers.forEach((handler) => handler(exitCode))
-  })
-
-  return {
-    stdout: {
-      on: (event, handler) => {
-        if (event === 'data') {
-          stdoutHandlers.push(handler)
-        }
-      }
-    },
-    stderr: {
-      on: (event, handler) => {
-        if (event === 'data') {
-          stderrHandlers.push(handler)
-        }
-      }
-    },
-    on: (event, handler) => {
-      if (event === 'close') {
-        closeHandlers.push(handler)
-      }
-
-      if (event === 'error') {
-        errorHandlers.push(handler)
-      }
-    }
-  }
-})
-
-vi.mock('node:child_process', () => ({
-  spawn: mockSpawn,
-  default: {
-    spawn: mockSpawn
-  }
-}))
-
-vi.mock('inquirer', () => {
-  class Separator {}
-
-  return {
-    default: {
-      prompt: mockPrompt,
-      Separator
-    },
-    Separator,
-    prompt: mockPrompt
-  }
-})
-
-vi.mock('node-ssh', () => ({
-  NodeSSH: vi.fn(() => ({
-    connect: mockConnect,
-    execCommand: mockExecCommand,
-    dispose: mockDispose
-  }))
-}))
-
-vi.mock('node:os', () => ({
-  default: {
-    homedir: () => '/home/local',
-    userInfo: () => ({ username: 'localuser' })
-  },
-  homedir: () => '/home/local',
-  userInfo: () => ({ username: 'localuser' })
-}))
-
-describe('zephyr deployment helpers', () => {
-  beforeEach(() => {
-    vi.resetModules()
-    spawnQueue.length = 0
-    mockSpawn.mockClear()
-    mockReadFile.mockReset()
-    mockReaddir.mockReset()
-    mockAccess.mockReset()
-    mockWriteFile.mockReset()
-  mockMkdir.mockReset()
-    mockExecCommand.mockReset()
-    mockConnect.mockReset()
-    mockDispose.mockReset()
-    mockPrompt.mockReset()
-    globalThis.__zephyrSSHFactory = () => ({
-      connect: mockConnect,
-      execCommand: mockExecCommand,
-      dispose: mockDispose
-    })
-    globalThis.__zephyrPrompt = mockPrompt
-  })
-
-  afterEach(() => {
-    delete globalThis.__zephyrSSHFactory
-    delete globalThis.__zephyrPrompt
-  })
-
-  it('resolves remote paths correctly', async () => {
-    const { resolveRemotePath } = await import('../src/index.mjs')
-
-    expect(resolveRemotePath('~/webapps/app', '/home/runcloud')).toBe(
-      '/home/runcloud/webapps/app'
-    )
-    expect(resolveRemotePath('app', '/home/runcloud')).toBe('/home/runcloud/app')
-    expect(resolveRemotePath('/var/www/html', '/home/runcloud')).toBe(
-      '/var/www/html'
-    )
-    expect(resolveRemotePath('~', '/home/runcloud')).toBe('/home/runcloud')
-  })
-
-  it('detects private key files from contents', async () => {
-    mockReadFile.mockResolvedValueOnce('-----BEGIN OPENSSH PRIVATE KEY-----')
-
-    const { isPrivateKeyFile } = await import('../src/index.mjs')
-
-    await expect(isPrivateKeyFile('/home/local/.ssh/id_rsa')).resolves.toBe(true)
-
-    mockReadFile.mockResolvedValueOnce('not-a-key')
-    await expect(isPrivateKeyFile('/home/local/.ssh/config')).resolves.toBe(false)
-  })
-
-  it('lists only valid SSH private keys', async () => {
-    mockReaddir.mockResolvedValue([
-      { name: 'id_rsa', isFile: () => true },
-      { name: 'id_rsa.pub', isFile: () => true },
-      { name: '.DS_Store', isFile: () => true },
-      { name: 'config', isFile: () => true },
-      { name: 'deploy_key', isFile: () => true }
-    ])
-
-    mockReadFile.mockImplementation(async (filePath) => {
-      if (filePath.endsWith('id_rsa')) {
-        return '-----BEGIN RSA PRIVATE KEY-----'
-      }
-
-      if (filePath.endsWith('deploy_key')) {
-        return '-----BEGIN OPENSSH PRIVATE KEY-----'
-      }
-
-      return 'invalid'
-    })
-
-    // Import path module to ensure cross-platform path handling
-    const path = await import('node:path')
-    const { listSshKeys } = await import('../src/index.mjs')
-
-    const result = await listSshKeys()
-
-    expect(result).toEqual({
-      sshDir: path.default.join('/home/local', '.ssh'),
-      keys: ['id_rsa', 'deploy_key']
-    })
-  })
-
-  describe('configuration management', () => {
-    it('registers a new server when none exist', async () => {
-      mockPrompt.mockResolvedValueOnce({ serverName: 'production', serverIp: '203.0.113.10' })
-
-      const { selectServer } = await import('../src/index.mjs')
-
-      const servers = []
-      const server = await selectServer(servers)
-
-      expect(server).toEqual({ serverName: 'production', serverIp: '203.0.113.10' })
-      expect(servers).toHaveLength(1)
-      expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.config/zephyr'), { recursive: true })
-      const [writePath, payload] = mockWriteFile.mock.calls.at(-1)
-      expect(writePath).toContain('servers.json')
-      expect(payload).toContain('production')
-    })
-
-    it('creates a new application configuration when none exist for a server', async () => {
-      queueSpawnResponse({ stdout: 'main\n' })
-      mockPrompt
-        .mockResolvedValueOnce({ projectPath: '~/webapps/demo', branchSelection: 'main' })
-        .mockResolvedValueOnce({ sshUser: 'forge', sshKeySelection: '/home/local/.ssh/id_rsa' })
-      mockReaddir.mockResolvedValue([])
-
-      const { selectApp } = await import('../src/index.mjs')
-
-      const projectConfig = { apps: [] }
-      const server = { serverName: 'production', serverIp: '203.0.113.10' }
-
-      const app = await selectApp(projectConfig, server, process.cwd())
-
-      expect(app).toMatchObject({
-        serverName: 'production',
-        projectPath: '~/webapps/demo',
-        branch: 'main',
-        sshUser: 'forge',
-        sshKey: '/home/local/.ssh/id_rsa'
-      })
-      expect(projectConfig.apps).toHaveLength(1)
-      expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.zephyr'), { recursive: true })
-      const [writePath, payload] = mockWriteFile.mock.calls.at(-1)
-      expect(writePath).toContain('.zephyr/config.json')
-      expect(payload).toContain('~/webapps/demo')
-    })
-  })
-
-  it('schedules Laravel tasks based on diff', async () => {
-    queueSpawnResponse({ stdout: 'main\n' })
-    queueSpawnResponse({ stdout: '' })
-
-    mockConnect.mockResolvedValue()
-    mockDispose.mockResolvedValue()
-
-    mockExecCommand.mockImplementation(async (command) => {
-      const response = { stdout: '', stderr: '', code: 0 }
-
-      if (command.includes('printf "%s" "$HOME"')) {
-        return { ...response, stdout: '/home/runcloud' }
-      }
-
-      if (command.includes('grep -q "laravel/framework"')) {
-        return { ...response, stdout: 'yes' }
-      }
-
-      if (command.startsWith('git diff')) {
-        return {
-          ...response,
-          stdout:
-            'composer.json\n' +
-            'database/migrations/2025_10_21_000000_create_table.php\n' +
-            'resources/js/app.js\n' +
-            'resources/views/welcome.blade.php\n' +
-            'config/horizon.php\n'
-        }
-      }
-
-      if (command.includes('config/horizon.php')) {
-        return { ...response, stdout: 'yes' }
-      }
-
-      return response
-    })
-
-    const { runRemoteTasks } = await import('../src/index.mjs')
-
-    await runRemoteTasks({
-      serverIp: '127.0.0.1',
-      projectPath: '~/app',
-      branch: 'main',
-      sshUser: 'forge',
-      sshKey: '~/.ssh/id_rsa'
-    })
-
-    const cwdValues = mockExecCommand.mock.calls
-      .map(([, options]) => options?.cwd)
-      .filter(Boolean)
-    expect(cwdValues.length).toBeGreaterThan(0)
-    expect(cwdValues.every((cwd) => typeof cwd === 'string')).toBe(true)
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('git pull origin main'),
-      expect.objectContaining({ cwd: expect.any(String) })
-    )
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('composer update'),
-      expect.objectContaining({ cwd: expect.any(String) })
-    )
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('php artisan migrate'),
-      expect.objectContaining({ cwd: expect.any(String) })
-    )
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('npm run build'),
-      expect.objectContaining({ cwd: expect.any(String) })
-    )
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('cache:clear'),
-      expect.objectContaining({ cwd: expect.any(String) })
-    )
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('horizon:terminate'),
-      expect.objectContaining({ cwd: expect.any(String) })
-    )
-  })
-
-  it('skips Laravel tasks when framework not detected', async () => {
-    queueSpawnResponse({ stdout: 'main\n' })
-    queueSpawnResponse({ stdout: '' })
-
-    mockConnect.mockResolvedValue()
-    mockDispose.mockResolvedValue()
-
-    mockExecCommand
-      .mockResolvedValueOnce({ stdout: '/home/runcloud', stderr: '', code: 0 })
-      .mockResolvedValueOnce({ stdout: 'no', stderr: '', code: 0 })
-      .mockResolvedValue({ stdout: '', stderr: '', code: 0 })
-
-    const { runRemoteTasks } = await import('../src/index.mjs')
-
-    await runRemoteTasks({
-      serverIp: '127.0.0.1',
-      projectPath: '~/app',
-      branch: 'main',
-      sshUser: 'forge',
-      sshKey: '~/.ssh/id_rsa'
-    })
-
-    expect(mockExecCommand).not.toHaveBeenCalledWith(
-      expect.stringContaining('composer update'),
-      expect.anything()
-    )
-    expect(mockExecCommand).toHaveBeenCalledWith(
-      expect.stringContaining('git pull origin main'),
-      expect.anything()
-    )
-  })
-
-  describe('ensureLocalRepositoryState', () => {
-    it('switches to the target branch when clean', async () => {
-      queueSpawnResponse({ stdout: 'develop\n' })
-      queueSpawnResponse({ stdout: '' })
-      queueSpawnResponse({})
-      queueSpawnResponse({ stdout: '' })
-
-      const { ensureLocalRepositoryState } = await import('../src/index.mjs')
-
-      await expect(
-        ensureLocalRepositoryState('main', process.cwd())
-      ).resolves.toBeUndefined()
-
-      expect(
-        mockSpawn.mock.calls.some(
-          ([command, args]) => command === 'git' && args.includes('checkout') && args.includes('main')
-        )
-      ).toBe(true)
-    })
-
-    it('throws when attempting to switch branches with uncommitted changes', async () => {
-      queueSpawnResponse({ stdout: 'develop\n' })
-      queueSpawnResponse({ stdout: ' M file.txt\n' })
-
-      const { ensureLocalRepositoryState } = await import('../src/index.mjs')
-
-      await expect(
-        ensureLocalRepositoryState('main', process.cwd())
-      ).rejects.toThrow(/uncommitted changes/)
-    })
-
-    it('commits and pushes pending changes on the target branch', async () => {
-      queueSpawnResponse({ stdout: 'main\n' })
-      queueSpawnResponse({ stdout: ' M file.php\n' })
-      queueSpawnResponse({})
-      queueSpawnResponse({})
-      queueSpawnResponse({})
-      queueSpawnResponse({ stdout: '' })
-
-      mockPrompt.mockResolvedValueOnce({ commitMessage: 'Prepare deployment' })
-
-      const { ensureLocalRepositoryState } = await import('../src/index.mjs')
-
-      await expect(
-        ensureLocalRepositoryState('main', process.cwd())
-      ).resolves.toBeUndefined()
-
-      expect(mockPrompt).toHaveBeenCalledTimes(1)
-      expect(
-        mockSpawn.mock.calls.some(
-          ([command, args]) => command === 'git' && args[0] === 'commit'
-        )
-      ).toBe(true)
-      expect(
-        mockSpawn.mock.calls.some(
-          ([command, args]) => command === 'git' && args[0] === 'push' && args.includes('main')
-        )
-      ).toBe(true)
-    })
-  })
-})