kernelbot 1.0.25 → 1.0.28

package/src/swarm/job-manager.js

@@ -0,0 +1,169 @@
+import { EventEmitter } from 'events';
+import { Job } from './job.js';
+import { getLogger } from '../utils/logger.js';
+
+/**
+ * Manages all jobs across all chats. Emits lifecycle events
+ * so the orchestrator can react when workers finish.
+ *
+ * Events:
+ *   job:completed  (job)
+ *   job:failed     (job)
+ *   job:cancelled  (job)
+ */
+export class JobManager extends EventEmitter {
+  constructor({ jobTimeoutSeconds = 300, cleanupIntervalMinutes = 30 } = {}) {
+    super();
+    this.jobs = new Map();            // id -> Job
+    this.jobTimeoutMs = jobTimeoutSeconds * 1000;
+    this.cleanupMaxAge = cleanupIntervalMinutes * 60 * 1000;
+  }
+
+  /** Create a new job (status: queued). */
+  createJob(chatId, workerType, task) {
+    const job = new Job({ chatId, workerType, task });
+    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.debug(`[JobManager] Total jobs tracked: ${this.jobs.size}`);
+    return job;
+  }
+
+  /** Move a job to running. */
+  startJob(jobId) {
+    const job = this._get(jobId);
+    job.transition('running');
+    getLogger().info(`[JobManager] Job ${job.id} [${job.workerType}] → running`);
+  }
+
+  /** Move a job to completed with a result. */
+  completeJob(jobId, result) {
+    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`);
+    this.emit('job:completed', job);
+  }
+
+  /** Move a job to failed with an error message. */
+  failJob(jobId, error) {
+    const job = this._get(jobId);
+    job.transition('failed');
+    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);
+  }
+
+  /** Cancel a specific job. Returns the job or null if not found / already terminal. */
+  cancelJob(jobId) {
+    const logger = getLogger();
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      logger.warn(`[JobManager] Cancel: job ${jobId} not found`);
+      return null;
+    }
+    if (job.isTerminal) {
+      logger.warn(`[JobManager] Cancel: job ${jobId} already in terminal state (${job.status})`);
+      return null;
+    }
+
+    const prevStatus = job.status;
+    job.transition('cancelled');
+    // Abort the worker if it's running
+    if (job.worker && typeof job.worker.cancel === 'function') {
+      logger.info(`[JobManager] Job ${job.id} [${job.workerType}] → cancelled (was: ${prevStatus}) — sending cancel to worker`);
+      job.worker.cancel();
+    } else {
+      logger.info(`[JobManager] Job ${job.id} [${job.workerType}] → cancelled (was: ${prevStatus}) — no active worker to abort`);
+    }
+    this.emit('job:cancelled', job);
+    return job;
+  }
+
+  /** Cancel all non-terminal jobs for a chat. Returns array of cancelled jobs. */
+  cancelAllForChat(chatId) {
+    const logger = getLogger();
+    const allForChat = [...this.jobs.values()].filter(j => j.chatId === chatId && !j.isTerminal);
+    logger.info(`[JobManager] Cancel all for chat ${chatId} — ${allForChat.length} active jobs found`);
+
+    const cancelled = [];
+    for (const job of allForChat) {
+      const prevStatus = job.status;
+      job.transition('cancelled');
+      if (job.worker && typeof job.worker.cancel === 'function') {
+        job.worker.cancel();
+      }
+      logger.info(`[JobManager] Job ${job.id} [${job.workerType}] → cancelled (was: ${prevStatus})`);
+      this.emit('job:cancelled', job);
+      cancelled.push(job);
+    }
+    return cancelled;
+  }
+
+  /** Get all jobs for a chat (most recent first). */
+  getJobsForChat(chatId) {
+    const jobs = [...this.jobs.values()]
+      .filter((j) => j.chatId === chatId)
+      .sort((a, b) => b.createdAt - a.createdAt);
+    getLogger().debug(`[JobManager] getJobsForChat(${chatId}): ${jobs.length} jobs`);
+    return jobs;
+  }
+
+  /** Get only running jobs for a chat. */
+  getRunningJobsForChat(chatId) {
+    const running = [...this.jobs.values()]
+      .filter((j) => j.chatId === chatId && j.status === 'running');
+    getLogger().debug(`[JobManager] getRunningJobsForChat(${chatId}): ${running.length} running`);
+    return running;
+  }
+
+  /** Get a job by id. */
+  getJob(jobId) {
+    return this.jobs.get(jobId) || null;
+  }
+
+  /** Garbage-collect old terminal jobs. */
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [id, job] of this.jobs) {
+      if (job.isTerminal && job.completedAt && now - job.completedAt > this.cleanupMaxAge) {
+        this.jobs.delete(id);
+        removed++;
+      }
+    }
+    if (removed) {
+      getLogger().info(`[JobManager] Cleanup: removed ${removed} old jobs — ${this.jobs.size} remaining`);
+    }
+  }
+
+  /** Enforce timeout on running jobs. Called periodically. */
+  enforceTimeouts() {
+    const now = Date.now();
+    let checkedCount = 0;
+    for (const job of this.jobs.values()) {
+      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`);
+          // 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`);
+        }
+      }
+    }
+    if (checkedCount > 0) {
+      getLogger().debug(`[JobManager] Timeout check: ${checkedCount} running jobs checked`);
+    }
+  }
+
+  /** Internal: get job or throw. */
+  _get(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job) throw new Error(`Job not found: ${jobId}`);
+    return job;
+  }
+}

