@wyxos/zephyr 0.2.27 → 0.2.31

package/package.json

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

package/src/deploy/preflight.mjs

@@ -45,7 +45,7 @@ export async function hasLaravelPint(rootDir) {
   }
 }
 
-export async function runLinting(rootDir, { runCommand, logProcessing, logSuccess } = {}) {
+export async function runLinting(rootDir, { runCommand, logProcessing, logSuccess, logWarning, commandExists } = {}) {
   const hasNpmLint = await hasLintScript(rootDir)
   const hasPint = await hasLaravelPint(rootDir)
 
@@ -57,6 +57,15 @@ export async function runLinting(rootDir, { runCommand, logProcessing, logSucces
   }
 
   if (hasPint) {
+    // Check if PHP is available before trying to run Pint
+    if (commandExists && !commandExists('php')) {
+      logWarning?.(
+        'PHP is not available in PATH. Skipping Laravel Pint.\n' +
+        '  To run Pint locally, ensure PHP is installed and added to your PATH.'
+      )
+      return false
+    }
+
     logProcessing?.('Running Laravel Pint...')
     await runCommand('php', ['vendor/bin/pint'], { cwd: rootDir })
     logSuccess?.('Linting completed.')

package/src/main.mjs

@@ -9,7 +9,7 @@ import { releaseNode } from './release-node.mjs'
 import { releasePackagist } from './release-packagist.mjs'
 import { validateLocalDependencies } from './dependency-scanner.mjs'
 import { createChalkLogger, writeStderrLine, writeStdoutLine } from './utils/output.mjs'
-import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
+import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase, commandExists } from './utils/command.mjs'
 import { planLaravelDeploymentTasks } from './utils/task-planner.mjs'
 import { getPhpVersionRequirement, findPhpBinary } from './utils/php-version.mjs'
 import {
@@ -122,7 +122,7 @@ async function resolveSshKeyPath(targetPath) {
 // resolveRemotePath moved to src/utils/remote-path.mjs
 
 async function runLinting(rootDir) {
-  return await preflight.runLinting(rootDir, { runCommand, logProcessing, logSuccess })
+  return await preflight.runLinting(rootDir, { runCommand, logProcessing, logSuccess, logWarning, commandExists })
 }
 
 async function commitLintingChanges(rootDir) {
@@ -164,12 +164,28 @@ async function runRemoteTasks(config, options = {}) {
 
     // Run tests for Laravel projects
     if (isLaravel) {
-      logProcessing('Running Laravel tests locally...')
-      try {
-        await runCommand('php', ['artisan', 'test', '--compact'], { cwd: rootDir })
-        logSuccess('Local tests passed.')
-      } catch (error) {
-        throw new Error(`Local tests failed. Fix test failures before deploying. ${error.message}`)
+      // Check if PHP is available before trying to run tests
+      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.'
+        )
+      } else {
+        logProcessing('Running Laravel tests locally...')
+        try {
+          await runCommand('php', ['artisan', 'test', '--compact'], { cwd: rootDir })
+          logSuccess('Local tests passed.')
+        } catch (error) {
+          // Provide clearer error message based on error type
+          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}`)
+        }
       }
     }
   } else {

package/src/release-node.mjs

@@ -229,29 +229,6 @@ async function runLibBuild(skipBuild, pkg, rootDir = process.cwd()) {
   return hasLibChanges
 }
 
-async function ensureNpmAuth(pkg, rootDir = process.cwd()) {
-  const isPrivate = pkg?.publishConfig?.access === 'restricted'
-  if (isPrivate) {
-    logStep('Skipping npm authentication check (package is private/restricted).')
-    return
-  }
-
-  logStep('Confirming npm authentication...')
-  try {
-    const result = await runCommand('npm', ['whoami'], { capture: true, cwd: rootDir })
-    // Only show username if we captured it, otherwise just show success
-    if (result?.stdout) {
-      // Silently authenticated - we don't need to show the username
-    }
-    logSuccess('npm authenticated.')
-  } catch (error) {
-    if (error.stderr) {
-      writeStderr(error.stderr)
-    }
-    throw error
-  }
-}
-
 async function bumpVersion(releaseType, rootDir = process.cwd()) {
   logStep(`Bumping package version...`)
 
@@ -316,40 +293,6 @@ async function pushChanges(rootDir = process.cwd()) {
   }
 }
 
-async function publishPackage(pkg, rootDir = process.cwd()) {
-  // Check if package is configured as private/restricted
-  const isPrivate = pkg.publishConfig?.access === 'restricted'
-
-  if (isPrivate) {
-    logWarning('Skipping npm publish (package is configured as private/restricted).')
-    logWarning('Private packages require npm paid plan. Publish manually or use GitHub Packages.')
-    return
-  }
-
-  const publishArgs = ['publish', '--ignore-scripts'] // Skip prepublishOnly since we already built lib
-
-  if (pkg.name.startsWith('@')) {
-    // For scoped packages, determine access level from publishConfig
-    // Default to 'public' for scoped packages if not specified (free npm accounts require public for scoped packages)
-    const access = pkg.publishConfig?.access || 'public'
-    publishArgs.push('--access', access)
-  }
-
-  logStep(`Publishing ${pkg.name}@${pkg.version} to npm...`)
-  try {
-    await runCommand('npm', publishArgs, { capture: true, cwd: rootDir })
-    logSuccess('npm publish 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 {
@@ -470,14 +413,14 @@ export async function releaseNode() {
     await runLint(skipLint, pkg, rootDir)
     await runTests(skipTests, pkg, rootDir)
     await runLibBuild(skipBuild, pkg, rootDir)
-    await ensureNpmAuth(pkg, rootDir)
 
     const updatedPkg = await bumpVersion(releaseType, rootDir)
     await runBuild(skipBuild, updatedPkg, rootDir)
     await pushChanges(rootDir)
-    await publishPackage(updatedPkg, rootDir)
     await deployGHPages(skipDeploy, updatedPkg, rootDir)
 
+    logStep('Publishing will be handled by GitHub Actions via trusted publishing.')
+
     logSuccess(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
   } catch (error) {
     writeStderrLine('\nRelease failed:')

package/src/utils/command.mjs

@@ -1,8 +1,30 @@
-import { spawn } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import process from 'node:process'
 
 const DEFAULT_IS_WINDOWS = process.platform === 'win32'
 
+/**
+ * Check if a command exists in PATH.
+ * @param {string} command - The command to check
+ * @returns {boolean} - True if the command exists
+ */
+export function commandExists(command) {
+  const resolvedCommand = resolveCommandForPlatform(command)
+
+  // On Windows, use 'where', on Unix use 'which'
+  const checker = DEFAULT_IS_WINDOWS ? 'where' : 'which'
+
+  try {
+    const result = spawnSync(checker, [resolvedCommand], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      shell: DEFAULT_IS_WINDOWS
+    })
+    return result.status === 0
+  } catch {
+    return false
+  }
+}
+
 export function resolveCommandForPlatform(command, { isWindows = DEFAULT_IS_WINDOWS } = {}) {
   if (!isWindows) {
     return command
@@ -16,6 +38,20 @@ export function resolveCommandForPlatform(command, { isWindows = DEFAULT_IS_WIND
   return command
 }
 
+/**
+ * Check if a command should be run with shell: true on Windows.
+ * This is needed for commands that might be .bat or .cmd shims (like php via Herd).
+ */
+export function shouldUseShellOnWindows(command) {
+  if (!DEFAULT_IS_WINDOWS) {
+    return false
+  }
+  // Commands that are commonly provided as batch file shims on Windows
+  // Note: git is NOT included because Git for Windows installs a proper git.exe
+  const shellCommands = ['php', 'composer']
+  return shellCommands.includes(command.toLowerCase())
+}
+
 function isWindowsShellShim(command) {
   return DEFAULT_IS_WINDOWS && typeof command === 'string' && /\.(cmd|bat)$/i.test(command)
 }
@@ -33,13 +69,26 @@ function quoteForCmd(arg) {
 
 export async function runCommand(command, args, { cwd = process.cwd(), stdio = 'inherit' } = {}) {
   const resolvedCommand = resolveCommandForPlatform(command)
+  const useShell = isWindowsShellShim(resolvedCommand) || shouldUseShellOnWindows(command)
 
   return new Promise((resolve, reject) => {
-    const child = isWindowsShellShim(resolvedCommand)
+    const child = useShell
       ? spawn([resolvedCommand, ...(args ?? []).map(quoteForCmd)].join(' '), { cwd, stdio, shell: true })
       : spawn(resolvedCommand, args, { cwd, stdio })
 
-    child.on('error', reject)
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const error = new Error(
+          `Command not found: "${resolvedCommand}". ` +
+          `Make sure "${command}" is installed and available in your PATH.`
+        )
+        error.code = 'ENOENT'
+        error.originalError = err
+        reject(error)
+      } else {
+        reject(err)
+      }
+    })
     child.on('close', (code) => {
       if (code === 0) {
         resolve()
@@ -54,12 +103,13 @@ export async function runCommand(command, args, { cwd = process.cwd(), stdio = '
 
 export async function runCommandCapture(command, args, { cwd = process.cwd() } = {}) {
   const resolvedCommand = resolveCommandForPlatform(command)
+  const useShell = isWindowsShellShim(resolvedCommand) || shouldUseShellOnWindows(command)
 
   return new Promise((resolve, reject) => {
     let stdout = ''
     let stderr = ''
 
-    const child = isWindowsShellShim(resolvedCommand)
+    const child = useShell
       ? spawn([resolvedCommand, ...(args ?? []).map(quoteForCmd)].join(' '), {
         cwd,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -75,7 +125,19 @@ export async function runCommandCapture(command, args, { cwd = process.cwd() } =
       stderr += chunk
     })
 
-    child.on('error', reject)
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const error = new Error(
+          `Command not found: "${resolvedCommand}". ` +
+          `Make sure "${command}" is installed and available in your PATH.`
+        )
+        error.code = 'ENOENT'
+        error.originalError = err
+        reject(error)
+      } else {
+        reject(err)
+      }
+    })
     child.on('close', (code) => {
       if (code === 0) {
         resolve({ stdout, stderr })