@wyxos/zephyr 0.1.1 → 0.1.3

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@wyxos/zephyr",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "scripts": {
-    "test": "vitest"
+    "test": "vitest",
+    "release": "node publish.mjs"
   },
   "bin": {
-    "zephyr": "./bin/zephyr.mjs"
+    "zephyr": "bin/zephyr.mjs"
   },
   "dependencies": {
     "chalk": "5.3.0",

package/publish.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import { readFile } from 'node:fs/promises'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+const PACKAGE_PATH = join(ROOT, 'package.json')
+
+const STEP_PREFIX = '→'
+const OK_PREFIX = '✔'
+const WARN_PREFIX = '⚠'
+
+function logStep(message) {
+  console.log(`${STEP_PREFIX} ${message}`)
+}
+
+function logSuccess(message) {
+  console.log(`${OK_PREFIX} ${message}`)
+}
+
+function logWarning(message) {
+  console.warn(`${WARN_PREFIX} ${message}`)
+}
+
+function runCommand(command, args, { cwd = ROOT, capture = false } = {}) {
+  return new Promise((resolve, reject) => {
+    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
+      })
+    }
+
+    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)
+      }
+    })
+  })
+}
+
+async function readPackage() {
+  const raw = await readFile(PACKAGE_PATH, 'utf8')
+  return JSON.parse(raw)
+}
+
+async function ensureCleanWorkingTree() {
+  const { stdout } = await runCommand('git', ['status', '--porcelain'], { capture: true })
+
+  if (stdout.length > 0) {
+    throw new Error('Working tree has uncommitted changes. Commit or stash them before releasing.')
+  }
+}
+
+async function getCurrentBranch() {
+  const { stdout } = await runCommand('git', ['branch', '--show-current'], { capture: true })
+  return stdout || null
+}
+
+async function getUpstreamRef() {
+  try {
+    const { stdout } = await runCommand('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], {
+      capture: true
+    })
+
+    return stdout || null
+  } catch {
+    return null
+  }
+}
+
+async function ensureUpToDateWithUpstream(branch, upstreamRef) {
+  if (!upstreamRef) {
+    logWarning(`Branch ${branch} has no upstream configured; skipping ahead/behind checks.`)
+    return
+  }
+
+  const aheadResult = await runCommand('git', ['rev-list', '--count', `${upstreamRef}..HEAD`], {
+    capture: true
+  })
+  const behindResult = await runCommand('git', ['rev-list', '--count', `HEAD..${upstreamRef}`], {
+    capture: true
+  })
+
+  const ahead = Number.parseInt(aheadResult.stdout || '0', 10)
+  const behind = Number.parseInt(behindResult.stdout || '0', 10)
+
+  if (Number.isFinite(behind) && behind > 0) {
+    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'}.`)
+  }
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2)
+  const positionals = args.filter((arg) => !arg.startsWith('--'))
+  const flags = new Set(args.filter((arg) => arg.startsWith('--')))
+
+  const releaseType = positionals[0] ?? 'patch'
+  const skipTests = flags.has('--skip-tests')
+
+  const allowedTypes = new Set([
+    'major',
+    'minor',
+    'patch',
+    'premajor',
+    'preminor',
+    'prepatch',
+    'prerelease'
+  ])
+
+  if (!allowedTypes.has(releaseType)) {
+    throw new Error(
+      `Invalid release type "${releaseType}". Use one of: ${Array.from(allowedTypes).join(', ')}.`
+    )
+  }
+
+  return { releaseType, skipTests }
+}
+
+async function runTests(skipTests) {
+  if (skipTests) {
+    logWarning('Skipping tests because --skip-tests flag was provided.')
+    return
+  }
+
+  logStep('Running test suite (vitest run)...')
+  await runCommand('npx', ['vitest', 'run'])
+  logSuccess('Tests passed.')
+}
+
+async function ensureNpmAuth() {
+  logStep('Confirming npm authentication...')
+  await runCommand('npm', ['whoami'])
+}
+
+async function bumpVersion(releaseType) {
+  logStep(`Bumping package version with "npm version ${releaseType}"...`)
+  await runCommand('npm', ['version', releaseType, '--message', 'chore: release %s'])
+  const pkg = await readPackage()
+  logSuccess(`Version updated to ${pkg.version}.`)
+  return pkg
+}
+
+async function pushChanges() {
+  logStep('Pushing commits and tags to origin...')
+  await runCommand('git', ['push', '--follow-tags'])
+  logSuccess('Git push completed.')
+}
+
+async function publishPackage(pkg) {
+  const publishArgs = ['publish']
+
+  if (pkg.name.startsWith('@')) {
+    publishArgs.push('--access', 'public')
+  }
+
+  logStep(`Publishing ${pkg.name}@${pkg.version} to npm...`)
+  await runCommand('npm', publishArgs)
+  logSuccess('npm publish completed.')
+}
+
+async function main() {
+  const { releaseType, skipTests } = parseArgs()
+
+  logStep('Reading package metadata...')
+  const pkg = await readPackage()
+
+  logStep('Checking working tree status...')
+  await ensureCleanWorkingTree()
+
+  const branch = await getCurrentBranch()
+  if (!branch) {
+    throw new Error('Unable to determine current branch.')
+  }
+
+  logStep(`Current branch: ${branch}`)
+  const upstreamRef = await getUpstreamRef()
+  await ensureUpToDateWithUpstream(branch, upstreamRef)
+
+  await runTests(skipTests)
+  await ensureNpmAuth()
+
+  const updatedPkg = await bumpVersion(releaseType)
+  await pushChanges()
+  await publishPackage(updatedPkg)
+
+  logSuccess(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
+}
+
+main().catch((error) => {
+  console.error('\nRelease failed:')
+  console.error(error.message)
+  process.exit(1)
+})

package/src/index.mjs

@@ -6,7 +6,10 @@ import chalk from 'chalk'
 import inquirer from 'inquirer'
 import { NodeSSH } from 'node-ssh'
 
-const RELEASE_FILE = 'release.json'
+const PROJECT_CONFIG_DIR = '.zephyr'
+const PROJECT_CONFIG_FILE = 'config.json'
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.config', 'zephyr')
+const SERVERS_FILE = path.join(GLOBAL_CONFIG_DIR, 'servers.json')
 
 const logProcessing = (message = '') => console.log(chalk.yellow(message))
 const logSuccess = (message = '') => console.log(chalk.green(message))
@@ -245,6 +248,7 @@ async function ensureLocalRepositoryState(targetBranch, rootDir = process.cwd())
 
 async function ensureGitignoreEntry(rootDir) {
   const gitignorePath = path.join(rootDir, '.gitignore')
+  const targetEntry = `${PROJECT_CONFIG_DIR}/`
   let existingContent = ''
 
   try {
@@ -257,18 +261,18 @@ async function ensureGitignoreEntry(rootDir) {
 
   const hasEntry = existingContent
     .split(/\r?\n/)
-    .some((line) => line.trim() === RELEASE_FILE)
+    .some((line) => line.trim() === targetEntry)
 
   if (hasEntry) {
     return
   }
 
   const updatedContent = existingContent
-    ? `${existingContent.replace(/\s*$/, '')}\n${RELEASE_FILE}\n`
-    : `${RELEASE_FILE}\n`
+    ? `${existingContent.replace(/\s*$/, '')}\n${targetEntry}\n`
+    : `${targetEntry}\n`
 
   await fs.writeFile(gitignorePath, updatedContent)
-  logSuccess('Added release.json to .gitignore')
+  logSuccess('Added .zephyr/ to .gitignore')
 
   let isGitRepo = false
   try {
@@ -287,7 +291,7 @@ async function ensureGitignoreEntry(rootDir) {
 
   try {
     await runCommand('git', ['add', '.gitignore'], { cwd: rootDir })
-    await runCommand('git', ['commit', '-m', 'chore: ignore release config'], { 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.')
@@ -297,9 +301,13 @@ async function ensureGitignoreEntry(rootDir) {
   }
 }
 
-async function loadReleases(filePath) {
+async function ensureDirectory(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true })
+}
+
+async function loadServers() {
   try {
-    const raw = await fs.readFile(filePath, 'utf8')
+    const raw = await fs.readFile(SERVERS_FILE, 'utf8')
     const data = JSON.parse(raw)
     return Array.isArray(data) ? data : []
   } catch (error) {
@@ -307,14 +315,45 @@ async function loadReleases(filePath) {
       return []
     }
 
-    logWarning('Failed to read release.json, starting with an empty list.')
+    logWarning('Failed to read servers.json, starting with an empty list.')
     return []
   }
 }
 
-async function saveReleases(filePath, releases) {
-  const payload = JSON.stringify(releases, null, 2)
-  await fs.writeFile(filePath, `${payload}\n`)
+async function saveServers(servers) {
+  await ensureDirectory(GLOBAL_CONFIG_DIR)
+  const payload = JSON.stringify(servers, null, 2)
+  await fs.writeFile(SERVERS_FILE, `${payload}\n`)
+}
+
+function getProjectConfigPath(rootDir) {
+  return path.join(rootDir, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE)
+}
+
+async function loadProjectConfig(rootDir) {
+  const configPath = getProjectConfigPath(rootDir)
+
+  try {
+    const raw = await fs.readFile(configPath, 'utf8')
+    const data = JSON.parse(raw)
+    return {
+      apps: Array.isArray(data?.apps) ? data.apps : []
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return { apps: [] }
+    }
+
+    logWarning('Failed to read .zephyr/config.json, starting with an empty list of apps.')
+    return { apps: [] }
+  }
+}
+
+async function saveProjectConfig(rootDir, config) {
+  const configDir = path.join(rootDir, PROJECT_CONFIG_DIR)
+  await ensureDirectory(configDir)
+  const payload = JSON.stringify({ apps: config.apps ?? [] }, null, 2)
+  await fs.writeFile(path.join(configDir, PROJECT_CONFIG_FILE), `${payload}\n`)
 }
 
 function defaultProjectPath(currentDir) {
@@ -719,14 +758,10 @@ async function runRemoteTasks(config) {
   }
 }
 
-async function collectServerConfig(currentDir) {
-  const branches = await listGitBranches(currentDir)
-  const defaultBranch = branches.includes('master') ? 'master' : branches[0]
+async function promptServerDetails(existingServers = []) {
   const defaults = {
-    serverName: 'home',
-    serverIp: '1.1.1.1',
-    projectPath: defaultProjectPath(currentDir),
-    branch: defaultBranch
+    serverName: existingServers.length === 0 ? 'home' : `server-${existingServers.length + 1}`,
+    serverIp: '1.1.1.1'
   }
 
   const answers = await runPrompt([
@@ -739,19 +774,77 @@ async function collectServerConfig(currentDir) {
     {
       type: 'input',
       name: 'serverIp',
-      message: 'Server IP',
+      message: 'Server IP address',
       default: defaults.serverIp
-    },
+    }
+  ])
+
+  return {
+    serverName: answers.serverName.trim() || defaults.serverName,
+    serverIp: answers.serverIp.trim() || defaults.serverIp
+  }
+}
+
+async function selectServer(servers) {
+  if (servers.length === 0) {
+    logProcessing("No servers configured. Let's create one.")
+    const server = await promptServerDetails()
+    servers.push(server)
+    await saveServers(servers)
+    logSuccess('Saved server configuration to ~/.config/zephyr/servers.json')
+    return server
+  }
+
+  const choices = servers.map((server, index) => ({
+    name: `${server.serverName} (${server.serverIp})`,
+    value: index
+  }))
+
+  choices.push(new inquirer.Separator(), {
+    name: '➕ Register a new server',
+    value: 'create'
+  })
+
+  const { selection } = await runPrompt([
+    {
+      type: 'list',
+      name: 'selection',
+      message: 'Select server or register new',
+      choices,
+      default: 0
+    }
+  ])
+
+  if (selection === 'create') {
+    const server = await promptServerDetails(servers)
+    servers.push(server)
+    await saveServers(servers)
+    logSuccess('Appended server configuration to ~/.config/zephyr/servers.json')
+    return server
+  }
+
+  return servers[selection]
+}
+
+async function promptAppDetails(currentDir, existing = {}) {
+  const branches = await listGitBranches(currentDir)
+  const defaultBranch = existing.branch || (branches.includes('master') ? 'master' : branches[0])
+  const defaults = {
+    projectPath: existing.projectPath || defaultProjectPath(currentDir),
+    branch: defaultBranch
+  }
+
+  const answers = await runPrompt([
     {
       type: 'input',
       name: 'projectPath',
-      message: 'Project path',
+      message: 'Remote project path',
       default: defaults.projectPath
     },
     {
       type: 'list',
       name: 'branchSelection',
-      message: 'Branch',
+      message: 'Branch to deploy',
       choices: [
         ...branches.map((branch) => ({ name: branch, value: branch })),
         new inquirer.Separator(),
@@ -764,7 +857,7 @@ async function collectServerConfig(currentDir) {
   let branch = answers.branchSelection
 
   if (branch === '__custom') {
-    const { customBranch } = await inquirer.prompt([
+    const { customBranch } = await runPrompt([
       {
         type: 'input',
         name: 'customBranch',
@@ -776,25 +869,41 @@ async function collectServerConfig(currentDir) {
     branch = customBranch.trim() || defaults.branch
   }
 
-  const sshDetails = await promptSshDetails(currentDir)
+  const sshDetails = await promptSshDetails(currentDir, existing)
 
   return {
-    serverName: answers.serverName,
-    serverIp: answers.serverIp,
-    projectPath: answers.projectPath,
+    projectPath: answers.projectPath.trim() || defaults.projectPath,
     branch,
     ...sshDetails
   }
 }
 
-async function promptSelection(releases) {
-  const choices = releases.map((entry, index) => ({
-    name: `${entry.serverName} (${entry.serverIp})` || `Server ${index + 1}`,
+async function selectApp(projectConfig, server, currentDir) {
+  const apps = projectConfig.apps ?? []
+  const matches = apps
+    .map((app, index) => ({ app, index }))
+    .filter(({ app }) => app.serverName === server.serverName)
+
+  if (matches.length === 0) {
+    logProcessing(`No applications configured for ${server.serverName}. Let's create one.`)
+    const appDetails = await promptAppDetails(currentDir)
+    const appConfig = {
+      serverName: server.serverName,
+      ...appDetails
+    }
+    projectConfig.apps.push(appConfig)
+    await saveProjectConfig(currentDir, projectConfig)
+    logSuccess('Saved deployment configuration to .zephyr/config.json')
+    return appConfig
+  }
+
+  const choices = matches.map(({ app, index }) => ({
+    name: `${app.projectPath} (${app.branch})`,
     value: index
   }))
 
   choices.push(new inquirer.Separator(), {
-    name: '➕ Create new deployment target',
+    name: '➕ Configure new application for this server',
     value: 'create'
   })
 
@@ -802,55 +911,58 @@ async function promptSelection(releases) {
     {
       type: 'list',
       name: 'selection',
-      message: 'Select server or create new',
+      message: `Select application for ${server.serverName}`,
       choices,
       default: 0
     }
   ])
 
-  return selection
+  if (selection === 'create') {
+    const appDetails = await promptAppDetails(currentDir)
+    const appConfig = {
+      serverName: server.serverName,
+      ...appDetails
+    }
+    projectConfig.apps.push(appConfig)
+    await saveProjectConfig(currentDir, projectConfig)
+    logSuccess('Appended deployment configuration to .zephyr/config.json')
+    return appConfig
+  }
+
+  const chosen = projectConfig.apps[selection]
+  return chosen
 }
 
 async function main() {
   const rootDir = process.cwd()
-  const releasePath = path.join(rootDir, RELEASE_FILE)
 
   await ensureGitignoreEntry(rootDir)
 
-  const releases = await loadReleases(releasePath)
+  const servers = await loadServers()
+  const server = await selectServer(servers)
+  const projectConfig = await loadProjectConfig(rootDir)
+  const appConfig = await selectApp(projectConfig, server, rootDir)
 
-  if (releases.length === 0) {
-    logProcessing("No deployment targets found. Let's create one.")
-    const config = await collectServerConfig(rootDir)
-    releases.push(config)
-    await saveReleases(releasePath, releases)
-    logSuccess('Saved deployment configuration to release.json')
-    await runRemoteTasks(config)
-    return
-  }
-
-  const selection = await promptSelection(releases)
+  const updated = await ensureSshDetails(appConfig, rootDir)
 
-  if (selection === 'create') {
-    const config = await collectServerConfig(rootDir)
-    releases.push(config)
-    await saveReleases(releasePath, releases)
-    logSuccess('Appended new deployment configuration to release.json')
-    await runRemoteTasks(config)
-    return
+  if (updated) {
+    await saveProjectConfig(rootDir, projectConfig)
+    logSuccess('Updated .zephyr/config.json with SSH details.')
   }
 
-  const chosen = releases[selection]
-  const updated = await ensureSshDetails(chosen, rootDir)
-
-  if (updated) {
-    await saveReleases(releasePath, releases)
-    logSuccess('Updated release.json with SSH details.')
+  const deploymentConfig = {
+    serverName: server.serverName,
+    serverIp: server.serverIp,
+    projectPath: appConfig.projectPath,
+    branch: appConfig.branch,
+    sshUser: appConfig.sshUser,
+    sshKey: appConfig.sshKey
   }
+
   logProcessing('\nSelected deployment target:')
-  console.log(JSON.stringify(chosen, null, 2))
+  console.log(JSON.stringify(deploymentConfig, null, 2))
 
-  await runRemoteTasks(chosen)
+  await runRemoteTasks(deploymentConfig)
 }
 
 export {
@@ -859,9 +971,14 @@ export {
   resolveRemotePath,
   isPrivateKeyFile,
   runRemoteTasks,
-  collectServerConfig,
+  promptServerDetails,
+  selectServer,
+  promptAppDetails,
+  selectApp,
   promptSshDetails,
   ensureSshDetails,
   ensureLocalRepositoryState,
+  loadServers,
+  loadProjectConfig,
   main
 }

package/tests/index.test.js

@@ -4,6 +4,7 @@ const mockReadFile = vi.fn()
 const mockReaddir = vi.fn()
 const mockAccess = vi.fn()
 const mockWriteFile = vi.fn()
+const mockMkdir = vi.fn()
 const mockExecCommand = vi.fn()
 const mockConnect = vi.fn()
 const mockDispose = vi.fn()
@@ -14,12 +15,14 @@ vi.mock('node:fs/promises', () => ({
     readFile: mockReadFile,
     readdir: mockReaddir,
     access: mockAccess,
-    writeFile: mockWriteFile
+    writeFile: mockWriteFile,
+    mkdir: mockMkdir
   },
   readFile: mockReadFile,
   readdir: mockReaddir,
   access: mockAccess,
-  writeFile: mockWriteFile
+  writeFile: mockWriteFile,
+  mkdir: mockMkdir
 }))
 
 const spawnQueue = []
@@ -90,11 +93,18 @@ vi.mock('node:child_process', () => ({
   }
 }))
 
-vi.mock('inquirer', () => ({
-  default: {
+vi.mock('inquirer', () => {
+  class Separator {}
+
+  return {
+    default: {
+      prompt: mockPrompt,
+      Separator
+    },
+    Separator,
     prompt: mockPrompt
   }
-}))
+})
 
 vi.mock('node-ssh', () => ({
   NodeSSH: vi.fn(() => ({
@@ -122,6 +132,7 @@ describe('zephyr deployment helpers', () => {
     mockReaddir.mockReset()
     mockAccess.mockReset()
     mockWriteFile.mockReset()
+  mockMkdir.mockReset()
     mockExecCommand.mockReset()
     mockConnect.mockReset()
     mockDispose.mockReset()
@@ -196,6 +207,52 @@ describe('zephyr deployment helpers', () => {
     })
   })
 
+  describe('configuration management', () => {
+    it('registers a new server when none exist', async () => {
+      mockPrompt.mockResolvedValueOnce({ serverName: 'production', serverIp: '203.0.113.10' })
+
+      const { selectServer } = await import('../src/index.mjs')
+
+      const servers = []
+      const server = await selectServer(servers)
+
+      expect(server).toEqual({ serverName: 'production', serverIp: '203.0.113.10' })
+      expect(servers).toHaveLength(1)
+      expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.config/zephyr'), { recursive: true })
+      const [writePath, payload] = mockWriteFile.mock.calls.at(-1)
+      expect(writePath).toContain('servers.json')
+      expect(payload).toContain('production')
+    })
+
+    it('creates a new application configuration when none exist for a server', async () => {
+      queueSpawnResponse({ stdout: 'main\n' })
+      mockPrompt
+        .mockResolvedValueOnce({ projectPath: '~/webapps/demo', branchSelection: 'main' })
+        .mockResolvedValueOnce({ sshUser: 'forge', sshKeySelection: '/home/local/.ssh/id_rsa' })
+      mockReaddir.mockResolvedValue([])
+
+      const { selectApp } = await import('../src/index.mjs')
+
+      const projectConfig = { apps: [] }
+      const server = { serverName: 'production', serverIp: '203.0.113.10' }
+
+      const app = await selectApp(projectConfig, server, process.cwd())
+
+      expect(app).toMatchObject({
+        serverName: 'production',
+        projectPath: '~/webapps/demo',
+        branch: 'main',
+        sshUser: 'forge',
+        sshKey: '/home/local/.ssh/id_rsa'
+      })
+      expect(projectConfig.apps).toHaveLength(1)
+      expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.zephyr'), { recursive: true })
+      const [writePath, payload] = mockWriteFile.mock.calls.at(-1)
+      expect(writePath).toContain('.zephyr/config.json')
+      expect(payload).toContain('~/webapps/demo')
+    })
+  })
+
   it('schedules Laravel tasks based on diff', async () => {
     queueSpawnResponse({ stdout: 'main\n' })
     queueSpawnResponse({ stdout: '' })