@wyxos/zephyr 0.2.18 → 0.2.19

package/src/project/bootstrap.mjs

@@ -0,0 +1,147 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export async function ensureGitignoreEntry(rootDir, {
+  projectConfigDir = '.zephyr',
+  runCommand,
+  logSuccess,
+  logWarning
+} = {}) {
+  const gitignorePath = path.join(rootDir, '.gitignore')
+  const targetEntry = `${projectConfigDir}/`
+  let existingContent = ''
+
+  try {
+    existingContent = await fs.readFile(gitignorePath, 'utf8')
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  const hasEntry = existingContent
+    .split(/\r?\n/)
+    .some((line) => line.trim() === targetEntry)
+
+  if (hasEntry) {
+    return
+  }
+
+  const updatedContent = existingContent
+    ? `${existingContent.replace(/\s*$/, '')}\n${targetEntry}\n`
+    : `${targetEntry}\n`
+
+  await fs.writeFile(gitignorePath, updatedContent)
+  logSuccess?.('Added .zephyr/ to .gitignore')
+
+  let isGitRepo = false
+  try {
+    await runCommand('git', ['rev-parse', '--is-inside-work-tree'], {
+      silent: true,
+      cwd: rootDir
+    })
+    isGitRepo = true
+  } catch (_error) {
+    logWarning?.('Not a git repository; skipping commit for .gitignore update.')
+  }
+
+  if (!isGitRepo) {
+    return
+  }
+
+  try {
+    await runCommand('git', ['add', '.gitignore'], { cwd: rootDir })
+    await runCommand('git', ['commit', '-m', 'chore: ignore zephyr config'], { cwd: rootDir })
+  } catch (error) {
+    if (error.exitCode === 1) {
+      logWarning?.('Git commit skipped: nothing to commit or pre-commit hook prevented commit.')
+    } else {
+      throw error
+    }
+  }
+}
+
+export async function ensureProjectReleaseScript(rootDir, {
+  runPrompt,
+  runCommand,
+  logSuccess,
+  logWarning,
+  releaseScriptName = 'release',
+  releaseScriptCommand = 'npx @wyxos/zephyr@latest'
+} = {}) {
+  const packageJsonPath = path.join(rootDir, 'package.json')
+
+  let raw
+  try {
+    raw = await fs.readFile(packageJsonPath, 'utf8')
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return false
+    }
+
+    throw error
+  }
+
+  let packageJson
+  try {
+    packageJson = JSON.parse(raw)
+  } catch (_error) {
+    logWarning?.('Unable to parse package.json; skipping release script injection.')
+    return false
+  }
+
+  const currentCommand = packageJson?.scripts?.[releaseScriptName]
+
+  if (currentCommand && currentCommand.includes('@wyxos/zephyr')) {
+    return false
+  }
+
+  const { installReleaseScript } = await runPrompt([
+    {
+      type: 'confirm',
+      name: 'installReleaseScript',
+      message: 'Add "release" script to package.json that runs "npx @wyxos/zephyr@latest"?',
+      default: true
+    }
+  ])
+
+  if (!installReleaseScript) {
+    return false
+  }
+
+  if (!packageJson.scripts || typeof packageJson.scripts !== 'object') {
+    packageJson.scripts = {}
+  }
+
+  packageJson.scripts[releaseScriptName] = releaseScriptCommand
+
+  const updatedPayload = `${JSON.stringify(packageJson, null, 2)}\n`
+  await fs.writeFile(packageJsonPath, updatedPayload)
+  logSuccess?.('Added release script to package.json.')
+
+  let isGitRepo = false
+
+  try {
+    await runCommand('git', ['rev-parse', '--is-inside-work-tree'], { cwd: rootDir, silent: true })
+    isGitRepo = true
+  } catch (_error) {
+    logWarning?.('Not a git repository; skipping commit for release script addition.')
+  }
+
+  if (isGitRepo) {
+    try {
+      await runCommand('git', ['add', 'package.json'], { cwd: rootDir, silent: true })
+      await runCommand('git', ['commit', '-m', 'chore: add zephyr release script'], { cwd: rootDir, silent: true })
+      logSuccess?.('Committed package.json release script addition.')
+    } catch (error) {
+      if (error.exitCode === 1) {
+        logWarning?.('Git commit skipped: nothing to commit or pre-commit hook prevented commit.')
+      } else {
+        throw error
+      }
+    }
+  }
+
+  return true
+}
+

