kanon-cli 0.1.0

package/src/lib/admin.js

@@ -0,0 +1,330 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { getStatusPath } from './config.js';
+import { getActiveWorkers, killWorker, spawnClaude } from './claude.js';
+import { buildBundlePrompt } from '../prompts/templates.js';
+
+export class AgentController {
+  constructor(config = {}) {
+    this.checkInterval = (config.check_interval_seconds || 60) * 1000;
+    this.maxSessionMs = (config.max_session_minutes || 30) * 60 * 1000;
+    this.stuckTimeoutMs = (config.stuck_timeout_minutes || 5) * 60 * 1000;
+    this.autoRestartStuck = config.auto_restart_stuck ?? true;
+    this.queueMaxSize = config.queue_max_size || 20;
+    this.bundleQueue = config.bundle_queue ?? true;
+    this.projectConfig = config._projectConfig || {};
+
+    // Per-board max_concurrent: build a map from boardId -> limit
+    this._boardMaxConcurrent = new Map();
+    for (const board of this.projectConfig.boards || []) {
+      this._boardMaxConcurrent.set(board.id, board.claude?.max_concurrent || 1);
+    }
+    // Total max concurrent is sum of all active board limits
+    this.maxConcurrent = this._getTotalMaxConcurrent();
+
+    this.queue = []; // { cardId, prompt, config, priority, addedAt, card?, extraPrompt?, boardId? }
+    this.eventLog = []; // { timestamp, type, cardId, message }
+    this.completedWorkers = []; // last N completed workers with their output
+    this._boardWorkerCounts = new Map(); // boardId -> number of active workers
+    this.timer = null;
+    this.paused = false;
+  }
+
+  _getTotalMaxConcurrent() {
+    if (this._boardMaxConcurrent.size === 0) return 1;
+    let total = 0;
+    for (const limit of this._boardMaxConcurrent.values()) total += limit;
+    return Math.max(1, total);
+  }
+
+  _getBoardMaxConcurrent(boardId) {
+    return this._boardMaxConcurrent.get(boardId) || 1;
+  }
+
+  start() {
+    this.log('info', null, `Agent controller started (check every ${this.checkInterval / 1000}s)`);
+    this.tick(); // Run immediately
+    this.timer = setInterval(() => this.tick(), this.checkInterval);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.log('info', null, 'Agent controller stopped');
+  }
+
+  tick() {
+    if (this.paused) return;
+
+    const workers = getActiveWorkers();
+
+    // Health checks
+    for (const [cardId, worker] of workers) {
+      const runtime = Date.now() - worker.startedAt;
+      const idleTime = Date.now() - worker.lastOutput;
+
+      // Max runtime exceeded
+      if (runtime > this.maxSessionMs) {
+        this.log('warn', cardId, `Worker exceeded max runtime (${Math.round(runtime / 60000)}min), killing`);
+        killWorker(cardId);
+        if (this.autoRestartStuck) {
+          this.log('info', cardId, 'Auto-restart queued');
+          // Re-queue with same context (if available)
+        }
+        continue;
+      }
+
+      // Stuck detection: no output for too long
+      if (idleTime > this.stuckTimeoutMs) {
+        this.log('warn', cardId, `Worker stuck (no output for ${Math.round(idleTime / 60000)}min), killing`);
+        killWorker(cardId);
+        continue;
+      }
+    }
+
+    // Process queue if slots available
+    this._processQueue();
+
+    // Write status snapshot
+    this._writeStatus();
+  }
+
+  /**
+   * Enqueue a new task. Returns true if queued, false if queue is full.
+   */
+  enqueue(cardId, prompt, claudeConfig, { priority = 0, card = null, extraPrompt = '', boardId = null } = {}) {
+    // Don't double-queue
+    if (this.queue.some(q => q.cardId === cardId)) {
+      this.log('info', cardId, 'Already in queue, skipping');
+      return false;
+    }
+
+    // Don't queue if already running
+    if (getActiveWorkers().has(cardId)) {
+      this.log('info', cardId, 'Already running, skipping');
+      return false;
+    }
+
+    if (this.queue.length >= this.queueMaxSize) {
+      this.log('warn', cardId, 'Queue full, dropping event');
+      return false;
+    }
+
+    this.queue.push({ cardId, prompt, config: claudeConfig, priority, addedAt: Date.now(), card, extraPrompt, boardId });
+    // Sort by priority (higher first), then by time (older first)
+    this.queue.sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
+
+    this.log('info', cardId, `Queued (position ${this.queue.findIndex(q => q.cardId === cardId) + 1}/${this.queue.length})`);
+
+    // Try to process immediately
+    this._processQueue();
+    return true;
+  }
+
+  _processQueue() {
+    const workers = getActiveWorkers();
+    if (this.queue.length === 0) return;
+
+    if (this.bundleQueue) {
+      // Bundle mode: group queue items by boardId, bundle within each board
+      const byBoard = new Map();
+      for (const task of this.queue) {
+        const key = task.boardId || '__default__';
+        if (!byBoard.has(key)) byBoard.set(key, []);
+        byBoard.get(key).push(task);
+      }
+
+      // Process one board group per available slot, respecting per-board limits
+      for (const [boardKey, tasks] of byBoard) {
+        const boardLimit = this._getBoardMaxConcurrent(boardKey);
+        const boardActive = this._boardWorkerCounts.get(boardKey) || 0;
+        if (boardActive >= boardLimit) continue;
+
+        // Remove these tasks from the queue
+        for (const t of tasks) {
+          const idx = this.queue.indexOf(t);
+          if (idx !== -1) this.queue.splice(idx, 1);
+        }
+
+        if (tasks.length === 1) {
+          this._incBoard(boardKey);
+          this._startSingleWorker(tasks[0], boardKey);
+        } else {
+          this._incBoard(boardKey);
+          this._startBundledWorker(tasks, boardKey);
+        }
+      }
+    } else {
+      // One task per worker, respecting per-board limits
+      const toProcess = [];
+      for (const task of this.queue) {
+        const boardKey = task.boardId || '__default__';
+        const boardLimit = this._getBoardMaxConcurrent(boardKey);
+        const boardActive = (this._boardWorkerCounts.get(boardKey) || 0) + toProcess.filter(t => (t.boardId || '__default__') === boardKey).length;
+        if (boardActive < boardLimit) {
+          toProcess.push(task);
+        }
+      }
+      for (const task of toProcess) {
+        const boardKey = task.boardId || '__default__';
+        const idx = this.queue.indexOf(task);
+        if (idx !== -1) this.queue.splice(idx, 1);
+        this._incBoard(boardKey);
+        this._startSingleWorker(task, boardKey);
+      }
+    }
+  }
+
+  _incBoard(boardKey) {
+    this._boardWorkerCounts.set(boardKey, (this._boardWorkerCounts.get(boardKey) || 0) + 1);
+  }
+
+  _decBoard(boardKey) {
+    const count = this._boardWorkerCounts.get(boardKey) || 1;
+    this._boardWorkerCounts.set(boardKey, Math.max(0, count - 1));
+  }
+
+  _startBundledWorker(tasks, boardKey) {
+    const cardIds = tasks.map(t => t.cardId);
+    const bundleId = `bundle-${Date.now()}`;
+
+    let combinedPrompt;
+    const hasCardData = tasks.every(t => t.card);
+
+    if (hasCardData) {
+      combinedPrompt = buildBundlePrompt(tasks, this.projectConfig);
+    } else {
+      combinedPrompt = tasks.map((t, i) =>
+        `## Task ${i + 1} (Card ${t.cardId})\n\n${t.prompt}`
+      ).join('\n\n---\n\n');
+    }
+
+    this.log('info', null, `Starting bundled worker for ${tasks.length} cards: ${cardIds.map(id => id.substring(0, 8)).join(', ')}`);
+    const worker = spawnClaude(bundleId, combinedPrompt, tasks[0].config);
+    if (worker?.process) {
+      worker.process.on('close', (code) => {
+        this._decBoard(boardKey);
+        this.completedWorkers.push({
+          cardId: bundleId,
+          cardIds,
+          bundled: true,
+          startedAt: worker.startedAt,
+          finishedAt: Date.now(),
+          runtimeMs: Date.now() - worker.startedAt,
+          exitCode: code,
+          output: worker.output.slice(-50),
+        });
+        if (this.completedWorkers.length > 10) this.completedWorkers.shift();
+        this.log(code === 0 ? 'info' : 'warn', null, `Bundled worker finished (exit ${code}, ${Math.round((Date.now() - worker.startedAt) / 1000)}s) — cards: ${cardIds.map(id => id.substring(0, 8)).join(', ')}`);
+        this._processQueue();
+      });
+    }
+  }
+
+  _startSingleWorker(task, boardKey) {
+    this.log('info', task.cardId, 'Starting worker from queue');
+    const worker = spawnClaude(task.cardId, task.prompt, task.config);
+    if (worker?.process) {
+      worker.process.on('close', (code) => {
+        if (boardKey) this._decBoard(boardKey);
+        this.completedWorkers.push({
+          cardId: task.cardId,
+          startedAt: worker.startedAt,
+          finishedAt: Date.now(),
+          runtimeMs: Date.now() - worker.startedAt,
+          exitCode: code,
+          output: worker.output.slice(-50),
+        });
+        if (this.completedWorkers.length > 10) this.completedWorkers.shift();
+        this.log(code === 0 ? 'info' : 'warn', task.cardId, `Worker finished (exit ${code}, ${Math.round((Date.now() - worker.startedAt) / 1000)}s)`);
+        this._processQueue();
+      });
+    }
+  }
+
+  _writeStatus() {
+    try {
+      const workers = getActiveWorkers();
+      const status = {
+        timestamp: new Date().toISOString(),
+        paused: this.paused,
+        workers: Array.from(workers.entries()).map(([cardId, w]) => ({
+          cardId,
+          startedAt: new Date(w.startedAt).toISOString(),
+          runtimeMs: Date.now() - w.startedAt,
+          lastOutputMs: Date.now() - w.lastOutput,
+          outputTail: w.output.slice(-30),
+          exitCode: w.exitCode,
+        })),
+        queue: this.queue.map(q => ({
+          cardId: q.cardId,
+          priority: q.priority,
+          waitingMs: Date.now() - q.addedAt,
+        })),
+        recentEvents: this.eventLog.slice(-20),
+      };
+      fs.writeFileSync(getStatusPath(), JSON.stringify(status, null, 2));
+    } catch {
+      // Non-critical, ignore
+    }
+  }
+
+  log(type, cardId, message, { triggered, boardId } = {}) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      type,
+      cardId,
+      message,
+    };
+    if (triggered !== undefined) entry.triggered = triggered;
+    if (boardId) entry.boardId = boardId;
+    this.eventLog.push(entry);
+    // Keep last 200 entries
+    if (this.eventLog.length > 200) this.eventLog.shift();
+
+    const prefix = cardId ? `[${cardId.substring(0, 8)}]` : '[admin]';
+    const color = type === 'warn' ? chalk.yellow : type === 'error' ? chalk.red : chalk.dim;
+    console.log(color(`${prefix} ${message}`));
+  }
+
+  getStatus() {
+    const workers = getActiveWorkers();
+    return {
+      paused: this.paused,
+      activeWorkers: workers.size,
+      queueLength: this.queue.length,
+      maxConcurrent: this.maxConcurrent,
+      workers: Array.from(workers.entries()).map(([cardId, w]) => ({
+        cardId,
+        runtimeMs: Date.now() - w.startedAt,
+        lastOutputMs: Date.now() - w.lastOutput,
+        outputTail: w.output.slice(-30),
+      })),
+      queue: this.queue.map(q => ({
+        cardId: q.cardId,
+        priority: q.priority,
+        waitingMs: Date.now() - q.addedAt,
+      })),
+      completedWorkers: this.completedWorkers.slice(-10),
+    };
+  }
+
+  getEventLog(limit = 50) {
+    return this.eventLog.slice(-limit);
+  }
+
+  pause() {
+    this.paused = true;
+    this.log('info', null, 'Agent controller paused');
+  }
+
+  resume() {
+    this.paused = false;
+    this.log('info', null, 'Agent controller resumed');
+    this._processQueue();
+  }
+}
+
+export default AgentController;

