kanon-cli 0.1.0

package/src/commands/list.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import api from '../lib/api.js';
+import { getToken, loadProjectConfig } from '../lib/config.js';
+
+function requireAuth() {
+  if (!getToken()) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+}
+
+function getBoardId() {
+  const config = loadProjectConfig();
+  const boardId = config?.board_id;
+  if (!boardId) throw new Error('No board configured. Run: kanon init');
+  return boardId;
+}
+
+async function getBoardContext() {
+  const boardId = getBoardId();
+  const data = await api.getBoard(boardId, { cardLimit: 0 });
+  return data.board || data;
+}
+
+function resolveList(board, name) {
+  const lower = name.toLowerCase();
+  const list = (board.lists || []).find(l => l.title.toLowerCase() === lower);
+  if (!list) {
+    const available = (board.lists || []).map(l => l.title).join(', ');
+    throw new Error(`List "${name}" not found. Available: ${available}`);
+  }
+  return list;
+}
+
+// --- kanon list create "title" ---
+
+export async function listCreateCommand(title) {
+  requireAuth();
+  try {
+    const boardId = getBoardId();
+    const result = await api.createList(boardId, title);
+    const id = result.list?.id || result.id;
+    console.log(chalk.green(`List "${title}" created (${id}).`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to create list: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon list rename "old" "new" ---
+
+export async function listRenameCommand(oldName, newName) {
+  requireAuth();
+  try {
+    const board = await getBoardContext();
+    const list = resolveList(board, oldName);
+    await api.updateList(list.id, { title: newName });
+    console.log(chalk.green(`List renamed: "${oldName}" -> "${newName}".`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to rename list: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon list delete "name" (archives) ---
+
+export async function listDeleteCommand(name) {
+  requireAuth();
+  try {
+    const board = await getBoardContext();
+    const list = resolveList(board, name);
+    await api.updateList(list.id, { archived: true });
+    console.log(chalk.green(`List "${name}" archived.`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to archive list: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/login.js

@@ -0,0 +1,91 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import { loadGlobalConfig, saveGlobalConfig, getServerUrl } from '../lib/config.js';
+import api from '../lib/api.js';
+
+function prompt(rl, question, defaultVal = '') {
+  const suffix = defaultVal ? ` (${defaultVal})` : '';
+  return new Promise(resolve => {
+    rl.question(`${question}${suffix}: `, answer => {
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+function promptSecret(rl, question) {
+  return new Promise(resolve => {
+    // Use raw mode to hide password input
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+
+    process.stdout.write(`${question}: `);
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    let password = '';
+    const onData = (char) => {
+      const c = char.toString();
+      if (c === '\n' || c === '\r') {
+        stdin.setRawMode(wasRaw || false);
+        stdin.removeListener('data', onData);
+        process.stdout.write('\n');
+        resolve(password);
+      } else if (c === '\u0003') {
+        // Ctrl+C
+        process.exit(1);
+      } else if (c === '\u007f' || c === '\b') {
+        // Backspace
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          process.stdout.write('\b \b');
+        }
+      } else {
+        password += c;
+        process.stdout.write('*');
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+export async function loginCommand() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const config = loadGlobalConfig();
+
+    console.log(chalk.bold('\nKanon CLI Login\n'));
+
+    const serverUrl = await prompt(rl, 'Server URL', config.server_url || 'https://kanones.com');
+    const email = await prompt(rl, 'Email', config.email || '');
+
+    // Close readline before prompting password (raw mode conflict)
+    rl.close();
+
+    const password = await promptSecret(readline, 'Password');
+
+    console.log(chalk.dim('\nAuthenticating...'));
+
+    const data = await api.login(email, password);
+
+    saveGlobalConfig({
+      server_url: serverUrl,
+      token: data.token,
+      user_id: data.user.id,
+      user_name: data.user.name,
+      email,
+      password, // Stored for auto-refresh
+    });
+
+    console.log(chalk.green(`\nLogged in as ${chalk.bold(data.user.name)} (${data.user.email})`));
+    console.log(chalk.dim(`Token saved to ~/.kanon/config.yaml`));
+  } catch (err) {
+    rl.close();
+    console.error(chalk.red(`\nLogin failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/watch.js

@@ -0,0 +1,224 @@
+import chalk from 'chalk';
+import { KanonWebSocket } from '../lib/websocket.js';
+import { AgentController } from '../lib/admin.js';
+import { shouldTrigger, getContextFromLabels } from '../lib/pipeline.js';
+import { buildPrompt } from '../prompts/templates.js';
+import api from '../lib/api.js';
+import { killWorker } from '../lib/claude.js';
+import { getToken, getUserId, getServerUrl, loadProjectConfig, getAgentLockPath, getActiveBoardIds, getBoardConfig } from '../lib/config.js';
+import http from 'http';
+import fs from 'fs';
+
+export async function watchCommand(options) {
+  const token = getToken();
+  if (!token) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+
+  const config = loadProjectConfig();
+  const boardIds = getActiveBoardIds(config);
+  if (boardIds.length === 0) {
+    console.error(chalk.red('No active boards configured. Run: kanon init'));
+    process.exit(1);
+  }
+
+  const ownUserId = getUserId();
+  const serverUrl = getServerUrl();
+  const dryRun = options.dryRun || false;
+
+  // Cooldown tracking
+  const cooldowns = new Map();
+
+  // Agent controller (global settings, per-board max_concurrent from boards config)
+  const admin = new AgentController({
+    ...config.admin,
+    bundle_queue: config.admin?.bundle_queue ?? true,
+    _projectConfig: config,
+  });
+
+  console.log(chalk.bold('\nKanon Watch Daemon\n'));
+  console.log(`  Server:     ${chalk.cyan(serverUrl)}`);
+  console.log(`  Boards:     ${chalk.cyan(boardIds.length)} active`);
+  for (const bid of boardIds) {
+    const bc = getBoardConfig(config, bid);
+    const labelRules = (bc?.rules?.labels || []).filter(l => l.enabled !== false);
+    const eventRules = Object.entries(bc?.rules?.events || {}).filter(([, v]) => v.enabled);
+    console.log(`    ${chalk.dim(bid.substring(0, 8))} ${bc?.name || 'unnamed'}: ${labelRules.length} labels, ${eventRules.length} events`);
+  }
+  console.log(`  Dry run:    ${dryRun ? chalk.yellow('yes') : 'no'}`);
+  console.log();
+
+  // Connect WebSocket
+  const ws = new KanonWebSocket(serverUrl, token, {
+    name: 'Kanon CLI',
+    color: '#6366f1',
+  });
+
+  try {
+    console.log(chalk.dim('Connecting to WebSocket...'));
+    await ws.connect();
+    console.log(chalk.green('Connected and authenticated.\n'));
+  } catch (err) {
+    console.error(chalk.red(`Failed to connect: ${err.message}`));
+    process.exit(1);
+  }
+
+  // Join boards
+  for (const boardId of boardIds) {
+    ws.joinBoard(boardId);
+    console.log(chalk.dim(`Joined board ${boardId}`));
+  }
+
+  // Start agent controller
+  admin.start();
+
+  // Start IPC server for dashboard
+  const ipcServer = startIPCServer(admin);
+
+  // Listen for card events
+  ws.on('card_event', async (event) => {
+    const { cardId, eventType, userId, eventData, boardId } = event;
+
+    // Look up board-specific config
+    const boardConfig = getBoardConfig(config, boardId);
+    if (!boardConfig) {
+      admin.log('event', cardId, `${eventType}: no config for board ${boardId}`, { triggered: false, boardId });
+      return;
+    }
+
+    // Build a compat config object for shouldTrigger (it expects top-level rules/watch)
+    const compatConfig = {
+      watch: boardConfig.watch,
+      rules: boardConfig.rules,
+      claude: boardConfig.claude,
+      prompts: boardConfig.prompts,
+    };
+
+    // Check if this event should trigger (includes own-event filtering)
+    const result = shouldTrigger(event, compatConfig, ownUserId);
+
+    // Log all incoming events for dashboard visibility
+    const eventSummary = eventData?.label_name || eventData?.member_name || eventType;
+    admin.log('event', cardId, `${eventType}: ${eventSummary}`, { triggered: result.trigger, boardId });
+
+    if (!result.trigger) return;
+
+    // Cooldown check (per-board cooldown)
+    const cooldownSeconds = boardConfig.watch?.cooldown_seconds || 30;
+    const cooldownKey = `${boardId}:${cardId}`;
+    const lastTrigger = cooldowns.get(cooldownKey);
+    if (lastTrigger && (Date.now() - lastTrigger) < cooldownSeconds * 1000) {
+      console.log(chalk.dim(`[cooldown] Skipping card ${cardId} (${eventData?.label_name || eventType})`));
+      return;
+    }
+    cooldowns.set(cooldownKey, Date.now());
+
+    const labelName = eventData?.label_name || eventType;
+    console.log(chalk.cyan(`\n[event] ${eventType}: ${labelName} on card ${cardId} (board: ${boardConfig.name || boardId.substring(0, 8)})`));
+
+    if (dryRun) {
+      console.log(chalk.yellow(`[dry-run] Would spawn Claude for card ${cardId}`));
+      return;
+    }
+
+    // Fetch full card
+    try {
+      const cardData = await api.getCard(cardId);
+      const card = cardData.card || cardData;
+
+      console.log(chalk.dim(`  Card: "${card.title}"`));
+
+      // Scope check: if trigger is scoped to 'assigned', verify agent is assigned to this card
+      if (result.scope === 'assigned') {
+        const isAssigned = card.assignees?.some(a => a.id === ownUserId || a.user_id === ownUserId);
+        if (!isAssigned) {
+          admin.log('event', cardId, `Skipped (not assigned)`, { triggered: false, boardId });
+          return;
+        }
+      }
+
+      // Collect context from context-only labels on the card
+      const context = getContextFromLabels(card, compatConfig);
+      const combinedPrompt = [result.extraPrompt, context.extraPrompt].filter(Boolean).join('\n');
+      const combinedArgs = [result.extraArgs, context.extraArgs].filter(Boolean).join(' ');
+
+      // Build unified prompt from board config + trigger + context prompts
+      const prompt = buildPrompt(card, compatConfig, combinedPrompt);
+
+      // Merge extra args into claude config
+      const claudeConfig = { ...boardConfig.claude };
+      if (combinedArgs) {
+        claudeConfig.args = [claudeConfig.args || '', combinedArgs].filter(Boolean).join('\n');
+      }
+
+      // Enqueue via agent controller (pass card + extraPrompt for bundle mode)
+      admin.enqueue(cardId, prompt, claudeConfig, { card, extraPrompt: combinedPrompt, boardId });
+    } catch (err) {
+      console.error(chalk.red(`  Failed to process card ${cardId}: ${err.message}`));
+    }
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log(chalk.dim('\nShutting down...'));
+    admin.stop();
+    ws.disconnect();
+    ipcServer?.close();
+    cleanupLockFile();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  console.log(chalk.green('\nWatching for events. Press Ctrl+C to stop.\n'));
+}
+
+function startIPCServer(admin) {
+  const server = http.createServer((req, res) => {
+    res.setHeader('Content-Type', 'application/json');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
+
+    if (req.method === 'GET' && req.url === '/status') {
+      res.end(JSON.stringify(admin.getStatus()));
+    } else if (req.method === 'GET' && req.url === '/events') {
+      res.end(JSON.stringify(admin.getEventLog()));
+    } else if (req.method === 'POST' && req.url === '/pause') {
+      admin.pause();
+      res.end(JSON.stringify({ ok: true }));
+    } else if (req.method === 'POST' && req.url === '/resume') {
+      admin.resume();
+      res.end(JSON.stringify({ ok: true }));
+    } else if (req.method === 'POST' && req.url?.startsWith('/kill/')) {
+      const cardId = req.url.split('/kill/')[1];
+      killWorker(cardId);
+      res.end(JSON.stringify({ ok: true }));
+    } else {
+      res.statusCode = 404;
+      res.end(JSON.stringify({ error: 'not found' }));
+    }
+  });
+
+  // Listen on random port
+  server.listen(0, '127.0.0.1', () => {
+    const port = server.address().port;
+    const lockPath = getAgentLockPath();
+    fs.writeFileSync(lockPath, JSON.stringify({
+      pid: process.pid,
+      port,
+      startedAt: new Date().toISOString(),
+    }));
+    console.log(chalk.dim(`IPC server on port ${port}`));
+  });
+
+  return server;
+}
+
+function cleanupLockFile() {
+  try {
+    const lockPath = getAgentLockPath();
+    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+  } catch {}
+}