khabotcli 1.0.0

package/api/routes/system.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const express = require('express');
+const router = express.Router();
+const context = require('../../utils/context');
+const db = require('../../infrastructure/database');
+
+const startTime = Date.now();
+
+// GET /health
+router.get('/health', (req, res) => {
+  res.json({ status: 'ok', version: context.getVersion(), uptime: Math.floor((Date.now() - startTime) / 1000) });
+});
+
+// GET /status
+router.get('/status', (req, res, next) => {
+  try {
+    const cwd = context.getCwd();
+    const { listAgents } = require('../../core/agent');
+    const agents = listAgents({ cwd });
+    const scheduler = req.app.locals.scheduler;
+    const daemons = scheduler ? scheduler.listDaemons() : [];
+
+    const activeSessions = db.listSessions({ instanceFolder: cwd, status: 'active', limit: 1000 });
+    const pendingTasks = db.listTasks({ instanceFolder: cwd, status: 'pending', limit: 1000 });
+    const processingTasks = db.listTasks({ instanceFolder: cwd, status: 'processing', limit: 1000 });
+
+    res.json({
+      status: 'ok',
+      version: context.getVersion(),
+      uptime: Math.floor((Date.now() - startTime) / 1000),
+      cwd,
+      agents: agents.length,
+      activeSessions: activeSessions.length,
+      pendingTasks: pendingTasks.length,
+      processingTasks: processingTasks.length,
+      daemons: daemons.length,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /shutdown
+router.post('/shutdown', (req, res) => {
+  res.json({ status: 'shutting_down' });
+  setTimeout(() => process.exit(0), 500);
+});
+
+module.exports = router;

package/api/routes/tasks.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const express = require('express');
+const router = express.Router({ mergeParams: true });
+const { runTask } = require('../../core/router');
+const { loadAgent } = require('../../core/agent');
+const { sendError } = require('../middleware');
+const context = require('../../utils/context');
+const db = require('../../infrastructure/database');
+
+// POST /agents/:name/task  — create a new task
+router.post('/agents/:name/task', async (req, res, next) => {
+  try {
+    const { name } = req.params;
+    const { input, priority, tags, maxIterations, maxDurationSeconds, tokenBudget } = req.body;
+    const cwd = context.getCwd();
+
+    if (!input || typeof input !== 'string') {
+      return sendError(res, 400, 'VALIDATION_ERROR', 'input is required and must be a string');
+    }
+
+    let agent;
+    try {
+      agent = loadAgent({ cwd, name });
+    } catch {
+      return sendError(res, 404, 'AGENT_NOT_FOUND', `Agent "${name}" not found`);
+    }
+
+    if (!agent.modes?.task?.enabled) {
+      return sendError(res, 400, 'MODE_NOT_SUPPORTED', `Agent "${name}" does not support task mode`);
+    }
+
+    const taskId = db.createTask({
+      agentName: name,
+      input,
+      priority: priority || 'normal',
+      tags,
+      maxIterations,
+      maxDurationSeconds,
+      tokenBudget: tokenBudget || null,
+      instanceFolder: cwd,
+    });
+
+    // Run task asynchronously (don't await — return taskId immediately)
+    const settings = req.app.locals.settings;
+    setImmediate(() => runTask({ taskId, cwd, settings }).catch(err => {
+      console.error(`Task ${taskId} failed:`, err.message);
+      db.updateTask(taskId, { status: 'failed', error: err.message });
+    }));
+
+    res.status(202).json({ taskId, status: 'pending' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /tasks — list tasks
+router.get('/tasks', (req, res, next) => {
+  try {
+    const cwd = context.getCwd();
+    const { agentName, status, priority, limit, cursor } = req.query;
+    const tasks = db.listTasks({
+      instanceFolder: cwd,
+      agentName,
+      status,
+      priority,
+      limit: limit ? parseInt(limit, 10) : 20,
+      cursor,
+    });
+    res.json({ tasks });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /tasks/:id — get task details
+router.get('/tasks/:id', (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+    res.json({ task });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /tasks/:id/events — get task progress events
+router.get('/tasks/:id/events', (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+    const { since, limit } = req.query;
+    const events = db.getTaskEvents(req.params.id, {
+      since: since ? parseInt(since, 10) : 0,
+      limit: limit ? parseInt(limit, 10) : 500,
+    });
+    res.json({ taskId: req.params.id, events });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /tasks/:id/context — LLM context snapshot for debuggability
+router.get('/tasks/:id/context', (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+    const context = db.getTaskContext(req.params.id);
+    res.json({
+      taskId: req.params.id,
+      context,
+      note: context ? null : 'No context snapshot yet (task may still be pending or has not made an LLM call)',
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /tasks/:id/respond — respond to a waiting task and resume it
+router.post('/tasks/:id/respond', async (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+    if (task.status !== 'waiting') return sendError(res, 400, 'TASK_NOT_WAITING', `Task is not in waiting status (current: ${task.status})`);
+
+    const { message } = req.body;
+    if (!message) return sendError(res, 400, 'VALIDATION_ERROR', 'message is required');
+
+    // Enqueue the response message so it's picked up by the loop
+    db.enqueueAgentMessage({
+      targetAgent: task.agent_name,
+      fromAgent: 'user',
+      content: message,
+      followup: false,
+    });
+
+    // Respond immediately, then resume the task asynchronously
+    res.json({ taskId: req.params.id, status: 'processing' });
+
+    // Resume the task loop in the background
+    const { resumeTask } = require('../../core/router');
+    const cwd = req.app.locals.cwd;
+    const settings = req.app.locals.settings;
+    resumeTask({ taskId: req.params.id, cwd, settings }).catch(err => {
+      console.error(`[tasks] Failed to resume task ${req.params.id}:`, err.message);
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// DELETE /tasks/:id — hard-delete a task and all its associated data
+router.delete('/tasks/:id', (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+
+    const ACTIVE_STATUSES = ['pending', 'processing', 'waiting'];
+    if (ACTIVE_STATUSES.includes(task.status) && req.query.force !== 'true') {
+      return sendError(res, 409, 'TASK_ACTIVE', `Task is still active (status: ${task.status}). Use ?force=true to cancel and delete.`);
+    }
+
+    // Cancel first if active and forced
+    if (ACTIVE_STATUSES.includes(task.status)) {
+      const cancelRegistry = require('../../core/cancel');
+      cancelRegistry.cancel(req.params.id);
+      db.updateTask(req.params.id, { status: 'canceled', finishedAt: new Date().toISOString() });
+    }
+
+    db.deleteTask(req.params.id);
+    res.json({ deleted: true, taskId: req.params.id });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// GET /tasks/:id/stream — SSE real-time event stream for a single task
+router.get('/tasks/:id/stream', (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+
+    const TERMINAL_STATUSES = new Set(['finished', 'failed', 'canceled']);
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+
+    const taskId = req.params.id;
+
+    function send(eventType, data) {
+      try {
+        res.write(`event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`);
+      } catch { /* client disconnected */ }
+    }
+
+    // 1. Replay historical DB events
+    const history = db.getTaskEvents(taskId, { since: 0, limit: 1000 });
+    for (const ev of history) {
+      send('task', { id: ev.id, type: ev.type, data: ev.data ? JSON.parse(ev.data) : null, created_at: ev.created_at });
+    }
+
+    // 2. Send current task state
+    send('status', { taskId, status: task.status, output: task.output || null, error: task.error ? JSON.parse(task.error) : null });
+
+    // 3. If already terminal, close immediately
+    if (TERMINAL_STATUSES.has(task.status)) {
+      res.end();
+      return;
+    }
+
+    // 4. Subscribe to live events from the event bus
+    const eventBus = require('../../core/events');
+
+    function onEvent(msg) {
+      if (msg.taskId !== taskId) return;
+
+      send('task', { type: msg.type, event: msg.event, timestamp: msg.event?.timestamp });
+
+      // Auto-close when task reaches a terminal state
+      if (msg.type === 'task.status' && TERMINAL_STATUSES.has(msg.event?.status)) {
+        cleanup();
+        res.end();
+      }
+    }
+
+    eventBus.on('event', onEvent);
+
+    // 5. Keepalive ping every 15s to prevent proxy timeouts
+    const keepalive = setInterval(() => {
+      try { res.write(': keepalive\n\n'); } catch { cleanup(); }
+    }, 15000);
+
+    function cleanup() {
+      clearInterval(keepalive);
+      eventBus.off('event', onEvent);
+    }
+
+    req.on('close', cleanup);
+    req.on('error', cleanup);
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /tasks/:id/cancel — cancel a task (cooperative for processing tasks)
+router.post('/tasks/:id/cancel', (req, res, next) => {
+  try {
+    const task = db.getTask(req.params.id);
+    if (!task) return sendError(res, 404, 'TASK_NOT_FOUND', `Task not found: ${req.params.id}`);
+    if (['finished', 'failed', 'canceled'].includes(task.status)) {
+      return sendError(res, 400, 'TASK_ALREADY_TERMINAL', `Task is already in terminal state: ${task.status}`);
+    }
+    // Signal the running loop to abort (cooperative cancellation)
+    const cancelRegistry = require('../../core/cancel');
+    cancelRegistry.cancel(req.params.id);
+    // Also update DB immediately for pending/waiting tasks that have no running loop
+    if (task.status !== 'processing') {
+      db.updateTask(req.params.id, { status: 'canceled', finishedAt: new Date().toISOString() });
+      db.addTaskEvent({ taskId: req.params.id, type: 'status.change', data: { from: task.status, to: 'canceled', reason: 'user_cancel' } });
+    }
+    res.json({ taskId: req.params.id, status: 'canceled' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+module.exports = router;

package/api/server.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const express = require('express');
+const cors = require('cors');
+const { authMiddleware, errorHandler } = require('./middleware');
+const agentsRouter = require('./routes/agents');
+const chatRouter = require('./routes/chat');
+const tasksRouter = require('./routes/tasks');
+const sessionsRouter = require('./routes/sessions');
+const daemonsRouter = require('./routes/daemons');
+const systemRouter = require('./routes/system');
+const memoryRouter = require('./routes/memory');
+const settingsRouter = require('./routes/settings');
+const modelsRouter = require('./routes/models');
+const completionsRouter = require('./routes/completions');
+const remoteMethodsRouter = require('./routes/remote-methods');
+
+/**
+ * Create and configure the Express app.
+ * @param {{ settings: Object, scheduler: Object }} opts
+ * @returns {import('express').Application}
+ */
+function createApp({ settings, scheduler }) {
+  const app = express();
+
+  // Store shared state in app.locals (no circular deps)
+  app.locals.settings = settings;
+  app.locals.scheduler = scheduler;
+
+  app.use(cors());
+  app.use(express.json({ limit: '10mb' }));
+
+  // Auth middleware on all routes
+  app.use(authMiddleware);
+
+  // ── Routes ────────────────────────────────────────────────────────────────
+  app.use('/agents', agentsRouter);
+  app.use('/agents/:name/chat', chatRouter);
+
+  // Task routes are mixed — some under /agents/:name/task, some under /tasks
+  app.use('/', tasksRouter);
+
+  app.use('/sessions', sessionsRouter);
+
+  // Daemon routes: GET /daemons + POST /agents/:name/daemon/*
+  app.use('/daemons', daemonsRouter);
+  app.use('/agents', daemonsRouter);
+
+  // Memory API: /agents/:name/memory/* (must come before generic agents router catches :name)
+  app.use('/agents', memoryRouter);
+
+  // Global memory API: /memory/*
+  app.use('/', memoryRouter);
+
+  // Settings API: GET/PUT /settings
+  app.use('/settings', settingsRouter);
+
+  // Models API: GET /models, GET /models/:provider/:name, POST /models/refresh
+  app.use('/models', modelsRouter);
+
+  // Standalone completions: POST /completions (raw LLM call, no agent/session)
+  app.use('/completions', completionsRouter);
+
+  // Remote Method Execution: GET /remote-methods (SSE) + POST /remote-methods/:id/result
+  app.use('/remote-methods', remoteMethodsRouter);
+
+  app.use('/', systemRouter);
+
+  // Global error handler (must be last)
+  app.use(errorHandler);
+
+  return app;
+}
+
+/**
+ * Start the HTTP server (with WebSocket support on /ws).
+ * @param {{ settings: Object, scheduler: Object, port?: number }} opts
+ * @returns {Promise<import('http').Server>}
+ */
+function startServer({ settings, scheduler, port }) {
+  const app = createApp({ settings, scheduler });
+  const listenPort = port || settings.port || 5050;
+
+  return new Promise((resolve, reject) => {
+    const server = app.listen(listenPort, (err) => {
+      if (err) return reject(err);
+
+      // Attach WebSocket server for real-time event streaming
+      try {
+        const { WebSocketServer } = require('ws');
+        const eventBus = require('../core/events');
+        const wss = new WebSocketServer({ server, path: '/ws' });
+
+        wss.on('connection', (ws) => {
+          const handler = (ev) => {
+            try {
+              if (ws.readyState === 1) ws.send(JSON.stringify(ev));
+            } catch { /* client may have disconnected */ }
+          };
+          eventBus.on('event', handler);
+          ws.on('close', () => eventBus.off('event', handler));
+          ws.on('error', () => eventBus.off('event', handler));
+          // Send a welcome ping so client knows connection is live
+          try { ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() })); } catch { /* ignore */ }
+        });
+
+        wss.on('error', (err) => {
+          console.error('[ws] WebSocket server error:', err.message);
+        });
+      } catch (wsErr) {
+        console.warn('[ws] WebSocket unavailable (install ws package):', wsErr.message);
+      }
+
+      resolve(server);
+    });
+    server.on('error', reject);
+  });
+}
+
+module.exports = { createApp, startServer };

package/cli/formatter.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * CLI output formatting helpers.
+ */
+
+function bold(text) { return `\x1b[1m${text}\x1b[0m`; }
+function green(text) { return `\x1b[32m${text}\x1b[0m`; }
+function yellow(text) { return `\x1b[33m${text}\x1b[0m`; }
+function red(text) { return `\x1b[31m${text}\x1b[0m`; }
+function dim(text) { return `\x1b[2m${text}\x1b[0m`; }
+function cyan(text) { return `\x1b[36m${text}\x1b[0m`; }
+
+/**
+ * Print a success message.
+ * @param {string} msg
+ */
+function success(msg) { console.log(green('✓ ') + msg); }
+
+/**
+ * Print a warning message.
+ * @param {string} msg
+ */
+function warn(msg) { console.log(yellow('⚠ ') + msg); }
+
+/**
+ * Print an error message.
+ * @param {string} msg
+ */
+function error(msg) { console.error(red('✗ ') + msg); }
+
+/**
+ * Print an info message.
+ * @param {string} msg
+ */
+function info(msg) { console.log(dim('  ') + msg); }
+
+/**
+ * Print a section header.
+ * @param {string} title
+ */
+function header(title) { console.log('\n' + bold(title)); }
+
+/**
+ * Format a table from an array of objects.
+ * @param {Object[]} rows
+ * @param {string[]} columns
+ */
+function table(rows, columns) {
+  if (rows.length === 0) { console.log(dim('  (none)')); return; }
+  const widths = columns.map(col => Math.max(col.length, ...rows.map(r => String(r[col] || '').length)));
+  const header = columns.map((col, i) => bold(col.padEnd(widths[i]))).join('  ');
+  const separator = widths.map(w => '─'.repeat(w)).join('  ');
+  console.log('  ' + header);
+  console.log('  ' + dim(separator));
+  for (const row of rows) {
+    const line = columns.map((col, i) => String(row[col] || '').padEnd(widths[i])).join('  ');
+    console.log('  ' + line);
+  }
+}
+
+/**
+ * Print a progress event (for one-shot mode).
+ * @param {Object} event
+ */
+function progress(event) {
+  process.stdout.write(`KHABOT_PROGRESS=${JSON.stringify(event)}\n`);
+}
+
+module.exports = { bold, green, yellow, red, dim, cyan, success, warn, error, info, header, table, progress };