@wyxos/zephyr 0.2.5 → 0.2.8

package/package.json

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

package/src/release-node.mjs

@@ -5,24 +5,14 @@ import { readFile } from 'node:fs/promises'
 import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
-
-const STEP_PREFIX = '→'
-const OK_PREFIX = '✔'
-const WARN_PREFIX = '⚠'
+import chalk from 'chalk'
 
 const IS_WINDOWS = process.platform === 'win32'
 
-function logStep(message) {
-  console.log(`${STEP_PREFIX} ${message}`)
-}
-
-function logSuccess(message) {
-  console.log(`${OK_PREFIX} ${message}`)
-}
-
-function logWarning(message) {
-  console.warn(`${WARN_PREFIX} ${message}`)
-}
+const logProcessing = (message = '') => console.log(chalk.yellow(message))
+const logSuccess = (message = '') => console.log(chalk.green(message))
+const logWarning = (message = '') => console.warn(chalk.yellow(message))
+const logError = (message = '') => console.error(chalk.red(message))
 
 function runCommand(command, args, { cwd = process.cwd(), capture = false, useShell = false } = {}) {
   return new Promise((resolve, reject) => {
@@ -114,7 +104,7 @@ async function ensureUpToDateWithUpstream(branch, upstreamRef, rootDir = process
   const remoteBranch = branchParts.join('/')
 
   if (remoteName && remoteBranch) {
-    logStep(`Fetching latest updates from ${remoteName}/${remoteBranch}...`)
+    logProcessing(`Fetching latest updates from ${remoteName}/${remoteBranch}...`)
     try {
       await runCommand('git', ['fetch', remoteName, remoteBranch], { cwd: rootDir })
     } catch (error) {
@@ -136,7 +126,7 @@ async function ensureUpToDateWithUpstream(branch, upstreamRef, rootDir = process
 
   if (Number.isFinite(behind) && behind > 0) {
     if (remoteName && remoteBranch) {
-      logStep(`Fast-forwarding ${branch} with ${upstreamRef}...`)
+      logProcessing(`Fast-forwarding ${branch} with ${upstreamRef}...`)
 
       try {
         await runCommand('git', ['pull', '--ff-only', remoteName, remoteBranch], { cwd: rootDir })
@@ -198,11 +188,11 @@ async function runLint(skipLint, pkg, rootDir = process.cwd()) {
   }
 
   if (!hasScript(pkg, 'lint')) {
-    logStep('Skipping lint (no lint script found in package.json).')
+    logProcessing('Skipping lint (no lint script found in package.json).')
     return
   }
 
-  logStep('Running lint...')
+  logProcessing('Running lint...')
   await runCommand('npm', ['run', 'lint'], { cwd: rootDir })
   logSuccess('Lint passed.')
 }
@@ -215,21 +205,49 @@ async function runTests(skipTests, pkg, rootDir = process.cwd()) {
 
   // Check for test:run or test script
   if (!hasScript(pkg, 'test:run') && !hasScript(pkg, 'test')) {
-    logStep('Skipping tests (no test or test:run script found in package.json).')
+    logProcessing('Skipping tests (no test or test:run script found in package.json).')
     return
   }
 
-  logStep('Running test suite...')
+  logProcessing('Running test suite...')
 
-  // Prefer test:run if available, otherwise use test with --run flag
-  if (hasScript(pkg, 'test:run')) {
-    await runCommand('npm', ['run', 'test:run'], { cwd: rootDir })
-  } else {
-    // For test script, try to pass --run flag (works with vitest)
-    await runCommand('npm', ['test', '--', '--run'], { cwd: rootDir })
-  }
+  let dotInterval = null
+  try {
+    // Capture output and show dots as progress
+    process.stdout.write('  ')
+    dotInterval = setInterval(() => {
+      process.stdout.write('.')
+    }, 200)
+
+    // Prefer test:run if available, otherwise use test with --run flag
+    if (hasScript(pkg, 'test:run')) {
+      await runCommand('npm', ['run', 'test:run'], { capture: true, cwd: rootDir })
+    } else {
+      // For test script, try to pass --run flag (works with vitest)
+      await runCommand('npm', ['test', '--', '--run'], { capture: true, cwd: rootDir })
+    }
 
-  logSuccess('Tests passed.')
+    if (dotInterval) {
+      clearInterval(dotInterval)
+      dotInterval = null
+    }
+    process.stdout.write('\n')
+    logSuccess('Tests passed.')
+  } catch (error) {
+    // Clear dots and show error output
+    if (dotInterval) {
+      clearInterval(dotInterval)
+      dotInterval = null
+    }
+    process.stdout.write('\n')
+    if (error.stdout) {
+      logError(error.stdout)
+    }
+    if (error.stderr) {
+      logError(error.stderr)
+    }
+    throw error
+  }
 }
 
 async function runBuild(skipBuild, pkg, rootDir = process.cwd()) {
@@ -239,11 +257,11 @@ async function runBuild(skipBuild, pkg, rootDir = process.cwd()) {
   }
 
   if (!hasScript(pkg, 'build')) {
-    logStep('Skipping build (no build script found in package.json).')
+    logProcessing('Skipping build (no build script found in package.json).')
     return
   }
 
-  logStep('Building project...')
+  logProcessing('Building project...')
   await runCommand('npm', ['run', 'build'], { cwd: rootDir })
   logSuccess('Build completed.')
 }
@@ -255,11 +273,11 @@ async function runLibBuild(skipBuild, pkg, rootDir = process.cwd()) {
   }
 
   if (!hasScript(pkg, 'build:lib')) {
-    logStep('Skipping library build (no build:lib script found in package.json).')
+    logProcessing('Skipping library build (no build:lib script found in package.json).')
     return false
   }
 
-  logStep('Building library...')
+  logProcessing('Building library...')
   await runCommand('npm', ['run', 'build:lib'], { cwd: rootDir })
   logSuccess('Library built.')
 
@@ -271,7 +289,7 @@ async function runLibBuild(skipBuild, pkg, rootDir = process.cwd()) {
   })
 
   if (hasLibChanges) {
-    logStep('Committing lib build artifacts...')
+    logProcessing('Committing lib build artifacts...')
     await runCommand('git', ['add', 'lib/'], { cwd: rootDir })
     await runCommand('git', ['commit', '-m', 'chore: build lib artifacts'], { cwd: rootDir })
     logSuccess('Lib build artifacts committed.')
@@ -281,13 +299,13 @@ async function runLibBuild(skipBuild, pkg, rootDir = process.cwd()) {
 }
 
 async function ensureNpmAuth(rootDir = process.cwd()) {
-  logStep('Confirming npm authentication...')
+  logProcessing('Confirming npm authentication...')
   await runCommand('npm', ['whoami'], { cwd: rootDir })
   logSuccess('npm authenticated.')
 }
 
 async function bumpVersion(releaseType, rootDir = process.cwd()) {
-  logStep(`Bumping package version...`)
+  logProcessing(`Bumping package version...`)
 
   // Lib changes should already be committed by runLibBuild, but check anyway
   const { stdout: statusBefore } = await runCommand('git', ['status', '--porcelain'], { capture: true, cwd: rootDir })
@@ -297,7 +315,7 @@ async function bumpVersion(releaseType, rootDir = process.cwd()) {
   })
 
   if (hasLibChanges) {
-    logStep('Stashing lib build artifacts...')
+    logProcessing('Stashing lib build artifacts...')
     await runCommand('git', ['stash', 'push', '-u', '-m', 'temp: lib build artifacts', 'lib/'], { cwd: rootDir })
   }
 
@@ -307,7 +325,7 @@ async function bumpVersion(releaseType, rootDir = process.cwd()) {
   } finally {
     // Restore lib changes and ensure they're in the commit
     if (hasLibChanges) {
-      logStep('Restoring lib build artifacts...')
+      logProcessing('Restoring lib build artifacts...')
       await runCommand('git', ['stash', 'pop'], { cwd: rootDir })
       await runCommand('git', ['add', 'lib/'], { cwd: rootDir })
       const { stdout: statusAfter } = await runCommand('git', ['status', '--porcelain'], { capture: true, cwd: rootDir })
@@ -328,7 +346,7 @@ async function bumpVersion(releaseType, rootDir = process.cwd()) {
 }
 
 async function pushChanges(rootDir = process.cwd()) {
-  logStep('Pushing commits and tags to origin...')
+  logProcessing('Pushing commits and tags to origin...')
   await runCommand('git', ['push', '--follow-tags'], { cwd: rootDir })
   logSuccess('Git push completed.')
 }
@@ -337,10 +355,13 @@ async function publishPackage(pkg, rootDir = process.cwd()) {
   const publishArgs = ['publish', '--ignore-scripts'] // Skip prepublishOnly since we already built lib
 
   if (pkg.name.startsWith('@')) {
-    publishArgs.push('--access', 'public')
+    // 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...`)
+  logProcessing(`Publishing ${pkg.name}@${pkg.version} to npm...`)
   await runCommand('npm', publishArgs, { cwd: rootDir })
   logSuccess('npm publish completed.')
 }
@@ -374,11 +395,11 @@ async function deployGHPages(skipDeploy, pkg, rootDir = process.cwd()) {
   }
 
   if (!distExists) {
-    logStep('Skipping GitHub Pages deployment (no dist directory found).')
+    logProcessing('Skipping GitHub Pages deployment (no dist directory found).')
     return
   }
 
-  logStep('Deploying to GitHub Pages...')
+  logProcessing('Deploying to GitHub Pages...')
 
   // Write CNAME file to dist if homepage is set
   const cnamePath = path.join(distPath, 'CNAME')
@@ -428,35 +449,41 @@ async function deployGHPages(skipDeploy, pkg, rootDir = process.cwd()) {
 }
 
 export async function releaseNode() {
-  const { releaseType, skipTests, skipLint, skipBuild, skipDeploy } = parseArgs()
-  const rootDir = process.cwd()
-
-  logStep('Reading package metadata...')
-  const pkg = await readPackage(rootDir)
-
-  logStep('Checking working tree status...')
-  await ensureCleanWorkingTree(rootDir)
-
-  const branch = await getCurrentBranch(rootDir)
-  if (!branch) {
-    throw new Error('Unable to determine current branch.')
-  }
+  try {
+    const { releaseType, skipTests, skipLint, skipBuild, skipDeploy } = parseArgs()
+    const rootDir = process.cwd()
 
-  logStep(`Current branch: ${branch}`)
-  const upstreamRef = await getUpstreamRef(rootDir)
-  await ensureUpToDateWithUpstream(branch, upstreamRef, rootDir)
+    logProcessing('Reading package metadata...')
+    const pkg = await readPackage(rootDir)
 
-  await runLint(skipLint, pkg, rootDir)
-  await runTests(skipTests, pkg, rootDir)
-  await runBuild(skipBuild, pkg, rootDir)
-  await runLibBuild(skipBuild, pkg, rootDir)
-  await ensureNpmAuth(rootDir)
+    logProcessing('Checking working tree status...')
+    await ensureCleanWorkingTree(rootDir)
 
-  const updatedPkg = await bumpVersion(releaseType, rootDir)
-  await pushChanges(rootDir)
-  await publishPackage(updatedPkg, rootDir)
-  await deployGHPages(skipDeploy, updatedPkg, rootDir)
+    const branch = await getCurrentBranch(rootDir)
+    if (!branch) {
+      throw new Error('Unable to determine current branch.')
+    }
 
-  logSuccess(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
+    logProcessing(`Current branch: ${branch}`)
+    const upstreamRef = await getUpstreamRef(rootDir)
+    await ensureUpToDateWithUpstream(branch, upstreamRef, rootDir)
+
+    await runLint(skipLint, pkg, rootDir)
+    await runTests(skipTests, pkg, rootDir)
+    await runBuild(skipBuild, pkg, rootDir)
+    await runLibBuild(skipBuild, pkg, rootDir)
+    await ensureNpmAuth(rootDir)
+
+    const updatedPkg = await bumpVersion(releaseType, rootDir)
+    await pushChanges(rootDir)
+    await publishPackage(updatedPkg, rootDir)
+    await deployGHPages(skipDeploy, updatedPkg, rootDir)
+
+    logSuccess(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
+  } catch (error) {
+    logError('\nRelease failed:')
+    logError(error.message)
+    throw error
+  }
 }
 

package/src/ssh-utils.mjs

@@ -92,11 +92,11 @@ export async function connectToServer(config, rootDir) {
  * @param {NodeSSH} ssh - SSH client instance
  * @param {string} label - Human-readable label for the command
  * @param {string} command - Command to execute
- * @param {Object} options - Options: { cwd, allowFailure, printStdout, bootstrapEnv, rootDir, writeToLogFile }
+ * @param {Object} options - Options: { cwd, allowFailure, printStdout, bootstrapEnv, rootDir, writeToLogFile, env }
  * @returns {Promise<Object>} Command result
  */
 export async function executeRemoteCommand(ssh, label, command, options = {}) {
-  const { cwd, allowFailure = false, printStdout = true, bootstrapEnv = true, rootDir = null, writeToLogFile = null } = options
+  const { cwd, allowFailure = false, printStdout = true, bootstrapEnv = true, rootDir = null, writeToLogFile = null, env = {} } = options
 
   logProcessing(`\n→ ${label}`)
 
@@ -120,14 +120,27 @@ export async function executeRemoteCommand(ssh, label, command, options = {}) {
   ].join('; ')
 
   const escapeForDoubleQuotes = (value) => value.replace(/(["\\$`])/g, '\\$1')
+  const escapeForSingleQuotes = (value) => value.replace(/'/g, "'\\''")
+
+  // Build environment variable exports
+  let envExports = ''
+  if (Object.keys(env).length > 0) {
+    const envPairs = Object.entries(env).map(([key, value]) => {
+      const escapedValue = escapeForSingleQuotes(String(value))
+      return `${key}='${escapedValue}'`
+    })
+    envExports = envPairs.join(' ') + ' '
+  }
 
   let wrappedCommand = command
   let execOptions = { cwd }
 
   if (bootstrapEnv && cwd) {
     const cwdForShell = escapeForDoubleQuotes(cwd)
-    wrappedCommand = `${profileBootstrap}; cd "${cwdForShell}" && ${command}`
+    wrappedCommand = `${profileBootstrap}; cd "${cwdForShell}" && ${envExports}${command}`
     execOptions = {}
+  } else if (Object.keys(env).length > 0) {
+    wrappedCommand = `${envExports}${command}`
   }
 
   const result = await ssh.execCommand(wrappedCommand, execOptions)
@@ -191,7 +204,13 @@ export async function readRemoteFile(ssh, filePath, remoteCwd) {
 }
 
 /**
- * Download file from remote server via SFTP
+ * Download file from remote server via SFTP with progress
+ * 
+ * Note: Currently uses single-stream download (most reliable).
+ * Multi-streaming is technically possible with ssh2-sftp-client's fastGet,
+ * but it's unreliable on many servers and can cause data corruption.
+ * Single-stream ensures data integrity at the cost of potentially slower speeds.
+ * 
  * @param {NodeSSH} ssh - SSH client instance
  * @param {string} remotePath - Path to file on remote server
  * @param {string} localPath - Local path to save file
@@ -206,8 +225,26 @@ export async function downloadRemoteFile(ssh, remotePath, localPath, remoteCwd)
 
   logProcessing(`Downloading ${absoluteRemotePath} to ${localPath}...`)
 
-  await ssh.getFile(localPath, absoluteRemotePath)
+  let transferred = 0
+  const startTime = Date.now()
+
+  // Single-stream download (most reliable for data integrity)
+  await ssh.getFile(localPath, absoluteRemotePath, null, {
+    step: (totalTransferred, chunk, total) => {
+      transferred = totalTransferred
+      const percent = total > 0 ? Math.round((transferred / total) * 100) : 0
+      const elapsed = (Date.now() - startTime) / 1000
+      const speed = elapsed > 0 ? (transferred / elapsed / 1024 / 1024).toFixed(2) : 0
+      const sizeMB = (transferred / 1024 / 1024).toFixed(2)
+      const totalMB = total > 0 ? (total / 1024 / 1024).toFixed(2) : '?'
+
+      // Update progress on same line
+      process.stdout.write(`\r  Progress: ${percent}% (${sizeMB}MB / ${totalMB}MB) - ${speed} MB/s`)
+    }
+  })
 
+  // Clear progress line and show completion
+  process.stdout.write('\r' + ' '.repeat(80) + '\r')
   logSuccess(`Downloaded ${absoluteRemotePath} to ${localPath}`)
 }