@wyxos/zephyr 0.2.24 → 0.2.26

package/README.md

@@ -33,9 +33,6 @@ 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:
@@ -46,14 +43,6 @@ Follow the interactive prompts to configure your deployment target:
 
 Configuration is saved automatically for future deployments.
 
-## Update Checks
-
-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`, or
-  - Use `zephyr --skip-version-check`
-
 ## Features
 
 - Automated Git operations (branch switching, commits, pushes)

package/bin/zephyr.mjs

@@ -13,15 +13,10 @@ 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(options.type ?? null)
 } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "A streamlined deployment tool for web applications with intelligent Laravel project detection",
   "type": "module",
   "main": "./src/index.mjs",

package/src/deploy/remote-exec.mjs

@@ -90,7 +90,7 @@ export function createRemoteExecutor({ ssh, rootDir, remoteCwd, writeToLogFile,
     }
 
     if (result.code === 0) {
-      logSuccess?.(`✓ ${command}`)
+      logSuccess?.(`✓ ${label}`)
     }
 
     return result

package/src/main.mjs

@@ -8,7 +8,6 @@ import { NodeSSH } from 'node-ssh'
 import { releaseNode } from './release-node.mjs'
 import { releasePackagist } from './release-packagist.mjs'
 import { validateLocalDependencies } from './dependency-scanner.mjs'
-import { checkAndUpdateVersion } from './version-checker.mjs'
 import { createChalkLogger, writeStderrLine, writeStdoutLine } from './utils/output.mjs'
 import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
 import { planLaravelDeploymentTasks } from './utils/task-planner.mjs'
@@ -429,24 +428,6 @@ async function selectPreset(projectConfig, servers) {
 }
 
 async function main(releaseType = null) {
-  // Best-effort update check (skip during tests or when explicitly disabled)
-  // If an update is accepted, the process will re-execute via npx @latest and we should exit early.
-  if (
-    process.env.ZEPHYR_SKIP_VERSION_CHECK !== '1' &&
-    process.env.NODE_ENV !== 'test' &&
-    process.env.VITEST !== 'true'
-  ) {
-    try {
-      const args = process.argv.slice(2)
-      const reExecuted = await checkAndUpdateVersion(runPrompt, args)
-      if (reExecuted) {
-        return
-      }
-    } catch (_error) {
-      // Never block execution due to update check issues
-    }
-  }
-
   // Handle node/vue package release
   if (releaseType === 'node' || releaseType === 'vue') {
     try {

package/src/utils/php-version.mjs

@@ -56,67 +56,130 @@ export async function getPhpVersionRequirement(rootDir) {
   }
 }
 
+const RUNCLOUD_PACKAGES = '/RunCloud/Packages'
+
+function satisfiesVersion(actualVersionStr, requiredVersion) {
+  const normalized = semver.coerce(actualVersionStr)
+  const required = semver.coerce(requiredVersion)
+  return normalized && required && semver.gte(normalized, required)
+}
+
+async function tryPhpPath(ssh, remoteCwd, pathOrCommand) {
+  const versionCheck = await ssh.execCommand(`${pathOrCommand} -r "echo PHP_VERSION;"`, { cwd: remoteCwd })
+  return versionCheck.code === 0 ? versionCheck.stdout.trim() : null
+}
+
+/**
+ * Discovers PHP binaries under RunCloud Packages (e.g. /RunCloud/Packages/php84rc/bin/php).
+ * Lists the directory and tries each php*rc/bin/php, returning the path that satisfies the version.
+ */
+async function findRunCloudPhp(ssh, remoteCwd, requiredVersion) {
+  const listResult = await ssh.execCommand(`ls -1 ${RUNCLOUD_PACKAGES} 2>/dev/null || true`, { cwd: remoteCwd })
+  if (listResult.code !== 0 || !listResult.stdout.trim()) {
+    return null
+  }
+  const entries = listResult.stdout.trim().split(/\r?\n/).map((s) => s.trim()).filter(Boolean)
+  // e.g. php74rc, php80rc, php84rc
+  const phpDirs = entries.filter((name) => /^php\d+rc$/.test(name))
+  const majorMinor = semver.major(requiredVersion) + '.' + semver.minor(requiredVersion)
+  const targetSuffix = `php${majorMinor.replace('.', '')}rc` // php84rc for 8.4
+
+  // Prefer exact match (php84rc for 8.4), then try any that might satisfy
+  const toTry = phpDirs.filter((d) => d === targetSuffix).concat(phpDirs.filter((d) => d !== targetSuffix))
+
+  for (const dir of toTry) {
+    const binPath = `${RUNCLOUD_PACKAGES}/${dir}/bin/php`
+    const actualVersion = await tryPhpPath(ssh, remoteCwd, binPath)
+    if (actualVersion && satisfiesVersion(actualVersion, requiredVersion)) {
+      return binPath
+    }
+  }
+  return null
+}
+
 /**
- * Finds the appropriate PHP binary command for a given version
- * Tries common patterns: php8.4, php8.3, etc.
+ * Resolves a command (e.g. php84) via login shell so aliases are expanded; returns the path if it runs and satisfies version.
+ */
+async function resolveViaLoginShell(ssh, remoteCwd, commandName, requiredVersion) {
+  const whichResult = await ssh.execCommand(`bash -lc 'command -v ${commandName}' 2>/dev/null || true`, { cwd: remoteCwd })
+  if (whichResult.code !== 0 || !whichResult.stdout.trim()) {
+    return null
+  }
+  const pathOrCommand = whichResult.stdout.trim()
+  const actualVersion = await tryPhpPath(ssh, remoteCwd, pathOrCommand)
+  if (actualVersion && satisfiesVersion(actualVersion, requiredVersion)) {
+    return pathOrCommand
+  }
+  return null
+}
+
+/**
+ * Finds the appropriate PHP binary command for a given version.
+ * Tries RunCloud paths, login-shell alias resolution, then common names (php8.4, php84), then default php.
  * @param {object} ssh - SSH client instance
  * @param {string} remoteCwd - Remote working directory
  * @param {string} requiredVersion - Required PHP version (e.g., "8.4.0")
- * @returns {Promise<string>} - PHP command prefix (e.g., "php8.4" or "php")
+ * @returns {Promise<string>} - PHP command or path (e.g., "php8.4", "/RunCloud/Packages/php84rc/bin/php", or "php")
  */
 export async function findPhpBinary(ssh, remoteCwd, requiredVersion) {
   if (!requiredVersion) {
     return 'php'
   }
 
-  // Extract major.minor version (e.g., "8.4" from "8.4.0")
   const majorMinor = semver.major(requiredVersion) + '.' + semver.minor(requiredVersion)
   const versionedPhp = `php${majorMinor.replace('.', '')}` // e.g., "php84"
 
-  // Try versioned PHP binary first (e.g., php8.4, php84)
-  const candidates = [
-    `php${majorMinor}`, // php8.4
-    versionedPhp, // php84
-    'php' // fallback
-  ]
+  // 1. RunCloud: discover /RunCloud/Packages/php*rc/bin/php
+  try {
+    const runcloudPath = await findRunCloudPhp(ssh, remoteCwd, requiredVersion)
+    if (runcloudPath) {
+      return runcloudPath
+    }
+  } catch {
+    // Ignore
+  }
 
+  // 2. Resolve alias via login shell (e.g. php84 -> real path)
+  try {
+    const resolved = await resolveViaLoginShell(ssh, remoteCwd, versionedPhp, requiredVersion)
+    if (resolved) {
+      return resolved
+    }
+    const resolvedDot = await resolveViaLoginShell(ssh, remoteCwd, `php${majorMinor}`, requiredVersion)
+    if (resolvedDot) {
+      return resolvedDot
+    }
+  } catch {
+    // Ignore
+  }
+
+  // 3. Try common names in current PATH (non-login shell)
+  const candidates = [`php${majorMinor}`, versionedPhp]
   for (const candidate of candidates) {
     try {
       const result = await ssh.execCommand(`command -v ${candidate}`, { cwd: remoteCwd })
       if (result.code === 0 && result.stdout.trim()) {
-        // Verify it's actually the right version
-        const versionCheck = await ssh.execCommand(`${candidate} -r "echo PHP_VERSION;"`, { cwd: remoteCwd })
-        if (versionCheck.code === 0) {
-          const actualVersion = versionCheck.stdout.trim()
-          // Normalize version and check if it satisfies the requirement
-          const normalizedVersion = semver.coerce(actualVersion)
-          if (normalizedVersion && semver.gte(normalizedVersion, semver.coerce(requiredVersion))) {
-            return candidate
-          }
+        const actualVersion = await tryPhpPath(ssh, remoteCwd, candidate)
+        if (actualVersion && satisfiesVersion(actualVersion, requiredVersion)) {
+          return candidate
         }
       }
     } catch {
-      // Continue to next candidate
+      // Continue
     }
   }
 
-  // Fallback: try to use default php and check version
+  // 4. Default php
   try {
-    const versionCheck = await ssh.execCommand('php -r "echo PHP_VERSION;"', { cwd: remoteCwd })
-    if (versionCheck.code === 0) {
-      const actualVersion = versionCheck.stdout.trim()
-      const normalizedVersion = semver.coerce(actualVersion)
-      if (normalizedVersion && semver.gte(normalizedVersion, semver.coerce(requiredVersion))) {
-        return 'php'
-      }
+    const actualVersion = await tryPhpPath(ssh, remoteCwd, 'php')
+    if (actualVersion && satisfiesVersion(actualVersion, requiredVersion)) {
+      return 'php'
     }
   } catch {
     // Ignore
   }
 
-  // If we can't find a suitable version, return the versioned command anyway
-  // The error will be clearer when the command fails
-  return `php${majorMinor}`
+  return 'php'
 }
 
 /**

package/src/version-checker.mjs

@@ -1,162 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { fileURLToPath } from 'node:url'
-import path from 'node:path'
-import { spawn } from 'node:child_process'
-import process from 'node:process'
-import https from 'node:https'
-import semver from 'semver'
-
-const IS_WINDOWS = process.platform === 'win32'
-const ZEPHYR_SKIP_VERSION_CHECK_ENV = 'ZEPHYR_SKIP_VERSION_CHECK'
-
-async function getCurrentVersion() {
-  try {
-    // Try to get version from package.json
-    // When running via npx, the package.json is in the installed package directory
-    const packageJsonPath = path.resolve(
-      path.dirname(fileURLToPath(import.meta.url)),
-      '..',
-      'package.json'
-    )
-    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'))
-    return packageJson.version
-  } catch (_error) {
-    // If we can't read package.json, return null
-    return null
-  }
-}
-
-function httpsGetJson(url) {
-  return new Promise((resolve, reject) => {
-    const request = https.get(
-      url,
-      {
-        headers: {
-          accept: 'application/json'
-        }
-      },
-      (response) => {
-        const { statusCode } = response
-        if (!statusCode || statusCode < 200 || statusCode >= 300) {
-          response.resume()
-          resolve(null)
-          return
-        }
-
-        response.setEncoding('utf8')
-        let raw = ''
-        response.on('data', (chunk) => {
-          raw += chunk
-        })
-        response.on('end', () => {
-          try {
-            resolve(JSON.parse(raw))
-          } catch (error) {
-            reject(error)
-          }
-        })
-      }
-    )
-
-    request.on('error', reject)
-    request.end()
-  })
-}
-
-async function getLatestVersion() {
-  try {
-    const data = await httpsGetJson('https://registry.npmjs.org/@wyxos/zephyr/latest')
-    if (!data) {
-      return null
-    }
-    return data.version || null
-  } catch (_error) {
-    return null
-  }
-}
-
-function isNewerVersionAvailable(current, latest) {
-  if (!current || !latest) {
-    return false
-  }
-
-  // Use semver to properly compare versions
-  try {
-    return semver.gt(latest, current)
-  } catch (_error) {
-    // If semver comparison fails, fall back to simple string comparison
-    return latest !== current
-  }
-}
-
-async function reExecuteWithLatest(args) {
-  // Re-execute with npx @wyxos/zephyr@latest
-  const command = IS_WINDOWS ? 'npx.cmd' : 'npx'
-  const npxArgs = ['@wyxos/zephyr@latest', ...args]
-
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, npxArgs, {
-      stdio: 'inherit',
-      env: {
-        ...process.env,
-        [ZEPHYR_SKIP_VERSION_CHECK_ENV]: '1'
-      }
-    })
-
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve()
-      } else {
-        reject(new Error(`Command exited with code ${code}`))
-      }
-    })
-  })
-}
-
-export async function checkAndUpdateVersion(promptFn, args) {
-  try {
-    if (process.env[ZEPHYR_SKIP_VERSION_CHECK_ENV] === '1') {
-      return false
-    }
-
-    const currentVersion = await getCurrentVersion()
-    if (!currentVersion) {
-      // Can't determine current version, skip check
-      return false
-    }
-
-    const latestVersion = await getLatestVersion()
-    if (!latestVersion) {
-      // Can't fetch latest version, skip check
-      return false
-    }
-
-    if (!isNewerVersionAvailable(currentVersion, latestVersion)) {
-      // Already on latest or newer
-      return false
-    }
-
-    // Newer version available, prompt user
-    const { shouldUpdate } = await promptFn([
-      {
-        type: 'confirm',
-        name: 'shouldUpdate',
-        message: `A new version of @wyxos/zephyr is available (${latestVersion}). You are currently on ${currentVersion}. Update and continue?`,
-        default: true
-      }
-    ])
-
-    if (!shouldUpdate) {
-      return false
-    }
-
-    // User confirmed, re-execute with latest version
-    await reExecuteWithLatest(args)
-    return true // Indicates we've re-executed, so the current process should exit
-  } catch (_error) {
-    // If version check fails, just continue with current version
-    // Don't block the user from using the tool
-    return false
-  }
-}