@wyxos/zephyr 0.3.3 → 0.4.0

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})
+    }
+}