@wyxos/zephyr 0.2.17 → 0.2.19

package/src/utils/git.mjs

@@ -0,0 +1,91 @@
+import process from 'node:process'
+import { runCommand, runCommandCapture } from './command.mjs'
+
+export async function getCurrentBranch(rootDir = process.cwd(), { method = 'rev-parse' } = {}) {
+  if (method === 'show-current') {
+    const { stdout } = await runCommandCapture('git', ['branch', '--show-current'], { cwd: rootDir })
+    return stdout.trim() || null
+  }
+
+  const { stdout } = await runCommandCapture('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: rootDir })
+  return stdout.trim() || null
+}
+
+export async function getUpstreamRef(rootDir = process.cwd()) {
+  try {
+    const { stdout } = await runCommandCapture(
+      'git',
+      ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'],
+      { cwd: rootDir }
+    )
+
+    return stdout.trim() || null
+  } catch {
+    return null
+  }
+}
+
+export async function ensureUpToDateWithUpstream({
+  branch,
+  upstreamRef,
+  rootDir = process.cwd(),
+  logStep = null,
+  logWarning = null
+}) {
+  if (!upstreamRef) {
+    logWarning?.(`Branch ${branch} has no upstream configured; skipping ahead/behind checks.`)
+    return
+  }
+
+  const [remoteName, ...branchParts] = upstreamRef.split('/')
+  const remoteBranch = branchParts.join('/')
+
+  if (remoteName && remoteBranch) {
+    logStep?.(`Fetching latest updates from ${remoteName}/${remoteBranch}...`)
+    try {
+      await runCommand('git', ['fetch', remoteName, remoteBranch], { cwd: rootDir, stdio: 'ignore' })
+    } catch (error) {
+      throw new Error(`Failed to fetch ${upstreamRef}: ${error.message}`)
+    }
+  }
+
+  const aheadResult = await runCommandCapture('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], {
+    cwd: rootDir
+  })
+  const behindResult = await runCommandCapture('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], {
+    cwd: rootDir
+  })
+
+  const ahead = Number.parseInt(aheadResult.stdout || '0', 10)
+  const behind = Number.parseInt(behindResult.stdout || '0', 10)
+
+  if (Number.isFinite(behind) && behind > 0) {
+    if (remoteName && remoteBranch) {
+      logStep?.(`Fast-forwarding ${branch} with ${upstreamRef}...`)
+
+      try {
+        await runCommand('git', ['pull', '--ff-only', remoteName, remoteBranch], { cwd: rootDir, stdio: 'ignore' })
+      } catch (error) {
+        throw new Error(
+          `Unable to fast-forward ${branch} with ${upstreamRef}. Resolve conflicts manually, then rerun.\n${error.message}`
+        )
+      }
+
+      await ensureUpToDateWithUpstream({ branch, upstreamRef, rootDir, logStep, logWarning })
+      return
+    }
+
+    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'}.`)
+  }
+}
+
+export async function pushQuiet(rootDir = process.cwd(), args = []) {
+  await runCommandCapture('git', ['push', ...args], { cwd: rootDir })
+}
+

package/src/utils/id.mjs

@@ -0,0 +1,6 @@
+import crypto from 'node:crypto'
+
+export function generateId() {
+  return crypto.randomBytes(8).toString('hex')
+}
+

package/src/utils/log-file.mjs

@@ -0,0 +1,76 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { ensureDirectory, getProjectConfigDir } from './paths.mjs'
+
+let logFilePath = null
+
+export async function getLogFilePath(rootDir) {
+  if (logFilePath) {
+    return logFilePath
+  }
+
+  const configDir = getProjectConfigDir(rootDir)
+  await ensureDirectory(configDir)
+
+  const now = new Date()
+  const dateStr = now.toISOString().replace(/:/g, '-').replace(/\..+/, '')
+  logFilePath = path.join(configDir, `${dateStr}.log`)
+
+  return logFilePath
+}
+
+export async function writeToLogFile(rootDir, message) {
+  const logPath = await getLogFilePath(rootDir)
+  const timestamp = new Date().toISOString()
+  await fs.appendFile(logPath, `${timestamp} - ${message}\n`)
+}
+
+export async function closeLogFile() {
+  logFilePath = null
+}
+
+export async function cleanupOldLogs(rootDir) {
+  const configDir = getProjectConfigDir(rootDir)
+
+  try {
+    const files = await fs.readdir(configDir)
+    const logFiles = files
+      .filter((file) => file.endsWith('.log'))
+      .map((file) => ({
+        name: file,
+        path: path.join(configDir, file)
+      }))
+
+    if (logFiles.length <= 3) {
+      return
+    }
+
+    const filesWithStats = await Promise.all(
+      logFiles.map(async (file) => {
+        const stats = await fs.stat(file.path)
+        return {
+          ...file,
+          mtime: stats.mtime
+        }
+      })
+    )
+
+    filesWithStats.sort((a, b) => b.mtime - a.mtime)
+
+    const filesToDelete = filesWithStats.slice(3)
+
+    for (const file of filesToDelete) {
+      try {
+        await fs.unlink(file.path)
+      } catch (_error) {
+        // Ignore errors when deleting old logs
+      }
+    }
+  } catch (error) {
+    // Ignore errors during log cleanup
+    if (error.code !== 'ENOENT') {
+      // Only log if it's not a "directory doesn't exist" error
+    }
+  }
+}
+

package/src/utils/output.mjs

