kernelbot 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",

package/src/coder.js

@@ -9,13 +9,11 @@ function ensureClaudeCodeSetup() {
   const claudeJson = join(homedir(), '.claude.json');
   const claudeDir = join(homedir(), '.claude');
 
-  // Create ~/.claude/ directory if missing
   if (!existsSync(claudeDir)) {
     mkdirSync(claudeDir, { recursive: true });
     logger.info('Created ~/.claude/ directory');
   }
 
-  // Create ~/.claude.json with onboarding completed if missing
   if (!existsSync(claudeJson)) {
     const defaults = {
       hasCompletedOnboarding: true,
@@ -27,42 +25,112 @@ function ensureClaudeCodeSetup() {
   }
 }
 
-function parseStreamEvent(line, onOutput, logger) {
+function extractText(event) {
+  // Try to find text in various possible event structures
+  // Format 1: { type: "message", role: "assistant", content: [{ type: "text", text: "..." }] }
+  // Format 2: { type: "assistant", message: { content: [{ type: "text", text: "..." }] } }
+  // Format 3: { type: "assistant", content: [{ type: "text", text: "..." }] }
+
+  const contentSources = [
+    event.content,
+    event.message?.content,
+  ];
+
+  for (const content of contentSources) {
+    if (Array.isArray(content)) {
+      const texts = content
+        .filter((b) => b.type === 'text' && b.text?.trim())
+        .map((b) => b.text.trim());
+      if (texts.length > 0) return texts.join('\n');
+    }
+  }
+
+  // Direct text field
+  if (event.text?.trim()) return event.text.trim();
+  if (event.result?.trim()) return event.result.trim();
+
+  return null;
+}
+
+function extractToolUse(event) {
+  // Format 1: { type: "tool_use", name: "Bash", input: { command: "..." } }
+  // Format 2: content block with type tool_use
+  if (event.name && event.input) {
+    const input = event.input;
+    const summary = input.command || input.file_path || input.pattern || input.query || input.content?.slice(0, 80) || JSON.stringify(input).slice(0, 100);
+    return { name: event.name, summary: String(summary).slice(0, 150) };
+  }
+
+  // Check inside content array
+  const content = event.content || event.message?.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block.type === 'tool_use' && block.name) {
+        const input = block.input || {};
+        const summary = input.command || input.file_path || input.pattern || input.query || JSON.stringify(input).slice(0, 100);
+        return { name: block.name, summary: String(summary).slice(0, 150) };
+      }
+    }
+  }
+
+  return null;
+}
+
+function processEvent(line, onOutput, logger) {
   let event;
   try {
     event = JSON.parse(line);
   } catch {
-    return; // skip non-JSON lines
+    // Not JSON — send raw text if it looks meaningful
+    if (line.trim() && line.length > 3 && onOutput) {
+      logger.info(`Claude Code (raw): ${line.slice(0, 200)}`);
+      onOutput(`📟 ${line.trim()}`).catch(() => {});
+    }
+    return null;
   }
 
-  // Assistant text message
-  if (event.type === 'message' && event.role === 'assistant') {
-    const texts = (event.content || [])
-      .filter((b) => b.type === 'text' && b.text?.trim())
-      .map((b) => b.text.trim());
-    if (texts.length > 0) {
-      const msg = texts.join('\n');
-      logger.info(`Claude Code: ${msg.slice(0, 200)}`);
-      if (onOutput) onOutput(`💬 *Claude Code:*\n${msg}`).catch(() => {});
+  const type = event.type || '';
+
+  // Assistant thinking/text
+  if (type === 'message' || type === 'assistant') {
+    const text = extractText(event);
+    if (text) {
+      logger.info(`Claude Code: ${text.slice(0, 200)}`);
+      if (onOutput) onOutput(`💬 *Claude Code:*\n${text}`).catch(() => {});
     }
+
+    // Also check for tool_use inside the same message
+    const tool = extractToolUse(event);
+    if (tool) {
+      logger.info(`Claude Code tool: ${tool.name}: ${tool.summary}`);
+      if (onOutput) onOutput(`🔨 \`${tool.name}: ${tool.summary}\``).catch(() => {});
+    }
+    return event;
   }
 
-  // Tool use
-  if (event.type === 'tool_use') {
-    const name = event.name || 'unknown';
-    const input = event.input || {};
-    const summary = input.command || input.file_path || input.pattern || input.query || JSON.stringify(input).slice(0, 100);
-    logger.info(`Claude Code tool: ${name}: ${String(summary).slice(0, 150)}`);
-    if (onOutput) onOutput(`🔨 \`${name}: ${String(summary).slice(0, 150)}\``).catch(() => {});
+  // Standalone tool use event
+  if (type === 'tool_use') {
+    const tool = extractToolUse(event);
+    if (tool) {
+      logger.info(`Claude Code tool: ${tool.name}: ${tool.summary}`);
+      if (onOutput) onOutput(`🔨 \`${tool.name}: ${tool.summary}\``).catch(() => {});
+    }
+    return event;
   }
 
-  // Result
-  if (event.type === 'result') {
-    const status = event.status || 'done';
-    const duration = event.duration_ms ? `${(event.duration_ms / 1000).toFixed(1)}s` : '';
-    logger.info(`Claude Code finished: ${status} ${duration}`);
-    if (onOutput) onOutput(`✅ Claude Code finished (${status}${duration ? ` in ${duration}` : ''})`).catch(() => {});
+  // Result / completion
+  if (type === 'result') {
+    const status = event.status || event.subtype || 'done';
+    const duration = event.duration_ms ? ` in ${(event.duration_ms / 1000).toFixed(1)}s` : '';
+    const cost = event.cost_usd ? ` ($${event.cost_usd.toFixed(3)})` : '';
+    logger.info(`Claude Code finished: ${status}${duration}${cost}`);
+    if (onOutput) onOutput(`✅ Claude Code finished (${status}${duration}${cost})`).catch(() => {});
+    return event;
   }
+
+  // Log any other event type for debugging
+  logger.debug(`Claude Code event [${type}]: ${JSON.stringify(event).slice(0, 300)}`);
+  return event;
 }
 
 export class ClaudeCodeSpawner {
@@ -76,10 +144,10 @@ export class ClaudeCodeSpawner {
     const logger = getLogger();
     const turns = maxTurns || this.maxTurns;
 
-    // Auto-setup Claude Code if not configured
     ensureClaudeCodeSetup();
 
-    logger.info(`Spawning Claude Code in ${workingDirectory}`);
+    logger.info(`Spawning Claude Code in ${workingDirectory}${this.model ? ` (model: ${this.model})` : ''}`);
+    if (onOutput) onOutput(`⏳ Starting Claude Code...`).catch(() => {});
 
     return new Promise((resolve, reject) => {
       const args = [
@@ -106,9 +174,8 @@ export class ClaudeCodeSpawner {
       child.stdout.on('data', (data) => {
         buffer += data.toString();
 
-        // Process complete JSON lines
         const lines = buffer.split('\n');
-        buffer = lines.pop(); // keep incomplete line
+        buffer = lines.pop();
 
         for (const line of lines) {
           const trimmed = line.trim();
@@ -116,44 +183,52 @@ export class ClaudeCodeSpawner {
 
           fullOutput += trimmed + '\n';
 
-          // Extract final result text
+          // Try to extract result text
           try {
             const event = JSON.parse(trimmed);
-            if (event.type === 'result' && event.result) {
-              resultText = event.result;
+            if (event.type === 'result') {
+              resultText = event.result || resultText;
             }
           } catch {}
 
-          parseStreamEvent(trimmed, onOutput, logger);
+          processEvent(trimmed, onOutput, logger);
         }
       });
 
       child.stderr.on('data', (data) => {
-        stderr += data.toString();
+        const chunk = data.toString();
+        stderr += chunk;
+        // Forward stderr too — might contain useful info
+        logger.warn(`Claude Code stderr: ${chunk.trim().slice(0, 200)}`);
       });
 
       const timer = setTimeout(() => {
         child.kill('SIGTERM');
+        if (onOutput) onOutput(`⏰ Claude Code timed out after ${this.timeout / 1000}s`).catch(() => {});
         reject(new Error(`Claude Code timed out after ${this.timeout / 1000}s`));
       }, this.timeout);
 
       child.on('close', (code) => {
         clearTimeout(timer);
 
-        // Process remaining buffer
         if (buffer.trim()) {
           fullOutput += buffer.trim();
           try {
             const event = JSON.parse(buffer.trim());
-            if (event.type === 'result' && event.result) {
-              resultText = event.result;
+            if (event.type === 'result') {
+              resultText = event.result || resultText;
             }
           } catch {}
-          parseStreamEvent(buffer.trim(), onOutput, logger);
+          processEvent(buffer.trim(), onOutput, logger);
         }
 
-        if (code !== 0 && !fullOutput) {
-          reject(new Error(`Claude Code exited with code ${code}: ${stderr}`));
+        logger.info(`Claude Code exited with code ${code} | stdout: ${fullOutput.length} chars | stderr: ${stderr.length} chars`);
+
+        if (code !== 0) {
+          const errMsg = stderr.trim() || fullOutput.trim() || `exited with code ${code}`;
+          logger.error(`Claude Code failed: ${errMsg.slice(0, 500)}`);
+          if (onOutput) onOutput(`❌ Claude Code failed (exit ${code}):\n\`\`\`\n${errMsg.slice(0, 400)}\n\`\`\``).catch(() => {});
+          reject(new Error(`Claude Code exited with code ${code}: ${errMsg.slice(0, 500)}`));
         } else {
           resolve({
             output: resultText || fullOutput.trim(),

package/src/tools/coding.js

@@ -1,4 +1,7 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
 import { ClaudeCodeSpawner } from '../coder.js';
+import { getLogger } from '../utils/logger.js';
 
 let spawner = null;
 
@@ -35,16 +38,36 @@ export const definitions = [
 
 export const handlers = {
   spawn_claude_code: async (params, context) => {
+    const logger = getLogger();
+    const onUpdate = context.onUpdate || null;
+    const dir = resolve(params.working_directory);
+
+    // Validate directory exists
+    if (!existsSync(dir)) {
+      const msg = `Directory not found: ${dir}`;
+      logger.error(`spawn_claude_code: ${msg}`);
+      if (onUpdate) onUpdate(`❌ ${msg}`).catch(() => {});
+      return { error: msg };
+    }
+
     try {
       const coder = getSpawner(context.config);
       const result = await coder.run({
-        workingDirectory: params.working_directory,
+        workingDirectory: dir,
         prompt: params.prompt,
         maxTurns: params.max_turns,
-        onOutput: context.onUpdate || null,
+        onOutput: onUpdate,
       });
+
+      // Show stderr if any
+      if (result.stderr && onUpdate) {
+        onUpdate(`⚠️ Claude Code stderr:\n\`\`\`\n${result.stderr.slice(0, 500)}\n\`\`\``).catch(() => {});
+      }
+
       return { success: true, output: result.output };
     } catch (err) {
+      logger.error(`spawn_claude_code failed: ${err.message}`);
+      if (onUpdate) onUpdate(`❌ Claude Code error: ${err.message}`).catch(() => {});
       return { error: err.message };
     }
   },

package/src/tools/os.js

@@ -129,11 +129,22 @@ export const handlers = {
           if (error && error.killed) {
             return res({ error: `Command timed out after ${timeout_seconds}s` });
           }
-          res({
+          const result = {
             stdout: stdout || '',
             stderr: stderr || '',
             exit_code: error ? error.code ?? 1 : 0,
-          });
+          };
+
+          // Send output summary to Telegram
+          if (context.onUpdate) {
+            const output = (result.stdout || result.stderr || '').trim();
+            if (output) {
+              const preview = output.length > 300 ? output.slice(0, 300) + '...' : output;
+              context.onUpdate(`📋 \`${command.slice(0, 60)}\`\n\`\`\`\n${preview}\n\`\`\``).catch(() => {});
+            }
+          }
+
+          res(result);
         },
       );
     });