@link-assistant/agent 0.0.8 → 0.0.11

package/src/index.js

@@ -1,371 +1,593 @@
 #!/usr/bin/env bun
 
-import { Server } from './server/server.ts'
-import { Instance } from './project/instance.ts'
-import { Log } from './util/log.ts'
-import { Bus } from './bus/index.ts'
-import { Session } from './session/index.ts'
-import { SessionPrompt } from './session/prompt.ts'
-import { EOL } from 'os'
-import yargs from 'yargs'
-import { hideBin } from 'yargs/helpers'
-
-async function readStdin() {
+import { Server } from './server/server.ts';
+import { Instance } from './project/instance.ts';
+import { Log } from './util/log.ts';
+import { Bus } from './bus/index.ts';
+import { Session } from './session/index.ts';
+import { SessionPrompt } from './session/prompt.ts';
+// EOL is reserved for future use
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import {
+  createEventHandler,
+  isValidJsonStandard,
+} from './json-standard/index.ts';
+import { McpCommand } from './cli/cmd/mcp.ts';
+import { AuthCommand } from './cli/cmd/auth.ts';
+import { Flag } from './flag/flag.ts';
+
+// Track if any errors occurred during execution
+let hasError = false;
+
+// Install global error handlers to ensure non-zero exit codes
+process.on('uncaughtException', (error) => {
+  hasError = true;
+  console.error(
+    JSON.stringify(
+      {
+        type: 'error',
+        errorType: error.name || 'UncaughtException',
+        message: error.message,
+        stack: error.stack,
+      },
+      null,
+      2
+    )
+  );
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, _promise) => {
+  hasError = true;
+  console.error(
+    JSON.stringify(
+      {
+        type: 'error',
+        errorType: 'UnhandledRejection',
+        message: reason?.message || String(reason),
+        stack: reason?.stack,
+      },
+      null,
+      2
+    )
+  );
+  process.exit(1);
+});
+
+function readStdin() {
   return new Promise((resolve, reject) => {
-    let data = ''
-    const onData = chunk => {
-      data += chunk
-    }
+    let data = '';
+    const onData = (chunk) => {
+      data += chunk;
+    };
     const onEnd = () => {
-      cleanup()
-      resolve(data)
+      cleanup();
+      resolve(data);
+    };
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+    const cleanup = () => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.removeListener('end', onEnd);
+      process.stdin.removeListener('error', onError);
+    };
+    process.stdin.on('data', onData);
+    process.stdin.on('end', onEnd);
+    process.stdin.on('error', onError);
+  });
+}
+
+async function runAgentMode(argv) {
+  // Set verbose mode if requested via CLI flag
+  if (argv.verbose) {
+    Flag.setVerbose(true);
+  }
+
+  // Parse model argument (handle model IDs with slashes like groq/qwen/qwen3-32b)
+  const modelParts = argv.model.split('/');
+  let providerID = modelParts[0] || 'opencode';
+  let modelID = modelParts.slice(1).join('/') || 'grok-code';
+
+  // Handle --use-existing-claude-oauth option
+  // This reads OAuth credentials from ~/.claude/.credentials.json (Claude Code CLI)
+  // For new authentication, use: agent auth login (select Anthropic > Claude Pro/Max)
+  if (argv['use-existing-claude-oauth']) {
+    // Import ClaudeOAuth to check for credentials from Claude Code CLI
+    const { ClaudeOAuth } = await import('./auth/claude-oauth.ts');
+    const creds = await ClaudeOAuth.getCredentials();
+
+    if (!creds?.accessToken) {
+      console.error(
+        JSON.stringify({
+          type: 'error',
+          errorType: 'AuthenticationError',
+          message:
+            'No Claude OAuth credentials found in ~/.claude/.credentials.json. Either authenticate with Claude Code CLI first, or use: agent auth login (select Anthropic > Claude Pro/Max)',
+        })
+      );
+      process.exit(1);
     }
-    const onError = err => {
-      cleanup()
-      reject(err)
+
+    // Set environment variable for the provider to use
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = creds.accessToken;
+
+    // If user specified a model, use it with claude-oauth provider
+    // If not, use claude-oauth/claude-sonnet-4-5 as default
+    if (providerID === 'opencode' && modelID === 'grok-code') {
+      providerID = 'claude-oauth';
+      modelID = 'claude-sonnet-4-5';
+    } else if (!['claude-oauth', 'anthropic'].includes(providerID)) {
+      // If user specified a different provider, warn them
+      console.error(
+        JSON.stringify({
+          type: 'warning',
+          message: `--use-existing-claude-oauth is set but model uses provider "${providerID}". Using OAuth credentials anyway.`,
+        })
+      );
+      providerID = 'claude-oauth';
     }
-    const cleanup = () => {
-      process.stdin.removeListener('data', onData)
-      process.stdin.removeListener('end', onEnd)
-      process.stdin.removeListener('error', onError)
+  }
+
+  // Validate and get JSON standard
+  const jsonStandard = argv['json-standard'];
+  if (!isValidJsonStandard(jsonStandard)) {
+    console.error(
+      `Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`
+    );
+    process.exit(1);
+  }
+
+  // Read system message files
+  let systemMessage = argv['system-message'];
+  let appendSystemMessage = argv['append-system-message'];
+
+  if (argv['system-message-file']) {
+    const resolvedPath = require('path').resolve(
+      process.cwd(),
+      argv['system-message-file']
+    );
+    const file = Bun.file(resolvedPath);
+    if (!(await file.exists())) {
+      console.error(
+        `System message file not found: ${argv['system-message-file']}`
+      );
+      process.exit(1);
     }
-    process.stdin.on('data', onData)
-    process.stdin.on('end', onEnd)
-    process.stdin.on('error', onError)
-  })
+    systemMessage = await file.text();
+  }
+
+  if (argv['append-system-message-file']) {
+    const resolvedPath = require('path').resolve(
+      process.cwd(),
+      argv['append-system-message-file']
+    );
+    const file = Bun.file(resolvedPath);
+    if (!(await file.exists())) {
+      console.error(
+        `Append system message file not found: ${argv['append-system-message-file']}`
+      );
+      process.exit(1);
+    }
+    appendSystemMessage = await file.text();
+  }
+
+  // Initialize logging to redirect to log file instead of stderr
+  // This prevents log messages from mixing with JSON output
+  // In verbose mode, print to stderr for debugging
+  await Log.init({
+    print: Flag.OPENCODE_VERBOSE, // Print to stderr only in verbose mode
+    level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',
+  });
+
+  // Read input from stdin
+  const input = await readStdin();
+  const trimmedInput = input.trim();
+
+  // Try to parse as JSON, if it fails treat it as plain text message
+  let request;
+  try {
+    request = JSON.parse(trimmedInput);
+  } catch (_e) {
+    // Not JSON, treat as plain text message
+    request = {
+      message: trimmedInput,
+    };
+  }
+
+  // Wrap in Instance.provide for OpenCode infrastructure
+  await Instance.provide({
+    directory: process.cwd(),
+    fn: async () => {
+      if (argv.server) {
+        // SERVER MODE: Start server and communicate via HTTP
+        await runServerMode(
+          request,
+          providerID,
+          modelID,
+          systemMessage,
+          appendSystemMessage,
+          jsonStandard
+        );
+      } else {
+        // DIRECT MODE: Run everything in single process
+        await runDirectMode(
+          request,
+          providerID,
+          modelID,
+          systemMessage,
+          appendSystemMessage,
+          jsonStandard
+        );
+      }
+    },
+  });
+
+  // Explicitly exit to ensure process terminates
+  process.exit(hasError ? 1 : 0);
+}
+
+async function runServerMode(
+  request,
+  providerID,
+  modelID,
+  systemMessage,
+  appendSystemMessage,
+  jsonStandard
+) {
+  // Start server like OpenCode does
+  const server = Server.listen({ port: 0, hostname: '127.0.0.1' });
+  let unsub = null;
+
+  try {
+    // Create a session
+    const createRes = await fetch(
+      `http://${server.hostname}:${server.port}/session`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      }
+    );
+    const session = await createRes.json();
+    const sessionID = session.id;
+
+    if (!sessionID) {
+      throw new Error('Failed to create session');
+    }
+
+    // Create event handler for the selected JSON standard
+    const eventHandler = createEventHandler(jsonStandard, sessionID);
+
+    // Subscribe to all bus events and output in selected format
+    const eventPromise = new Promise((resolve) => {
+      unsub = Bus.subscribeAll((event) => {
+        // Output events in selected JSON format
+        if (event.type === 'message.part.updated') {
+          const part = event.properties.part;
+          if (part.sessionID !== sessionID) {
+            return;
+          }
+
+          // Output different event types
+          if (part.type === 'step-start') {
+            eventHandler.output({
+              type: 'step_start',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+
+          if (part.type === 'step-finish') {
+            eventHandler.output({
+              type: 'step_finish',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+
+          if (part.type === 'text' && part.time?.end) {
+            eventHandler.output({
+              type: 'text',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+
+          if (part.type === 'tool' && part.state.status === 'completed') {
+            eventHandler.output({
+              type: 'tool_use',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+        }
+
+        // Handle session idle to know when to stop
+        if (
+          event.type === 'session.idle' &&
+          event.properties.sessionID === sessionID
+        ) {
+          resolve();
+        }
+
+        // Handle errors
+        if (event.type === 'session.error') {
+          const props = event.properties;
+          if (props.sessionID !== sessionID || !props.error) {
+            return;
+          }
+          hasError = true;
+          eventHandler.output({
+            type: 'error',
+            timestamp: Date.now(),
+            sessionID,
+            error: props.error,
+          });
+        }
+      });
+    });
+
+    // Send message to session with specified model (default: opencode/grok-code)
+    const message = request.message || 'hi';
+    const parts = [{ type: 'text', text: message }];
+
+    // Start the prompt (don't wait for response, events come via Bus)
+    fetch(
+      `http://${server.hostname}:${server.port}/session/${sessionID}/message`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          parts,
+          model: {
+            providerID,
+            modelID,
+          },
+          system: systemMessage,
+          appendSystem: appendSystemMessage,
+        }),
+      }
+    ).catch((error) => {
+      hasError = true;
+      eventHandler.output({
+        type: 'error',
+        timestamp: Date.now(),
+        sessionID,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    });
+
+    // Wait for session to become idle
+    await eventPromise;
+  } finally {
+    // Always clean up resources
+    if (unsub) {
+      unsub();
+    }
+    server.stop();
+    await Instance.dispose();
+  }
+}
+
+async function runDirectMode(
+  request,
+  providerID,
+  modelID,
+  systemMessage,
+  appendSystemMessage,
+  jsonStandard
+) {
+  // DIRECT MODE: Run in single process without server
+  let unsub = null;
+
+  try {
+    // Create a session directly
+    const session = await Session.createNext({
+      directory: process.cwd(),
+    });
+    const sessionID = session.id;
+
+    // Create event handler for the selected JSON standard
+    const eventHandler = createEventHandler(jsonStandard, sessionID);
+
+    // Subscribe to all bus events and output in selected format
+    const eventPromise = new Promise((resolve) => {
+      unsub = Bus.subscribeAll((event) => {
+        // Output events in selected JSON format
+        if (event.type === 'message.part.updated') {
+          const part = event.properties.part;
+          if (part.sessionID !== sessionID) {
+            return;
+          }
+
+          // Output different event types
+          if (part.type === 'step-start') {
+            eventHandler.output({
+              type: 'step_start',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+
+          if (part.type === 'step-finish') {
+            eventHandler.output({
+              type: 'step_finish',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+
+          if (part.type === 'text' && part.time?.end) {
+            eventHandler.output({
+              type: 'text',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+
+          if (part.type === 'tool' && part.state.status === 'completed') {
+            eventHandler.output({
+              type: 'tool_use',
+              timestamp: Date.now(),
+              sessionID,
+              part,
+            });
+          }
+        }
+
+        // Handle session idle to know when to stop
+        if (
+          event.type === 'session.idle' &&
+          event.properties.sessionID === sessionID
+        ) {
+          resolve();
+        }
+
+        // Handle errors
+        if (event.type === 'session.error') {
+          const props = event.properties;
+          if (props.sessionID !== sessionID || !props.error) {
+            return;
+          }
+          hasError = true;
+          eventHandler.output({
+            type: 'error',
+            timestamp: Date.now(),
+            sessionID,
+            error: props.error,
+          });
+        }
+      });
+    });
+
+    // Send message to session directly
+    const message = request.message || 'hi';
+    const parts = [{ type: 'text', text: message }];
+
+    // Start the prompt directly without HTTP
+    SessionPrompt.prompt({
+      sessionID,
+      parts,
+      model: {
+        providerID,
+        modelID,
+      },
+      system: systemMessage,
+      appendSystem: appendSystemMessage,
+    }).catch((error) => {
+      hasError = true;
+      eventHandler.output({
+        type: 'error',
+        timestamp: Date.now(),
+        sessionID,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    });
+
+    // Wait for session to become idle
+    await eventPromise;
+  } finally {
+    // Always clean up resources
+    if (unsub) {
+      unsub();
+    }
+    await Instance.dispose();
+  }
 }
 
 async function main() {
   try {
-    // Parse command line arguments
+    // Parse command line arguments with subcommands
     const argv = await yargs(hideBin(process.argv))
+      .scriptName('agent')
+      .usage('$0 [command] [options]')
+      // MCP subcommand
+      .command(McpCommand)
+      // Auth subcommand
+      .command(AuthCommand)
+      // Default run mode (when piping stdin)
       .option('model', {
         type: 'string',
         description: 'Model to use in format providerID/modelID',
-        default: 'opencode/grok-code'
+        default: 'opencode/grok-code',
+      })
+      .option('json-standard', {
+        type: 'string',
+        description:
+          'JSON output format standard: "opencode" (default) or "claude" (experimental)',
+        default: 'opencode',
+        choices: ['opencode', 'claude'],
       })
       .option('system-message', {
         type: 'string',
-        description: 'Full override of the system message'
+        description: 'Full override of the system message',
       })
       .option('system-message-file', {
         type: 'string',
-        description: 'Full override of the system message from file'
+        description: 'Full override of the system message from file',
       })
       .option('append-system-message', {
         type: 'string',
-        description: 'Append to the default system message'
+        description: 'Append to the default system message',
       })
       .option('append-system-message-file', {
         type: 'string',
-        description: 'Append to the default system message from file'
+        description: 'Append to the default system message from file',
       })
       .option('server', {
         type: 'boolean',
         description: 'Run in server mode (default)',
-        default: true
+        default: true,
       })
-      .help()
-      .argv
-
-    // Parse model argument
-    const modelParts = argv.model.split('/')
-    const providerID = modelParts[0] || 'opencode'
-    const modelID = modelParts[1] || 'grok-code'
-
-    // Read system message files
-    let systemMessage = argv['system-message']
-    let appendSystemMessage = argv['append-system-message']
-
-    if (argv['system-message-file']) {
-      const resolvedPath = require('path').resolve(process.cwd(), argv['system-message-file'])
-      const file = Bun.file(resolvedPath)
-      if (!(await file.exists())) {
-        console.error(`System message file not found: ${argv['system-message-file']}`)
-        process.exit(1)
-      }
-      systemMessage = await file.text()
-    }
-
-    if (argv['append-system-message-file']) {
-      const resolvedPath = require('path').resolve(process.cwd(), argv['append-system-message-file'])
-      const file = Bun.file(resolvedPath)
-      if (!(await file.exists())) {
-        console.error(`Append system message file not found: ${argv['append-system-message-file']}`)
-        process.exit(1)
-      }
-      appendSystemMessage = await file.text()
-    }
-
-    // Initialize logging to redirect to log file instead of stderr
-    // This prevents log messages from mixing with JSON output
-    await Log.init({
-      print: false,  // Don't print to stderr
-      level: 'INFO'
-    })
-
-    // Read input from stdin
-    const input = await readStdin()
-    const trimmedInput = input.trim()
-
-    // Try to parse as JSON, if it fails treat it as plain text message
-    let request
-    try {
-      request = JSON.parse(trimmedInput)
-    } catch (e) {
-      // Not JSON, treat as plain text message
-      request = {
-        message: trimmedInput
-      }
-    }
-
-    // Wrap in Instance.provide for OpenCode infrastructure
-    await Instance.provide({
-      directory: process.cwd(),
-      fn: async () => {
-        if (argv.server) {
-          // SERVER MODE: Start server and communicate via HTTP
-          await runServerMode()
-        } else {
-          // DIRECT MODE: Run everything in single process
-          await runDirectMode()
-        }
-      }
-    })
-
-    async function runServerMode() {
-      // Start server like OpenCode does
-      const server = Server.listen({ port: 0, hostname: "127.0.0.1" })
-      let unsub = null
-
-      try {
-        // Create a session
-        const createRes = await fetch(`http://${server.hostname}:${server.port}/session`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({})
-        })
-        const session = await createRes.json()
-        const sessionID = session.id
-
-        if (!sessionID) {
-          throw new Error("Failed to create session")
-        }
-
-        // Subscribe to all bus events to output them in OpenCode format
-        const eventPromise = new Promise((resolve) => {
-          unsub = Bus.subscribeAll((event) => {
-            // Output events in OpenCode JSON format
-            if (event.type === 'message.part.updated') {
-              const part = event.properties.part
-              if (part.sessionID !== sessionID) return
-
-              // Output different event types (pretty-printed for readability)
-              if (part.type === 'step-start') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_start',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'step-finish') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_finish',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'text' && part.time?.end) {
-                process.stdout.write(JSON.stringify({
-                  type: 'text',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'tool' && part.state.status === 'completed') {
-                process.stdout.write(JSON.stringify({
-                  type: 'tool_use',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-            }
-
-            // Handle session idle to know when to stop
-            if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
-              resolve()
-            }
-
-            // Handle errors
-            if (event.type === 'session.error') {
-              const props = event.properties
-              if (props.sessionID !== sessionID || !props.error) return
-              process.stdout.write(JSON.stringify({
-                type: 'error',
-                timestamp: Date.now(),
-                sessionID,
-                error: props.error
-              }, null, 2) + EOL)
-            }
-          })
-        })
-
-        // Send message to session with specified model (default: opencode/grok-code)
-        const message = request.message || "hi"
-        const parts = [{ type: "text", text: message }]
-
-        // Start the prompt (don't wait for response, events come via Bus)
-        fetch(`http://${server.hostname}:${server.port}/session/${sessionID}/message`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            parts,
-            model: {
-              providerID,
-              modelID
-            },
-            system: systemMessage,
-            appendSystem: appendSystemMessage
-          })
-        }).catch(() => {
-          // Ignore errors, we're listening to events
-        })
-
-        // Wait for session to become idle
-        await eventPromise
-      } finally {
-        // Always clean up resources
-        if (unsub) unsub()
-        server.stop()
-        await Instance.dispose()
-      }
-    }
-
-    async function runDirectMode() {
-      // DIRECT MODE: Run in single process without server
-      let unsub = null
-
-      try {
-        // Create a session directly
-        const session = await Session.createNext({
-          directory: process.cwd()
-        })
-        const sessionID = session.id
-
-        // Subscribe to all bus events to output them in OpenCode format
-        const eventPromise = new Promise((resolve) => {
-          unsub = Bus.subscribeAll((event) => {
-            // Output events in OpenCode JSON format
-            if (event.type === 'message.part.updated') {
-              const part = event.properties.part
-              if (part.sessionID !== sessionID) return
-
-              // Output different event types (pretty-printed for readability)
-              if (part.type === 'step-start') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_start',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'step-finish') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_finish',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'text' && part.time?.end) {
-                process.stdout.write(JSON.stringify({
-                  type: 'text',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'tool' && part.state.status === 'completed') {
-                process.stdout.write(JSON.stringify({
-                  type: 'tool_use',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-            }
-
-            // Handle session idle to know when to stop
-            if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
-              resolve()
-            }
-
-            // Handle errors
-            if (event.type === 'session.error') {
-              const props = event.properties
-              if (props.sessionID !== sessionID || !props.error) return
-              process.stdout.write(JSON.stringify({
-                type: 'error',
-                timestamp: Date.now(),
-                sessionID,
-                error: props.error
-              }, null, 2) + EOL)
-            }
-          })
-        })
-
-        // Send message to session directly
-        const message = request.message || "hi"
-        const parts = [{ type: "text", text: message }]
+      .option('verbose', {
+        type: 'boolean',
+        description:
+          'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
+        default: false,
+      })
+      .option('use-existing-claude-oauth', {
+        type: 'boolean',
+        description:
+          'Use existing Claude OAuth credentials from ~/.claude/.credentials.json (from Claude Code CLI)',
+        default: false,
+      })
+      .help().argv;
 
-        // Start the prompt directly without HTTP
-        SessionPrompt.prompt({
-          sessionID,
-          parts,
-          model: {
-            providerID,
-            modelID
-          },
-          system: systemMessage,
-          appendSystem: appendSystemMessage
-        }).catch((error) => {
-          process.stdout.write(JSON.stringify({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: error instanceof Error ? error.message : String(error)
-          }, null, 2) + EOL)
-        })
+    // If a command was executed (like mcp), yargs handles it
+    // Otherwise, check if we should run in agent mode (stdin piped)
+    const commandExecuted = argv._ && argv._.length > 0;
 
-        // Wait for session to become idle
-        await eventPromise
-      } finally {
-        // Always clean up resources
-        if (unsub) unsub()
-        await Instance.dispose()
-      }
+    if (!commandExecuted) {
+      // No command specified, run in default agent mode (stdin processing)
+      await runAgentMode(argv);
     }
-
-    // Explicitly exit to ensure process terminates
-    process.exit(0)
   } catch (error) {
-    console.error(JSON.stringify({
-      type: 'error',
-      timestamp: Date.now(),
-      error: error instanceof Error ? error.message : String(error)
-    }))
-    process.exit(1)
+    hasError = true;
+    console.error(
+      JSON.stringify(
+        {
+          type: 'error',
+          timestamp: Date.now(),
+          errorType: error instanceof Error ? error.name : 'Error',
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        },
+        null,
+        2
+      )
+    );
+    process.exit(1);
   }
 }
 
-main()
+main();