@iqai/adk-cli 0.3.19 → 0.3.22

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @iqai/adk-cli
 
+## 0.3.22
+
+### Patch Changes
+
+- 1ec769a: fix: improve type safety across cli and adk package
+- 9ba699c: fix: state persistence
+- 4fbb724: Fix: state management
+- 69d3431: fix: state persistence and allows initial state of agents to be passed down to proper sessions
+- Updated dependencies [1ec769a]
+- Updated dependencies [9ba699c]
+- Updated dependencies [4fbb724]
+- Updated dependencies [edfe628]
+  - @iqai/adk@0.5.3
+
+## 0.3.21
+
+### Patch Changes
+
+- Updated dependencies [ae81c74]
+  - @iqai/adk@0.5.2
+
+## 0.3.20
+
+### Patch Changes
+
+- 170dafc: fix: multiple cache file creation
+- 31264cb: Improves the logging for adk run by silencing the logs from agent processes by default
+- Updated dependencies [d8fd6e8]
+  - @iqai/adk@0.5.1
+
 ## 0.3.19
 
 ### Patch Changes

package/dist/cli/run.command.d.ts

@@ -1,8 +1,6 @@
 import { CommandRunner } from "nest-commander";
-interface ServeLikeOptions {
+interface RunOptions {
     host?: string;
-}
-interface RunOptions extends ServeLikeOptions {
     server?: boolean;
     verbose?: boolean;
     hot?: boolean;

package/dist/cli/run.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.command.d.ts","sourceRoot":"","sources":["../../src/cli/run.command.ts"],"names":[],"mappings":"AAKA,OAAO,EAAW,aAAa,EAAU,MAAM,gBAAgB,CAAC;AAiBhE,UAAU,gBAAgB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,UAAU,UAAW,SAAQ,gBAAgB;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAsKD,qBAKa,UAAW,SAAQ,aAAa;IACtC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA4GhE,WAAW,IAAI,OAAO;IAQtB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAQ9B,YAAY,IAAI,OAAO;IAQvB,QAAQ,IAAI,OAAO;IASnB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;CAMjC"}
+{"version":3,"file":"run.command.d.ts","sourceRoot":"","sources":["../../src/cli/run.command.ts"],"names":[],"mappings":"AAIA,OAAO,EAAW,aAAa,EAAU,MAAM,gBAAgB,CAAC;AAQhE,UAAU,UAAU;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAueD,qBAKa,UAAW,SAAQ,aAAa;IACtC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAsHhE,WAAW,IAAI,OAAO;IAQtB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAQ9B,YAAY,IAAI,OAAO;IAQvB,QAAQ,IAAI,OAAO;IASnB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE;CAMjC"}

package/dist/cli/run.command.js

@@ -47,28 +47,261 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunCommand = void 0;
 const p = __importStar(require("@clack/prompts"));
-const prompts_1 = require("@clack/prompts");
 const chalk_1 = __importDefault(require("chalk"));
 const marked_1 = require("marked");
 const markedTerminal = __importStar(require("marked-terminal"));
 const nest_commander_1 = require("nest-commander");
 const bootstrap_1 = require("../http/bootstrap");
+// Setup markdown terminal renderer
 const mt = markedTerminal.markedTerminal ?? markedTerminal;
 marked_1.marked.use(mt());
-/**
- * Render markdown to ANSI for terminal using 'marked' + 'marked-terminal'.
- * Simple static import and configuration as per package docs.
- */
-async function render(text) {
-    const input = text ?? "";
-    const out = marked_1.marked.parse(input);
-    return typeof out === "string" ? out : String(out ?? "");
+// Console management for quiet mode
+class ConsoleManager {
+    originals = null;
+    originalStdoutWrite = null;
+    originalStderrWrite = null;
+    originalSpawn = null;
+    verbose;
+    outputAllowed = false;
+    isDestroyed = false;
+    constructor(verbose) {
+        this.verbose = verbose;
+        // Ensure cleanup on process exit
+        process.on("exit", () => this.restore());
+        process.on("SIGINT", () => this.restore());
+        process.on("SIGTERM", () => this.restore());
+    }
+    hookConsole() {
+        if (this.verbose || this.originals || this.isDestroyed)
+            return;
+        try {
+            this.originals = {
+                log: console.log,
+                info: console.info,
+                warn: console.warn,
+                error: console.error,
+                debug: console.debug,
+            };
+            this.originalStdoutWrite = process.stdout.write.bind(process.stdout);
+            this.originalStderrWrite = process.stderr.write.bind(process.stderr);
+            // Smart console method replacement - allow errors and warnings in verbose mode
+            const shouldSilenceConsole = (level) => {
+                if (this.outputAllowed)
+                    return false;
+                // Always allow error and warn messages to prevent diagnostic issues
+                return !["error", "warn"].includes(level);
+            };
+            const createConsoleFn = (level, original) => {
+                return ((...args) => {
+                    if (!shouldSilenceConsole(level)) {
+                        original.apply(console, args);
+                    }
+                });
+            };
+            console.log = createConsoleFn("log", this.originals.log);
+            console.info = createConsoleFn("info", this.originals.info);
+            console.warn = createConsoleFn("warn", this.originals.warn);
+            console.error = createConsoleFn("error", this.originals.error);
+            console.debug = createConsoleFn("debug", this.originals.debug);
+            // Smart stdout silencing - allow certain output patterns
+            const shouldSilenceStdout = (chunk) => {
+                if (this.outputAllowed)
+                    return false;
+                return !this.isImportantOutput(chunk);
+            };
+            process.stdout.write = ((chunk, encoding, callback) => {
+                if (shouldSilenceStdout(chunk))
+                    return true;
+                return this.originalStdoutWrite(chunk, encoding, callback);
+            });
+            // Allow stderr for error messages but filter out non-critical output
+            process.stderr.write = ((chunk, encoding, callback) => {
+                if (this.outputAllowed) {
+                    return this.originalStderrWrite(chunk, encoding, callback);
+                }
+                // Allow error-like content through stderr
+                const str = String(chunk).toLowerCase();
+                if (str.includes("error") ||
+                    str.includes("warning") ||
+                    str.includes("failed")) {
+                    return this.originalStderrWrite(chunk, encoding, callback);
+                }
+                return true;
+            });
+        }
+        catch (error) {
+            // If console hooking fails, continue without it to avoid breaking the app
+            if (this.verbose) {
+                console.error("Failed to hook console:", error);
+            }
+        }
+    }
+    isImportantOutput(chunk) {
+        const str = String(chunk);
+        // Allow spinner characters and UI elements
+        const spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        // Allow interactive prompts, errors, and control sequences
+        return (spinnerChars.some((char) => str.includes(char)) ||
+            str.includes("🤖") ||
+            str.includes("Thinking") ||
+            str.includes("\r") ||
+            str.includes("\x1b") ||
+            str.toLowerCase().includes("error") ||
+            str.toLowerCase().includes("warning") ||
+            str.includes("?") // Interactive prompts
+        );
+    }
+    hookChildProcessSilence() {
+        if (this.verbose || this.originalSpawn || this.isDestroyed)
+            return;
+        try {
+            const cp = require("node:child_process");
+            this.originalSpawn = cp.spawn;
+            const shouldSilenceProcess = (command, args) => {
+                if (!command)
+                    return false;
+                const cmd = command.toLowerCase();
+                const allArgs = (args || []).map((a) => String(a).toLowerCase());
+                const fullCommand = [cmd, ...allArgs].join(" ");
+                // Only silence specific known noisy processes
+                const silencePatterns = [
+                    "mcp-remote",
+                    "@iqai/mcp",
+                    "modelcontextprotocol",
+                    "@modelcontextprotocol",
+                ];
+                return silencePatterns.some((pattern) => fullCommand.includes(pattern));
+            };
+            cp.spawn = ((command, args, options) => {
+                try {
+                    const shouldSilence = shouldSilenceProcess(command, Array.isArray(args) ? args : options?.args);
+                    if (shouldSilence) {
+                        // Determine the correct options object
+                        const opts = Array.isArray(args) ? options || {} : args || {};
+                        // Create safer stdio configuration
+                        const currentStdio = opts.stdio;
+                        let newStdio;
+                        if (Array.isArray(currentStdio)) {
+                            newStdio = [
+                                currentStdio[0] || "pipe",
+                                "pipe", // stdout to pipe (can be handled)
+                                "pipe", // stderr to pipe (allow error monitoring)
+                            ];
+                        }
+                        else if (typeof currentStdio === "string") {
+                            newStdio = ["pipe", "pipe", "pipe"];
+                        }
+                        else {
+                            newStdio = ["pipe", "pipe", "pipe"];
+                        }
+                        const patchedOpts = { ...opts, stdio: newStdio };
+                        if (Array.isArray(args)) {
+                            return this.originalSpawn(command, args, patchedOpts);
+                        }
+                        return this.originalSpawn(command, patchedOpts);
+                    }
+                }
+                catch (error) {
+                    // Log error and continue with original spawn to avoid breaking functionality
+                    if (this.verbose) {
+                        console.error("Error in child process hook:", error);
+                    }
+                }
+                return this.originalSpawn(command, args, options);
+            });
+        }
+        catch (error) {
+            if (this.verbose) {
+                console.error("Failed to hook child process:", error);
+            }
+        }
+    }
+    restore() {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        try {
+            if (this.originals) {
+                console.log = this.originals.log;
+                console.info = this.originals.info;
+                console.warn = this.originals.warn;
+                console.error = this.originals.error;
+                console.debug = this.originals.debug;
+                this.originals = null;
+            }
+            if (this.originalStdoutWrite) {
+                process.stdout.write = this.originalStdoutWrite;
+                this.originalStdoutWrite = null;
+            }
+            if (this.originalStderrWrite) {
+                process.stderr.write = this.originalStderrWrite;
+                this.originalStderrWrite = null;
+            }
+            if (this.originalSpawn) {
+                const cp = require("node:child_process");
+                cp.spawn = this.originalSpawn;
+                this.originalSpawn = null;
+            }
+        }
+        catch (error) {
+            // Use original console.error if available, fallback to process.stderr
+            if (this.originals?.error) {
+                this.originals.error("Error during ConsoleManager restore:", error);
+            }
+            else {
+                process.stderr.write(`Error during ConsoleManager restore: ${error}\n`);
+            }
+        }
+    }
+    writeOut(text) {
+        if (this.originalStdoutWrite) {
+            this.originalStdoutWrite(text);
+        }
+        else {
+            process.stdout.write(text);
+        }
+    }
+    writeErr(text) {
+        if (this.originalStderrWrite) {
+            this.originalStderrWrite(text);
+        }
+        else {
+            process.stderr.write(text);
+        }
+    }
+    async withAllowedOutput(fn) {
+        if (this.verbose || this.isDestroyed) {
+            return await fn();
+        }
+        const wasOutputAllowed = this.outputAllowed;
+        this.outputAllowed = true; // Allow output during this function
+        try {
+            return await fn();
+        }
+        finally {
+            this.outputAllowed = wasOutputAllowed; // Restore previous state
+        }
+    }
+    error(text) {
+        this.writeErr(chalk_1.default.red(text) + "\n");
+    }
+    renderMarkdown(text) {
+        const input = text ?? "";
+        const out = marked_1.marked.parse(input);
+        return typeof out === "string" ? out : String(out ?? "");
+    }
+    printAnswer(markdown) {
+        const rendered = this.renderMarkdown(markdown);
+        this.writeOut((rendered || "").trim() + "\n");
+    }
 }
 class AgentChatClient {
     apiUrl;
     selectedAgent = null;
-    constructor(apiUrl) {
+    consoleManager;
+    constructor(apiUrl, consoleManager) {
         this.apiUrl = apiUrl;
+        this.consoleManager = consoleManager;
     }
     async connect() {
         try {
@@ -106,74 +339,118 @@ class AgentChatClient {
         if (agents.length === 1) {
             return agents[0];
         }
-        const selectedAgent = await p.select({
-            message: "Choose an agent to chat with:",
-            options: agents.map((agent) => ({
-                label: agent.name,
-                value: agent,
-                hint: agent.relativePath,
-            })),
+        return await this.consoleManager.withAllowedOutput(async () => {
+            const choice = await p.select({
+                message: "Choose an agent to chat with:",
+                options: agents.map((agent) => ({
+                    label: agent.name,
+                    value: agent,
+                    hint: agent.relativePath,
+                })),
+            });
+            if (p.isCancel(choice)) {
+                process.exit(0);
+            }
+            return choice;
         });
-        if (p.isCancel(selectedAgent)) {
-            p.cancel("Operation cancelled");
-            process.exit(0);
-        }
-        return selectedAgent;
     }
     async sendMessage(message) {
         if (!this.selectedAgent) {
             throw new Error("No agent selected");
         }
-        const s = (0, prompts_1.spinner)();
-        s.start("🤖 Thinking...");
-        try {
-            const response = await fetch(`${this.apiUrl}/api/agents/${encodeURIComponent(this.selectedAgent.relativePath)}/message`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ message }),
+        await this.consoleManager.withAllowedOutput(async () => {
+            const spinner = p.spinner();
+            spinner.start("🤖 Thinking...");
+            // Save original methods for targeted silencing during the request
+            const savedStdout = process.stdout.write;
+            const savedStderr = process.stderr.write;
+            const savedConsoleLog = console.log;
+            const savedConsoleInfo = console.info;
+            const savedConsoleWarn = console.warn;
+            const savedConsoleError = console.error;
+            // Intelligent stdout filtering - allow spinner chars but block log messages
+            const spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+            const isSpinnerOutput = (chunk) => {
+                const str = String(chunk);
+                return (spinnerChars.some((char) => str.includes(char)) ||
+                    str.includes("🤖 Thinking") ||
+                    str.includes("\r") || // carriage returns for spinner updates
+                    str.includes("\x1b")); // ANSI escape codes for colors/positioning
+            };
+            // Temporarily override output during the fetch
+            process.stdout.write = ((chunk, encoding, callback) => {
+                if (isSpinnerOutput(chunk)) {
+                    return savedStdout.call(process.stdout, chunk, encoding, callback);
+                }
+                return true; // Block everything else
             });
-            if (!response.ok) {
-                const errorText = await response.text();
-                s.stop("❌ Failed to send message");
-                throw new Error(`Failed to send message: ${errorText}`);
+            process.stderr.write = (() => true); // Block all stderr
+            console.log = (() => { });
+            console.info = (() => { });
+            console.warn = (() => { });
+            console.error = (() => { });
+            try {
+                if (!this.selectedAgent?.relativePath) {
+                    throw new Error("No agent selected or agent path not available");
+                }
+                const response = await fetch(`${this.apiUrl}/api/agents/${encodeURIComponent(this.selectedAgent.relativePath)}/message`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ message }),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    spinner.stop("❌ Failed to send message");
+                    throw new Error(`HTTP ${response.status}: ${errorText}`);
+                }
+                const result = (await response.json());
+                spinner.stop(`🤖 ${result.agentName ?? "Assistant"}:`);
+                if (result.response) {
+                    this.consoleManager.printAnswer(result.response);
+                }
             }
-            const result = (await response.json());
-            s.stop(`🤖 ${result.agentName ?? "Assistant"}:`);
-            if (result.response) {
-                const formattedResponse = await render(result.response);
-                p.log.message((formattedResponse || "").trim());
+            catch (error) {
+                spinner.stop("❌ Error");
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.consoleManager.error(`Failed to send message: ${errorMessage}`);
+                throw error;
             }
-        }
-        catch (_error) {
-            p.log.error("Failed to send message");
-        }
+            finally {
+                // Restore all methods
+                process.stdout.write = savedStdout;
+                process.stderr.write = savedStderr;
+                console.log = savedConsoleLog;
+                console.info = savedConsoleInfo;
+                console.warn = savedConsoleWarn;
+                console.error = savedConsoleError;
+            }
+        });
     }
     async startChat() {
         if (!this.selectedAgent) {
             throw new Error("Agent not selected");
         }
-        // Add SIGINT handler for interactive chat mode
         const sigintHandler = () => {
-            p.cancel("Chat ended");
+            this.consoleManager.withAllowedOutput(async () => {
+                p.outro("Chat ended");
+            });
             process.exit(0);
         };
         process.on("SIGINT", sigintHandler);
         try {
             while (true) {
                 try {
-                    const message = await p.text({
-                        message: "💬 Message:",
-                        placeholder: "Type your message here... (type 'exit' or 'quit' to end)",
+                    const input = await this.consoleManager.withAllowedOutput(async () => {
+                        const res = await p.text({
+                            message: "💬 Message:",
+                            placeholder: "Type your message here... (type 'exit' or 'quit' to end)",
+                        });
+                        if (p.isCancel(res))
+                            return "exit";
+                        return typeof res === "symbol" ? String(res) : (res ?? "");
                     });
-                    if (p.isCancel(message)) {
-                        sigintHandler();
-                    }
-                    const trimmed = typeof message === "symbol"
-                        ? String(message)
-                        : (message || "").trim();
-                    // Check for explicit exit commands
+                    const trimmed = (input || "").trim();
                     if (["exit", "quit"].includes(trimmed.toLowerCase())) {
-                        p.outro("Chat ended");
                         process.exit(0);
                     }
                     if (trimmed) {
@@ -181,13 +458,13 @@ class AgentChatClient {
                     }
                 }
                 catch (error) {
-                    console.error(chalk_1.default.red("Error in chat:"), error);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    this.consoleManager.error(`Error in chat: ${errorMessage}`);
                     process.exit(1);
                 }
             }
         }
         finally {
-            // Clean up SIGINT handler
             process.removeListener("SIGINT", sigintHandler);
         }
     }
@@ -200,11 +477,18 @@ let RunCommand = class RunCommand extends nest_commander_1.CommandRunner {
         const agentPathArg = passed?.[0];
         const envVerbose = process.env.ADK_VERBOSE;
         const isVerbose = options?.verbose ?? (envVerbose === "1" || envVerbose === "true");
+        const consoleManager = new ConsoleManager(isVerbose);
+        // Hook console and child process only in non-verbose mode
+        if (!isVerbose) {
+            consoleManager.hookConsole();
+            consoleManager.hookChildProcessSilence();
+        }
         if (options?.server) {
-            // Server-only mode
             const apiPort = 8042;
             const host = options.host || "localhost";
-            console.log(chalk_1.default.blue("🚀 Starting ADK Server..."));
+            if (isVerbose) {
+                console.log(chalk_1.default.blue("🚀 Starting ADK Server..."));
+            }
             const server = await (0, bootstrap_1.startHttpServer)({
                 port: apiPort,
                 host,
@@ -213,7 +497,9 @@ let RunCommand = class RunCommand extends nest_commander_1.CommandRunner {
                 hotReload: options?.hot,
                 watchPaths: options?.watch,
             });
-            console.log(chalk_1.default.cyan("Press Ctrl+C to stop the server"));
+            if (isVerbose) {
+                console.log(chalk_1.default.cyan("Press Ctrl+C to stop the server"));
+            }
             process.on("SIGINT", async () => {
                 console.log(chalk_1.default.yellow("\n🛑 Stopping server..."));
                 await server.stop();
@@ -224,12 +510,12 @@ let RunCommand = class RunCommand extends nest_commander_1.CommandRunner {
         }
         // Interactive chat mode
         const apiUrl = `http://${options?.host || "localhost"}:8042`;
-        p.intro("🤖 ADK Agent Chat");
-        // Ensure server is up, else start it
+        await consoleManager.withAllowedOutput(async () => {
+            p.intro("🤖 ADK Agent Chat");
+        });
+        // Start server if not running
         const healthResponse = await fetch(`${apiUrl}/health`).catch(() => null);
         if (!healthResponse || !healthResponse.ok) {
-            const serverSpinner = (0, prompts_1.spinner)();
-            serverSpinner.start("🚀 Starting server...");
             await (0, bootstrap_1.startHttpServer)({
                 port: 8042,
                 host: options?.host || "localhost",
@@ -239,18 +525,14 @@ let RunCommand = class RunCommand extends nest_commander_1.CommandRunner {
                 watchPaths: options?.watch,
             });
             await new Promise((resolve) => setTimeout(resolve, 1000));
-            serverSpinner.stop("✅ Server ready");
         }
-        const client = new AgentChatClient(apiUrl);
-        await client.connect();
-        const agentSpinner = (0, prompts_1.spinner)();
-        agentSpinner.start("🔍 Scanning for agents...");
+        const client = new AgentChatClient(apiUrl, consoleManager);
         try {
+            await client.connect();
             const agents = await client.fetchAgents();
             let selectedAgent;
             if (agents.length === 0) {
-                agentSpinner.stop("❌ No agents found");
-                p.cancel("No agents found in the current directory");
+                consoleManager.error("No agents found in the current directory");
                 process.exit(1);
             }
             else if (agents.length === 1 || agentPathArg) {
@@ -258,32 +540,38 @@ let RunCommand = class RunCommand extends nest_commander_1.CommandRunner {
                     (agentPathArg &&
                         agents.find((a) => a.relativePath === agentPathArg)) ||
                         agents[0];
-                agentSpinner.stop(`🤖 Selected agent: ${selectedAgent.name}`);
             }
             else {
-                agentSpinner.stop(`🤖 Found ${agents.length} agents`);
-                const choice = await p.select({
-                    message: "Choose an agent to chat with:",
-                    options: agents.map((agent) => ({
-                        label: agent.name,
-                        value: agent,
-                        hint: agent.relativePath,
-                    })),
+                selectedAgent = await consoleManager.withAllowedOutput(async () => {
+                    const choice = await p.select({
+                        message: "Choose an agent to chat with:",
+                        options: agents.map((agent) => ({
+                            label: agent.name,
+                            value: agent,
+                            hint: agent.relativePath,
+                        })),
+                    });
+                    if (p.isCancel(choice)) {
+                        process.exit(0);
+                    }
+                    return choice;
                 });
-                if (p.isCancel(choice)) {
-                    p.cancel("Operation cancelled");
-                    process.exit(0);
-                }
-                selectedAgent = choice;
             }
             client.setSelectedAgent(selectedAgent);
             await client.startChat();
-            p.outro("Chat ended");
+            await consoleManager.withAllowedOutput(async () => {
+                p.outro("Chat ended");
+            });
         }
         catch (error) {
-            p.cancel(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            consoleManager.error(`Error: ${errorMessage}`);
             process.exit(1);
         }
+        finally {
+            // Ensure cleanup happens
+            consoleManager.restore();
+        }
     }
     parseServer() {
         return true;