package/src/lib/api.js

@@ -0,0 +1,225 @@
+import { getToken, getServerUrl, loadGlobalConfig, saveGlobalConfig } from './config.js';
+
+class KanonAPI {
+  constructor() {
+    this._token = null;
+  }
+
+  get token() {
+    if (!this._token) this._token = getToken();
+    return this._token;
+  }
+
+  set token(val) {
+    this._token = val;
+  }
+
+  get baseUrl() {
+    return getServerUrl() + '/api';
+  }
+
+  async request(method, path, body = null, retried = false) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { 'Content-Type': 'application/json' };
+    if (this.token) headers['Authorization'] = `Bearer ${this.token}`;
+
+    const opts = { method, headers };
+    if (body) opts.body = JSON.stringify(body);
+
+    const res = await fetch(url, opts);
+
+    // Auto re-login on 401
+    if (res.status === 401 && !retried) {
+      const refreshed = await this.tryRefreshToken();
+      if (refreshed) return this.request(method, path, body, true);
+    }
+
+    if (!res.ok) {
+      const text = await res.text();
+      let message;
+      try { message = JSON.parse(text).error; } catch { message = text; }
+      throw new Error(`${method} ${path} failed (${res.status}): ${message}`);
+    }
+
+    const text = await res.text();
+    if (!text) return {};
+    return JSON.parse(text);
+  }
+
+  async tryRefreshToken() {
+    const config = loadGlobalConfig();
+    if (!config.email || !config.password) return false;
+    try {
+      const res = await fetch(`${this.baseUrl}/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email: config.email, password: config.password }),
+      });
+      if (!res.ok) return false;
+      const data = await res.json();
+      this.token = data.token;
+      saveGlobalConfig({ ...config, token: data.token });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // --- Auth ---
+
+  async login(email, password) {
+    const res = await fetch(`${this.baseUrl}/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      throw new Error(data.error || `Login failed (${res.status})`);
+    }
+    return res.json();
+  }
+
+  // --- Teams & Boards ---
+
+  async getTeams() {
+    return this.request('GET', '/teams');
+  }
+
+  async getBoard(boardId, { cardFields = 'essential', cardLimit = 20 } = {}) {
+    return this.request('GET', `/boards/${boardId}?card_fields=${cardFields}&card_limit=${cardLimit}`);
+  }
+
+  // --- Cards ---
+
+  async getCard(cardId) {
+    return this.request('GET', `/cards/${cardId}`);
+  }
+
+  async updateCard(cardId, data) {
+    return this.request('PUT', `/cards/${cardId}?minimal=true`, data);
+  }
+
+  async moveCard(cardId, listId, position = 0) {
+    return this.request('PUT', `/cards/${cardId}/move`, { listId, position });
+  }
+
+  async createCard(listId, data) {
+    return this.request('POST', `/lists/${listId}/cards`, data);
+  }
+
+  // --- Labels ---
+
+  async addLabel(cardId, labelId) {
+    return this.request('POST', `/cards/${cardId}/labels/${labelId}`);
+  }
+
+  async removeLabel(cardId, labelId) {
+    return this.request('DELETE', `/cards/${cardId}/labels/${labelId}`);
+  }
+
+  // --- Comments ---
+
+  async addComment(cardId, text) {
+    return this.request('POST', `/cards/${cardId}/comments`, { text });
+  }
+
+  // --- Assignees ---
+
+  async addAssignee(cardId, userId) {
+    return this.request('POST', `/cards/${cardId}/assignees/${userId}`);
+  }
+
+  async removeAssignee(cardId, userId) {
+    return this.request('DELETE', `/cards/${cardId}/assignees/${userId}`);
+  }
+
+  // --- Checklists ---
+
+  async createChecklist(cardId, title) {
+    return this.request('POST', `/cards/${cardId}/checklists`, { title });
+  }
+
+  async addChecklistItem(checklistId, text) {
+    return this.request('POST', `/checklists/${checklistId}/items`, { text });
+  }
+
+  async toggleChecklistItem(itemId) {
+    return this.request('POST', `/checklist-items/${itemId}/toggle`);
+  }
+
+  // --- Archive ---
+  async archiveCard(cardId) {
+    return this.request('PUT', `/cards/${cardId}/archive`);
+  }
+
+  // --- Lists ---
+  async createList(boardId, title, position) {
+    const body = { title };
+    if (position !== undefined) body.position = position;
+    return this.request('POST', `/boards/${boardId}/lists`, body);
+  }
+
+  async updateList(listId, data) {
+    return this.request('PUT', `/lists/${listId}`, data);
+  }
+
+  // --- Board Labels ---
+  async createBoardLabel(boardId, name, color) {
+    return this.request('POST', `/boards/${boardId}/labels`, { name, color });
+  }
+
+  // --- Checklist Items ---
+  async updateChecklistItem(itemId, data) {
+    return this.request('PUT', `/checklist-items/${itemId}`, data);
+  }
+
+  async deleteChecklistItem(itemId) {
+    return this.request('DELETE', `/checklist-items/${itemId}`);
+  }
+
+  // --- Attachments (mounted under /boards/ on the server) ---
+  async getAttachments(cardId) {
+    return this.request('GET', `/boards/cards/${cardId}/attachments`);
+  }
+
+  async getAttachmentUrl(cardId, attachmentId) {
+    return this.request('GET', `/boards/cards/${cardId}/attachments/${attachmentId}/url`);
+  }
+
+  async deleteAttachment(cardId, attachmentId) {
+    return this.request('DELETE', `/boards/cards/${cardId}/attachments/${attachmentId}`);
+  }
+
+  async uploadAttachment(cardId, filePath) {
+    const fs = await import('fs');
+    const path = await import('path');
+    const filename = path.default.basename(filePath);
+    const fileBuffer = fs.default.readFileSync(filePath);
+
+    const boundary = '----KanonCLI' + Date.now();
+    const body = Buffer.concat([
+      Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\r\nContent-Type: application/octet-stream\r\n\r\n`),
+      fileBuffer,
+      Buffer.from(`\r\n--${boundary}--\r\n`),
+    ]);
+
+    const url = `${this.baseUrl}/boards/cards/${cardId}/attachments`;
+    const headers = {
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+      'Authorization': `Bearer ${this.token}`,
+    };
+
+    const res = await fetch(url, { method: 'POST', headers, body });
+    if (!res.ok) {
+      const text = await res.text();
+      let msg;
+      try { msg = JSON.parse(text).error; } catch { msg = text; }
+      throw new Error(`Upload failed (${res.status}): ${msg}`);
+    }
+    return res.json();
+  }
+}
+
+export const api = new KanonAPI();
+export default api;