@wyxos/zephyr 0.3.4 → 0.4.1

package/src/release-node.mjs

@@ -1,27 +1,37 @@
 import process from 'node:process'
-import chalk from 'chalk'
-import {createChalkLogger} from './utils/output.mjs'
-import {
-    parseReleaseArgs,
-} from './release/shared.mjs'
+import {createAppContext} from './runtime/app-context.mjs'
+import {parseReleaseArgs} from './release/shared.mjs'
 import {releaseNodePackage} from './application/release/release-node-package.mjs'
 
-const {logProcessing: logStep, logSuccess, logWarning} = createChalkLogger(chalk)
-
-export async function releaseNode() {
-    const {releaseType, skipTests, skipLint, skipBuild, skipDeploy} = parseReleaseArgs({
-        booleanFlags: ['--skip-tests', '--skip-lint', '--skip-build', '--skip-deploy']
+export async function releaseNode(options = {}) {
+    const parsed = options.releaseType
+        ? options
+        : parseReleaseArgs({
+            booleanFlags: ['--skip-tests', '--skip-lint', '--skip-build', '--skip-deploy']
+        })
+    const rootDir = options.rootDir ?? process.cwd()
+    const context = options.context ?? createAppContext({
+        executionMode: {
+            interactive: true,
+            json: false,
+            workflow: 'release-node'
+        }
     })
-    const rootDir = process.cwd()
+    const {logProcessing: logStep, logSuccess, logWarning, runPrompt, runCommand, runCommandCapture, executionMode} = context
+
     await releaseNodePackage({
-        releaseType,
-        skipTests,
-        skipLint,
-        skipBuild,
-        skipDeploy,
+        releaseType: parsed.releaseType,
+        skipTests: parsed.skipTests === true,
+        skipLint: parsed.skipLint === true,
+        skipBuild: parsed.skipBuild === true,
+        skipDeploy: parsed.skipDeploy === true,
         rootDir,
         logStep,
         logSuccess,
-        logWarning
+        logWarning,
+        runPrompt,
+        runCommandImpl: runCommand,
+        runCommandCaptureImpl: runCommandCapture,
+        interactive: executionMode?.interactive !== false
     })
 }

package/src/release-packagist.mjs

@@ -1,25 +1,36 @@
 import process from 'node:process'
-import chalk from 'chalk'
-import {createChalkLogger} from './utils/output.mjs'
-import {
-    parseReleaseArgs,
-} from './release/shared.mjs'
+import {createAppContext} from './runtime/app-context.mjs'
+import {parseReleaseArgs} from './release/shared.mjs'
 import {releasePackagistPackage} from './application/release/release-packagist-package.mjs'
 
-const {logProcessing: logStep, logSuccess, logWarning} = createChalkLogger(chalk)
-
-export async function releasePackagist() {
-    const {releaseType, skipTests, skipLint} = parseReleaseArgs({
-        booleanFlags: ['--skip-tests', '--skip-lint']
+export async function releasePackagist(options = {}) {
+    const parsed = options.releaseType
+        ? options
+        : parseReleaseArgs({
+            booleanFlags: ['--skip-tests', '--skip-lint']
+        })
+    const rootDir = options.rootDir ?? process.cwd()
+    const context = options.context ?? createAppContext({
+        executionMode: {
+            interactive: true,
+            json: false,
+            workflow: 'release-packagist'
+        }
     })
-    const rootDir = process.cwd()
+    const {logProcessing: logStep, logSuccess, logWarning, runPrompt, runCommand, runCommandCapture, executionMode} = context
+
     await releasePackagistPackage({
-        releaseType,
-        skipTests,
-        skipLint,
+        releaseType: parsed.releaseType,
+        skipTests: parsed.skipTests === true,
+        skipLint: parsed.skipLint === true,
         rootDir,
         logStep,
         logSuccess,
-        logWarning
+        logWarning,
+        runPrompt,
+        runCommandImpl: runCommand,
+        runCommandCaptureImpl: runCommandCapture,
+        interactive: executionMode?.interactive !== false,
+        progressWriter: executionMode?.json ? process.stderr : process.stdout
     })
 }

package/src/runtime/app-context.mjs

@@ -2,7 +2,7 @@ import chalk from 'chalk'
 import inquirer from 'inquirer'
 import {NodeSSH} from 'node-ssh'
 
-import {createChalkLogger} from '../utils/output.mjs'
+import {createChalkLogger, createJsonEventEmitter, createJsonLogger} from '../utils/output.mjs'
 import {runCommand as runCommandBase, runCommandCapture as runCommandCaptureBase} from '../utils/command.mjs'
 import {createLocalCommandRunners} from './local-command.mjs'
 import {createRunPrompt} from './prompt.mjs'
@@ -13,16 +13,41 @@ export function createAppContext({
                                      inquirerInstance = inquirer,
                                      NodeSSHClass = NodeSSH,
                                      runCommandImpl = runCommandBase,
-                                     runCommandCaptureImpl = runCommandCaptureBase
+                                     runCommandCaptureImpl = runCommandCaptureBase,
+                                     executionMode = {}
                                  } = {}) {
-    const {logProcessing, logSuccess, logWarning, logError} = createChalkLogger(chalkInstance)
-    const runPrompt = createRunPrompt({inquirer: inquirerInstance})
+    const normalizedExecutionMode = {
+        interactive: executionMode.interactive !== false,
+        json: executionMode.json === true,
+        workflow: executionMode.workflow ?? 'deploy',
+        presetName: executionMode.presetName ?? null,
+        maintenanceMode: executionMode.maintenanceMode ?? null,
+        resumePending: executionMode.resumePending === true,
+        discardPending: executionMode.discardPending === true
+    }
+    const emitEvent = normalizedExecutionMode.json
+        ? createJsonEventEmitter({workflow: normalizedExecutionMode.workflow})
+        : null
+    const {logProcessing, logSuccess, logWarning, logError} = normalizedExecutionMode.json
+        ? createJsonLogger({emitEvent})
+        : createChalkLogger(chalkInstance)
+    const runPrompt = createRunPrompt({
+        inquirer: inquirerInstance,
+        interactive: normalizedExecutionMode.interactive,
+        emitEvent,
+        workflow: normalizedExecutionMode.workflow
+    })
     const createSshClient = createSshClientFactory({NodeSSH: NodeSSHClass})
     const {runCommand, runCommandCapture} = createLocalCommandRunners({
         runCommandBase: runCommandImpl,
         runCommandCaptureBase: runCommandCaptureImpl
     })
 
+    const runCommandWithMode = (command, args, options = {}) => runCommand(command, args, {
+        ...options,
+        forwardStdoutToStderr: normalizedExecutionMode.json
+    })
+
     return {
         logProcessing,
         logSuccess,
@@ -30,7 +55,9 @@ export function createAppContext({
         logError,
         runPrompt,
         createSshClient,
-        runCommand,
-        runCommandCapture
+        runCommand: runCommandWithMode,
+        runCommandCapture,
+        emitEvent,
+        executionMode: normalizedExecutionMode
     }
 }

package/src/runtime/errors.mjs

@@ -0,0 +1,46 @@
+export class ZephyrError extends Error {
+    constructor(message, {
+        code = 'ZEPHYR_FAILURE',
+        data = {},
+        cause
+    } = {}) {
+        super(message, cause ? {cause} : undefined)
+        this.name = this.constructor.name
+        this.code = code
+        this.data = data
+    }
+}
+
+export class PromptRequiredError extends ZephyrError {
+    constructor(message, {
+        data = {},
+        cause
+    } = {}) {
+        super(message, {
+            code: 'ZEPHYR_PROMPT_REQUIRED',
+            data,
+            cause
+        })
+    }
+}
+
+export class InvalidCliOptionsError extends ZephyrError {
+    constructor(message, {
+        data = {},
+        cause
+    } = {}) {
+        super(message, {
+            code: 'ZEPHYR_INVALID_OPTIONS',
+            data,
+            cause
+        })
+    }
+}
+
+export function getErrorCode(error) {
+    if (error && typeof error === 'object' && typeof error.code === 'string' && error.code.length > 0) {
+        return error.code
+    }
+
+    return 'ZEPHYR_FAILURE'
+}

package/src/runtime/local-command.mjs

@@ -1,10 +1,20 @@
+import process from 'node:process'
+
 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'
+  const runCommand = async (command, args, {
+    silent = false,
+    cwd,
+    forwardStdoutToStderr = false
+  } = {}) => {
+    const stdio = silent
+      ? 'ignore'
+      : forwardStdoutToStderr
+        ? ['ignore', process.stderr, process.stderr]
+        : 'inherit'
     return runCommandBase(command, args, { cwd, stdio })
   }
 
@@ -15,4 +25,3 @@ export function createLocalCommandRunners({ runCommandBase, runCommandCaptureBas
 
   return { runCommand, runCommandCapture }
 }
-

package/src/runtime/prompt.mjs

@@ -1,9 +1,48 @@
-export function createRunPrompt({ inquirer }) {
+import {PromptRequiredError} from './errors.mjs'
+
+function buildPromptMessage(questions = []) {
+  const messages = questions
+    .map((question) => question?.message)
+    .filter((message) => typeof message === 'string' && message.trim().length > 0)
+
+  return messages[0] ?? 'Zephyr requires interactive input to continue.'
+}
+
+export function createRunPrompt({
+  inquirer,
+  interactive = true,
+  emitEvent,
+  workflow = 'deploy'
+}) {
   if (!inquirer) {
     throw new Error('createRunPrompt requires inquirer')
   }
 
   return async function runPrompt(questions) {
+    if (!interactive) {
+      const message = buildPromptMessage(questions)
+      const error = new PromptRequiredError(message, {
+        data: {
+          workflow,
+          questions: Array.isArray(questions)
+            ? questions.map((question) => ({
+              name: question?.name ?? null,
+              type: question?.type ?? null,
+              message: question?.message ?? null
+            }))
+            : []
+        }
+      })
+
+      emitEvent?.('prompt_required', {
+        message,
+        code: error.code,
+        data: error.data
+      })
+
+      throw error
+    }
+
     if (typeof globalThis !== 'undefined' && globalThis.__zephyrPrompt) {
       return globalThis.__zephyrPrompt(questions)
     }
@@ -11,4 +50,3 @@ export function createRunPrompt({ inquirer }) {
     return inquirer.prompt(questions)
   }
 }
-

package/src/utils/output.mjs

@@ -25,6 +25,36 @@ export function writeStderr(message = '') {
     }
 }
 
+export function createJsonEventEmitter({
+    workflow,
+    writeEvent = writeStdoutLine
+} = {}) {
+    return function emitEvent(event, {
+        level,
+        message = '',
+        data = {},
+        code
+    } = {}) {
+        const payload = {
+            event,
+            timestamp: new Date().toISOString(),
+            workflow,
+            message
+        }
+
+        if (level) {
+            payload.level = level
+        }
+
+        if (code) {
+            payload.code = code
+        }
+
+        payload.data = data ?? {}
+        writeEvent(JSON.stringify(payload))
+    }
+}
+
 export function formatLogMessage(message = '', prefix = '') {
     const text = message == null ? '' : String(message)
 
@@ -52,3 +82,18 @@ export function createChalkLogger(chalk, {
         logError: (message = '') => writeStderrLine(chalk.red(formatLogMessage(message, prefixes.error)))
     }
 }
+
+export function createJsonLogger({
+    emitEvent
+} = {}) {
+    if (typeof emitEvent !== 'function') {
+        throw new Error('createJsonLogger requires emitEvent')
+    }
+
+    return {
+        logProcessing: (message = '', data = {}) => emitEvent('log', {level: 'processing', message: String(message ?? ''), data}),
+        logSuccess: (message = '', data = {}) => emitEvent('log', {level: 'success', message: String(message ?? ''), data}),
+        logWarning: (message = '', data = {}) => emitEvent('log', {level: 'warning', message: String(message ?? ''), data}),
+        logError: (message = '', data = {}) => emitEvent('log', {level: 'error', message: String(message ?? ''), data})
+    }
+}