kernelbot 1.0.28 → 1.0.32

package/src/services/tts.js

@@ -0,0 +1,124 @@
+import axios from 'axios';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getLogger } from '../utils/logger.js';
+
+const CACHE_DIR = join(homedir(), '.kernelbot', 'tts-cache');
+const DEFAULT_VOICE_ID = 'JBFqnCBsd6RMkjVDRZzb'; // ElevenLabs "George" voice
+const MAX_TEXT_LENGTH = 5000; // ElevenLabs limit
+
+/**
+ * Text-to-Speech service using ElevenLabs API.
+ * Converts text to OGG/opus audio compatible with Telegram voice messages.
+ */
+export class TTSService {
+  constructor(config = {}) {
+    this.apiKey = config.elevenlabs?.api_key || process.env.ELEVENLABS_API_KEY || null;
+    this.voiceId = config.elevenlabs?.voice_id || process.env.ELEVENLABS_VOICE_ID || DEFAULT_VOICE_ID;
+    this.enabled = config.voice?.tts_enabled !== false && !!this.apiKey;
+    this.logger = getLogger();
+
+    // Ensure cache directory exists
+    if (this.enabled) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+  }
+
+  /** Check if TTS is available. */
+  isAvailable() {
+    return this.enabled && !!this.apiKey;
+  }
+
+  /**
+   * Convert text to an OGG/opus audio buffer.
+   * Returns the file path to the generated audio, or null on failure.
+   */
+  async synthesize(text) {
+    if (!this.isAvailable()) return null;
+    if (!text || text.trim().length === 0) return null;
+
+    // Truncate if too long
+    const cleanText = text.slice(0, MAX_TEXT_LENGTH).trim();
+
+    // Check cache
+    const cacheKey = this._cacheKey(cleanText, this.voiceId);
+    const cachedPath = join(CACHE_DIR, `${cacheKey}.ogg`);
+    if (existsSync(cachedPath)) {
+      this.logger.debug(`[TTS] Cache hit: ${cacheKey}`);
+      return cachedPath;
+    }
+
+    try {
+      this.logger.info(`[TTS] Synthesizing ${cleanText.length} chars with voice ${this.voiceId}`);
+
+      const response = await axios.post(
+        `https://api.elevenlabs.io/v1/text-to-speech/${this.voiceId}`,
+        {
+          text: cleanText,
+          model_id: 'eleven_multilingual_v2',
+          voice_settings: {
+            stability: 0.5,
+            similarity_boost: 0.75,
+            style: 0.0,
+            use_speaker_boost: true,
+          },
+        },
+        {
+          headers: {
+            'Accept': 'audio/mpeg',
+            'Content-Type': 'application/json',
+            'xi-api-key': this.apiKey,
+          },
+          responseType: 'arraybuffer',
+          timeout: 30_000,
+        },
+      );
+
+      // ElevenLabs returns MP3 by default when Accept: audio/mpeg
+      // We write it as-is; Telegram accepts MP3 for voice messages via sendVoice
+      // when sent with the right content type
+      const audioBuffer = Buffer.from(response.data);
+
+      if (audioBuffer.length < 100) {
+        this.logger.warn('[TTS] Response too small, likely an error');
+        return null;
+      }
+
+      // Cache the result
+      writeFileSync(cachedPath, audioBuffer);
+      this.logger.info(`[TTS] Synthesized and cached: ${cachedPath} (${audioBuffer.length} bytes)`);
+
+      return cachedPath;
+    } catch (err) {
+      if (err.response) {
+        const errBody = err.response.data instanceof Buffer
+          ? err.response.data.toString('utf-8').slice(0, 200)
+          : JSON.stringify(err.response.data).slice(0, 200);
+        this.logger.error(`[TTS] API error ${err.response.status}: ${errBody}`);
+      } else {
+        this.logger.error(`[TTS] Request failed: ${err.message}`);
+      }
+      return null;
+    }
+  }
+
+  /** Generate a deterministic cache key from text + voice. */
+  _cacheKey(text, voiceId) {
+    return createHash('sha256').update(`${voiceId}:${text}`).digest('hex').slice(0, 16);
+  }
+
+  /** Clear the TTS cache. */
+  clearCache() {
+    try {
+      const files = readdirSync(CACHE_DIR);
+      for (const file of files) {
+        unlinkSync(join(CACHE_DIR, file));
+      }
+      this.logger.info(`[TTS] Cache cleared (${files.length} files)`);
+    } catch {
+      // Cache dir may not exist yet
+    }
+  }
+}

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

@@ -5,11 +5,15 @@ import { getLogger } from '../utils/logger.js';
 
 let spawner = null;
 
-function getSpawner(config) {
+export function getSpawner(config) {
   if (!spawner) spawner = new ClaudeCodeSpawner(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,31 +180,82 @@ 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
       const toolNames = getToolNamesForWorkerType(worker_type);
+      const missingCreds = [];
       for (const toolName of toolNames) {
         const missing = getMissingCredential(toolName, config);
         if (missing) {
-          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${missing.envKey}`);
+          missingCreds.push(missing);
+        }
+      }
+
+      let credentialWarning = null;
+      if (missingCreds.length > 0) {
+        if (worker_type === 'coding') {
+          // Soft warning for coding worker — spawn_claude_code handles git/GitHub internally
+          const warnings = missingCreds.map(c => `${c.label} (${c.envKey})`).join(', ');
+          logger.info(`[dispatch_task] Coding worker — soft credential warning (non-blocking): ${warnings}`);
+          credentialWarning = `Note: The following credentials are not configured as env vars: ${warnings}. If git/GitHub tools are unavailable, use spawn_claude_code for ALL operations — it handles git, GitHub, and PR creation internally.`;
+        } else {
+          // Hard block for all other worker types
+          const first = missingCreds[0];
+          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${first.envKey}`);
           return {
-            error: `Missing credential for ${worker_type} worker: ${missing.label} (${missing.envKey}). Ask the user to provide it.`,
+            error: `Missing credential for ${worker_type} worker: ${first.label} (${first.envKey}). Ask the user to provide it.`,
           };
         }
       }
 
-      // Create and spawn the job
+      // Create the job with context and dependencies
       const job = jobManager.createJob(chatId, worker_type, task);
+      job.context = [taskContext, credentialWarning].filter(Boolean).join('\n\n') || 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 +284,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 });
+        }
+      }
     });
   },