kernelbot 1.0.26 → 1.0.30

package/src/tools/categories.js

@@ -3,7 +3,7 @@
  */
 
 export const TOOL_CATEGORIES = {
-  core: ['execute_command', 'read_file', 'write_file', 'list_directory'],
+  core: ['execute_command', 'read_file', 'write_file', 'list_directory', 'update_user_persona'],
   git: ['git_clone', 'git_checkout', 'git_commit', 'git_push', 'git_diff'],
   github: ['github_create_pr', 'github_get_pr_diff', 'github_post_review', 'github_create_repo', 'github_list_prs'],
   coding: ['spawn_claude_code'],
@@ -11,7 +11,7 @@ export const TOOL_CATEGORIES = {
   process: ['process_list', 'kill_process', 'service_control'],
   monitor: ['disk_usage', 'memory_usage', 'cpu_usage', 'system_logs'],
   network: ['check_port', 'curl_url', 'nginx_reload'],
-  browser: ['browse_website', 'screenshot_website', 'extract_content', 'send_image', 'interact_with_page'],
+  browser: ['web_search', 'browse_website', 'screenshot_website', 'extract_content', 'send_image', 'interact_with_page'],
   jira: ['jira_get_ticket', 'jira_search_tickets', 'jira_list_my_tickets', 'jira_get_project_tickets'],
 };
 
@@ -23,7 +23,7 @@ const CATEGORY_KEYWORDS = {
   process: ['process', 'kill', 'restart', 'service', 'daemon', 'systemctl', 'pid'],
   monitor: ['disk', 'memory', 'cpu', 'usage', 'monitor', 'logs', 'status', 'health', 'space'],
   network: ['port', 'curl', 'http', 'nginx', 'network', 'api', 'endpoint', 'request', 'url', 'fetch'],
-  browser: ['browse', 'screenshot', 'scrape', 'website', 'web page', 'webpage', 'extract content', 'html', 'css selector'],
+  browser: ['search', 'find', 'look up', 'browse', 'screenshot', 'scrape', 'website', 'web page', 'webpage', 'extract content', 'html', 'css selector'],
   jira: ['jira', 'ticket', 'issue', 'sprint', 'backlog', 'story', 'epic'],
 };
 

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/index.js

@@ -8,6 +8,7 @@ import { definitions as githubDefinitions, handlers as githubHandlers } from './
 import { definitions as codingDefinitions, handlers as codingHandlers } from './coding.js';
 import { definitions as browserDefinitions, handlers as browserHandlers } from './browser.js';
 import { definitions as jiraDefinitions, handlers as jiraHandlers } from './jira.js';
+import { definitions as personaDefinitions, handlers as personaHandlers } from './persona.js';
 import { logToolCall } from '../security/audit.js';
 import { requiresConfirmation } from '../security/confirm.js';
 
@@ -22,6 +23,7 @@ export const toolDefinitions = [
   ...codingDefinitions,
   ...browserDefinitions,
   ...jiraDefinitions,
+  ...personaDefinitions,
 ];
 
 const handlerMap = {
@@ -35,6 +37,7 @@ const handlerMap = {
   ...codingHandlers,
   ...browserHandlers,
   ...jiraHandlers,
+  ...personaHandlers,
 };
 
 export function checkConfirmation(name, params, config) {

package/src/tools/orchestrator-tools.js

@@ -0,0 +1,428 @@
+import { WORKER_TYPES, getToolsForWorker, getToolNamesForWorkerType } from '../swarm/worker-registry.js';
+import { getMissingCredential } from '../utils/config.js';
+import { getLogger } from '../utils/logger.js';
+
+const workerTypeEnum = Object.keys(WORKER_TYPES);
+
+/**
+ * Tool definitions for the orchestrator's 3 meta-tools.
+ */
+export const orchestratorToolDefinitions = [
+  {
+    name: 'dispatch_task',
+    description: `Dispatch a task to a specialized background worker. Available worker types: ${workerTypeEnum.join(', ')}. The worker runs in the background and you'll be notified when it completes.`,
+    input_schema: {
+      type: 'object',
+      properties: {
+        worker_type: {
+          type: 'string',
+          enum: workerTypeEnum,
+          description: 'The type of worker to dispatch the task to.',
+        },
+        task: {
+          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'],
+    },
+  },
+  {
+    name: 'list_jobs',
+    description: 'List all jobs for the current chat with their status, type, and summary.',
+    input_schema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'cancel_job',
+    description: 'Cancel a running or queued job by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        job_id: {
+          type: 'string',
+          description: 'The ID of the job to cancel.',
+        },
+      },
+      required: ['job_id'],
+    },
+  },
+  {
+    name: 'create_automation',
+    description: 'Create a recurring automation that runs on a schedule. The task description will be executed as a standalone prompt each time it fires.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Short name for the automation (e.g. "Server Health Check").',
+        },
+        description: {
+          type: 'string',
+          description: 'Detailed task prompt that will be executed each time. Must be standalone and self-contained.',
+        },
+        schedule_type: {
+          type: 'string',
+          enum: ['cron', 'interval', 'random'],
+          description: 'Schedule type: cron (fixed times), interval (every N minutes), random (human-like random intervals).',
+        },
+        cron_expression: {
+          type: 'string',
+          description: 'Cron expression for schedule_type=cron (e.g. "0 9 * * *" for 9am daily). 5 fields: minute hour dayOfMonth month dayOfWeek.',
+        },
+        interval_minutes: {
+          type: 'number',
+          description: 'Interval in minutes for schedule_type=interval (minimum 5).',
+        },
+        min_minutes: {
+          type: 'number',
+          description: 'Minimum interval in minutes for schedule_type=random.',
+        },
+        max_minutes: {
+          type: 'number',
+          description: 'Maximum interval in minutes for schedule_type=random.',
+        },
+      },
+      required: ['name', 'description', 'schedule_type'],
+    },
+  },
+  {
+    name: 'list_automations',
+    description: 'List all automations for the current chat with their status, schedule, and next run time.',
+    input_schema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'update_automation',
+    description: 'Update an existing automation — change its name, description, schedule, or enable/disable it.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        automation_id: {
+          type: 'string',
+          description: 'The ID of the automation to update.',
+        },
+        enabled: {
+          type: 'boolean',
+          description: 'Enable or disable the automation.',
+        },
+        name: {
+          type: 'string',
+          description: 'New name for the automation.',
+        },
+        description: {
+          type: 'string',
+          description: 'New task prompt for the automation.',
+        },
+        schedule_type: {
+          type: 'string',
+          enum: ['cron', 'interval', 'random'],
+          description: 'New schedule type.',
+        },
+        cron_expression: { type: 'string' },
+        interval_minutes: { type: 'number' },
+        min_minutes: { type: 'number' },
+        max_minutes: { type: 'number' },
+      },
+      required: ['automation_id'],
+    },
+  },
+  {
+    name: 'delete_automation',
+    description: 'Permanently delete an automation by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        automation_id: {
+          type: 'string',
+          description: 'The ID of the automation to delete.',
+        },
+      },
+      required: ['automation_id'],
+    },
+  },
+];
+
+/**
+ * Execute an orchestrator meta-tool.
+ * The dispatch_task handler is async and fire-and-forget — it returns immediately.
+ *
+ * @param {string} name - Tool name
+ * @param {object} input - Tool input
+ * @param {object} context - { chatId, jobManager, config, spawnWorker }
+ * @returns {object} Tool result
+ */
+export async function executeOrchestratorTool(name, input, context) {
+  const logger = getLogger();
+  const { chatId, jobManager, config, spawnWorker, automationManager, user } = context;
+
+  switch (name) {
+    case 'dispatch_task': {
+      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]) {
+        logger.warn(`[dispatch_task] Invalid worker type: ${worker_type}`);
+        return { error: `Unknown worker type: ${worker_type}. Valid: ${workerTypeEnum.join(', ')}` };
+      }
+
+      // 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);
+      for (const toolName of toolNames) {
+        const missing = getMissingCredential(toolName, config);
+        if (missing) {
+          logger.warn(`[dispatch_task] Missing credential for ${worker_type}: ${missing.envKey}`);
+          return {
+            error: `Missing credential for ${worker_type} worker: ${missing.label} (${missing.envKey}). Ask the user to provide it.`,
+          };
+        }
+      }
+
+      // 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
+      spawnWorker(job).catch((err) => {
+        logger.error(`[dispatch_task] Worker spawn error for job ${job.id}: ${err.message}`);
+        if (!job.isTerminal) {
+          jobManager.failJob(job.id, err.message);
+        }
+      });
+
+      return {
+        job_id: job.id,
+        worker_type,
+        status: 'dispatched',
+        message: `${workerConfig.emoji} ${workerConfig.label} started.`,
+      };
+    }
+
+    case 'list_jobs': {
+      const jobs = jobManager.getJobsForChat(chatId);
+      logger.info(`[list_jobs] Chat ${chatId} — ${jobs.length} jobs found`);
+      if (jobs.length > 0) {
+        logger.debug(`[list_jobs] Jobs: ${jobs.slice(0, 5).map(j => `${j.id}[${j.status}]`).join(', ')}${jobs.length > 5 ? '...' : ''}`);
+      }
+      if (jobs.length === 0) {
+        return { message: 'No jobs for this chat.' };
+      }
+      return {
+        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;
+        }),
+      };
+    }
+
+    case 'cancel_job': {
+      const { job_id } = input;
+      logger.info(`[cancel_job] Request to cancel job ${job_id} in chat ${chatId}`);
+      const job = jobManager.cancelJob(job_id);
+      if (!job) {
+        logger.warn(`[cancel_job] Job ${job_id} not found or already finished`);
+        return { error: `Job ${job_id} not found or already finished.` };
+      }
+      logger.info(`[cancel_job] Successfully cancelled job ${job_id} [${job.workerType}]`);
+      return {
+        job_id: job.id,
+        status: 'cancelled',
+        message: `Cancelled ${WORKER_TYPES[job.workerType]?.emoji || ''} ${job.workerType} worker.`,
+      };
+    }
+
+    case 'create_automation': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const { name: autoName, description, schedule_type, cron_expression, interval_minutes, min_minutes, max_minutes } = input;
+      logger.info(`[create_automation] Request: name="${autoName}", type=${schedule_type}`);
+
+      let schedule;
+      switch (schedule_type) {
+        case 'cron':
+          schedule = { type: 'cron', expression: cron_expression };
+          break;
+        case 'interval':
+          schedule = { type: 'interval', minutes: interval_minutes };
+          break;
+        case 'random':
+          schedule = { type: 'random', minMinutes: min_minutes, maxMinutes: max_minutes };
+          break;
+        default:
+          return { error: `Unknown schedule type: ${schedule_type}` };
+      }
+
+      try {
+        const auto = automationManager.create(chatId, { name: autoName, description, schedule });
+        return {
+          automation_id: auto.id,
+          name: auto.name,
+          schedule: auto.schedule,
+          next_run: auto.nextRun ? new Date(auto.nextRun).toLocaleString() : null,
+          message: `Automation "${auto.name}" created and armed.`,
+        };
+      } catch (err) {
+        logger.warn(`[create_automation] Failed: ${err.message}`);
+        return { error: err.message };
+      }
+    }
+
+    case 'list_automations': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const autos = automationManager.listForChat(chatId);
+      logger.info(`[list_automations] Chat ${chatId} — ${autos.length} automation(s)`);
+
+      if (autos.length === 0) {
+        return { message: 'No automations for this chat.' };
+      }
+
+      return {
+        automations: autos.map((a) => ({
+          id: a.id,
+          name: a.name,
+          description: a.description.slice(0, 100),
+          schedule: a.schedule,
+          enabled: a.enabled,
+          next_run: a.nextRun ? new Date(a.nextRun).toLocaleString() : null,
+          run_count: a.runCount,
+          last_error: a.lastError,
+          summary: a.toSummary(),
+        })),
+      };
+    }
+
+    case 'update_automation': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const { automation_id, enabled, name: newName, description: newDesc, schedule_type: newSchedType, cron_expression: newCron, interval_minutes: newInterval, min_minutes: newMin, max_minutes: newMax } = input;
+      logger.info(`[update_automation] Request: id=${automation_id}`);
+
+      const changes = {};
+      if (enabled !== undefined) changes.enabled = enabled;
+      if (newName !== undefined) changes.name = newName;
+      if (newDesc !== undefined) changes.description = newDesc;
+
+      if (newSchedType !== undefined) {
+        switch (newSchedType) {
+          case 'cron':
+            changes.schedule = { type: 'cron', expression: newCron };
+            break;
+          case 'interval':
+            changes.schedule = { type: 'interval', minutes: newInterval };
+            break;
+          case 'random':
+            changes.schedule = { type: 'random', minMinutes: newMin, maxMinutes: newMax };
+            break;
+        }
+      }
+
+      try {
+        const auto = automationManager.update(automation_id, changes);
+        if (!auto) return { error: `Automation ${automation_id} not found.` };
+        return {
+          automation_id: auto.id,
+          name: auto.name,
+          enabled: auto.enabled,
+          schedule: auto.schedule,
+          next_run: auto.nextRun ? new Date(auto.nextRun).toLocaleString() : null,
+          message: `Automation "${auto.name}" updated.`,
+        };
+      } catch (err) {
+        logger.warn(`[update_automation] Failed: ${err.message}`);
+        return { error: err.message };
+      }
+    }
+
+    case 'delete_automation': {
+      if (!automationManager) return { error: 'Automation system not available.' };
+
+      const { automation_id } = input;
+      logger.info(`[delete_automation] Request: id=${automation_id}`);
+
+      const deleted = automationManager.delete(automation_id);
+      if (!deleted) return { error: `Automation ${automation_id} not found.` };
+      return { automation_id, status: 'deleted', message: `Automation deleted.` };
+    }
+
+    default:
+      return { error: `Unknown orchestrator tool: ${name}` };
+  }
+}

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/tools/persona.js

@@ -0,0 +1,32 @@
+export const definitions = [
+  {
+    name: 'update_user_persona',
+    description:
+      'Update the stored persona/profile for the current user. ' +
+      'Pass the COMPLETE updated persona document as markdown. ' +
+      'Before calling this, mentally merge any new information into the existing persona — ' +
+      'do not blindly append. Only call when you discover genuinely new, meaningful information ' +
+      '(expertise, preferences, projects, communication style).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'The full updated persona markdown document.',
+        },
+      },
+      required: ['content'],
+    },
+  },
+];
+
+export const handlers = {
+  async update_user_persona({ content }, context) {
+    const { personaManager, user } = context;
+    if (!personaManager) return { error: 'Persona manager not available.' };
+    if (!user?.id) return { error: 'User ID not available.' };
+
+    personaManager.save(user.id, content);
+    return { success: true, message: 'User persona updated.' };
+  },
+};