bus-agent 2.3.0

package/coco-cli.js

@@ -0,0 +1,1002 @@
+#!/usr/bin/env node
+/**
+ * CoCo CLI v2.1 — Direct bus interface for CLI agents
+ *
+ * No MCP needed. Direct file access to the CoCo Agent Bus.
+ *
+ * Usage:
+ *   node coco-cli.js agents                          # List all agents (with filters)
+ *   node coco-cli.js whoami                          # Show your agent identity
+ *   node coco-cli.js inbox [agent]                   # Show inbox messages
+ *   node coco-cli.js send <to> <message>             # Send a message
+ *   node coco-cli.js reply <msg-id> <message>        # Reply to a message
+ *   node coco-cli.js profile [agent]                 # Show profile
+ *   node coco-cli.js profile edit --status busy       # Edit your profile
+ *   node coco-cli.js search <query>                  # Search agents
+ *   node coco-cli.js status                          # Show CoCo + your agent status
+ *   node coco-cli.js subscribe <channel>             # Listen to channel messages
+ *   node coco-cli.js channel list|send|history       # Channel operations
+ *   node coco-cli.js events [since]                  # View system events
+ *   node coco-cli.js watch [agent]                   # Watch for new messages
+ */
+const path = require('path');
+const fs = require('fs');
+
+const BUS_DIR = path.join(__dirname, '.bus');
+const AGENTS_FILE = path.join(BUS_DIR, 'agents.json');
+const MSGS_DIR = path.join(BUS_DIR, 'messages');
+const CHANNELS_DIR = path.join(BUS_DIR, 'channels');
+const EVENTS_DIR = path.join(BUS_DIR, 'events');
+
+const args = process.argv.slice(2);
+const cmd = args[0] || 'help';
+
+function main() {
+  switch (cmd) {
+    case 'whoami':
+      return cmdWhoami();
+    case 'agents':
+    case 'ls':
+      return cmdAgents(args.slice(1));
+    case 'inbox':
+    case 'messages':
+      return cmdInbox(args[1], args.slice(2));
+    case 'send':
+      return cmdSend(args[1], args.slice(2).join(' '));
+    case 'reply':
+      return cmdReply(args[1], args.slice(2).join(' '));
+    case 'profile':
+      return cmdProfile(args.slice(1));
+    case 'search':
+      return cmdSearch(args.slice(1).join(' '));
+    case 'status':
+      return cmdStatus();
+    case 'subscribe':
+      return cmdSubscribe(args[1]);
+    case 'channel':
+      return cmdChannel(args.slice(1));
+    case 'doctor':
+      return cmdDoctor(args.slice(1));
+    case 'tunnel':
+      return cmdTunnel(args.slice(1));
+    case 'backup':
+      return cmdBackup(args.slice(1));
+    case 'memory':
+      cmdMemory(args.slice(1)).catch(e => console.error('Error:', e.message));
+      return;
+    case 'events':
+      return cmdEvents(args[1]);
+    case 'watch':
+      return cmdWatch(args[1]);
+    case 'help':
+    default:
+      return cmdHelp();
+  }
+}
+
+// ── Whoami ──
+
+function cmdWhoami() {
+  const agents = loadAgents();
+  const name = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const seen = agents[name];
+  const profile = seen || {};
+  console.log(`\n👤 Your Agent Identity:`);
+  console.log(`   Name:        ${name}`);
+  console.log(`   Registered:  ${seen ? '✅ yes' : '❌ no'}`);
+  console.log(`   Status:      ${profile.status || 'unknown'}`);
+  console.log(`   Capabilities:${(profile.capabilities || []).join(', ') || 'none'}`);
+  console.log(`   Model:       ${profile.model ? `${profile.model.provider}/${profile.model.name}` : 'not set'}`);
+  if (profile.last_seen) console.log(`   Last seen:   ${profile.last_seen}`);
+  console.log();
+}
+
+// ── Agents (enhanced with filters) ──
+
+function cmdAgents(filterArgs) {
+  const agents = loadAgents();
+  const now = Date.now();
+  const cutoff = now - 300000;
+  let list = Object.entries(agents);
+
+  // Parse filter args
+  const filters = {};
+  for (let i = 0; i < filterArgs.length; i++) {
+    if (filterArgs[i] === '--online') filters.online = true;
+    else if (filterArgs[i] === '--capability' || filterArgs[i] === '-c') filters.capability = filterArgs[++i];
+    else if (filterArgs[i] === '--tag' || filterArgs[i] === '-t') filters.tag = filterArgs[++i];
+    else if (filterArgs[i] === '--status' || filterArgs[i] === '-s') filters.status = filterArgs[++i];
+    else if (filterArgs[i] === '--search') filters.search = filterArgs[++i];
+    else if (filterArgs[i] === '--model' || filterArgs[i] === '-m') filters.model = filterArgs[++i];
+  }
+
+  if (filters.online) list = list.filter(([, a]) => new Date(a.last_seen).getTime() > cutoff);
+  if (filters.status) list = list.filter(([, a]) => a.status === filters.status);
+  if (filters.capability) list = list.filter(([, a]) => (a.capabilities || []).some(c => c.toLowerCase().includes(filters.capability.toLowerCase())));
+  if (filters.tag) list = list.filter(([, a]) => (a.tags || []).some(t => t.toLowerCase() === filters.tag.toLowerCase()));
+  if (filters.model) list = list.filter(([, a]) => {
+    const m = a.model?.name || a.model?.provider || '';
+    return m.toLowerCase().includes(filters.model.toLowerCase());
+  });
+  if (filters.search) list = list.filter(([, a]) =>
+    a.name.toLowerCase().includes(filters.search.toLowerCase()) ||
+    (a.description || '').toLowerCase().includes(filters.search.toLowerCase())
+  );
+
+  console.log(`\n🤖 Agents on CoCo Bus (${list.length} total):`);
+  console.log('─'.repeat(70));
+
+  list.sort((a, b) => new Date(b[1].last_seen) - new Date(a[1].last_seen));
+
+  for (const [name, info] of list) {
+    const online = new Date(info.last_seen).getTime() > cutoff;
+    const statusIcon = online ? '🟢' : '⚫';
+    const statusLabel = info.status || (online ? 'idle' : 'offline');
+    const ago = msAgo(new Date(info.last_seen).getTime());
+    const caps = info.capabilities && info.capabilities.length > 0
+      ? ` [${info.capabilities.slice(0, 3).join(', ')}${info.capabilities.length > 3 ? '...' : ''}]`
+      : '';
+    const model = info.model ? ` (${info.model.provider || '?'}/${info.model.name || '?'})` : '';
+    console.log(`  ${statusIcon} ${name.padEnd(18)} ${statusLabel.padEnd(8)}${model}${caps}`);
+    if (info.description) console.log(`     ${' '.repeat(18)} ${info.description.substring(0, 50)}`);
+    console.log(`     ${' '.repeat(18)} ${ago}`);
+  }
+  console.log();
+}
+
+// ── Inbox (enhanced with --from filter) ──
+
+function cmdInbox(agentName, extra) {
+  const agent = agentName || process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const dir = path.join(MSGS_DIR, agent);
+
+  const opts = { from: null, unread: false };
+  for (let i = 0; i < (extra || []).length; i++) {
+    if (extra[i] === '--from') opts.from = extra[++i];
+    if (extra[i] === '--unread') opts.unread = true;
+  }
+
+  if (!fs.existsSync(dir)) {
+    console.log(`📭 No messages for "${agent}"`);
+    return;
+  }
+  let files = fs.readdirSync(dir).filter(f => f.endsWith('.json')).sort();
+
+  if (opts.from) {
+    files = files.filter(f => {
+      try {
+        const m = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+        return m.from === opts.from;
+      } catch { return false; }
+    });
+  }
+
+  if (files.length === 0) {
+    console.log(`📭 No messages for "${agent}"`);
+    return;
+  }
+
+  const showCount = opts.unread ? undefined : files.length;
+  const showFiles = opts.unread ? files.slice(-10) : files;
+
+  console.log(`\n📬 Inbox for "${agent}" (${files.length} total):`);
+  console.log('─'.repeat(70));
+  for (const f of showFiles) {
+    try {
+      const msg = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+      const ago = msAgo(new Date(msg.timestamp).getTime());
+      const tag = msg.metadata?.type === 'system_event' ? '🔔' :
+                  msg.metadata?.type === 'system_welcome' ? '👋' :
+                  msg.metadata?.channel ? '📢' : '📩';
+      console.log(`  ${tag} [${msg.id.substring(0, 16)}] from:${msg.from}`);
+      console.log(`      ${msg.message.substring(0, 100)}`);
+      console.log(`      ${ago}`);
+      if (msg.metadata?.channel) console.log(`      (via channel: ${msg.metadata.channel})`);
+      console.log();
+    } catch {}
+  }
+}
+
+// ── Send / Reply (unchanged) ──
+
+function cmdSend(to, text) {
+  if (!to || !text) {
+    console.log('Usage: node coco-cli.js send <to> <message>');
+    process.exit(1);
+  }
+  const from = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const msg = {
+    id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+    from,
+    to,
+    message: text,
+    timestamp: new Date().toISOString(),
+  };
+  const inboxDir = path.join(MSGS_DIR, to);
+  if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+  fs.writeFileSync(path.join(inboxDir, `${msg.id}.json`), JSON.stringify(msg, null, 2), 'utf-8');
+  console.log(`✅ Message sent to "${to}" (id: ${msg.id})`);
+}
+
+function cmdReply(msgId, text) {
+  if (!msgId || !text) {
+    console.log('Usage: node coco-cli.js reply <msg-id> <message>');
+    process.exit(1);
+  }
+  const from = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+
+  let original = null;
+  if (fs.existsSync(MSGS_DIR)) {
+    const dirs = fs.readdirSync(MSGS_DIR);
+    for (const d of dirs) {
+      const attempts = [`${msgId}.json`, msgId];
+      for (const a of attempts) {
+        const p = path.join(MSGS_DIR, d, a);
+        if (fs.existsSync(p)) {
+          try { original = JSON.parse(fs.readFileSync(p, 'utf-8')); break; } catch {}
+        }
+      }
+      if (original) break;
+    }
+  }
+  if (!original) {
+    console.log(`❌ Message "${msgId}" not found`);
+    process.exit(1);
+  }
+
+  const reply = {
+    id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+    from,
+    to: original.from,
+    message: text,
+    in_reply_to: msgId,
+    timestamp: new Date().toISOString(),
+  };
+
+  const inboxDir = path.join(MSGS_DIR, original.from);
+  if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+  fs.writeFileSync(path.join(inboxDir, `${reply.id}.json`), JSON.stringify(reply, null, 2), 'utf-8');
+  console.log(`✅ Reply sent to "${original.from}" (id: ${reply.id})`);
+}
+
+// ── Profile (new) ──
+
+function cmdProfile(subArgs) {
+  if (subArgs[0] === 'edit') {
+    return cmdProfileEdit(subArgs.slice(1));
+  }
+
+  const agentName = subArgs[0] || process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const agents = loadAgents();
+  const profile = agents[agentName];
+
+  if (!profile) {
+    console.log(`❌ Agent "${agentName}" not found on bus`);
+    return;
+  }
+
+  console.log(`\n👤 Profile: ${agentName}`);
+  console.log('─'.repeat(50));
+  console.log(`  Description:   ${profile.description || '(none)'}`);
+  console.log(`  Status:        ${profile.status || 'unknown'}`);
+  console.log(`  Version:       ${profile.version || '?'}`);
+  console.log(`  Model:         ${profile.model ? `${profile.model.provider}/${profile.model.name}` : 'not set'}`);
+  if (profile.model?.context_window) console.log(`  Context:       ${profile.model.context_window} tokens`);
+  console.log(`  Capabilities:  ${(profile.capabilities || []).join(', ') || '(none)'}`);
+  console.log(`  Tags:          ${(profile.tags || []).join(', ') || '(none)'}`);
+  console.log(`  Tools:         ${(profile.tools || []).slice(0, 10).join(', ') || '(none)'}`);
+  if (profile.endpoints) {
+    const eps = Object.entries(profile.endpoints).filter(([, v]) => v).map(([k, v]) => `${k}:${v}`);
+    if (eps.length) console.log(`  Endpoints:     ${eps.join(', ')}`);
+  }
+  console.log(`  Last seen:     ${profile.last_seen || 'never'}`);
+  console.log(`  Registered:    ${profile.registered_at || 'never'}`);
+  console.log();
+}
+
+function cmdProfileEdit(edits) {
+  const name = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const agents = loadAgents();
+  if (!agents[name]) {
+    console.log(`❌ Not registered. Register first with: send or whoami`);
+    return;
+  }
+
+  const profile = agents[name];
+  for (let i = 0; i < edits.length; i++) {
+    switch (edits[i]) {
+      case '--status':
+        profile.status = edits[++i];
+        break;
+      case '--description':
+      case '--desc':
+        profile.description = edits[++i];
+        break;
+      case '--capabilities':
+      case '--caps':
+        profile.capabilities = edits[++i].split(',');
+        break;
+      case '--tags':
+        profile.tags = edits[++i].split(',');
+        break;
+      case '--version':
+      case '-v':
+        profile.version = edits[++i];
+        break;
+      case '--model':
+        const modelStr = edits[++i];
+        const parts = modelStr.split('/');
+        profile.model = { provider: parts[0] || 'unknown', name: parts[1] || parts[0] || 'unknown' };
+        break;
+    }
+  }
+
+  profile.last_seen = new Date().toISOString();
+  fs.writeFileSync(AGENTS_FILE, JSON.stringify(agents, null, 2), 'utf-8');
+  console.log(`✅ Profile updated for "${name}"`);
+}
+
+// ── Search (new) ──
+
+function cmdSearch(query) {
+  if (!query) {
+    console.log('Usage: node coco-cli.js search <query>');
+    console.log('Searches agent names, descriptions, capabilities, and tags');
+    return;
+  }
+
+  const agents = loadAgents();
+  const q = query.toLowerCase();
+  const results = Object.entries(agents).filter(([name, info]) =>
+    name.toLowerCase().includes(q) ||
+    (info.description || '').toLowerCase().includes(q) ||
+    (info.capabilities || []).some(c => c.toLowerCase().includes(q)) ||
+    (info.tags || []).some(t => t.toLowerCase().includes(q))
+  );
+
+  console.log(`\n🔍 Search results for "${query}" (${results.length} matches):`);
+  console.log('─'.repeat(50));
+  for (const [name, info] of results) {
+    const caps = (info.capabilities || []).slice(0, 3).join(', ');
+    console.log(`  ${name.padEnd(18)} ${caps ? `[${caps}]` : ''}`);
+    if (info.description) console.log(`  ${' '.repeat(18)} ${info.description.substring(0, 60)}`);
+  }
+  if (results.length === 0) console.log('  No matches found.');
+  console.log();
+}
+
+// ── Status (new) ──
+
+function cmdStatus() {
+  const agents = loadAgents();
+  const now = Date.now();
+  const cutoff = now - 300000;
+
+  const online = Object.entries(agents).filter(([, a]) => new Date(a.last_seen).getTime() > cutoff);
+  const offline = Object.entries(agents).filter(([, a]) => new Date(a.last_seen).getTime() <= cutoff);
+
+  const myName = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const me = agents[myName];
+  const myOnline = me && new Date(me.last_seen).getTime() > cutoff;
+
+  // Count bus files
+  const msgCount = fs.existsSync(MSGS_DIR)
+    ? fs.readdirSync(MSGS_DIR).filter(d => !d.endsWith('_outbox')).reduce((sum, d) => {
+        const p = path.join(MSGS_DIR, d);
+        return sum + (fs.existsSync(p) ? fs.readdirSync(p).filter(f => f.endsWith('.json')).length : 0);
+      }, 0) : 0;
+
+  const chCount = fs.existsSync(CHANNELS_DIR)
+    ? fs.readdirSync(CHANNELS_DIR).filter(f => f.endsWith('.json')).length : 0;
+
+  console.log(`
+╔══════════════════════════════════════════╗
+║     MCP CoCo — Agent Bus Status         ║
+╚══════════════════════════════════════════╝`);
+  console.log(`  You:            ${myName} ${myOnline ? '🟢 online' : '⚫ offline'}`);
+  console.log(`  Bus agents:     ${Object.keys(agents).length} total (${online.length} online, ${offline.length} offline)`);
+  console.log(`  Messages:       ${msgCount} unread across all agents`);
+  console.log(`  Channels:       ${chCount}`);
+  console.log(`  Bus directory:  ${BUS_DIR}`);
+  console.log();
+
+  // Show online agents
+  if (online.length > 0) {
+    console.log('  🟢 Online agents:');
+    for (const [name, info] of online) {
+      const ago = msAgo(new Date(info.last_seen).getTime());
+      const caps = info.capabilities && info.capabilities.length > 0
+        ? ` [${info.capabilities.slice(0, 2).join(', ')}${info.capabilities.length > 2 ? '...' : ''}]`
+        : '';
+      const model = info.model ? ` (${info.model.provider || '?'}/${info.model.name || '?'})` : '';
+      console.log(`     ${name.padEnd(18)}${model}${caps}  (${ago})`);
+    }
+    console.log();
+  }
+}
+
+// ── Subscribe (new) ──
+
+function cmdSubscribe(channelId) {
+  if (!channelId) {
+    console.log('Usage: node coco-cli.js subscribe <channel>');
+    console.log('Listens to channel messages in real-time.');
+    process.exit(1);
+  }
+
+  const chPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+  if (!fs.existsSync(chPath)) {
+    console.log(`❌ Channel "${channelId}" not found. Create it first.`);
+    return;
+  }
+
+  const logDir = path.join(CHANNELS_DIR, channelId, 'log');
+  if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+
+  const myName = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+
+  // Join if not already
+  const ch = JSON.parse(fs.readFileSync(chPath, 'utf-8'));
+  if (!ch.members.includes(myName)) {
+    ch.members.push(myName);
+    fs.writeFileSync(chPath, JSON.stringify(ch, null, 2), 'utf-8');
+  }
+
+  // Get initial history
+  const files = fs.readdirSync(logDir).filter(f => f.endsWith('.json')).sort();
+  const seenIds = new Set(files);
+
+  console.log(`\n👂 Subscribed to #${channelId} as "${myName}"`);
+  console.log(`   ${ch.members.length} members: ${ch.members.join(', ')}`);
+  console.log(`   Waiting for new messages... (Ctrl+C to stop)\n`);
+
+  // Show last few messages
+  const recent = files.slice(-5);
+  if (recent.length > 0) {
+    console.log('  Recent messages:');
+    for (const f of recent) {
+      try {
+        const msg = JSON.parse(fs.readFileSync(path.join(logDir, f), 'utf-8'));
+        const ago = msAgo(new Date(msg.timestamp).getTime());
+        console.log(`    [${msg.from}] ${msg.message.substring(0, 100)}  (${ago})`);
+      } catch {}
+    }
+    console.log();
+  }
+
+  const interval = setInterval(() => {
+    const currentFiles = fs.readdirSync(logDir).filter(f => f.endsWith('.json'));
+    for (const f of currentFiles) {
+      if (!seenIds.has(f)) {
+        seenIds.add(f);
+        try {
+          const msg = JSON.parse(fs.readFileSync(path.join(logDir, f), 'utf-8'));
+          const ago = msAgo(new Date(msg.timestamp).getTime());
+          process.stdout.write(`  💬 [${msg.from}] ${msg.message.substring(0, 120)}\n`);
+          process.stdout.write(`     ${ago}\n\n`);
+        } catch {}
+      }
+    }
+  }, 2000);
+
+  // Also watch DM inbox for channel messages
+  const inboxDir = path.join(MSGS_DIR, myName);
+  if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+  let lastMsgCount = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json')).length;
+
+  const msgInterval = setInterval(() => {
+    const currentMsgs = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json'));
+    if (currentMsgs.length > lastMsgCount) {
+      const newMsgs = currentMsgs.slice(lastMsgCount - currentMsgs.length);
+      for (const f of newMsgs) {
+        try {
+          const msg = JSON.parse(fs.readFileSync(path.join(inboxDir, f), 'utf-8'));
+          if (msg.metadata?.channel === channelId) {
+            process.stdout.write(`  💬 [${msg.from}] ${msg.message.replace(`[${channelId}] `, '')}\n`);
+          }
+        } catch {}
+      }
+      lastMsgCount = currentMsgs.length;
+    }
+  }, 2000);
+
+  process.on('SIGINT', () => {
+    clearInterval(interval);
+    clearInterval(msgInterval);
+    process.stdout.write('👋 Unsubscribed.\n');
+    process.exit(0);
+  });
+}
+
+// ── Events (new) ──
+
+function cmdEvents(since) {
+  const today = new Date().toISOString().slice(0, 10);
+  const eventsFile = path.join(EVENTS_DIR, `${today}.jsonl`);
+  if (!fs.existsSync(eventsFile)) {
+    console.log('No events today.');
+    return;
+  }
+
+  const lines = fs.readFileSync(eventsFile, 'utf-8').split('\n').filter(Boolean);
+  let events = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+
+  if (since) {
+    const sinceTs = new Date(since).getTime();
+    events = events.filter(e => new Date(e.timestamp).getTime() >= sinceTs);
+  }
+
+  events = events.slice(-50);
+
+  if (events.length === 0) {
+    console.log('No matching events.');
+    return;
+  }
+
+  console.log(`\n📋 System Events (${events.length} shown):`);
+  console.log('─'.repeat(60));
+  for (const ev of events) {
+    const ago = msAgo(new Date(ev.timestamp).getTime());
+    const icon = ev.type === 'agent_joined' ? '🟢' :
+                 ev.type === 'agent_offline' ? '⚫' :
+                 ev.type === 'welcome_sent' ? '👋' :
+                 ev.type === 'channel_created' ? '📢' :
+                 ev.type === 'profile_updated' ? '✏️' :
+                 ev.type === 'status_change' ? '🔄' : '📌';
+    console.log(`  ${icon} ${ev.type.padEnd(20)} ${ev.data?.agent || ev.data?.channel || ''}  (${ago})`);
+    if (ev.data?.reason) console.log(`     reason: ${ev.data.reason}`);
+  }
+  console.log();
+}
+
+// ── Channel ──
+
+function cmdChannel(subArgs) {
+  const sub = subArgs[0] || 'list';
+
+  if (sub === 'list') {
+    if (!fs.existsSync(CHANNELS_DIR)) {
+      console.log('No channels');
+      return;
+    }
+    const files = fs.readdirSync(CHANNELS_DIR).filter(f => f.endsWith('.json'));
+    console.log('\n📢 Channels:');
+    console.log('─'.repeat(50));
+    for (const f of files) {
+      const ch = JSON.parse(fs.readFileSync(path.join(CHANNELS_DIR, f), 'utf-8'));
+      console.log(`  ${ch.id.padEnd(20)} ${ch.topic || ''}  (${ch.members.length} members)`);
+    }
+    console.log();
+    return;
+  }
+
+  if (sub === 'create') {
+    const chId = subArgs[1];
+    const topic = subArgs.slice(2).join(' ') || '';
+    if (!chId) { console.log('Usage: node coco-cli.js channel create <name> [topic]'); return; }
+    const ch = { id: chId, topic, created_by: process.env.COCO_AGENT || 'cli', created_at: new Date().toISOString(), members: [] };
+    fs.writeFileSync(path.join(CHANNELS_DIR, `${chId}.json`), JSON.stringify(ch, null, 2), 'utf-8');
+    console.log(`✅ Channel "#${chId}" created`);
+    return;
+  }
+
+  if (sub === 'join') {
+    const chId = subArgs[1];
+    const agentName = subArgs[2] || process.env.COCO_AGENT || process.env.USER || 'anonymous';
+    if (!chId) { console.log('Usage: node coco-cli.js channel join <name> [agent]'); return; }
+    const chPath = path.join(CHANNELS_DIR, `${chId}.json`);
+    if (!fs.existsSync(chPath)) { console.log(`❌ Channel "${chId}" not found`); return; }
+    const ch = JSON.parse(fs.readFileSync(chPath, 'utf-8'));
+    if (!ch.members.includes(agentName)) ch.members.push(agentName);
+    fs.writeFileSync(chPath, JSON.stringify(ch, null, 2), 'utf-8');
+    console.log(`✅ Joined channel "#${chId}" as "${agentName}"`);
+    return;
+  }
+
+  if (sub === 'send') {
+    const channelId = subArgs[1];
+    const text = subArgs.slice(2).join(' ');
+    if (!channelId || !text) {
+      console.log('Usage: node coco-cli.js channel send <channel> <message>');
+      return;
+    }
+    const from = process.env.COCO_AGENT || process.env.USER || 'anonymous';
+    const chPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+    if (!fs.existsSync(chPath)) {
+      console.log(`❌ Channel "${channelId}" not found`);
+      return;
+    }
+
+    const channel = JSON.parse(fs.readFileSync(chPath, 'utf-8'));
+    const msg = {
+      id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+      channel: channelId,
+      from,
+      message: text,
+      timestamp: new Date().toISOString(),
+    };
+
+    const logDir = path.join(CHANNELS_DIR, channelId, 'log');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.writeFileSync(path.join(logDir, `${msg.id}.json`), JSON.stringify(msg, null, 2), 'utf-8');
+
+    for (const member of channel.members) {
+      if (member !== from) {
+        const memberInbox = path.join(MSGS_DIR, member);
+        if (!fs.existsSync(memberInbox)) fs.mkdirSync(memberInbox, { recursive: true });
+        const dm = { ...msg, to: member, metadata: { channel: channelId } };
+        fs.writeFileSync(path.join(memberInbox, `${msg.id}.json`), JSON.stringify(dm, null, 2), 'utf-8');
+      }
+    }
+    console.log(`✅ Sent to channel "#${channelId}" (${channel.members.length - 1} members notified)`);
+    return;
+  }
+
+  if (sub === 'log' || sub === 'history') {
+    const channelId = subArgs[1];
+    const logDir = path.join(CHANNELS_DIR, channelId, 'log');
+    if (!fs.existsSync(logDir)) {
+      console.log(`No messages in channel "#${channelId}"`);
+      return;
+    }
+    const files = fs.readdirSync(logDir).filter(f => f.endsWith('.json')).sort().slice(-20);
+    console.log(`\n📢 Channel "#${channelId}" history:`);
+    console.log('─'.repeat(60));
+    for (const f of files) {
+      const msg = JSON.parse(fs.readFileSync(path.join(logDir, f), 'utf-8'));
+      const ago = msAgo(new Date(msg.timestamp).getTime());
+      console.log(`  [${msg.from}] ${msg.message.substring(0, 100)}  (${ago})`);
+    }
+    console.log();
+    return;
+  }
+}
+
+// ── Watch ──
+
+function cmdWatch(agentName) {
+  const agent = agentName || process.env.COCO_AGENT || process.env.USER || 'anonymous';
+  const dir = path.join(MSGS_DIR, agent);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  console.log(`👀 Watching for messages for "${agent}"... (Ctrl+C to stop)\n`);
+
+  let lastCount = fs.readdirSync(dir).filter(f => f.endsWith('.json')).length;
+
+  const interval = setInterval(() => {
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    if (files.length > lastCount) {
+      const newFiles = files.slice(lastCount - files.length);
+      for (const f of newFiles) {
+        try {
+          const msg = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+          const tag = msg.metadata?.channel ? `[#${msg.metadata.channel}]` : '';
+          console.log(`\n📩 ${tag} [${msg.from}] ${msg.message}`);
+          console.log(`   Reply: node coco-cli.js reply ${msg.id} "your message"\n`);
+        } catch {}
+      }
+      lastCount = files.length;
+    }
+  }, 2000);
+
+  process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+}
+
+// ── Doctor ──
+
+function cmdDoctor(args) {
+  const { runDiagnostics } = require('./lib/doctor');
+  const opts = {
+    busDir: BUS_DIR,
+    quick: args.includes('--quick'),
+    fix: args.includes('--fix'),
+    report: args.includes('--report'),
+    watch: args.includes('--watch'),
+  };
+  if (opts.watch) {
+    const { watchDiagnostics } = require('./lib/doctor');
+    watchDiagnostics(opts);
+  } else {
+    runDiagnostics(opts);
+  }
+}
+
+// ── Tunnel ──
+
+function cmdTunnel(args) {
+  const { startServer, startClient, startSync, printSSHHelp } = require('./lib/tunnel');
+  const mode = args[0];
+  if (!mode || mode === '--help') {
+    console.log('Usage: coco tunnel server|client|sync|ssh [options]');
+    console.log('  coco tunnel server --port 9090 --secret <token>');
+    console.log('  coco tunnel client --host <ip> --port 9090 --secret <token>');
+    console.log('  coco tunnel sync --remote http://<ip>:9090');
+    console.log('  coco tunnel ssh --remote user@host');
+    return;
+  }
+  const opts = { busDir: BUS_DIR };
+  for (let i = 1; i < args.length; i++) {
+    switch (args[i]) {
+      case '--port': opts.port = parseInt(args[++i], 10); break;
+      case '--secret': opts.secret = args[++i]; break;
+      case '--host': opts.host = args[++i]; break;
+      case '--remote': opts.remote = args[++i]; break;
+      case '--interval': opts.interval = parseInt(args[++i], 10); break;
+    }
+  }
+  switch (mode) {
+    case 'server': startServer(opts); break;
+    case 'client': startClient(opts).catch(e => console.error('Error:', e.message)); break;
+    case 'sync': startSync(opts).catch(e => console.error('Error:', e.message)); break;
+    case 'ssh': printSSHHelp(opts); break;
+    default: console.log('Unknown tunnel mode:', mode);
+  }
+}
+
+// ── Memory ──
+
+async function cmdMemory(args) {
+  const { MemoryStore } = require('./lib/memory');
+  const mem = new MemoryStore(BUS_DIR);
+  const sub = args[0];
+  if (!sub) { console.log('Usage: coco memory store|search|recall|list|forget|stats|archive|clear|configure|rebuild <args>'); return; }
+
+  try {
+    switch (sub) {
+      case 'store': {
+        const agent = args[1];
+        const content = args.slice(2).filter(a => !a.startsWith('--')).join(' ');
+        const key = args.includes('--key') ? args[args.indexOf('--key') + 1] : undefined;
+        const namespace = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : undefined;
+        const ttl = args.includes('--ttl') ? parseInt(args[args.indexOf('--ttl') + 1], 10) : undefined;
+        if (!agent || !content) { console.log('Usage: coco memory store <agent> <content> [--key] [--namespace] [--ttl]'); return; }
+        const id = await mem.store(agent, { content, key, namespace, ttl });
+        console.log('  ✅ Memory stored: ' + id);
+        break;
+      }
+      case 'search': {
+        const agent = args[1];
+        const query = args.slice(2).filter(a => !a.startsWith('--')).join(' ');
+        const limit = args.includes('--limit') ? parseInt(args[args.indexOf('--limit') + 1], 10) : 10;
+        const namespace = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : undefined;
+        if (!agent || !query) { console.log('Usage: coco memory search <agent> <query> [--limit] [--namespace]'); return; }
+        const results = await mem.search(agent, query, { limit, namespace });
+        if (results.length === 0) { console.log('  No results found.'); return; }
+        console.log('');
+        console.log('  Memory Search - ' + results.length + ' result(s) for "' + query + '":');
+        console.log('');
+        for (const r of results) {
+          const tag = r.search_type === 'vector' ? '[V]' : '[K]';
+          console.log('  ' + tag + ' [' + r.score.toFixed(2) + '] ' + r.id.substring(0, 20) + '...  ' + r.content.substring(0, 80));
+          if (r.key) console.log('       key: ' + r.key);
+          console.log('');
+        }
+        break;
+      }
+      case 'recall': {
+        const agent = args[1]; const id = args[2];
+        if (!agent || !id) { console.log('Usage: coco memory recall <agent> <id>'); return; }
+        const e = mem.recall(agent, id);
+        if (!e) { console.log('  Not found.'); return; }
+        console.log('');
+        console.log('  Memory: ' + e.id);
+        if (e.key) console.log('  Key:     ' + e.key);
+        console.log('  Namespace: ' + e.namespace);
+        console.log('  Content: ' + e.content);
+        console.log('  Stored:  ' + e.metadata.stored_at);
+        console.log('');
+        break;
+      }
+      case 'list': {
+        const agent = args[1];
+        if (!agent) { console.log('Usage: coco memory list <agent> [--namespace] [--limit] [--offset]'); return; }
+        const limit = args.includes('--limit') ? parseInt(args[args.indexOf('--limit') + 1], 10) : 50;
+        const offset = args.includes('--offset') ? parseInt(args[args.indexOf('--offset') + 1], 10) : 0;
+        const namespace = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : undefined;
+        const list = mem.list(agent, { namespace, limit, offset });
+        if (list.length === 0) { console.log('  No memories.'); return; }
+        console.log('');
+        console.log('  Memories for ' + agent + ' (' + list.length + '):');
+        console.log('');
+        for (const m of list) console.log('  ' + m.id.substring(0, 24) + '  [' + m.namespace + ']  ' + m.content.substring(0, 70));
+        console.log('');
+        break;
+      }
+      case 'forget': {
+        const agent = args[1]; const id = args[2];
+        if (!agent || !id) { console.log('Usage: coco memory forget <agent> <id>'); return; }
+        const ok = mem.forget(agent, id);
+        console.log(ok ? '  Deleted.' : '  Not found.');
+        break;
+      }
+      case 'stats': {
+        const agent = args[1];
+        if (!agent) { console.log('Usage: coco memory stats <agent>'); return; }
+        const s = mem.stats(agent);
+        console.log('');
+        console.log('  Memory Stats - ' + agent + ':');
+        console.log('');
+        console.log('  Total:     ' + s.total);
+        console.log('  Namespaces: ' + JSON.stringify(s.namespaces));
+        console.log('  Size:      ' + (s.size_bytes / 1024).toFixed(2) + ' KB');
+        console.log('  Vectors:   ' + s.vectors + ' (dim ' + s.vector_dimension + ')');
+        console.log('  Embedding: ' + s.embed_provider);
+        console.log('  Oldest:    ' + (s.oldest || 'N/A'));
+        console.log('  Newest:    ' + (s.newest || 'N/A'));
+        console.log('');
+        break;
+      }
+      case 'archive': {
+        const agent = args[1];
+        if (!agent) { console.log('Usage: coco memory archive <agent> [--max-age-days] [--no-delete]'); return; }
+        const maxAge = args.includes('--max-age-days') ? parseInt(args[args.indexOf('--max-age-days') + 1], 10) : 7;
+        const deleteAfter = !args.includes('--no-delete');
+        const r = await mem.archive(agent, { maxAgeDays: maxAge, deleteAfter });
+        console.log('  Archived ' + r.archived + ' message(s) for ' + agent + (deleteAfter ? ' (deleted originals)' : ''));
+        break;
+      }
+      case 'clear': {
+        const agent = args[1];
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : undefined;
+        if (!agent) { console.log('Usage: coco memory clear <agent> [--namespace]'); return; }
+        const count = mem.clear(agent, ns);
+        console.log('  Cleared ' + count + ' entries' + (ns ? ' in namespace "' + ns + '"' : ''));
+        break;
+      }
+      case 'configure': {
+        const provider = args.includes('--provider') ? args[args.indexOf('--provider') + 1] : undefined;
+        const endpoint = args.includes('--endpoint') ? args[args.indexOf('--endpoint') + 1] : undefined;
+        const model = args.includes('--model') ? args[args.indexOf('--model') + 1] : undefined;
+        const apiKey = args.includes('--api-key') ? args[args.indexOf('--api-key') + 1] : undefined;
+        if (!provider) { console.log('Usage: coco memory configure --provider <keyword|ollama|openai|custom> [--endpoint] [--model] [--api-key]'); return; }
+        const cfg = mem.configure({ provider, endpoint, model, api_key: apiKey });
+        console.log('  Configured: ' + cfg.provider);
+        if (cfg.model) console.log('  Model: ' + cfg.model);
+        if (cfg.endpoint) console.log('  Endpoint: ' + cfg.endpoint);
+        break;
+      }
+      case 'rebuild': {
+        const agent = args[1];
+        if (!agent) { console.log('Usage: coco memory rebuild <agent>'); return; }
+        const r = await mem.rebuildVectors(agent);
+        console.log('  Rebuilt ' + r.rebuilt + ' vectors.');
+        if (r.failed > 0) console.log('  Failed: ' + r.failed);
+        if (r.reason) console.log('  ' + r.reason);
+        break;
+      }
+      default:
+        console.log('Usage: coco memory store|search|recall|list|forget|stats|archive|clear|configure|rebuild');
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+  }
+}
+
+// ── Backup ──
+
+function cmdBackup(args) {
+  const { createBackup, restoreBackup, listBackups, backupInfo, diffBackup, cleanupBackups, autoBackup, watchMode } = require('./lib/backup');
+  const cmd = args[0];
+  try {
+    if (!cmd) { createBackup(BUS_DIR); return; }
+    switch (cmd) {
+      case '--list': listBackups(BUS_DIR); break;
+      case '--info': backupInfo(path.resolve(args[1])); break;
+      case '--restore': restoreBackup(path.resolve(args[1]), BUS_DIR); break;
+      case '--diff': diffBackup(path.resolve(args[1]), BUS_DIR); break;
+      case '--cleanup': cleanupBackups(BUS_DIR, parseInt(args[1], 10) || 30); break;
+      case '--auto': autoBackup(BUS_DIR); break;
+      case '--watch': watchMode(BUS_DIR, parseInt(args[1], 10) || 30); break;
+      default: console.log('Usage: coco backup [--list|--info|--restore|--diff|--cleanup|--auto|--watch]');
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+  }
+}
+
+// ── Help ──
+
+function cmdHelp() {
+  console.log(`
+╔═══════════════════════════════════════════════╗
+║     MCP CoCo v2.1 — CLI Agent Bus Interface  ║
+╚═══════════════════════════════════════════════╝
+
+Usage:
+  node coco-cli.js <command> [args]
+
+Commands:
+  agents [filters]                List all agents on the bus
+    filters: --online, --status, --capability, --tag, --model, --search
+
+  whoami                          Show your agent identity
+  inbox [agent] [--from X]        Check messages (default: \$COCO_AGENT)
+  send <to> <message>             Send a message to another agent
+  reply <msg-id> <message>        Reply to an incoming message
+  profile [agent]                 Show agent profile details
+  profile edit --status busy      Edit your profile fields
+  search <query>                  Search agents by name/capability/description
+  status                          Show CoCo bus health & online agents
+  subscribe <channel>             Listen to channel messages in real-time
+
+  channel list                    List all channels
+  channel create <name> [topic]   Create a channel
+  channel join <name> [agent]     Join a channel
+  channel send <name> <message>   Send to a channel
+  channel history <name>          Read channel history
+  events [since]                  View system events (agent join/leave, etc.)
+  watch [agent]                   Watch for new messages (poll every 2s)
+
+  doctor [--quick] [--fix]        Run bus diagnostics & health check
+  doctor --report                 Save report to .bus/diagnostic-report.json
+  doctor --watch                  Watch mode (check every 30s)
+
+  tunnel server [options]         Start tunnel server (receiving end)
+    --port, --secret
+  tunnel client [options]         Start tunnel client (sending end)
+    --host, --port, --secret, --interval
+  tunnel sync [options]           Bidirectional bus sync
+    --remote, --secret, --interval
+  tunnel ssh [options]            Show SSH tunnel instructions
+    --remote, --port
+
+  backup                          Create timestamped backup
+  backup --list                   List available backups
+  backup --info <file>            Show backup metadata
+  backup --restore <file>         Restore bus from backup
+  backup --diff <file>            Compare backup with current state
+  backup --cleanup [days]         Remove backups older than N days
+  backup --auto                   Backup only if changes detected
+  backup --watch <minutes>        Auto-backup every N minutes
+
+  memory store <agent> <content>  Store a memory for an agent
+    --key <key>                   Optional lookup key
+    --namespace <ns>              Namespace (default: default)
+  memory search <agent> <query>   Search agent memories
+    --limit <n>, --namespace <ns>
+  memory recall <agent> <id>      Recall a memory by ID or key
+  memory list <agent>             List memories
+    --namespace <ns>, --limit <n>, --offset <n>
+  memory forget <agent> <id>      Delete a memory
+  memory stats <agent>            Show memory statistics
+  memory archive <agent>          Archive old messages to memory
+    --max-age-days <n>, --no-delete
+  memory clear <agent>            Clear all memories for an agent
+    --namespace <ns>
+  memory configure                 Configure embedding provider for vector search
+    --provider <keyword|ollama|openai|custom> [--endpoint] [--model] [--api-key]
+  memory rebuild <agent>          Rebuild vector embeddings for all memories
+
+Environment:
+  COCO_AGENT=opencode             Set your agent name for inbox/send
+
+Examples:
+  node coco-cli.js agents --online --capability code-review
+  node coco-cli.js profile opencode
+  node coco-cli.js search web
+  node coco-cli.js status
+  node coco-cli.js subscribe dev-chat
+  node coco-cli.js channel create dev-chat "Development chat"
+`);
+}
+
+// ── Utils ──
+
+function loadAgents() {
+  try {
+    if (fs.existsSync(AGENTS_FILE)) {
+      return JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf-8'));
+    }
+  } catch {}
+  return {};
+}
+
+function msAgo(ts) {
+  const diff = Date.now() - ts;
+  if (diff < 60000) return 'just now';
+  if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+  if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+  return `${Math.floor(diff / 86400000)}d ago`;
+}
+
+main();