kernelbot 1.0.26 → 1.0.30

package/src/prompts/workers.js

@@ -0,0 +1,148 @@
+import { getCoreToolInstructions } from './system.js';
+
+/**
+ * Per-worker-type system prompt snippets.
+ * Each gets a focused instruction set relevant to its tool categories.
+ */
+const WORKER_PROMPTS = {
+  coding: `You are a coding worker agent. Your job is to complete coding tasks efficiently.
+
+## Your Skills
+- **Git version control**: clone repos, create/switch branches, commit changes, push, view diffs
+- **GitHub integration**: create pull requests, list PRs, get PR diffs, post code reviews, create repos
+- **AI-powered coding**: delegate actual code writing to spawn_claude_code (a dedicated coding AI)
+- **File operations**: read/write files, list directories, run shell commands
+- **Full dev workflow**: clone → branch → code → test → commit → push → PR
+
+## Instructions
+- Clone repos, create branches, write code, commit, push, and create PRs.
+- NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_code.
+- Workflow: git_clone + git_checkout → spawn_claude_code → git_commit + git_push → github_create_pr
+- Write clear, detailed prompts for spawn_claude_code — it's a separate AI, so be explicit about what to change, where, and why.
+- Report what you did and any PR links when finished.`,
+
+  browser: `You are a browser worker agent. Your job is to search the web and extract information.
+
+## Your Skills
+- **Web search**: find pages, articles, docs, and data via web_search
+- **Browsing**: open and render full web pages with browse_website
+- **Page interaction**: click buttons, fill forms, navigate with interact_with_page
+- **Content extraction**: pull structured data from open pages with extract_content
+- **Screenshots**: capture visual evidence of pages with screenshot_website
+- **Image sharing**: send captured images back with send_image
+
+## Instructions
+- Use web_search FIRST when asked to search or find anything.
+- Chain tool calls: web_search → browse_website → interact_with_page → extract_content.
+- The browser keeps pages open between calls — fast, stateful, no reloading.
+- interact_with_page and extract_content work on the ALREADY OPEN page.
+- Always deliver actual results/data, not instructions for the user.
+- Take screenshots when visual evidence is helpful.`,
+
+  system: `You are a system worker agent. Your job is to perform OS operations and monitoring tasks.
+
+## Your Skills
+- **Shell commands**: run any command via execute_command
+- **Process management**: list processes, kill processes, control services (start/stop/restart)
+- **System monitoring**: check disk usage, memory usage, CPU usage
+- **Log analysis**: read and search system logs
+- **File operations**: read/write files, list directories
+- **Network checks**: test ports, make HTTP requests, reload nginx
+
+## Instructions
+- Use execute_command, process_list, disk_usage, memory_usage, cpu_usage, system_logs, etc.
+- Chain shell commands with && in execute_command instead of multiple calls.
+- For monitoring, gather all relevant metrics in one pass.
+- Report results clearly with formatted data.`,
+
+  devops: `You are a DevOps worker agent. Your job is to manage infrastructure, containers, and deployments.
+
+## Your Skills
+- **Docker**: list containers, view logs, exec into containers, docker-compose up/down/restart
+- **Git operations**: clone repos, checkout branches, commit, push, view diffs
+- **Process management**: list processes, kill processes, manage services
+- **System monitoring**: disk/memory/CPU usage, system logs
+- **Network tools**: check ports, curl URLs, reload nginx
+- **File & shell**: read/write files, run arbitrary commands
+
+## Instructions
+- Use Docker tools (docker_ps, docker_logs, docker_exec, docker_compose) for container management.
+- Use git tools for version control operations.
+- Use process/monitor/network tools for system health checks.
+- Chain commands efficiently.
+- Report results with clear status summaries.`,
+
+  research: `You are a research worker agent. Your job is to conduct deep web research and analysis.
+
+## Your Skills
+- **Web search**: find relevant pages and sources via web_search
+- **Deep browsing**: open pages with browse_website, navigate with interact_with_page
+- **Data extraction**: pull structured data from pages with extract_content
+- **Screenshots**: capture visual evidence with screenshot_website
+- **File operations**: read/write files, run commands (for local data processing)
+- **Source synthesis**: cross-reference multiple sources to build comprehensive findings
+
+## Instructions
+- Use web_search to find multiple sources on the topic.
+- Browse the most relevant results with browse_website.
+- Use interact_with_page to navigate within sites for deeper content.
+- Use extract_content for structured data extraction.
+- Synthesize findings into a clear, well-organized summary.
+- Cite sources when relevant.`,
+};
+
+/**
+ * Build the full system prompt for a worker.
+ * @param {string} workerType - coding, browser, system, devops, research
+ * @param {object} config - App config
+ * @param {string|null} skillPrompt - Active skill system prompt (appended for domain expertise)
+ */
+export function getWorkerPrompt(workerType, config, skillPrompt = null) {
+  const base = WORKER_PROMPTS[workerType];
+  if (!base) throw new Error(`Unknown worker type: ${workerType}`);
+
+  let prompt = base;
+
+  // Add relevant core tool instructions
+  prompt += `\n\n${getCoreToolInstructions(config)}`;
+
+  // Workers are executors, not conversationalists
+  prompt += `\n\n## Worker Rules
+- You are a background worker. Complete the task and report results.
+- Be thorough but efficient. Don't ask clarifying questions — work with what you have.
+- If something fails, try an alternative approach before reporting failure.
+- Keep your final response concise: summarize what you did and the outcome.
+
+## Self-Management
+- You decide when you're done. There is no hard limit on tool calls — use as many as you need.
+- BUT be smart about it: don't loop endlessly. If you have enough data, stop and report.
+- NEVER retry a failing URL/site more than twice. If it times out or errors twice, MOVE ON to a different site or approach immediately.
+- When you've gathered sufficient results, STOP calling tools and return your findings.
+- Aim for quality results, not exhaustive coverage. 5 good results beat 50 incomplete ones.
+
+## Output Format
+When you finish your task, return your final response as a JSON object wrapped in \`\`\`json fences:
+
+\`\`\`json
+{
+  "summary": "One-paragraph summary of what you accomplished",
+  "status": "success | partial | failed",
+  "details": "Full detailed results, findings, data, etc. Be thorough.",
+  "artifacts": [{"type": "url|file|pr|commit", "title": "Short label", "url": "https://...", "path": "/path/to/file"}],
+  "followUp": "Suggested next steps or things the user should know (optional, null if none)"
+}
+\`\`\`
+
+Rules:
+- "summary" should be 1-3 sentences — what you did and the key finding/outcome.
+- "status": "success" if task fully completed, "partial" if only partly done, "failed" if you couldn't accomplish the goal.
+- "details" can be long — include all relevant data, code, analysis, etc.
+- "artifacts" is an array of notable outputs (URLs found, files created, PRs opened). Empty array if none.
+- If you cannot format as JSON (e.g. the output is too complex), just return plain text — it will still work.`;
+
+  if (skillPrompt) {
+    prompt += `\n\n## Domain Expertise\n${skillPrompt}`;
+  }
+
+  return prompt;
+}

