@4ge/cli 0.2.2 → 0.2.4

package/dist/base.js

@@ -177,21 +177,47 @@ export class BaseCommand extends Command {
             },
         }, null, 2));
     }
+    /**
+     * Render an error respecting the active output mode.
+     *
+     * - JSON mode: emit the structured `{ data, error, metadata }` envelope.
+     * - Pretty mode: render a human-readable error (never a JSON blob) using
+     *   oclif's `error()`, which pretty-prints to stderr and exits non-zero.
+     *
+     * Centralising the mode branch here means command authors can call
+     * `outputErrorAndExit({ message, code, hint })` without guarding on
+     * `isJsonMode` themselves — eliminating a class of bug where pretty-mode
+     * users saw raw JSON error envelopes.
+     */
     outputError(error, metadata) {
         const errorObj = typeof error === 'string'
             ? { message: error }
             : error;
-        this.log(JSON.stringify({
-            data: null,
-            error: errorObj,
-            metadata: {
-                timestamp: new Date().toISOString(),
-                ...metadata,
-            },
-        }, null, 2));
+        if (this.isJsonMode) {
+            this.log(JSON.stringify({
+                data: null,
+                error: errorObj,
+                metadata: {
+                    timestamp: new Date().toISOString(),
+                    ...metadata,
+                },
+            }, null, 2));
+            return;
+        }
+        // Pretty mode — mirror the human format used by handleError():
+        //   <message>
+        //   💡 <hint>
+        // oclif's error() throws a PrettyPrintableError caught by the framework;
+        // it never returns, so callers chained off outputError() (e.g.
+        // outputErrorAndExit) reliably terminate.
+        const lines = [errorObj.message];
+        if (errorObj.hint)
+            lines.push(`💡 ${errorObj.hint}`);
+        this.error(lines.join('\n'));
     }
     outputErrorAndExit(error, metadata) {
         this.outputError(error, metadata);
+        // Only reached in JSON mode — in pretty mode outputError() throws.
         this.exit(1);
     }
     /**
@@ -387,11 +413,16 @@ export class BaseCommand extends Command {
             this.log(`  Payload: ${JSON.stringify(payload, null, 2)}`);
         }
     }
-    // Handle errors — in JSON mode output JSON error, otherwise use oclif default
+    // Handle errors. In JSON mode emit a structured envelope for unexpected
+    // errors, then re-throw so the framework sets the exit code. Intentional
+    // exit errors (oclif ExitError, thrown by this.exit()/outputErrorAndExit)
+    // are NOT re-emitted in JSON mode — the command has already produced any
+    // envelope it intended to, and re-emitting would double-print a trailing
+    // {data:null,error:{EEXIT}} envelope (#34). The framework renders
+    // ExitError as empty (no output) and exits non-zero, matching pretty mode.
     async catch(error) {
-        if (this.isJsonMode) {
+        if (this.isJsonMode && error?.code !== 'EEXIT') {
             this.outputError({ message: error.message, code: error.code || error.constructor.name });
-            this.exit(1);
         }
         throw error;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4ge/cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "4ge Service Architecture Bridge & CLI",
   "main": "dist/index.js",
   "bin": {