@wyxos/zephyr 0.2.19 → 0.2.21

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "A streamlined deployment tool for web applications with intelligent Laravel project detection",
   "type": "module",
-  "main": "./src/main.mjs",
+  "main": "./src/index.mjs",
   "exports": {
-    ".": "./src/main.mjs",
+    ".": "./src/index.mjs",
     "./ssh": "./src/ssh/index.mjs"
   },
   "bin": {

package/src/dependency-scanner.mjs

@@ -31,7 +31,7 @@ function isLocalPathOutsideRepo(depPath, rootDir) {
   // Check if resolved path is outside the repository root
   // Use path.relative to check if the path goes outside
   const relative = path.relative(normalizedRoot, normalizedResolved)
-  
+
   // If relative path starts with .., it's outside the repo
   // Also check if the resolved path doesn't start with the root + separator (for absolute paths)
   return relative.startsWith('..') || !normalizedResolved.startsWith(normalizedRoot + path.sep)
@@ -256,31 +256,8 @@ async function commitDependencyUpdates(rootDir, updatedFiles, promptFn, logFn) {
     return false
   }
 
-  const statusBefore = await getGitStatus(rootDir)
-
-  // Avoid accidentally committing unrelated staged changes
-  if (hasStagedChanges(statusBefore)) {
-    if (logFn) {
-      logFn('Staged changes detected. Skipping auto-commit of dependency updates.')
-    }
-    return false
-  }
-
   const fileList = updatedFiles.map((f) => path.basename(f)).join(', ')
 
-  const { shouldCommit } = await promptFn([
-    {
-      type: 'confirm',
-      name: 'shouldCommit',
-      message: `Commit dependency updates now? (${fileList})`,
-      default: true
-    }
-  ])
-
-  if (!shouldCommit) {
-    return false
-  }
-
   // Stage the updated files
   for (const file of updatedFiles) {
     try {
@@ -290,11 +267,6 @@ async function commitDependencyUpdates(rootDir, updatedFiles, promptFn, logFn) {
     }
   }
 
-  const newStatus = await getGitStatus(rootDir)
-  if (!hasStagedChanges(newStatus)) {
-    return false
-  }
-
   // Build commit message
   const commitMessage = `chore: update local file dependencies to online versions (${fileList})`
 
@@ -302,7 +274,7 @@ async function commitDependencyUpdates(rootDir, updatedFiles, promptFn, logFn) {
     logFn('Committing dependency updates...')
   }
 
-  await runCommand('git', ['commit', '-m', commitMessage], { cwd: rootDir })
+  await runCommand('git', ['commit', '-m', commitMessage, '--', ...updatedFiles], { cwd: rootDir })
 
   if (logFn) {
     logFn('Dependency updates committed.')
@@ -371,6 +343,9 @@ async function validateLocalDependencies(rootDir, promptFn, logFn = null) {
     throw new Error('Release cancelled: local file dependencies must be updated before release.')
   }
 
+  // If we cannot commit the update, do not proceed (otherwise release-node will fail later with a dirty tree).
+  // We allow users to opt-in to committing together with existing staged changes via prompt.
+
   // Track which files were updated
   const updatedFiles = new Set()
 
@@ -437,7 +412,12 @@ async function validateLocalDependencies(rootDir, promptFn, logFn = null) {
 
   // Commit the changes if any files were updated
   if (updatedFiles.size > 0) {
-    await commitDependencyUpdates(rootDir, Array.from(updatedFiles), promptFn, logFn)
+    const committed = await commitDependencyUpdates(rootDir, Array.from(updatedFiles), promptFn, logFn)
+    if (!committed) {
+      throw new Error(
+        'Release cancelled: dependency updates were applied but were not committed. Commit/stash your changes and rerun.'
+      )
+    }
   }
 }
 

package/src/index.mjs

@@ -0,0 +1,91 @@
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { NodeSSH } from 'node-ssh'
+
+import { createChalkLogger } from './utils/output.mjs'
+import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
+import { createLocalCommandRunners } from './runtime/local-command.mjs'
+import { createRunPrompt } from './runtime/prompt.mjs'
+import { createSshClientFactory } from './runtime/ssh-client.mjs'
+import { generateId } from './utils/id.mjs'
+
+import { loadServers as loadServersImpl, saveServers } from './config/servers.mjs'
+import { loadProjectConfig as loadProjectConfigImpl, saveProjectConfig } from './config/project.mjs'
+import * as configFlow from './utils/config-flow.mjs'
+import * as sshKeys from './ssh/keys.mjs'
+import { writeToLogFile } from './utils/log-file.mjs'
+
+export { main, runRemoteTasks } from './main.mjs'
+export { connectToServer, executeRemoteCommand, readRemoteFile, downloadRemoteFile, deleteRemoteFile } from './ssh/index.mjs'
+
+const { logProcessing, logSuccess, logWarning, logError } = createChalkLogger(chalk)
+const runPrompt = createRunPrompt({ inquirer })
+const { runCommand, runCommandCapture } = createLocalCommandRunners({
+  runCommandBase,
+  runCommandCaptureBase
+})
+
+// Keep this aligned with main's test injection behavior
+const createSshClient = createSshClientFactory({ NodeSSH })
+
+export { logProcessing, logSuccess, logWarning, logError, runCommand, runCommandCapture, writeToLogFile, createSshClient }
+
+export async function loadServers() {
+  return await loadServersImpl({ logSuccess, logWarning })
+}
+
+export async function loadProjectConfig(rootDir, servers) {
+  return await loadProjectConfigImpl(rootDir, servers, { logSuccess, logWarning })
+}
+
+export function defaultProjectPath(currentDir) {
+  return configFlow.defaultProjectPath(currentDir)
+}
+
+export async function listGitBranches(currentDir) {
+  return await configFlow.listGitBranches(currentDir, { runCommandCapture, logWarning })
+}
+
+export async function promptSshDetails(currentDir, existing = {}) {
+  return await sshKeys.promptSshDetails(currentDir, existing, { runPrompt })
+}
+
+export async function promptServerDetails(existingServers = []) {
+  return await configFlow.promptServerDetails(existingServers, { runPrompt, generateId })
+}
+
+export async function selectServer(servers) {
+  return await configFlow.selectServer(servers, {
+    runPrompt,
+    logProcessing,
+    logSuccess,
+    saveServers,
+    promptServerDetails
+  })
+}
+
+export async function promptAppDetails(currentDir, existing = {}) {
+  return await configFlow.promptAppDetails(currentDir, existing, {
+    runPrompt,
+    listGitBranches,
+    defaultProjectPath,
+    promptSshDetails
+  })
+}
+
+export async function selectApp(projectConfig, server, currentDir) {
+  return await configFlow.selectApp(projectConfig, server, currentDir, {
+    runPrompt,
+    logWarning,
+    logProcessing,
+    logSuccess,
+    saveProjectConfig,
+    generateId,
+    promptAppDetails
+  })
+}
+
+export async function selectPreset(projectConfig, servers) {
+  return await configFlow.selectPreset(projectConfig, servers, { runPrompt })
+}
+

package/src/release-node.mjs

@@ -126,13 +126,25 @@ async function runTests(skipTests, pkg, rootDir = process.cwd()) {
   logStep('Running test suite...')
 
   try {
+    const testRunScript = pkg?.scripts?.['test:run'] ?? ''
+    const testScript = pkg?.scripts?.test ?? ''
+    const usesNodeTest = (script) => /\bnode\b.*\s--test\b/.test(script)
+
     // Prefer test:run if available, otherwise use test with --run and --reporter flags
     if (hasScript(pkg, 'test:run')) {
-      // Pass reporter flag to test:run script
-      await runCommand('npm', ['run', 'test:run', '--', '--reporter=dot'], { cwd: rootDir })
+      if (usesNodeTest(testRunScript)) {
+        await runCommand('npm', ['run', 'test:run'], { cwd: rootDir })
+      } else {
+        // Pass reporter flag to test:run script
+        await runCommand('npm', ['run', 'test:run', '--', '--reporter=dot'], { cwd: rootDir })
+      }
     } else {
-      // For test script, pass --run and --reporter flags (works with vitest)
-      await runCommand('npm', ['test', '--', '--run', '--reporter=dot'], { cwd: rootDir })
+      if (usesNodeTest(testScript)) {
+        await runCommand('npm', ['test'], { cwd: rootDir })
+      } else {
+        // For test script, pass --run and --reporter flags (works with vitest)
+        await runCommand('npm', ['test', '--', '--run', '--reporter=dot'], { cwd: rootDir })
+      }
     }
 
     logSuccess('Tests passed.')
@@ -217,7 +229,13 @@ async function runLibBuild(skipBuild, pkg, rootDir = process.cwd()) {
   return hasLibChanges
 }
 
-async function ensureNpmAuth(rootDir = process.cwd()) {
+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 })
@@ -452,7 +470,7 @@ export async function releaseNode() {
     await runLint(skipLint, pkg, rootDir)
     await runTests(skipTests, pkg, rootDir)
     await runLibBuild(skipBuild, pkg, rootDir)
-    await ensureNpmAuth(rootDir)
+    await ensureNpmAuth(pkg, rootDir)
 
     const updatedPkg = await bumpVersion(releaseType, rootDir)
     await runBuild(skipBuild, updatedPkg, rootDir)

package/src/ssh/ssh.mjs

@@ -13,6 +13,11 @@ const { logProcessing, logSuccess, logWarning, logError } = createChalkLogger(ch
 
 const createSshClient = createSshClientFactory({ NodeSSH })
 
+function normalizeRemotePath(value) {
+  if (value == null) return value
+  return String(value).replace(/\\/g, '/')
+}
+
 export async function connectToServer(config) {
   const ssh = createSshClient()
   const sshUser = config.sshUser || os.userInfo().username
@@ -64,10 +69,11 @@ export async function executeRemoteCommand(ssh, label, command, options = {}) {
 }
 
 export async function readRemoteFile(ssh, filePath, remoteCwd) {
-  const escapedPath = filePath.replace(/'/g, "'\\''")
+  const normalizedPath = normalizeRemotePath(filePath)
+  const escapedPath = normalizedPath.replace(/'/g, "'\\''")
   const command = `cat '${escapedPath}'`
 
-  const result = await ssh.execCommand(command, { cwd: remoteCwd })
+  const result = await ssh.execCommand(command, { cwd: normalizeRemotePath(remoteCwd) })
 
   if (result.code !== 0) {
     throw new Error(`Failed to read remote file ${filePath}: ${result.stderr}`)
@@ -77,9 +83,11 @@ export async function readRemoteFile(ssh, filePath, remoteCwd) {
 }
 
 export async function downloadRemoteFile(ssh, remotePath, localPath, remoteCwd) {
-  const absoluteRemotePath = remotePath.startsWith('/')
-    ? remotePath
-    : `${remoteCwd}/${remotePath}`
+  const normalizedRemotePath = normalizeRemotePath(remotePath)
+  const normalizedCwd = normalizeRemotePath(remoteCwd)
+  const absoluteRemotePath = normalizedRemotePath.startsWith('/')
+    ? normalizedRemotePath
+    : `${normalizedCwd}/${normalizedRemotePath}`
 
   logProcessing(`Downloading ${absoluteRemotePath} to ${localPath}...`)
 
@@ -104,16 +112,18 @@ export async function downloadRemoteFile(ssh, remotePath, localPath, remoteCwd)
 }
 
 export async function deleteRemoteFile(ssh, remotePath, remoteCwd) {
-  const absoluteRemotePath = remotePath.startsWith('/')
-    ? remotePath
-    : `${remoteCwd}/${remotePath}`
+  const normalizedRemotePath = normalizeRemotePath(remotePath)
+  const normalizedCwd = normalizeRemotePath(remoteCwd)
+  const absoluteRemotePath = normalizedRemotePath.startsWith('/')
+    ? normalizedRemotePath
+    : `${normalizedCwd}/${normalizedRemotePath}`
 
   const escapedPath = absoluteRemotePath.replace(/'/g, "'\\''")
   const command = `rm -f '${escapedPath}'`
 
   logProcessing(`Deleting remote file: ${absoluteRemotePath}...`)
 
-  const result = await ssh.execCommand(command, { cwd: remoteCwd })
+  const result = await ssh.execCommand(command, { cwd: normalizedCwd })
 
   if (result.code !== 0 && result.code !== 1) {
     logWarning(`Failed to delete remote file ${absoluteRemotePath}: ${result.stderr}`)