kernelbot 1.0.28 → 1.0.32

package/src/utils/config.js

@@ -13,6 +13,7 @@ const DEFAULTS = {
     description: 'AI engineering agent with full OS control',
   },
   orchestrator: {
+    provider: 'anthropic',
     model: 'claude-opus-4-6',
     max_tokens: 2048,
     temperature: 0.3,
@@ -38,6 +39,7 @@ const DEFAULTS = {
     max_turns: 50,
     timeout_seconds: 600,
     workspace_dir: null, // defaults to ~/.kernelbot/workspaces
+    auth_mode: 'system', // system | api_key | oauth_token
   },
   github: {
     default_branch: 'main',
@@ -190,6 +192,84 @@ export function saveProviderToYaml(providerKey, modelId) {
   return configPath;
 }
 
+/**
+ * Save orchestrator provider and model to config.yaml.
+ */
+export function saveOrchestratorToYaml(providerKey, modelId) {
+  const configDir = getConfigDir();
+  mkdirSync(configDir, { recursive: true });
+  const configPath = join(configDir, 'config.yaml');
+
+  let existing = {};
+  if (existsSync(configPath)) {
+    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
+  }
+
+  existing.orchestrator = {
+    ...(existing.orchestrator || {}),
+    provider: providerKey,
+    model: modelId,
+  };
+
+  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+  return configPath;
+}
+
+/**
+ * Save Claude Code model to config.yaml.
+ */
+export function saveClaudeCodeModelToYaml(modelId) {
+  const configDir = getConfigDir();
+  mkdirSync(configDir, { recursive: true });
+  const configPath = join(configDir, 'config.yaml');
+
+  let existing = {};
+  if (existsSync(configPath)) {
+    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
+  }
+
+  existing.claude_code = {
+    ...(existing.claude_code || {}),
+    model: modelId,
+  };
+
+  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+  return configPath;
+}
+
+/**
+ * Save Claude Code auth mode + credential to config.yaml and .env.
+ */
+export function saveClaudeCodeAuth(config, mode, value) {
+  const configDir = getConfigDir();
+  mkdirSync(configDir, { recursive: true });
+  const configPath = join(configDir, 'config.yaml');
+
+  let existing = {};
+  if (existsSync(configPath)) {
+    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
+  }
+
+  existing.claude_code = {
+    ...(existing.claude_code || {}),
+    auth_mode: mode,
+  };
+
+  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+
+  // Update live config
+  config.claude_code.auth_mode = mode;
+
+  if (mode === 'api_key' && value) {
+    saveCredential(config, 'CLAUDE_CODE_API_KEY', value);
+    config.claude_code.api_key = value;
+  } else if (mode === 'oauth_token' && value) {
+    saveCredential(config, 'CLAUDE_CODE_OAUTH_TOKEN', value);
+    config.claude_code.oauth_token = value;
+  }
+  // mode === 'system' — no credentials to save
+}
+
 /**
  * Full interactive flow: change brain model + optionally enter API key.
  */
@@ -329,8 +409,13 @@ export function loadConfig() {
 
   const config = deepMerge(DEFAULTS, fileConfig);
 
-  // Orchestrator always uses Anthropic — resolve its API key
-  if (process.env.ANTHROPIC_API_KEY) {
+  // Orchestrator — resolve API key based on configured provider
+  const orchProvider = PROVIDERS[config.orchestrator.provider];
+  if (orchProvider && process.env[orchProvider.envKey]) {
+    config.orchestrator.api_key = process.env[orchProvider.envKey];
+  }
+  // Legacy fallback: ANTHROPIC_API_KEY for anthropic orchestrator
+  if (config.orchestrator.provider === 'anthropic' && !config.orchestrator.api_key && process.env.ANTHROPIC_API_KEY) {
     config.orchestrator.api_key = process.env.ANTHROPIC_API_KEY;
   }
 
@@ -351,6 +436,16 @@ export function loadConfig() {
     if (!config.github) config.github = {};
     config.github.token = process.env.GITHUB_TOKEN;
   }
+  // ElevenLabs voice credentials
+  if (process.env.ELEVENLABS_API_KEY) {
+    if (!config.elevenlabs) config.elevenlabs = {};
+    config.elevenlabs.api_key = process.env.ELEVENLABS_API_KEY;
+  }
+  if (process.env.ELEVENLABS_VOICE_ID) {
+    if (!config.elevenlabs) config.elevenlabs = {};
+    config.elevenlabs.voice_id = process.env.ELEVENLABS_VOICE_ID;
+  }
+
   if (process.env.JIRA_BASE_URL || process.env.JIRA_EMAIL || process.env.JIRA_API_TOKEN) {
     if (!config.jira) config.jira = {};
     if (process.env.JIRA_BASE_URL) config.jira.base_url = process.env.JIRA_BASE_URL;
@@ -358,6 +453,14 @@ export function loadConfig() {
     if (process.env.JIRA_API_TOKEN) config.jira.api_token = process.env.JIRA_API_TOKEN;
   }
 
+  // Claude Code auth credentials from env
+  if (process.env.CLAUDE_CODE_API_KEY) {
+    config.claude_code.api_key = process.env.CLAUDE_CODE_API_KEY;
+  }
+  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+    config.claude_code.oauth_token = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  }
+
   return config;
 }
 

package/src/worker.js

@@ -26,18 +26,22 @@ export class WorkerAgent {
    * @param {string} opts.jobId - Job ID for logging
    * @param {Array} opts.tools - Scoped tool definitions
    * @param {string|null} opts.skillId - Active skill ID (for worker prompt)
+   * @param {string|null} opts.workerContext - Structured context (conversation history, persona, dependency results)
    * @param {object} opts.callbacks - { onProgress, onComplete, onError }
    * @param {AbortController} opts.abortController - For cancellation
    */
-  constructor({ config, workerType, jobId, tools, skillId, callbacks, abortController }) {
+  constructor({ config, workerType, jobId, tools, skillId, workerContext, callbacks, abortController }) {
     this.config = config;
     this.workerType = workerType;
     this.jobId = jobId;
     this.tools = tools;
     this.skillId = skillId;
+    this.workerContext = workerContext || null;
     this.callbacks = callbacks || {};
     this.abortController = abortController || new AbortController();
     this._cancelled = false;
+    this._toolCallCount = 0;
+    this._errors = [];
 
     // Create provider from worker brain config
     this.provider = createProvider(config);
@@ -51,7 +55,7 @@ export class WorkerAgent {
     this.maxIterations = 200;
 
     const logger = getLogger();
-    logger.info(`[Worker ${jobId}] Created: type=${workerType}, provider=${config.brain.provider}/${config.brain.model}, tools=${tools.length}, skill=${skillId || 'none'}`);
+    logger.info(`[Worker ${jobId}] Created: type=${workerType}, provider=${config.brain.provider}/${config.brain.model}, tools=${tools.length}, skill=${skillId || 'none'}, context=${workerContext ? 'yes' : 'none'}`);
   }
 
   /** Cancel this worker. */
@@ -66,7 +70,14 @@ export class WorkerAgent {
     const logger = getLogger();
     logger.info(`[Worker ${this.jobId}] Starting task: "${task.slice(0, 150)}"`);
 
-    const messages = [{ role: 'user', content: task }];
+    // Build first message: context sections + task
+    let firstMessage = '';
+    if (this.workerContext) {
+      firstMessage += this.workerContext + '\n\n---\n\n';
+    }
+    firstMessage += task;
+
+    const messages = [{ role: 'user', content: firstMessage }];
 
     try {
       const result = await this._runLoop(messages);
@@ -74,8 +85,9 @@ export class WorkerAgent {
         logger.info(`[Worker ${this.jobId}] Run completed but worker was cancelled — skipping callbacks`);
         return;
       }
-      logger.info(`[Worker ${this.jobId}] Run finished successfully — result: "${(result || '').slice(0, 150)}"`);
-      if (this.callbacks.onComplete) this.callbacks.onComplete(result);
+      const parsed = this._parseResult(result);
+      logger.info(`[Worker ${this.jobId}] Run finished successfully — structured=${!!parsed.structured}, result: "${(result || '').slice(0, 150)}"`);
+      if (this.callbacks.onComplete) this.callbacks.onComplete(result, parsed);
     } catch (err) {
       if (this._cancelled) {
         logger.info(`[Worker ${this.jobId}] Run threw error but worker was cancelled — ignoring: ${err.message}`);
@@ -144,6 +156,8 @@ export class WorkerAgent {
           logger.debug(`[Worker ${this.jobId}] Tool input: ${JSON.stringify(block.input).slice(0, 300)}`);
           this._reportProgress(`🔧 ${summary}`);
 
+          this._toolCallCount++;
+
           const result = await executeTool(block.name, block.input, {
             config: this.config,
             user: null, // workers don't have user context
@@ -151,8 +165,14 @@ export class WorkerAgent {
             onUpdate: this.callbacks.onUpdate || null, // Real bot onUpdate (returns message_id for coder.js smart output)
             sendPhoto: this.callbacks.sendPhoto || null,
             sessionId: this.jobId, // Per-worker browser session isolation
+            signal: this.abortController.signal, // For killing child processes on cancellation
           });
 
+          // Track errors
+          if (result && typeof result === 'object' && result.error) {
+            this._errors.push({ tool: block.name, error: result.error });
+          }
+
           const resultStr = this._truncateResult(block.name, result);
           logger.info(`[Worker ${this.jobId}] Tool ${block.name} result: ${resultStr.slice(0, 200)}`);
 
@@ -254,10 +274,83 @@ export class WorkerAgent {
     return null;
   }
 
+  /**
+   * Parse the worker's final text into a structured WorkerResult.
+   * Attempts JSON parse from ```json fences, falls back to wrapping raw text.
+   */
+  _parseResult(text) {
+    if (!text) {
+      return {
+        structured: false,
+        summary: 'Task completed.',
+        status: 'success',
+        details: '',
+        artifacts: [],
+        followUp: null,
+        toolsUsed: this._toolCallCount,
+        errors: this._errors,
+      };
+    }
+
+    const _str = (v) => typeof v === 'string' ? v : (v ? JSON.stringify(v, null, 2) : '');
+
+    // Try to extract JSON from ```json ... ``` fences
+    const fenceMatch = text.match(/```json\s*\n?([\s\S]*?)\n?\s*```/);
+    if (fenceMatch) {
+      try {
+        const parsed = JSON.parse(fenceMatch[1]);
+        if (parsed.summary && parsed.status) {
+          return {
+            structured: true,
+            summary: String(parsed.summary || ''),
+            status: String(parsed.status || 'success'),
+            details: _str(parsed.details),
+            artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+            followUp: parsed.followUp ? String(parsed.followUp) : null,
+            toolsUsed: this._toolCallCount,
+            errors: this._errors,
+          };
+        }
+      } catch { /* fall through */ }
+    }
+
+    // Try raw JSON parse (no fences)
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed.summary && parsed.status) {
+        return {
+          structured: true,
+          summary: String(parsed.summary || ''),
+          status: String(parsed.status || 'success'),
+          details: _str(parsed.details),
+          artifacts: Array.isArray(parsed.artifacts) ? parsed.artifacts : [],
+          followUp: parsed.followUp ? String(parsed.followUp) : null,
+          toolsUsed: this._toolCallCount,
+          errors: this._errors,
+        };
+      }
+    } catch { /* fall through */ }
+
+    // Fallback: wrap raw text
+    return {
+      structured: false,
+      summary: text.slice(0, 200),
+      status: 'success',
+      details: text,
+      artifacts: [],
+      followUp: null,
+      toolsUsed: this._toolCallCount,
+      errors: this._errors,
+    };
+  }
+
   _reportProgress(text) {
     if (this.callbacks.onProgress) {
       try { this.callbacks.onProgress(text); } catch {}
     }
+    if (this.callbacks.onHeartbeat) {
+      try { this.callbacks.onHeartbeat(text); } catch {}
+    }
   }
 
   _truncateResult(name, result) {