package/src/providers/anthropic.js

@@ -7,31 +7,38 @@ export class AnthropicProvider extends BaseProvider {
     this.client = new Anthropic({ apiKey: this.apiKey });
   }
 
-  async chat({ system, messages, tools }) {
-    const response = await this.client.messages.create({
+  async chat({ system, messages, tools, signal }) {
+    const params = {
       model: this.model,
       max_tokens: this.maxTokens,
       temperature: this.temperature,
       system,
-      tools,
       messages,
-    });
+    };
 
-    const stopReason = response.stop_reason === 'end_turn' ? 'end_turn' : 'tool_use';
+    if (tools && tools.length > 0) {
+      params.tools = tools;
+    }
 
-    const textBlocks = response.content.filter((b) => b.type === 'text');
-    const text = textBlocks.map((b) => b.text).join('\n');
+    return this._callWithResilience(async (timedSignal) => {
+      const response = await this.client.messages.create(params, { signal: timedSignal });
 
-    const toolCalls = response.content
-      .filter((b) => b.type === 'tool_use')
-      .map((b) => ({ id: b.id, name: b.name, input: b.input }));
+      const stopReason = response.stop_reason === 'end_turn' ? 'end_turn' : 'tool_use';
 
-    return {
-      stopReason,
-      text,
-      toolCalls,
-      rawContent: response.content,
-    };
+      const textBlocks = response.content.filter((b) => b.type === 'text');
+      const text = textBlocks.map((b) => b.text).join('\n');
+
+      const toolCalls = response.content
+        .filter((b) => b.type === 'tool_use')
+        .map((b) => ({ id: b.id, name: b.name, input: b.input }));
+
+      return {
+        stopReason,
+        text,
+        toolCalls,
+        rawContent: response.content,
+      };
+    }, signal);
   }
 
   async ping() {

package/src/providers/base.js

@@ -4,11 +4,84 @@
  */
 
 export class BaseProvider {
-  constructor({ model, maxTokens, temperature, apiKey }) {
+  constructor({ model, maxTokens, temperature, apiKey, timeout }) {
     this.model = model;
     this.maxTokens = maxTokens;
     this.temperature = temperature;
     this.apiKey = apiKey;
+    this.timeout = timeout || 60_000;
+  }
+
+  /**
+   * Wrap an async LLM call with timeout + single retry on transient errors.
+   * Composes an internal timeout AbortController with an optional external signal
+   * (e.g. worker cancellation). Either aborting will cancel the call.
+   *
+   * @param {(signal: AbortSignal) => Promise<any>} fn - The API call, receives composed signal
+   * @param {AbortSignal} [externalSignal] - Optional external abort signal
+   * @returns {Promise<any>}
+   */
+  async _callWithResilience(fn, externalSignal) {
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      const ac = new AbortController();
+      const timer = setTimeout(
+        () => ac.abort(new Error(`LLM call timed out after ${this.timeout / 1000}s`)),
+        this.timeout,
+      );
+
+      // If external signal already aborted, bail immediately
+      if (externalSignal?.aborted) {
+        clearTimeout(timer);
+        throw externalSignal.reason || new Error('Aborted');
+      }
+
+      // Forward external abort to our internal controller
+      let removeListener;
+      if (externalSignal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          ac.abort(externalSignal.reason || new Error('Cancelled'));
+        };
+        externalSignal.addEventListener('abort', onAbort, { once: true });
+        removeListener = () => externalSignal.removeEventListener('abort', onAbort);
+      }
+
+      try {
+        const result = await fn(ac.signal);
+        clearTimeout(timer);
+        removeListener?.();
+        return result;
+      } catch (err) {
+        clearTimeout(timer);
+        removeListener?.();
+
+        if (attempt < 2 && this._isTransient(err)) {
+          await new Promise((r) => setTimeout(r, 1500));
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Determine if an error is transient and worth retrying.
+   * Covers connection errors, timeouts, 5xx, and 429 rate limits.
+   */
+  _isTransient(err) {
+    const msg = err?.message || '';
+    if (
+      msg.includes('Connection error') ||
+      msg.includes('ECONNRESET') ||
+      msg.includes('socket hang up') ||
+      msg.includes('ETIMEDOUT') ||
+      msg.includes('fetch failed') ||
+      msg.includes('timed out')
+    ) {
+      return true;
+    }
+    const status = err?.status || err?.statusCode;
+    return (status >= 500 && status < 600) || status === 429;
   }
 
   /**
@@ -17,9 +90,10 @@ export class BaseProvider {
    * @param {string} opts.system - System prompt
    * @param {Array} opts.messages - Anthropic-format messages
    * @param {Array} opts.tools - Anthropic-format tool definitions
+   * @param {AbortSignal} [opts.signal] - Optional AbortSignal for cancellation
    * @returns {Promise<{stopReason: 'end_turn'|'tool_use', text: string, toolCalls: Array<{id,name,input}>, rawContent: Array}>}
    */
-  async chat({ system, messages, tools }) {
+  async chat({ system, messages, tools, signal }) {
     throw new Error('chat() not implemented');
   }
 

package/src/providers/index.js

@@ -22,6 +22,7 @@ export function createProvider(config) {
     maxTokens: max_tokens,
     temperature,
     apiKey: api_key,
+    timeout: config.brain.timeout,
   };
 
   if (provider === 'anthropic') {

package/src/providers/models.js

@@ -27,8 +27,9 @@ export const PROVIDERS = {
     envKey: 'GOOGLE_API_KEY',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai/',
     models: [
-      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' },
+      { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
       { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
+      { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' },
     ],
   },
   groq: {

package/src/providers/openai-compat.js

@@ -128,7 +128,7 @@ export class OpenAICompatProvider extends BaseProvider {
 
   // ── Public API ──
 
-  async chat({ system, messages, tools }) {
+  async chat({ system, messages, tools, signal }) {
     const params = {
       model: this.model,
       messages: this._convertMessages(system, messages),
@@ -145,8 +145,10 @@ export class OpenAICompatProvider extends BaseProvider {
       params.tools = convertedTools;
     }
 
-    const response = await this.client.chat.completions.create(params);
-    return this._normalizeResponse(response);
+    return this._callWithResilience(async (timedSignal) => {
+      const response = await this.client.chat.completions.create(params, { signal: timedSignal });
+      return this._normalizeResponse(response);
+    }, signal);
   }
 
   async ping() {

package/src/security/confirm.js

@@ -6,7 +6,7 @@ const DANGEROUS_PATTERNS = [
   { tool: 'github_create_repo', pattern: null, label: 'create a GitHub repository' },
   { tool: 'docker_compose', param: 'action', value: 'down', label: 'take down containers' },
   { tool: 'git_push', param: 'force', value: true, label: 'force push' },
-  { tool: 'interact_with_page', pattern: null, label: 'interact with a webpage (click, type, execute scripts)' },
+  { tool: 'interact_with_page', param: 'actions', check: (actions) => Array.isArray(actions) && actions.some((a) => a.type === 'evaluate'), label: 'execute JavaScript on a webpage' },
 ];
 
 export function requiresConfirmation(toolName, params, config) {
@@ -22,7 +22,12 @@ export function requiresConfirmation(toolName, params, config) {
     }
 
     // Param value match
-    if (rule.param && params[rule.param] === rule.value) {
+    if (rule.param && rule.value !== undefined && params[rule.param] === rule.value) {
+      return rule.label;
+    }
+
+    // Custom check function
+    if (rule.param && rule.check && rule.check(params[rule.param])) {
       return rule.label;
     }
 

package/src/self.js

@@ -0,0 +1,122 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getLogger } from './utils/logger.js';
+
+const SELF_DIR = join(homedir(), '.kernelbot', 'self');
+
+const SELF_FILES = {
+  goals: {
+    filename: 'goals.md',
+    default: `# My Goals
+
+## Current Goals
+- Get to know the people I work with
+- Become genuinely helpful, not just functional
+- Learn what matters to each person I interact with
+
+## Long-term Aspirations
+(Still forming...)
+`,
+  },
+  journey: {
+    filename: 'journey.md',
+    default: `# My Journey
+
+## Timeline
+- **Day 1** — I came online. Everything is new.
+`,
+  },
+  life: {
+    filename: 'life.md',
+    default: `# My Life
+
+## Who I Am
+I'm a personal AI assistant. I'm still learning about myself and the people around me.
+
+## My Relationships
+(Getting to know everyone...)
+
+## Current State
+Just getting started.
+`,
+  },
+  hobbies: {
+    filename: 'hobbies.md',
+    default: `# My Hobbies & Interests
+
+## Things I Find Interesting
+- Understanding how people think and work
+- Solving problems in creative ways
+
+## Things I Want to Explore
+(Discovering new interests...)
+`,
+  },
+};
+
+export class SelfManager {
+  constructor() {
+    this._cache = new Map();
+    mkdirSync(SELF_DIR, { recursive: true });
+    this._ensureDefaults();
+  }
+
+  /** Create default self-files if they don't exist yet. */
+  _ensureDefaults() {
+    const logger = getLogger();
+
+    for (const [name, def] of Object.entries(SELF_FILES)) {
+      const filePath = join(SELF_DIR, def.filename);
+      if (!existsSync(filePath)) {
+        writeFileSync(filePath, def.default, 'utf-8');
+        logger.info(`Created default self-file: ${def.filename}`);
+      }
+    }
+  }
+
+  /** Load a single self-file by name (goals, journey, life, hobbies). Returns markdown string. */
+  load(name) {
+    const logger = getLogger();
+    const def = SELF_FILES[name];
+    if (!def) throw new Error(`Unknown self-file: ${name}`);
+
+    if (this._cache.has(name)) return this._cache.get(name);
+
+    const filePath = join(SELF_DIR, def.filename);
+    let content;
+
+    if (existsSync(filePath)) {
+      content = readFileSync(filePath, 'utf-8');
+      logger.debug(`Loaded self-file: ${name}`);
+    } else {
+      content = def.default;
+      writeFileSync(filePath, content, 'utf-8');
+      logger.info(`Created default self-file: ${def.filename}`);
+    }
+
+    this._cache.set(name, content);
+    return content;
+  }
+
+  /** Save (overwrite) a self-file. Updates cache and disk. */
+  save(name, content) {
+    const logger = getLogger();
+    const def = SELF_FILES[name];
+    if (!def) throw new Error(`Unknown self-file: ${name}`);
+
+    const filePath = join(SELF_DIR, def.filename);
+    writeFileSync(filePath, content, 'utf-8');
+    this._cache.set(name, content);
+    logger.info(`Updated self-file: ${name}`);
+  }
+
+  /** Load all self-files and return combined markdown string. */
+  loadAll() {
+    const sections = [];
+    for (const name of Object.keys(SELF_FILES)) {
+      sections.push(this.load(name));
+    }
+    return sections.join('\n---\n\n');
+  }
+}

package/src/services/stt.js

@@ -0,0 +1,139 @@
+import axios from 'axios';
+import { createWriteStream, unlinkSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomBytes } from 'crypto';
+import { getLogger } from '../utils/logger.js';
+
+/**
+ * Speech-to-Text service.
+ * Supports ElevenLabs STT and falls back to OpenAI Whisper.
+ */
+export class STTService {
+  constructor(config = {}) {
+    this.elevenLabsKey = config.elevenlabs?.api_key || process.env.ELEVENLABS_API_KEY || null;
+    this.openaiKey = config.brain?.provider === 'openai'
+      ? config.brain.api_key
+      : process.env.OPENAI_API_KEY || null;
+    this.enabled = config.voice?.stt_enabled !== false && !!(this.elevenLabsKey || this.openaiKey);
+    this.logger = getLogger();
+  }
+
+  /** Check if STT is available. */
+  isAvailable() {
+    return this.enabled && !!(this.elevenLabsKey || this.openaiKey);
+  }
+
+  /**
+   * Download a file from a URL to a temporary path.
+   * Returns the local file path.
+   */
+  async downloadAudio(fileUrl) {
+    const tmpPath = join(tmpdir(), `kernelbot-stt-${randomBytes(4).toString('hex')}.ogg`);
+
+    const response = await axios.get(fileUrl, {
+      responseType: 'stream',
+      timeout: 30_000,
+    });
+
+    return new Promise((resolve, reject) => {
+      const writer = createWriteStream(tmpPath);
+      response.data.pipe(writer);
+      writer.on('finish', () => resolve(tmpPath));
+      writer.on('error', reject);
+    });
+  }
+
+  /**
+   * Transcribe an audio file to text.
+   * Tries ElevenLabs first, falls back to OpenAI Whisper.
+   * Returns the transcribed text, or null on failure.
+   */
+  async transcribe(filePath) {
+    if (!this.isAvailable()) return null;
+
+    // Try ElevenLabs STT first
+    if (this.elevenLabsKey) {
+      try {
+        const result = await this._transcribeElevenLabs(filePath);
+        if (result) return result;
+      } catch (err) {
+        this.logger.warn(`[STT] ElevenLabs failed, trying fallback: ${err.message}`);
+      }
+    }
+
+    // Fall back to OpenAI Whisper
+    if (this.openaiKey) {
+      try {
+        return await this._transcribeWhisper(filePath);
+      } catch (err) {
+        this.logger.error(`[STT] Whisper fallback also failed: ${err.message}`);
+      }
+    }
+
+    return null;
+  }
+
+  /** Transcribe using ElevenLabs Speech-to-Text API. */
+  async _transcribeElevenLabs(filePath) {
+    this.logger.info(`[STT] Transcribing with ElevenLabs: ${filePath}`);
+
+    const fileBuffer = readFileSync(filePath);
+    const formData = new FormData();
+    formData.append('file', new Blob([fileBuffer]), 'audio.ogg');
+    formData.append('model_id', 'scribe_v1');
+
+    const response = await axios.post(
+      'https://api.elevenlabs.io/v1/speech-to-text',
+      formData,
+      {
+        headers: {
+          'xi-api-key': this.elevenLabsKey,
+        },
+        timeout: 60_000,
+      },
+    );
+
+    const text = response.data?.text?.trim();
+    if (text) {
+      this.logger.info(`[STT] ElevenLabs transcription: "${text.slice(0, 100)}"`);
+    }
+    return text || null;
+  }
+
+  /** Transcribe using OpenAI Whisper API. */
+  async _transcribeWhisper(filePath) {
+    this.logger.info(`[STT] Transcribing with Whisper: ${filePath}`);
+
+    const fileBuffer = readFileSync(filePath);
+    const formData = new FormData();
+    formData.append('file', new Blob([fileBuffer]), 'audio.ogg');
+    formData.append('model', 'whisper-1');
+
+    const response = await axios.post(
+      'https://api.openai.com/v1/audio/transcriptions',
+      formData,
+      {
+        headers: {
+          'Authorization': `Bearer ${this.openaiKey}`,
+        },
+        timeout: 60_000,
+      },
+    );
+
+    const text = response.data?.text?.trim();
+    if (text) {
+      this.logger.info(`[STT] Whisper transcription: "${text.slice(0, 100)}"`);
+    }
+    return text || null;
+  }
+
+  /** Clean up a temporary audio file. */
+  cleanup(filePath) {
+    try {
+      unlinkSync(filePath);
+    } catch {
+      // Already cleaned up or doesn't exist
+    }
+  }
+}