package/src/release-node.mjs

@@ -1,4 +1,3 @@
-import { spawn, exec } from 'node:child_process'
 import { join } from 'node:path'
 import { readFile } from 'node:fs/promises'
 import fs from 'node:fs'
@@ -7,26 +6,9 @@ import process from 'node:process'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
 import { validateLocalDependencies } from './dependency-scanner.mjs'
-
-const IS_WINDOWS = process.platform === 'win32'
-
-function writeStdoutLine(message = '') {
-  const text = message == null ? '' : String(message)
-  process.stdout.write(`${text}\n`)
-}
-
-function writeStderrLine(message = '') {
-  const text = message == null ? '' : String(message)
-  process.stderr.write(`${text}\n`)
-}
-
-function writeStderr(message = '') {
-  const text = message == null ? '' : String(message)
-  process.stderr.write(text)
-  if (text && !text.endsWith('\n')) {
-    process.stderr.write('\n')
-  }
-}
+import { writeStderr, writeStderrLine, writeStdoutLine } from './utils/output.mjs'
+import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
+import { ensureUpToDateWithUpstream, getCurrentBranch, getUpstreamRef } from './utils/git.mjs'
 
 function logStep(message) {
   writeStdoutLine(chalk.yellow(`→ ${message}`))
@@ -40,86 +22,14 @@ function logWarning(message) {
   writeStderrLine(chalk.yellow(`⚠ ${message}`))
 }
 
-function runCommand(command, args, { cwd = process.cwd(), capture = false, useShell = false } = {}) {
-  return new Promise((resolve, reject) => {
-    // On Windows, npm-related commands need shell to resolve npx.cmd
-    // Git commands work fine without shell, so we only use it when explicitly requested
-    const needsShell = useShell || (IS_WINDOWS && (command === 'npm' || command === 'npx'))
-
-    if (needsShell) {
-      // When using shell, use exec to avoid deprecation warning with spawn
-      // Properly escape arguments for Windows cmd.exe
-      const escapedArgs = args.map(arg => {
-        // If arg contains spaces or special chars, wrap in quotes and escape internal quotes
-        if (arg.includes(' ') || arg.includes('"') || arg.includes('&') || arg.includes('|')) {
-          return `"${arg.replace(/"/g, '\\"')}"`
-        }
-        return arg
-      })
-      const commandString = `${command} ${escapedArgs.join(' ')}`
-
-      exec(commandString, { cwd, encoding: 'utf8' }, (error, stdout, stderr) => {
-        if (error) {
-          const err = new Error(`Command failed (${error.code}): ${command} ${args.join(' ')}`)
-          if (capture) {
-            err.stdout = stdout || ''
-            err.stderr = stderr || ''
-          } else {
-            // When not capturing, exec still provides output, so show it
-            if (stdout) process.stdout.write(stdout)
-            if (stderr) process.stderr.write(stderr)
-          }
-          err.exitCode = error.code
-          reject(err)
-          return
-        }
-
-        if (capture) {
-          resolve({ stdout: stdout.trim(), stderr: stderr.trim() })
-        } else {
-          // When not capturing, exec still provides output, so show it
-          if (stdout) process.stdout.write(stdout)
-          if (stderr) process.stderr.write(stderr)
-          resolve(undefined)
-        }
-      })
-    } else {
-      // Use spawn for commands that don't need shell
-      const spawnOptions = {
-        cwd,
-        stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit'
-      }
-
-      const child = spawn(command, args, spawnOptions)
-      let stdout = ''
-      let stderr = ''
-
-      if (capture) {
-        child.stdout.on('data', (chunk) => {
-          stdout += chunk
-        })
-
-        child.stderr.on('data', (chunk) => {
-          stderr += chunk
-        })
-      }
+async function runCommand(command, args, { cwd = process.cwd(), capture = false } = {}) {
+  if (capture) {
+    const { stdout, stderr } = await runCommandCaptureBase(command, args, { cwd })
+    return { stdout: stdout.trim(), stderr: stderr.trim() }
+  }
 
-      child.on('error', reject)
-      child.on('close', (code) => {
-        if (code === 0) {
-          resolve(capture ? { stdout: stdout.trim(), stderr: stderr.trim() } : undefined)
-        } else {
-          const error = new Error(`Command failed (${code}): ${command} ${args.join(' ')}`)
-          if (capture) {
-            error.stdout = stdout
-            error.stderr = stderr
-          }
-          error.exitCode = code
-          reject(error)
-        }
-      })
-    }
-  })
+  await runCommandBase(command, args, { cwd })
+  return undefined
 }
 
 async function readPackage(rootDir = process.cwd()) {
@@ -140,84 +50,7 @@ async function ensureCleanWorkingTree(rootDir = process.cwd()) {
   }
 }
 
-async function getCurrentBranch(rootDir = process.cwd()) {
-  const { stdout } = await runCommand('git', ['branch', '--show-current'], { capture: true, cwd: rootDir })
-  return stdout || null
-}
-
-async function getUpstreamRef(rootDir = process.cwd()) {
-  try {
-    const { stdout } = await runCommand('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], {
-      capture: true,
-      cwd: rootDir
-    })
-
-    return stdout || null
-  } catch {
-    return null
-  }
-}
-
-async function ensureUpToDateWithUpstream(branch, upstreamRef, rootDir = process.cwd()) {
-  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], { capture: true, cwd: rootDir })
-    } catch (error) {
-      if (error.stderr) {
-        writeStderr(error.stderr)
-      }
-      throw new Error(`Failed to fetch ${upstreamRef}: ${error.message}`)
-    }
-  }
-
-  const aheadResult = await runCommand('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], {
-    capture: true,
-    cwd: rootDir
-  })
-  const behindResult = await runCommand('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], {
-    capture: true,
-    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], { capture: true, cwd: rootDir })
-      } catch (error) {
-        if (error.stderr) {
-          writeStderr(error.stderr)
-        }
-        throw new Error(
-          `Unable to fast-forward ${branch} with ${upstreamRef}. Resolve conflicts manually, then rerun the release.\n${error.message}`
-        )
-      }
-
-      return ensureUpToDateWithUpstream(branch, upstreamRef, rootDir)
-    }
-
-    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'}.`)
-  }
-}
+// Git helpers imported from src/utils/git.mjs
 
 function parseArgs() {
   const args = process.argv.slice(2)
@@ -607,14 +440,14 @@ export async function releaseNode() {
     logStep('Checking working tree status...')
     await ensureCleanWorkingTree(rootDir)
 
-    const branch = await getCurrentBranch(rootDir)
+    const branch = await getCurrentBranch(rootDir, { method: 'show-current' })
     if (!branch) {
       throw new Error('Unable to determine current branch.')
     }
 
     logStep(`Current branch: ${branch}`)
     const upstreamRef = await getUpstreamRef(rootDir)
-    await ensureUpToDateWithUpstream(branch, upstreamRef, rootDir)
+    await ensureUpToDateWithUpstream({ branch, upstreamRef, rootDir, logStep, logWarning })
 
     await runLint(skipLint, pkg, rootDir)
     await runTests(skipTests, pkg, rootDir)

package/src/release-packagist.mjs

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process'
 import { join } from 'node:path'
 import { readFile, writeFile } from 'node:fs/promises'
 import fs from 'node:fs'
@@ -6,6 +5,9 @@ import process from 'node:process'
 import semver from 'semver'
 import inquirer from 'inquirer'
 import { validateLocalDependencies } from './dependency-scanner.mjs'
+import { writeStderr, writeStderrLine, writeStdoutLine } from './utils/output.mjs'
+import { runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase } from './utils/command.mjs'
+import { ensureUpToDateWithUpstream, getCurrentBranch as getGitCurrentBranch, getUpstreamRef } from './utils/git.mjs'
 
 const STEP_PREFIX = '→'
 const OK_PREFIX = '✔'
@@ -13,24 +15,6 @@ const WARN_PREFIX = '⚠'
 
 const IS_WINDOWS = process.platform === 'win32'
 
-function writeStdoutLine(message = '') {
-  const text = message == null ? '' : String(message)
-  process.stdout.write(`${text}\n`)
-}
-
-function writeStderrLine(message = '') {
-  const text = message == null ? '' : String(message)
-  process.stderr.write(`${text}\n`)
-}
-
-function writeStderr(message = '') {
-  const text = message == null ? '' : String(message)
-  process.stderr.write(text)
-  if (text && !text.endsWith('\n')) {
-    process.stderr.write('\n')
-  }
-}
-
 function logStep(message) {
   writeStdoutLine(`${STEP_PREFIX} ${message}`)
 }
@@ -43,60 +27,14 @@ function logWarning(message) {
   writeStderrLine(`${WARN_PREFIX} ${message}`)
 }
 
-function runCommand(command, args, { cwd = process.cwd(), capture = false, useShell = false } = {}) {
-  return new Promise((resolve, reject) => {
-    const needsShell = useShell || (IS_WINDOWS && (command === 'php' || command === 'composer'))
-    
-    const spawnOptions = {
-      cwd,
-      stdio: capture ? ['ignore', 'pipe', 'pipe'] : 'inherit'
-    }
-
-    let child
-    if (needsShell) {
-      // When using shell, construct the command string to avoid deprecation warning
-      // Properly escape arguments for Windows cmd.exe
-      const escapedArgs = args.map(arg => {
-        // If arg contains spaces or special chars, wrap in quotes and escape internal quotes
-        if (arg.includes(' ') || arg.includes('"') || arg.includes('&') || arg.includes('|')) {
-          return `"${arg.replace(/"/g, '\\"')}"`
-        }
-        return arg
-      })
-      const commandString = `${command} ${escapedArgs.join(' ')}`
-      spawnOptions.shell = true
-      child = spawn(commandString, [], spawnOptions)
-    } else {
-      child = spawn(command, args, spawnOptions)
-    }
-    let stdout = ''
-    let stderr = ''
-
-    if (capture) {
-      child.stdout.on('data', (chunk) => {
-        stdout += chunk
-      })
-
-      child.stderr.on('data', (chunk) => {
-        stderr += chunk
-      })
-    }
+async function runCommand(command, args, { cwd = process.cwd(), capture = false } = {}) {
+  if (capture) {
+    const { stdout, stderr } = await runCommandCaptureBase(command, args, { cwd })
+    return { stdout: stdout.trim(), stderr: stderr.trim() }
+  }
 
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(capture ? { stdout: stdout.trim(), stderr: stderr.trim() } : undefined)
-      } else {
-        const error = new Error(`Command failed (${code}): ${command} ${args.join(' ')}`)
-        if (capture) {
-          error.stdout = stdout
-          error.stderr = stderr
-        }
-        error.exitCode = code
-        reject(error)
-      }
-    })
-  })
+  await runCommandBase(command, args, { cwd })
+  return undefined
 }
 
 async function readComposer(rootDir = process.cwd()) {
@@ -145,78 +83,7 @@ async function ensureCleanWorkingTree(rootDir = process.cwd()) {
   }
 }
 