package/src/swarm/job.js

@@ -0,0 +1,67 @@
+import { randomBytes } from 'crypto';
+
+/** Valid job statuses and allowed transitions. */
+const TRANSITIONS = {
+  queued:    ['running', 'cancelled'],
+  running:   ['completed', 'failed', 'cancelled'],
+  completed: [],
+  failed:    [],
+  cancelled: [],
+};
+
+/**
+ * A single unit of work dispatched from the orchestrator to a worker.
+ */
+export class Job {
+  constructor({ chatId, workerType, task }) {
+    this.id = randomBytes(4).toString('hex');        // short 8-char hex id
+    this.chatId = chatId;
+    this.workerType = workerType;
+    this.task = task;
+    this.status = 'queued';
+    this.result = null;
+    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;
+  }
+
+  /** Transition to a new status. Throws if the transition is invalid. */
+  transition(newStatus) {
+    const allowed = TRANSITIONS[this.status];
+    if (!allowed || !allowed.includes(newStatus)) {
+      throw new Error(`Invalid job transition: ${this.status} -> ${newStatus}`);
+    }
+    this.status = newStatus;
+    if (newStatus === 'running') this.startedAt = Date.now();
+    if (['completed', 'failed', 'cancelled'].includes(newStatus)) this.completedAt = Date.now();
+  }
+
+  /** Duration in seconds (or null if not started). */
+  get duration() {
+    if (!this.startedAt) return null;
+    const end = this.completedAt || Date.now();
+    return Math.round((end - this.startedAt) / 1000);
+  }
+
+  /** Whether this job is in a terminal state. */
+  get isTerminal() {
+    return ['completed', 'failed', 'cancelled'].includes(this.status);
+  }
+
+  /** Human-readable one-line summary. */
+  toSummary() {
+    const statusEmoji = {
+      queued: '🔜',
+      running: '⚙️',
+      completed: '✅',
+      failed: '❌',
+      cancelled: '🚫',
+    };
+    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}`;
+  }
+}

package/src/swarm/worker-registry.js

@@ -0,0 +1,74 @@
+import { TOOL_CATEGORIES } from '../tools/categories.js';
+import { toolDefinitions } from '../tools/index.js';
+
+/**
+ * Worker type definitions — maps each worker type to the tool categories it needs.
+ */
+export const WORKER_TYPES = {
+  coding: {
+    label: 'Coding Worker',
+    emoji: '💻',
+    categories: ['core', 'coding', 'git', 'github'],
+    description: 'Write code, fix bugs, create PRs',
+  },
+  browser: {
+    label: 'Browser Worker',
+    emoji: '🌐',
+    categories: ['browser'],
+    description: 'Web search, scraping, screenshots',
+  },
+  system: {
+    label: 'System Worker',
+    emoji: '🖥️',
+    categories: ['core', 'process', 'monitor', 'network'],
+    description: 'OS operations, monitoring, network',
+  },
+  devops: {
+    label: 'DevOps Worker',
+    emoji: '🚀',
+    categories: ['core', 'docker', 'process', 'monitor', 'network', 'git'],
+    description: 'Docker, deploy, infrastructure',
+  },
+  research: {
+    label: 'Research Worker',
+    emoji: '🔍',
+    categories: ['browser', 'core'],
+    description: 'Deep web research and analysis',
+  },
+};
+
+/**
+ * Get the tool name set for a given worker type.
+ * @param {string} workerType
+ * @returns {Set<string>}
+ */
+function getToolNamesForWorker(workerType) {
+  const config = WORKER_TYPES[workerType];
+  if (!config) throw new Error(`Unknown worker type: ${workerType}`);
+
+  const names = new Set();
+  for (const cat of config.categories) {
+    const tools = TOOL_CATEGORIES[cat];
+    if (tools) tools.forEach((t) => names.add(t));
+  }
+  return names;
+}
+
+/**
+ * Get Anthropic-format tool definitions scoped to a worker type.
+ * @param {string} workerType
+ * @returns {Array} filtered tool definitions
+ */
+export function getToolsForWorker(workerType) {
+  const names = getToolNamesForWorker(workerType);
+  return toolDefinitions.filter((t) => names.has(t.name));
+}
+
+/**
+ * Get all tool names for a worker type (for credential checking).
+ * @param {string} workerType
+ * @returns {string[]}
+ */
+export function getToolNamesForWorkerType(workerType) {
+  return [...getToolNamesForWorker(workerType)];
+}