kernelbot 1.0.28 → 1.0.30

package/src/swarm/job-manager.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'events';
 import { Job } from './job.js';
+import { WORKER_TYPES } from './worker-registry.js';
 import { getLogger } from '../utils/logger.js';
 
 /**
@@ -10,6 +11,7 @@ import { getLogger } from '../utils/logger.js';
  *   job:completed  (job)
  *   job:failed     (job)
  *   job:cancelled  (job)
+ *   job:ready      (job) — emitted when a queued job's dependencies are all met
  */
 export class JobManager extends EventEmitter {
   constructor({ jobTimeoutSeconds = 300, cleanupIntervalMinutes = 30 } = {}) {
@@ -22,9 +24,12 @@ export class JobManager extends EventEmitter {
   /** Create a new job (status: queued). */
   createJob(chatId, workerType, task) {
     const job = new Job({ chatId, workerType, task });
+    // Set per-job timeout from worker type config, fall back to global
+    const workerConfig = WORKER_TYPES[workerType];
+    job.timeoutMs = workerConfig?.timeout ? workerConfig.timeout * 1000 : this.jobTimeoutMs;
     this.jobs.set(job.id, job);
     const logger = getLogger();
-    logger.info(`[JobManager] Job created: ${job.id} [${workerType}] for chat ${chatId} — "${task.slice(0, 100)}"`);
+    logger.info(`[JobManager] Job created: ${job.id} [${workerType}] for chat ${chatId} — timeout: ${job.timeoutMs / 1000}s — "${task.slice(0, 100)}"`);
     logger.debug(`[JobManager] Total jobs tracked: ${this.jobs.size}`);
     return job;
   }
@@ -36,13 +41,17 @@ export class JobManager extends EventEmitter {
     getLogger().info(`[JobManager] Job ${job.id} [${job.workerType}] → running`);
   }
 
-  /** Move a job to completed with a result. */
-  completeJob(jobId, result) {
+  /** Move a job to completed with a result and optional structured data. */
+  completeJob(jobId, result, structuredResult = null) {
     const job = this._get(jobId);
     job.transition('completed');
     job.result = result;
-    getLogger().info(`[JobManager] Job ${job.id} [${job.workerType}] → completed (${job.duration}s) — result: ${(result || '').length} chars`);
+    if (structuredResult) {
+      job.structuredResult = structuredResult;
+    }
+    getLogger().info(`[JobManager] Job ${job.id} [${job.workerType}] → completed (${job.duration}s) — result: ${(result || '').length} chars, structured: ${!!structuredResult}`);
     this.emit('job:completed', job);
+    this._checkDependents(job);
   }
 
   /** Move a job to failed with an error message. */
@@ -52,6 +61,7 @@ export class JobManager extends EventEmitter {
     job.error = typeof error === 'string' ? error : error?.message || String(error);
     getLogger().error(`[JobManager] Job ${job.id} [${job.workerType}] → failed (${job.duration}s) — ${job.error}`);
     this.emit('job:failed', job);
+    this._failDependents(job);
   }
 
   /** Cancel a specific job. Returns the job or null if not found / already terminal. */
@@ -145,13 +155,14 @@ export class JobManager extends EventEmitter {
       if (job.status === 'running' && job.startedAt) {
         checkedCount++;
         const elapsed = now - job.startedAt;
-        if (elapsed > this.jobTimeoutMs) {
-          getLogger().warn(`[JobManager] Job ${job.id} [${job.workerType}] timed out — elapsed: ${Math.round(elapsed / 1000)}s, limit: ${this.jobTimeoutMs / 1000}s`);
+        const timeoutMs = job.timeoutMs || this.jobTimeoutMs;
+        if (elapsed > timeoutMs) {
+          getLogger().warn(`[JobManager] Job ${job.id} [${job.workerType}] timed out — elapsed: ${Math.round(elapsed / 1000)}s, limit: ${timeoutMs / 1000}s`);
           // Cancel the worker first so it stops executing & frees resources
           if (job.worker && typeof job.worker.cancel === 'function') {
             job.worker.cancel();
           }
-          this.failJob(job.id, `Timed out after ${this.jobTimeoutMs / 1000}s`);
+          this.failJob(job.id, `Timed out after ${timeoutMs / 1000}s`);
         }
       }
     }
@@ -160,6 +171,42 @@ export class JobManager extends EventEmitter {
     }
   }
 
+  /** Check if any queued jobs have all dependencies met after a job completes. */
+  _checkDependents(completedJob) {
+    const logger = getLogger();
+    for (const job of this.jobs.values()) {
+      if (job.status !== 'queued' || job.dependsOn.length === 0) continue;
+      if (!job.dependsOn.includes(completedJob.id)) continue;
+
+      // Check if ALL dependencies are completed
+      const allMet = job.dependsOn.every(depId => {
+        const dep = this.jobs.get(depId);
+        return dep && dep.status === 'completed';
+      });
+
+      if (allMet) {
+        logger.info(`[JobManager] Job ${job.id} [${job.workerType}] — all dependencies met, emitting job:ready`);
+        this.emit('job:ready', job);
+      }
+    }
+  }
+
+  /** Cascade failure to dependent jobs when a job fails. */
+  _failDependents(failedJob) {
+    const logger = getLogger();
+    for (const job of this.jobs.values()) {
+      if (job.status !== 'queued' || job.dependsOn.length === 0) continue;
+      if (!job.dependsOn.includes(failedJob.id)) continue;
+
+      logger.warn(`[JobManager] Job ${job.id} [${job.workerType}] — dependency ${failedJob.id} failed, cascading failure`);
+      job.transition('failed');
+      job.error = `Dependency job ${failedJob.id} failed: ${failedJob.error || 'unknown error'}`;
+      this.emit('job:failed', job);
+      // Recursively cascade to jobs depending on this one
+      this._failDependents(job);
+    }
+  }
+
   /** Internal: get job or throw. */
   _get(jobId) {
     const job = this.jobs.get(jobId);

package/src/swarm/job.js

@@ -20,12 +20,19 @@ export class Job {
     this.task = task;
     this.status = 'queued';
     this.result = null;
+    this.structuredResult = null;                      // WorkerResult: { summary, status, details, artifacts, followUp, toolsUsed, errors }
+    this.context = null;                               // Orchestrator-provided context string
+    this.dependsOn = [];                               // Job IDs this job depends on
+    this.userId = null;                                // Telegram user ID for persona loading
     this.error = null;
     this.worker = null;                               // WorkerAgent ref
     this.statusMessageId = null;                      // Telegram message for progress edits
     this.createdAt = Date.now();
     this.startedAt = null;
     this.completedAt = null;
+    this.timeoutMs = null;                              // Per-job timeout (set from worker type config)
+    this.progress = [];                                 // Recent activity entries
+    this.lastActivity = null;                           // Timestamp of last activity
   }
 
   /** Transition to a new status. Throws if the transition is invalid. */
@@ -46,6 +53,13 @@ export class Job {
     return Math.round((end - this.startedAt) / 1000);
   }
 
+  /** Record a progress heartbeat from the worker. Caps at 20 entries. */
+  addProgress(text) {
+    this.progress.push(text);
+    if (this.progress.length > 20) this.progress.shift();
+    this.lastActivity = Date.now();
+  }
+
   /** Whether this job is in a terminal state. */
   get isTerminal() {
     return ['completed', 'failed', 'cancelled'].includes(this.status);
@@ -62,6 +76,10 @@ export class Job {
     };
     const emoji = statusEmoji[this.status] || '❓';
     const dur = this.duration != null ? ` (${this.duration}s)` : '';
-    return `${emoji} \`${this.id}\` [${this.workerType}] ${this.task.slice(0, 60)}${this.task.length > 60 ? '...' : ''}${dur}`;
+    const summaryText = this.structuredResult?.summary || null;
+    const lastAct = !summaryText && this.progress.length > 0 ? ` | ${this.progress[this.progress.length - 1]}` : '';
+    const resultSnippet = summaryText ? ` | ${summaryText.slice(0, 80)}` : '';
+    const deps = this.dependsOn.length > 0 ? ` [deps: ${this.dependsOn.join(',')}]` : '';
+    return `${emoji} \`${this.id}\` [${this.workerType}] ${this.task.slice(0, 60)}${this.task.length > 60 ? '...' : ''}${dur}${resultSnippet}${lastAct}${deps}`;
   }
 }

package/src/swarm/worker-registry.js

@@ -10,30 +10,35 @@ export const WORKER_TYPES = {
     emoji: '💻',
     categories: ['core', 'coding', 'git', 'github'],
     description: 'Write code, fix bugs, create PRs',
+    timeout: 86400,  // 24 hours — Claude Code can legitimately run for hours
   },
   browser: {
     label: 'Browser Worker',
     emoji: '🌐',
     categories: ['browser'],
     description: 'Web search, scraping, screenshots',
+    timeout: 300,    // 5 minutes
   },
   system: {
     label: 'System Worker',
     emoji: '🖥️',
     categories: ['core', 'process', 'monitor', 'network'],
     description: 'OS operations, monitoring, network',
+    timeout: 600,    // 10 minutes
   },
   devops: {
     label: 'DevOps Worker',
     emoji: '🚀',
     categories: ['core', 'docker', 'process', 'monitor', 'network', 'git'],
     description: 'Docker, deploy, infrastructure',
+    timeout: 3600,   // 1 hour
   },
   research: {
     label: 'Research Worker',
     emoji: '🔍',
     categories: ['browser', 'core'],
     description: 'Deep web research and analysis',
+    timeout: 600,    // 10 minutes
   },
 };
 

package/src/tools/coding.js

@@ -10,6 +10,10 @@ function getSpawner(config) {
   return spawner;
 }
 
+export function resetClaudeCodeSpawner() {
+  spawner = null;
+}
+
 export const definitions = [
   {
     name: 'spawn_claude_code',
@@ -57,6 +61,7 @@ export const handlers = {
         prompt: params.prompt,
         maxTurns: params.max_turns,
         onOutput: onUpdate,
+        signal: context.signal || null,
       });
 
       // Show stderr if any

package/src/tools/orchestrator-tools.js

@@ -23,6 +23,15 @@ export const orchestratorToolDefinitions = [
           type: 'string',
           description: 'A clear, detailed description of what the worker should do.',
         },
+        context: {
+          type: 'string',
+          description: 'Optional background context for the worker — relevant conversation details, goals, constraints. The worker cannot see the chat history, so include anything important here.',
+        },
+        depends_on: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional array of job IDs that must complete before this worker starts. The worker will receive dependency results as context.',
+        },
       },
       required: ['worker_type', 'task'],
     },
@@ -158,12 +167,12 @@ export const orchestratorToolDefinitions = [
  */
 export async function executeOrchestratorTool(name, input, context) {
   const logger = getLogger();
-  const { chatId, jobManager, config, spawnWorker, automationManager } = context;
+  const { chatId, jobManager, config, spawnWorker, automationManager, user } = context;
 
   switch (name) {
     case 'dispatch_task': {
-      const { worker_type, task } = input;
-      logger.info(`[dispatch_task] Request: type=${worker_type}, task="${task.slice(0, 120)}"`);
+      const { worker_type, task, context: taskContext, depends_on } = input;
+      logger.info(`[dispatch_task] Request: type=${worker_type}, task="${task.slice(0, 120)}", deps=${depends_on?.length || 0}`);
 
       // Validate worker type
       if (!WORKER_TYPES[worker_type]) {
@@ -171,13 +180,34 @@ export async function executeOrchestratorTool(name, input, context) {
         return { error: `Unknown worker type: ${worker_type}. Valid: ${workerTypeEnum.join(', ')}` };
       }
 
-      // Check concurrent job limit
-      const running = jobManager.getRunningJobsForChat(chatId);
-      const maxConcurrent = config.swarm?.max_concurrent_jobs || 3;
-      logger.debug(`[dispatch_task] Running jobs: ${running.length}/${maxConcurrent} for chat ${chatId}`);
-      if (running.length >= maxConcurrent) {
-        logger.warn(`[dispatch_task] Rejected — concurrent limit reached: ${running.length}/${maxConcurrent} jobs for chat ${chatId}`);
-        return { error: `Maximum concurrent jobs (${maxConcurrent}) reached. Wait for a job to finish or cancel one.` };
+      // Validate dependency IDs
+      const depIds = Array.isArray(depends_on) ? depends_on : [];
+      for (const depId of depIds) {
+        const depJob = jobManager.getJob(depId);
+        if (!depJob) {
+          logger.warn(`[dispatch_task] Unknown dependency job: ${depId}`);
+          return { error: `Dependency job not found: ${depId}` };
+        }
+        if (depJob.status === 'failed' || depJob.status === 'cancelled') {
+          logger.warn(`[dispatch_task] Dependency job ${depId} already ${depJob.status}`);
+          return { error: `Dependency job ${depId} already ${depJob.status}. Cannot dispatch.` };
+        }
+      }
+
+      // Check concurrent job limit (only if we'll spawn immediately)
+      const hasUnmetDeps = depIds.some(id => {
+        const dep = jobManager.getJob(id);
+        return dep && dep.status !== 'completed';
+      });
+
+      if (!hasUnmetDeps) {
+        const running = jobManager.getRunningJobsForChat(chatId);
+        const maxConcurrent = config.swarm?.max_concurrent_jobs || 3;
+        logger.debug(`[dispatch_task] Running jobs: ${running.length}/${maxConcurrent} for chat ${chatId}`);
+        if (running.length >= maxConcurrent) {
+          logger.warn(`[dispatch_task] Rejected — concurrent limit reached: ${running.length}/${maxConcurrent} jobs for chat ${chatId}`);
+          return { error: `Maximum concurrent jobs (${maxConcurrent}) reached. Wait for a job to finish or cancel one.` };
+        }
       }
 
       // Pre-check credentials for the worker's tools
@@ -192,10 +222,25 @@ export async function executeOrchestratorTool(name, input, context) {
         }
       }
 
-      // Create and spawn the job
+      // Create the job with context and dependencies
       const job = jobManager.createJob(chatId, worker_type, task);
+      job.context = taskContext || null;
+      job.dependsOn = depIds;
+      job.userId = user?.id || null;
       const workerConfig = WORKER_TYPES[worker_type];
 
+      // If dependencies are not all met, leave job queued (job:ready will spawn it later)
+      if (hasUnmetDeps) {
+        logger.info(`[dispatch_task] Job ${job.id} queued — waiting for dependencies: ${depIds.join(', ')}`);
+        return {
+          job_id: job.id,
+          worker_type,
+          status: 'queued_waiting',
+          depends_on: depIds,
+          message: `${workerConfig.emoji} ${workerConfig.label} queued — waiting for ${depIds.length} dependency job(s) to complete.`,
+        };
+      }
+
       logger.info(`[dispatch_task] Dispatching job ${job.id} — ${workerConfig.emoji} ${workerConfig.label}: "${task.slice(0, 100)}"`);
 
       // Fire and forget — spawnWorker handles lifecycle
@@ -224,14 +269,26 @@ export async function executeOrchestratorTool(name, input, context) {
         return { message: 'No jobs for this chat.' };
       }
       return {
-        jobs: jobs.slice(0, 20).map((j) => ({
-          id: j.id,
-          worker_type: j.workerType,
-          status: j.status,
-          task: j.task.slice(0, 100),
-          duration: j.duration,
-          summary: j.toSummary(),
-        })),
+        jobs: jobs.slice(0, 20).map((j) => {
+          const entry = {
+            id: j.id,
+            worker_type: j.workerType,
+            status: j.status,
+            task: j.task.slice(0, 100),
+            duration: j.duration,
+            recent_activity: j.progress.slice(-5),
+            last_activity_seconds_ago: j.lastActivity ? Math.round((Date.now() - j.lastActivity) / 1000) : null,
+            summary: j.toSummary(),
+          };
+          if (j.dependsOn.length > 0) entry.depends_on = j.dependsOn;
+          if (j.structuredResult) {
+            entry.result_summary = j.structuredResult.summary;
+            entry.result_status = j.structuredResult.status;
+            if (j.structuredResult.artifacts?.length > 0) entry.artifacts = j.structuredResult.artifacts;
+            if (j.structuredResult.followUp) entry.follow_up = j.structuredResult.followUp;
+          }
+          return entry;
+        }),
       };
     }
 

package/src/tools/os.js

@@ -122,12 +122,15 @@ export const handlers = {
     }
 
     return new Promise((res) => {
+      let abortHandler = null;
+
       const child = exec(
         command,
         { timeout: timeout_seconds * 1000, maxBuffer: 10 * 1024 * 1024 },
         (error, stdout, stderr) => {
+          if (abortHandler && context.signal) context.signal.removeEventListener('abort', abortHandler);
           if (error && error.killed) {
-            return res({ error: `Command timed out after ${timeout_seconds}s` });
+            return res({ error: `Command timed out or was cancelled after ${timeout_seconds}s` });
           }
           const result = {
             stdout: stdout || '',
@@ -147,6 +150,16 @@ export const handlers = {
           res(result);
         },
       );
+
+      // Wire abort signal to kill the child process
+      if (context.signal) {
+        if (context.signal.aborted) {
+          child.kill('SIGTERM');
+        } else {
+          abortHandler = () => child.kill('SIGTERM');
+          context.signal.addEventListener('abort', abortHandler, { once: true });
+        }
+      }
     });
   },
 

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;
 }