@@ -0,0 +1,29 @@
+import process from 'node:process'
+
+export function writeStdoutLine(message = '') {
+  const text = message == null ? '' : String(message)
+  process.stdout.write(`${text}\n`)
+}
+
+export function writeStderrLine(message = '') {
+  const text = message == null ? '' : String(message)
+  process.stderr.write(`${text}\n`)
+}
+
+export function writeStderr(message = '') {
+  const text = message == null ? '' : String(message)
+  process.stderr.write(text)
+  if (text && !text.endsWith('\n')) {
+    process.stderr.write('\n')
+  }
+}
+
+export function createChalkLogger(chalk) {
+  return {
+    logProcessing: (message = '') => writeStdoutLine(chalk.yellow(message)),
+    logSuccess: (message = '') => writeStdoutLine(chalk.green(message)),
+    logWarning: (message = '') => writeStderrLine(chalk.yellow(message)),
+    logError: (message = '') => writeStderrLine(chalk.red(message))
+  }
+}
+

package/src/utils/paths.mjs

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export const PROJECT_CONFIG_DIR = '.zephyr'
+export const PROJECT_CONFIG_FILE = 'config.json'
+export const PROJECT_LOCK_FILE = 'deploy.lock'
+export const PENDING_TASKS_FILE = 'pending-tasks.json'
+
+export async function ensureDirectory(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true })
+}
+
+export function getProjectConfigDir(rootDir) {
+  return path.join(rootDir, PROJECT_CONFIG_DIR)
+}
+
+export function getProjectConfigPath(rootDir) {
+  return path.join(rootDir, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE)
+}
+
+export function getPendingTasksPath(rootDir) {
+  return path.join(getProjectConfigDir(rootDir), PENDING_TASKS_FILE)
+}
+
+export function getLockFilePath(rootDir) {
+  return path.join(getProjectConfigDir(rootDir), PROJECT_LOCK_FILE)
+}
+

package/src/utils/remote-path.mjs

@@ -0,0 +1,23 @@
+export function resolveRemotePath(projectPath, remoteHome) {
+  if (!projectPath) {
+    return projectPath
+  }
+
+  const sanitizedHome = remoteHome.replace(/\/+$/, '')
+
+  if (projectPath === '~') {
+    return sanitizedHome
+  }
+
+  if (projectPath.startsWith('~/')) {
+    const remainder = projectPath.slice(2)
+    return remainder ? `${sanitizedHome}/${remainder}` : sanitizedHome
+  }
+
+  if (projectPath.startsWith('/')) {
+    return projectPath
+  }
+
+  return `${sanitizedHome}/${projectPath}`
+}
+

package/src/utils/task-planner.mjs

@@ -0,0 +1,96 @@
+export function planLaravelDeploymentTasks({
+  branch,
+  isLaravel,
+  changedFiles,
+  horizonConfigured = false
+}) {
+  const safeChangedFiles = Array.isArray(changedFiles) ? changedFiles : []
+
+  const shouldRunComposer =
+    isLaravel &&
+    safeChangedFiles.some(
+      (file) =>
+        file === 'composer.json' ||
+        file === 'composer.lock' ||
+        file.endsWith('/composer.json') ||
+        file.endsWith('/composer.lock')
+    )
+
+  const shouldRunMigrations =
+    isLaravel &&
+    safeChangedFiles.some((file) => file.startsWith('database/migrations/') && file.endsWith('.php'))
+
+  const hasPhpChanges = isLaravel && safeChangedFiles.some((file) => file.endsWith('.php'))
+
+  const shouldRunNpmInstall =
+    isLaravel &&
+    safeChangedFiles.some(
+      (file) =>
+        file === 'package.json' ||
+        file === 'package-lock.json' ||
+        file.endsWith('/package.json') ||
+        file.endsWith('/package-lock.json')
+    )
+
+  const hasFrontendChanges =
+    isLaravel &&
+    safeChangedFiles.some((file) =>
+      ['.vue', '.css', '.scss', '.js', '.ts', '.tsx', '.less'].some((ext) => file.endsWith(ext))
+    )
+
+  const shouldRunBuild = isLaravel && (hasFrontendChanges || shouldRunNpmInstall)
+  const shouldClearCaches = hasPhpChanges
+  const shouldRestartQueues = hasPhpChanges
+
+  const steps = [
+    {
+      label: `Pull latest changes for ${branch}`,
+      command: `git pull origin ${branch}`
+    }
+  ]
+
+  if (shouldRunComposer) {
+    steps.push({
+      label: 'Update Composer dependencies',
+      command: 'composer update --no-dev --no-interaction --prefer-dist'
+    })
+  }
+
+  if (shouldRunMigrations) {
+    steps.push({
+      label: 'Run database migrations',
+      command: 'php artisan migrate --force'
+    })
+  }
+
+  if (shouldRunNpmInstall) {
+    steps.push({
+      label: 'Install Node dependencies',
+      command: 'npm install'
+    })
+  }
+
+  if (shouldRunBuild) {
+    steps.push({
+      label: 'Compile frontend assets',
+      command: 'npm run build'
+    })
+  }
+
+  if (shouldClearCaches) {
+    steps.push({
+      label: 'Clear Laravel caches',
+      command: 'php artisan cache:clear && php artisan config:clear && php artisan view:clear'
+    })
+  }
+
+  if (shouldRestartQueues) {
+    steps.push({
+      label: horizonConfigured ? 'Restart Horizon workers' : 'Restart queue workers',
+      command: horizonConfigured ? 'php artisan horizon:terminate' : 'php artisan queue:restart'
+    })
+  }
+
+  return steps
+}
+

package/src/version-checker.mjs

@@ -97,7 +97,6 @@ async function reExecuteWithLatest(args) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, npxArgs, {
       stdio: 'inherit',
-      shell: IS_WINDOWS,
       env: {
         ...process.env,
         [ZEPHYR_SKIP_VERSION_CHECK_ENV]: '1'