kernelbot 1.0.26 → 1.0.30

package/src/skills/custom.js

@@ -0,0 +1,128 @@
+/**
+ * Custom user-defined skills — CRUD operations with JSON storage,
+ * plus unified lookups that merge custom skills with the built-in catalog.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getSkillById, getSkillsByCategory, getCategoryList } from './catalog.js';
+
+const STORAGE_DIR = join(homedir(), '.kernelbot');
+const STORAGE_FILE = join(STORAGE_DIR, 'custom_skills.json');
+
+let cache = null;
+
+/** Slugify a name for use as an ID suffix. */
+function slugify(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+/** Generate a unique ID with `custom_` prefix. Appends -2, -3, etc. on collision. */
+function generateId(name, existingIds) {
+  const base = `custom_${slugify(name)}`;
+  if (!existingIds.has(base)) return base;
+  let n = 2;
+  while (existingIds.has(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+
+/** Load custom skills from disk into the in-memory cache. */
+export function loadCustomSkills() {
+  if (cache !== null) return cache;
+  if (!existsSync(STORAGE_FILE)) {
+    cache = [];
+    return cache;
+  }
+  try {
+    const raw = readFileSync(STORAGE_FILE, 'utf-8');
+    cache = JSON.parse(raw);
+    if (!Array.isArray(cache)) cache = [];
+  } catch {
+    cache = [];
+  }
+  return cache;
+}
+
+/** Write the current cache to disk. */
+export function saveCustomSkills(skills) {
+  cache = skills;
+  if (!existsSync(STORAGE_DIR)) {
+    mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+  writeFileSync(STORAGE_FILE, JSON.stringify(skills, null, 2), 'utf-8');
+}
+
+/** Return the cached array of custom skills. */
+export function getCustomSkills() {
+  if (cache === null) loadCustomSkills();
+  return cache;
+}
+
+/**
+ * Create a new custom skill, save, and return it.
+ * @param {{ name: string, systemPrompt: string, description?: string }} opts
+ */
+export function addCustomSkill({ name, systemPrompt, description }) {
+  const skills = getCustomSkills();
+  const existingIds = new Set(skills.map((s) => s.id));
+  const id = generateId(name, existingIds);
+
+  const skill = {
+    id,
+    name,
+    emoji: '\u{1F6E0}\uFE0F', // wrench emoji
+    description: description || `Custom skill: ${name}`,
+    systemPrompt,
+    createdAt: new Date().toISOString(),
+  };
+
+  skills.push(skill);
+  saveCustomSkills(skills);
+  return skill;
+}
+
+/** Delete a custom skill by ID. Returns true if found and removed. */
+export function deleteCustomSkill(id) {
+  const skills = getCustomSkills();
+  const idx = skills.findIndex((s) => s.id === id);
+  if (idx === -1) return false;
+  skills.splice(idx, 1);
+  saveCustomSkills(skills);
+  return true;
+}
+
+/** Find a custom skill by ID. */
+export function getCustomSkillById(id) {
+  const skills = getCustomSkills();
+  return skills.find((s) => s.id === id);
+}
+
+/** Unified lookup: check custom first, then fall through to built-in catalog. */
+export function getUnifiedSkillById(id) {
+  return getCustomSkillById(id) || getSkillById(id);
+}
+
+/** Unified category list: built-in categories + custom category (if any exist). */
+export function getUnifiedCategoryList() {
+  const categories = getCategoryList();
+  const customs = getCustomSkills();
+  if (customs.length > 0) {
+    categories.push({
+      key: 'custom',
+      name: 'Custom',
+      emoji: '\u{1F6E0}\uFE0F',
+      count: customs.length,
+    });
+  }
+  return categories;
+}
+
+/** Unified skills-by-category: for 'custom' return custom skills; otherwise delegate. */
+export function getUnifiedSkillsByCategory(key) {
+  if (key === 'custom') return getCustomSkills();
+  return getSkillsByCategory(key);
+}

package/src/swarm/job-manager.js

@@ -0,0 +1,216 @@
+import { EventEmitter } from 'events';
+import { Job } from './job.js';
+import { WORKER_TYPES } from './worker-registry.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)
+ *   job:ready      (job) — emitted when a queued job's dependencies are all met
+ */
+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 });
+    // 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} — timeout: ${job.timeoutMs / 1000}s — "${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 and optional structured data. */
+  completeJob(jobId, result, structuredResult = null) {
+    const job = this._get(jobId);
+    job.transition('completed');
+    job.result = result;
+    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. */
+  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);
+    this._failDependents(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;
+        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 ${timeoutMs / 1000}s`);
+        }
+      }
+    }
+    if (checkedCount > 0) {
+      getLogger().debug(`[JobManager] Timeout check: ${checkedCount} running jobs checked`);
+    }
+  }
+
+  /** 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);
+    if (!job) throw new Error(`Job not found: ${jobId}`);
+    return job;
+  }
+}

package/src/swarm/job.js

@@ -0,0 +1,85 @@
+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.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. */
+  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);
+  }
+
+  /** 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);
+  }
+
+  /** 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)` : '';
+    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

@@ -0,0 +1,79 @@
+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',
+    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
+  },
+};
+
+/**
+ * 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)];
+}