@wyxos/zephyr 0.9.8 → 0.9.10

package/package.json

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

package/src/application/release/release-node-package.mjs

@@ -12,6 +12,7 @@ import {
     runReleaseCommand,
     validateReleaseDependencies
 } from '../../release/shared.mjs'
+import {waitForGitHubReleaseWorkflows} from '../../release/github-actions.mjs'
 import {resolveReleaseType} from '../../release/release-type.mjs'
 import {gitCommitArgs, gitPushArgs, npmVersionArgs} from '../../utils/git-hooks.mjs'
 
@@ -469,10 +470,18 @@ export async function releaseNodePackage({
     if (skipVersioning) {
         await createReleaseTag(updatedPkg.version, rootDir, {logStep, runCommand})
     }
+    const releasePushStartedAt = new Date()
     await pushChanges(rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    logStep?.('Publishing will be handled by GitHub Actions via trusted publishing.')
+    await waitForGitHubReleaseWorkflows(rootDir, {
+        runCommand,
+        logStep,
+        logSuccess,
+        logWarning,
+        pushStartedAt: releasePushStartedAt
+    })
     await deployGHPages(skipDeploy, updatedPkg, rootDir, {logStep, logSuccess, logWarning, runCommand, skipGitHooks})
 
-    logStep?.('Publishing will be handled by GitHub Actions via trusted publishing.')
     logSuccess?.(`Release workflow completed for ${updatedPkg.name}@${updatedPkg.version}.`)
     return updatedPkg
 }

package/src/application/release/release-packagist-package.mjs

@@ -11,6 +11,7 @@ import {
     runReleaseCommand,
     validateReleaseDependencies
 } from '../../release/shared.mjs'
+import {waitForGitHubReleaseWorkflows} from '../../release/github-actions.mjs'
 import {resolveReleaseType} from '../../release/release-type.mjs'
 import {gitCommitArgs, gitPushArgs} from '../../utils/git-hooks.mjs'
 
@@ -322,7 +323,15 @@ export async function releasePackagistPackage({
     if (skipVersioning) {
         await createReleaseTag(updatedComposer.version, rootDir, {logStep, runCommand})
     }
+    const releasePushStartedAt = new Date()
     await pushChanges(rootDir, {logStep, logSuccess, runCommand, skipGitHooks})
+    await waitForGitHubReleaseWorkflows(rootDir, {
+        runCommand,
+        logStep,
+        logSuccess,
+        logWarning,
+        pushStartedAt: releasePushStartedAt
+    })
 
     logSuccess?.(`Release workflow completed for ${composer.name}@${updatedComposer.version}.`)
     logStep?.('Note: Packagist will automatically detect the new git tag and update the package.')

package/src/release/github-actions.mjs

@@ -0,0 +1,197 @@
+import {readdir} from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import {runReleaseCommand} from './shared.mjs'
+
+const DEFAULT_WORKFLOW_WAIT_TIMEOUT_MS = 60_000
+const DEFAULT_WORKFLOW_POLL_INTERVAL_MS = 3_000
+const RUN_CREATED_AT_TOLERANCE_MS = 5_000
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+function describeError(error) {
+  const stderr = String(error?.stderr ?? '').trim()
+  if (stderr) {
+    return stderr
+  }
+
+  const message = String(error?.message ?? '').trim()
+  if (message) {
+    return message
+  }
+
+  return String(error ?? 'unknown error')
+}
+
+async function hasGitHubWorkflowFiles(rootDir) {
+  const workflowDir = path.join(rootDir, '.github', 'workflows')
+
+  try {
+    const entries = await readdir(workflowDir, {withFileTypes: true})
+
+    return entries.some((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
+  } catch {
+    return false
+  }
+}
+
+function parseWorkflowRuns(stdout) {
+  try {
+    const parsed = JSON.parse(stdout || '[]')
+
+    return Array.isArray(parsed) ? parsed : []
+  } catch {
+    return []
+  }
+}
+
+function isRunForCurrentPush(run, pushStartedAt) {
+  if (!pushStartedAt || !run?.createdAt) {
+    return true
+  }
+
+  const runCreatedAt = Date.parse(run.createdAt)
+  const startedAt = pushStartedAt instanceof Date
+    ? pushStartedAt.getTime()
+    : Date.parse(pushStartedAt)
+
+  if (!Number.isFinite(runCreatedAt) || !Number.isFinite(startedAt)) {
+    return true
+  }
+
+  return runCreatedAt >= startedAt - RUN_CREATED_AT_TOLERANCE_MS
+}
+
+function workflowLabel(run) {
+  const workflowName = run?.workflowName || run?.name || 'GitHub Actions workflow'
+  const databaseId = run?.databaseId ? `#${run.databaseId}` : ''
+
+  return `${workflowName}${databaseId ? ` ${databaseId}` : ''}`
+}
+
+async function findCurrentPushRuns(rootDir, {
+  runCommand,
+  headSha,
+  pushStartedAt,
+  timeoutMs,
+  pollIntervalMs,
+  sleepImpl
+}) {
+  const deadline = Date.now() + timeoutMs
+  let shouldPoll = true
+
+  while (shouldPoll) {
+    const {stdout} = await runCommand('gh', [
+      'run',
+      'list',
+      '--commit',
+      headSha,
+      '--event',
+      'push',
+      '--json',
+      'databaseId,status,conclusion,workflowName,createdAt,url',
+      '--limit',
+      '20'
+    ], {
+      capture: true,
+      cwd: rootDir
+    })
+
+    const runs = parseWorkflowRuns(stdout)
+      .filter((run) => run?.databaseId)
+      .filter((run) => isRunForCurrentPush(run, pushStartedAt))
+
+    if (runs.length > 0) {
+      return runs
+    }
+
+    shouldPoll = Date.now() < deadline
+
+    if (shouldPoll) {
+      await sleepImpl(pollIntervalMs)
+    }
+  }
+
+  return []
+}
+
+export async function waitForGitHubReleaseWorkflows(rootDir = process.cwd(), {
+  runCommand = runReleaseCommand,
+  logStep,
+  logSuccess,
+  logWarning,
+  pushStartedAt = new Date(),
+  timeoutMs = DEFAULT_WORKFLOW_WAIT_TIMEOUT_MS,
+  pollIntervalMs = DEFAULT_WORKFLOW_POLL_INTERVAL_MS,
+  sleepImpl = sleep
+} = {}) {
+  if (!await hasGitHubWorkflowFiles(rootDir)) {
+    return {status: 'skipped', reason: 'no-workflows', runs: []}
+  }
+
+  try {
+    await runCommand('gh', ['--version'], {capture: true, cwd: rootDir})
+  } catch (error) {
+    logWarning?.(`GitHub Actions workflow monitoring skipped because GitHub CLI is unavailable: ${describeError(error)}`)
+    return {status: 'skipped', reason: 'gh-unavailable', runs: []}
+  }
+
+  let headSha
+  try {
+    const result = await runCommand('git', ['rev-parse', 'HEAD'], {capture: true, cwd: rootDir})
+    headSha = result.stdout.trim()
+  } catch (error) {
+    logWarning?.(`GitHub Actions workflow monitoring skipped because the release commit could not be resolved: ${describeError(error)}`)
+    return {status: 'skipped', reason: 'head-unavailable', runs: []}
+  }
+
+  if (!headSha) {
+    logWarning?.('GitHub Actions workflow monitoring skipped because the release commit could not be resolved.')
+    return {status: 'skipped', reason: 'head-unavailable', runs: []}
+  }
+
+  logStep?.('Checking for GitHub Actions workflows triggered by the release push...')
+
+  let runs = []
+  try {
+    runs = await findCurrentPushRuns(rootDir, {
+      runCommand,
+      headSha,
+      pushStartedAt,
+      timeoutMs,
+      pollIntervalMs,
+      sleepImpl
+    })
+  } catch (error) {
+    logWarning?.(`GitHub Actions workflow monitoring skipped because workflow runs could not be listed: ${describeError(error)}`)
+    return {status: 'skipped', reason: 'list-failed', runs: []}
+  }
+
+  if (runs.length === 0) {
+    logWarning?.('GitHub Actions workflow monitoring skipped because no workflow run appeared for the release push.')
+    return {status: 'skipped', reason: 'no-runs', runs: []}
+  }
+
+  for (const run of runs) {
+    const label = workflowLabel(run)
+    logStep?.(`Watching GitHub Actions workflow ${label}...`)
+
+    try {
+      await runCommand('gh', ['run', 'watch', String(run.databaseId), '--exit-status', '--compact'], {
+        cwd: rootDir
+      })
+    } catch (_error) {
+      const suffix = run.url ? ` ${run.url}` : ''
+      throw new Error(`GitHub Actions workflow ${label} failed or could not be watched.${suffix}`)
+    }
+
+    logSuccess?.(`GitHub Actions workflow ${label} completed successfully.`)
+  }
+
+  return {status: 'watched', reason: null, runs}
+}

package/src/runtime/app-context.mjs

@@ -54,7 +54,7 @@ export function createAppContext({
         workflow: normalizedExecutionMode.workflow
     })
     const hasInteractiveTerminal = Boolean(processInstance?.stdin?.isTTY && processInstance?.stdout?.isTTY)
-    const createSshClient = createSshClientFactory({NodeSSH: NodeSSHClass})
+    const createSshClient = createSshClientFactory({NodeSSH: NodeSSHClass, logWarning})
     const {runCommand, runCommandCapture} = createLocalCommandRunners({
         runCommandBase: runCommandImpl,
         runCommandCaptureBase: runCommandCaptureImpl

package/src/runtime/ssh-client.mjs

@@ -1,14 +1,69 @@
-export function createSshClientFactory({ NodeSSH }) {
+const connectionErrorHandlerSymbol = Symbol('zephyrSshConnectionErrorHandler')
+const connectWrapperSymbol = Symbol('zephyrSshConnectWrapper')
+
+function getErrorMessage(error) {
+  if (error instanceof Error && error.message) {
+    return error.message
+  }
+
+  return String(error ?? 'Unknown SSH connection error')
+}
+
+export function attachSshConnectionErrorHandler(ssh, { logWarning } = {}) {
+  const connection = ssh?.connection
+
+  if (!connection || typeof connection.on !== 'function') {
+    return false
+  }
+
+  if (connection[connectionErrorHandlerSymbol]) {
+    return false
+  }
+
+  let hasLogged = false
+  const handler = (error) => {
+    if (hasLogged) {
+      return
+    }
+
+    hasLogged = true
+    logWarning?.(`SSH connection emitted a background error after connect: ${getErrorMessage(error)}`)
+  }
+
+  connection.on('error', handler)
+  connection[connectionErrorHandlerSymbol] = handler
+
+  return true
+}
+
+function wrapSshConnect(ssh, { logWarning } = {}) {
+  if (!ssh || typeof ssh.connect !== 'function' || ssh[connectWrapperSymbol]) {
+    return ssh
+  }
+
+  const originalConnect = ssh.connect
+
+  ssh.connect = async function connectWithBackgroundErrorHandler(...args) {
+    const result = await originalConnect.apply(this, args)
+    attachSshConnectionErrorHandler(this, { logWarning })
+
+    return result
+  }
+  ssh[connectWrapperSymbol] = true
+
+  return ssh
+}
+
+export function createSshClientFactory({ NodeSSH, logWarning }) {
   if (!NodeSSH) {
     throw new Error('createSshClientFactory requires NodeSSH')
   }
 
   return function createSshClient() {
     if (typeof globalThis !== 'undefined' && globalThis.__zephyrSSHFactory) {
-      return globalThis.__zephyrSSHFactory()
+      return wrapSshConnect(globalThis.__zephyrSSHFactory(), { logWarning })
     }
 
-    return new NodeSSH()
+    return wrapSshConnect(new NodeSSH(), { logWarning })
   }
 }
-

package/src/ssh/ssh.mjs

@@ -11,7 +11,7 @@ import { createSshClientFactory } from '../runtime/ssh-client.mjs'
 
 const { logProcessing, logSuccess, logWarning, logError } = createChalkLogger(chalk)
 
-const createSshClient = createSshClientFactory({ NodeSSH })
+const createSshClient = createSshClientFactory({ NodeSSH, logWarning })
 
 function normalizeRemotePath(value) {
   if (value == null) return value
@@ -136,4 +136,3 @@ export async function deleteRemoteFile(ssh, remotePath, remoteCwd) {
     logSuccess(`Deleted remote file: ${absoluteRemotePath}`)
   }
 }
-