-async function getCurrentBranch(rootDir = process.cwd()) {
-  const { stdout } = await runCommand('git', ['branch', '--show-current'], { capture: true, cwd: rootDir })
-  return stdout || null
-}
-
-async function getUpstreamRef(rootDir = process.cwd()) {
-  try {
-    const { stdout } = await runCommand('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], {
-      capture: true,
-      cwd: rootDir
-    })
-
-    return stdout || null
-  } catch {
-    return null
-  }
-}
-
-async function ensureUpToDateWithUpstream(branch, upstreamRef, rootDir = process.cwd()) {
-  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 })
-    } catch (error) {
-      throw new Error(`Failed to fetch ${upstreamRef}: ${error.message}`)
-    }
-  }
-
-  const aheadResult = await runCommand('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], {
-    capture: true,
-    cwd: rootDir
-  })
-  const behindResult = await runCommand('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], {
-    capture: true,
-    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 })
-      } catch (error) {
-        throw new Error(
-          `Unable to fast-forward ${branch} with ${upstreamRef}. Resolve conflicts manually, then rerun the release.\n${error.message}`
-        )
-      }
-
-      return ensureUpToDateWithUpstream(branch, upstreamRef, rootDir)
-    }
-
-    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'}.`)
-  }
-}
+// Git helpers imported from src/utils/git.mjs
 
 function parseArgs() {
   const args = process.argv.slice(2)
@@ -408,14 +275,14 @@ export async function releasePackagist() {
   logStep('Checking working tree status...')
   await ensureCleanWorkingTree(rootDir)
 
-  const branch = await getCurrentBranch(rootDir)
+  const branch = await getGitCurrentBranch(rootDir, { method: 'show-current' })
   if (!branch) {
     throw new Error('Unable to determine current branch.')
   }
 
   logStep(`Current branch: ${branch}`)
   const upstreamRef = await getUpstreamRef(rootDir)
-  await ensureUpToDateWithUpstream(branch, upstreamRef, rootDir)
+  await ensureUpToDateWithUpstream({ branch, upstreamRef, rootDir, logStep, logWarning })
 
   await runLint(skipLint, rootDir)
   await runTests(skipTests, composer, rootDir)

package/src/runtime/local-command.mjs

@@ -0,0 +1,18 @@
+export function createLocalCommandRunners({ runCommandBase, runCommandCaptureBase }) {
+  if (!runCommandBase || !runCommandCaptureBase) {
+    throw new Error('createLocalCommandRunners requires runCommandBase and runCommandCaptureBase')
+  }
+
+  const runCommand = async (command, args, { silent = false, cwd } = {}) => {
+    const stdio = silent ? 'ignore' : 'inherit'
+    return runCommandBase(command, args, { cwd, stdio })
+  }
+
+  const runCommandCapture = async (command, args, { cwd } = {}) => {
+    const { stdout } = await runCommandCaptureBase(command, args, { cwd })
+    return stdout
+  }
+
+  return { runCommand, runCommandCapture }
+}
+

package/src/runtime/prompt.mjs

@@ -0,0 +1,14 @@
+export function createRunPrompt({ inquirer }) {
+  if (!inquirer) {
+    throw new Error('createRunPrompt requires inquirer')
+  }
+
+  return async function runPrompt(questions) {
+    if (typeof globalThis !== 'undefined' && globalThis.__zephyrPrompt) {
+      return globalThis.__zephyrPrompt(questions)
+    }
+
+    return inquirer.prompt(questions)
+  }
+}
+

package/src/runtime/ssh-client.mjs

@@ -0,0 +1,14 @@
+export function createSshClientFactory({ NodeSSH }) {
+  if (!NodeSSH) {
+    throw new Error('createSshClientFactory requires NodeSSH')
+  }
+
+  return function createSshClient() {
+    if (typeof globalThis !== 'undefined' && globalThis.__zephyrSSHFactory) {
+      return globalThis.__zephyrSSHFactory()
+    }
+
+    return new NodeSSH()
+  }
+}
+

package/src/ssh/index.mjs

@@ -0,0 +1,8 @@
+export {
+  connectToServer,
+  executeRemoteCommand,
+  readRemoteFile,
+  downloadRemoteFile,
+  deleteRemoteFile
+} from './ssh.mjs'
+