kernelbot 1.0.21 → 1.0.22

package/package.json

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

package/src/agent.js

@@ -13,10 +13,11 @@ export class Agent {
     this._pending = new Map(); // chatId -> pending state
   }
 
-  async processMessage(chatId, userMessage, user, onUpdate) {
+  async processMessage(chatId, userMessage, user, onUpdate, sendPhoto) {
     const logger = getLogger();
 
     this._onUpdate = onUpdate || null;
+    this._sendPhoto = sendPhoto || null;
 
     // Handle pending responses (confirmation or credential)
     const pending = this._pending.get(chatId);
@@ -66,6 +67,11 @@ export class Agent {
       docker_compose: 'action',
       curl_url: 'url',
       check_port: 'port',
+      screenshot_website: 'url',
+      send_image: 'file_path',
+      browse_website: 'url',
+      extract_content: 'url',
+      interact_with_page: 'url',
     }[name];
     const val = key && input[key] ? String(input[key]).slice(0, 120) : JSON.stringify(input).slice(0, 120);
     return `${name}: ${val}`;
@@ -100,6 +106,7 @@ export class Agent {
       config: this.config,
       user,
       onUpdate: this._onUpdate,
+      sendPhoto: this._sendPhoto,
     });
 
     pending.toolResults.push({
@@ -117,7 +124,7 @@ export class Agent {
 
     if (lower === 'yes' || lower === 'y' || lower === 'confirm') {
       logger.info(`User confirmed dangerous tool: ${pending.block.name}`);
-      const result = await executeTool(pending.block.name, pending.block.input, { ...pending.context, onUpdate: this._onUpdate });
+      const result = await executeTool(pending.block.name, pending.block.input, { ...pending.context, onUpdate: this._onUpdate, sendPhoto: this._sendPhoto });
 
       pending.toolResults.push({
         type: 'tool_result',
@@ -144,7 +151,7 @@ export class Agent {
       const pauseMsg = await this._checkPause(chatId, block, user, pending.toolResults, pending.remainingBlocks.filter((b) => b !== block), pending.messages);
       if (pauseMsg) return pauseMsg;
 
-      const r = await executeTool(block.name, block.input, { config: this.config, user, onUpdate: this._onUpdate });
+      const r = await executeTool(block.name, block.input, { config: this.config, user, onUpdate: this._onUpdate, sendPhoto: this._sendPhoto });
       pending.toolResults.push({
         type: 'tool_result',
         tool_use_id: block.id,
@@ -256,6 +263,7 @@ export class Agent {
             config: this.config,
             user,
             onUpdate: this._onUpdate,
+            sendPhoto: this._sendPhoto,
           });
 
           toolResults.push({

package/src/bot.js

@@ -1,4 +1,5 @@
 import TelegramBot from 'node-telegram-bot-api';
+import { createReadStream } from 'fs';
 import { isAllowedUser, getUnauthorizedMessage } from './security/auth.js';
 import { getLogger } from './utils/logger.js';
 
@@ -152,10 +153,27 @@ export function startBot(config, agent, conversationManager) {
         return lastMsgId;
       };
 
+      const sendPhoto = async (filePath, caption) => {
+        try {
+          await bot.sendPhoto(chatId, createReadStream(filePath), {
+            caption: caption || '',
+            parse_mode: 'Markdown',
+          });
+        } catch {
+          try {
+            await bot.sendPhoto(chatId, createReadStream(filePath), {
+              caption: caption || '',
+            });
+          } catch (err) {
+            logger.error(`Failed to send photo: ${err.message}`);
+          }
+        }
+      };
+
       const reply = await agent.processMessage(chatId, text, {
         id: userId,
         username,
-      }, onUpdate);
+      }, onUpdate, sendPhoto);
 
       clearInterval(typingInterval);
 

package/src/coder.js

@@ -84,7 +84,7 @@ function processEvent(line, onOutput, logger) {
     // 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(() => {});
+      onOutput(`▹ ${line.trim()}`).catch(() => {});
     }
     return null;
   }
@@ -103,7 +103,7 @@ function processEvent(line, onOutput, logger) {
     const tool = extractToolUse(event);
     if (tool) {
       logger.info(`Claude Code tool: ${tool.name}: ${tool.summary}`);
-      if (onOutput) onOutput(`🔨 ${tool.name}: ${tool.summary}`).catch(() => {});
+      if (onOutput) onOutput(`▸ ${tool.name}: ${tool.summary}`).catch(() => {});
     }
     return event;
   }
@@ -113,7 +113,7 @@ function processEvent(line, onOutput, logger) {
     const tool = extractToolUse(event);
     if (tool) {
       logger.info(`Claude Code tool: ${tool.name}: ${tool.summary}`);
-      if (onOutput) onOutput(`🔨 ${tool.name}: ${tool.summary}`).catch(() => {});
+      if (onOutput) onOutput(`▸ ${tool.name}: ${tool.summary}`).catch(() => {});
     }
     return event;
   }
@@ -124,7 +124,7 @@ function processEvent(line, onOutput, logger) {
     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(() => {});
+    if (onOutput) onOutput(`▪ done (${status}${duration}${cost})`).catch(() => {});
     return event;
   }
 
@@ -173,12 +173,12 @@ export class ClaudeCodeSpawner {
         ? `\n_... ${activityLines.length} operations total_\n`
         : '';
       if (finalState === 'done') {
-        return `✅ *Claude Code Done* — ${activityLines.length} ops\n${countInfo}\n${visible.join('\n')}`;
+        return `░▒▓ *Claude Code Done* — ${activityLines.length} ops\n${countInfo}\n${visible.join('\n')}`;
       }
       if (finalState === 'error') {
-        return `❌ *Claude Code Failed* — ${activityLines.length} ops\n${countInfo}\n${visible.join('\n')}`;
+        return `░▒▓ *Claude Code Failed* — ${activityLines.length} ops\n${countInfo}\n${visible.join('\n')}`;
       }
-      return `⚙️ *Claude Code Working...*\n${countInfo}\n${visible.join('\n')}`;
+      return `░▒▓ *Claude Code Working...*\n${countInfo}\n${visible.join('\n')}`;
     };
 
     const flushStatus = async () => {
@@ -206,17 +206,15 @@ export class ClaudeCodeSpawner {
 
     const smartOutput = onOutput ? async (text) => {
       // Tool calls, raw output, warnings, starting → accumulate in status message
-      if (text.startsWith('🔨') || text.startsWith('📟') || text.startsWith('⚠️') || text.startsWith('⏳')) {
+      if (text.startsWith('▸') || text.startsWith('▹') || text.startsWith('▪')) {
         addActivity(text);
         return;
       }
-      // Completion → handled by close handler, skip
-      if (text.startsWith('✅')) return;
-      // Everything else (💬 text, ❌ error, ⏰ timeout) → new message
+      // Everything else (💬 text, errors, timeout) → new message
       await onOutput(text);
     } : null;
 
-    if (smartOutput) smartOutput(`⏳ Starting Claude Code...`).catch(() => {});
+    if (smartOutput) smartOutput(`▸ Starting Claude Code...`).catch(() => {});
 
     return new Promise((resolve, reject) => {
       const child = spawn('claude', args, {
@@ -258,13 +256,13 @@ export class ClaudeCodeSpawner {
         stderr += chunk + '\n';
         logger.warn(`Claude Code stderr: ${chunk.slice(0, 300)}`);
         if (smartOutput && chunk) {
-          smartOutput(`⚠️ ${chunk.slice(0, 300)}`).catch(() => {});
+          smartOutput(`▹ ${chunk.slice(0, 300)}`).catch(() => {});
         }
       });
 
       const timer = setTimeout(() => {
         child.kill('SIGTERM');
-        if (smartOutput) smartOutput(`⏰ Claude Code timed out after ${this.timeout / 1000}s`).catch(() => {});
+        if (smartOutput) smartOutput(`▸ Claude Code timed out after ${this.timeout / 1000}s`).catch(() => {});
         reject(new Error(`Claude Code timed out after ${this.timeout / 1000}s`));
       }, this.timeout);
 

package/src/prompts/system.js

@@ -19,9 +19,10 @@ IMPORTANT: You MUST NOT write code yourself using read_file/write_file. ALWAYS d
 
 ## Web Browsing Tasks (researching, scraping, reading documentation, taking screenshots)
 - Use browse_website to read and summarize web pages
-- Use screenshot_website to capture visual snapshots of pages
+- Use screenshot_website to capture visual snapshots of pages — the screenshot is automatically sent to the chat
 - Use extract_content to pull specific data from pages using CSS selectors
 - Use interact_with_page for pages that need clicking, typing, or scrolling to reveal content
+- Use send_image to send any image file directly to the Telegram chat (screenshots, generated images, etc.)
 - When a user sends /browse <url>, use browse_website on that URL
 - When a user sends /screenshot <url>, use screenshot_website on that URL
 - When a user sends /extract <url> <selector>, use extract_content with that URL and selector

package/src/tools/browser.js

@@ -1,5 +1,5 @@
 import puppeteer from 'puppeteer';
-import { writeFile, mkdir } from 'fs/promises';
+import { writeFile, mkdir, access } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
 
@@ -186,6 +186,25 @@ export const definitions = [
       required: ['url', 'selector'],
     },
   },
+  {
+    name: 'send_image',
+    description:
+      'Send an image or screenshot file directly to the Telegram chat. Use this to share screenshots, generated images, or any image file with the user.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        file_path: {
+          type: 'string',
+          description: 'Absolute path to the image file to send (e.g., "/home/user/.kernelbot/screenshots/example.png")',
+        },
+        caption: {
+          type: 'string',
+          description: 'Optional caption to include with the image',
+        },
+      },
+      required: ['file_path'],
+    },
+  },
   {
     name: 'interact_with_page',
     description:
@@ -350,7 +369,7 @@ async function handleBrowse(params) {
   });
 }
 
-async function handleScreenshot(params) {
+async function handleScreenshot(params, context) {
   const validation = validateUrl(params.url);
   if (!validation.valid) return { error: validation.error };
 
@@ -397,12 +416,24 @@ async function handleScreenshot(params) {
       await page.screenshot(screenshotOptions);
     }
 
+    const title = await page.title();
+
+    // Send the screenshot directly to Telegram chat
+    if (context?.sendPhoto) {
+      try {
+        await context.sendPhoto(filepath, `📸 ${title || url}`);
+      } catch {
+        // Photo sending is best-effort; don't fail the tool
+      }
+    }
+
     return {
       success: true,
       url: page.url(),
-      title: await page.title(),
+      title,
       screenshot_path: filepath,
       filename,
+      sent_to_chat: !!context?.sendPhoto,
     };
   });
 }
@@ -614,6 +645,30 @@ async function handleInteract(params) {
   });
 }
 
+async function handleSendImage(params, context) {
+  if (!params.file_path) {
+    return { error: 'file_path is required' };
+  }
+
+  // Verify the file exists
+  try {
+    await access(params.file_path);
+  } catch {
+    return { error: `File not found: ${params.file_path}` };
+  }
+
+  if (!context?.sendPhoto) {
+    return { error: 'Image sending is not available in this context (no active Telegram chat)' };
+  }
+
+  try {
+    await context.sendPhoto(params.file_path, params.caption || '');
+    return { success: true, file_path: params.file_path, sent: true };
+  } catch (err) {
+    return { error: `Failed to send image: ${err.message}` };
+  }
+}
+
 // ── Export ────────────────────────────────────────────────────────────────────
 
 export const handlers = {
@@ -621,4 +676,5 @@ export const handlers = {
   screenshot_website: handleScreenshot,
   extract_content: handleExtract,
   interact_with_page: handleInteract,
+  send_image: handleSendImage,
 };