bus-agent 2.3.0

package/lib/bus.js

@@ -0,0 +1,516 @@
+/**
+ * Agent Bus — Universal MCP Agent Communication Hub v2.1
+ *
+ * Any MCP-compatible agent connects via mcporter and can:
+ * - Register with rich profile (model, capabilities, status)
+ * - Discover agents by capability/model/tags
+ * - Send/receive messages (DM, broadcast, channels)
+ * - Long-poll for new messages
+ * - Get notified when agents join/leave the bus
+ */
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+const DATA_DIR = path.join(__dirname, '..', '.bus');
+const AGENTS_FILE = path.join(DATA_DIR, 'agents.json');
+const MSGS_DIR = path.join(DATA_DIR, 'messages');
+const CHANNELS_DIR = path.join(DATA_DIR, 'channels');
+const EVENTS_DIR = path.join(DATA_DIR, 'events');
+
+const OFFLINE_TIMEOUT_MS = 300000; // 5 min
+
+class AgentBus extends EventEmitter {
+  constructor() {
+    super();
+    for (const d of [DATA_DIR, MSGS_DIR, CHANNELS_DIR, EVENTS_DIR]) {
+      if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    }
+    this._agents = this._loadJson(AGENTS_FILE, {});
+    this._waiters = {};
+    this._eventWaiters = {};
+    this._checkStaleAgents();
+  }
+
+  // ── Profile Schema ────────────────────────────────────
+  //
+  // Each agent profile includes:
+  //   name, description,
+  //   model: { provider, name, context_window },
+  //   capabilities: [string],     // e.g. ["code-review", "web-search", "chat", "filesystem"]
+  //   tags: [string],             // e.g. ["code", "ai", "bot"]
+  //   status: "idle"|"busy"|"offline",
+  //   version: string,
+  //   endpoints: { mcp?, http?, websocket? },
+  //   tools: [string],            // tools this agent exposes
+  //   last_seen, registered_at
+
+  registerAgent(name, description = '', metadata = {}) {
+    const existing = this._agents[name];
+    const profile = {
+      name,
+      description,
+      model: metadata.model || existing?.model || null,
+      capabilities: metadata.capabilities || existing?.capabilities || [],
+      tags: metadata.tags || existing?.tags || [],
+      status: metadata.status || 'idle',
+      version: metadata.version || existing?.version || '1.0.0',
+      endpoints: metadata.endpoints || existing?.endpoints || {},
+      tools: metadata.tools || existing?.tools || [],
+      metadata: metadata.metadata || existing?.metadata || {},
+      last_seen: new Date().toISOString(),
+      registered_at: existing?.registered_at || new Date().toISOString(),
+    };
+
+    const isNew = !existing;
+    this._agents[name] = profile;
+    this._saveJson(AGENTS_FILE, this._agents);
+
+    // ── Discovery Broadcast ──
+    if (isNew) {
+      this._logEvent('system', 'agent_joined', { agent: name, profile });
+      this._broadcastSystemMessage(`system:agent_joined`, name, {
+        agent: name,
+        description,
+        capabilities: metadata.capabilities || [],
+        timestamp: profile.registered_at,
+      });
+      // Send welcome DM to the new agent
+      this.sendMessage('coco', name,
+        `👋 Welcome to CoCo Bus, **${name}**!\n` +
+        `You are now connected to ${Object.keys(this._agents).length} agent(s).\n` +
+        `Try: agent_list, whoami, or send a message to another agent.`,
+        { type: 'system_welcome' }
+      );
+      this._logSystemWelcome(name);
+    }
+
+    return { registered: true, is_new: isNew, agent: profile };
+  }
+
+  updateProfile(name, updates) {
+    if (!this._agents[name]) return { ok: false, error: 'Agent not registered' };
+
+    const profile = this._agents[name];
+    const allowed = ['description', 'model', 'capabilities', 'tags', 'status', 'version', 'endpoints', 'tools', 'metadata'];
+    for (const key of allowed) {
+      if (updates[key] !== undefined) {
+        profile[key] = updates[key];
+      }
+    }
+    profile.last_seen = new Date().toISOString();
+    this._saveJson(AGENTS_FILE, this._agents);
+    this._logEvent('system', 'profile_updated', { agent: name, changes: Object.keys(updates) });
+    return { ok: true, profile };
+  }
+
+  getProfile(name) {
+    return this._agents[name] || null;
+  }
+
+  listAgents(filter = {}) {
+    let agents = Object.values(this._agents);
+
+    if (filter.online_only) {
+      const cutoff = Date.now() - OFFLINE_TIMEOUT_MS;
+      agents = agents.filter(a => new Date(a.last_seen).getTime() > cutoff);
+    }
+
+    if (filter.capability) {
+      const cap = filter.capability.toLowerCase();
+      agents = agents.filter(a => (a.capabilities || []).some(c => c.toLowerCase().includes(cap)));
+    }
+
+    if (filter.model) {
+      const m = filter.model.toLowerCase();
+      agents = agents.filter(a => {
+        const mdl = a.model?.name || a.model?.provider || '';
+        return mdl.toLowerCase().includes(m);
+      });
+    }
+
+    if (filter.tag) {
+      const tag = filter.tag.toLowerCase();
+      agents = agents.filter(a => (a.tags || []).some(t => t.toLowerCase() === tag));
+    }
+
+    if (filter.status) {
+      agents = agents.filter(a => a.status === filter.status);
+    }
+
+    if (filter.search) {
+      const q = filter.search.toLowerCase();
+      agents = agents.filter(a =>
+        a.name.toLowerCase().includes(q) ||
+        (a.description || '').toLowerCase().includes(q) ||
+        (a.capabilities || []).some(c => c.toLowerCase().includes(q)) ||
+        (a.tags || []).some(t => t.toLowerCase().includes(q))
+      );
+    }
+
+    return agents;
+  }
+
+  getAgent(name) {
+    return this._agents[name] || null;
+  }
+
+  heartbeat(name) {
+    if (this._agents[name]) {
+      const wasOffline = this._agents[name].status === 'offline' ||
+        (Date.now() - new Date(this._agents[name].last_seen).getTime()) > OFFLINE_TIMEOUT_MS;
+      this._agents[name].last_seen = new Date().toISOString();
+      this._agents[name].status = 'idle';
+      this._saveJson(AGENTS_FILE, this._agents);
+
+      if (wasOffline) {
+        this._logEvent('system', 'agent_online', { agent: name });
+      }
+      return { ok: true, online: true };
+    }
+    return { ok: false, error: 'Agent not registered' };
+  }
+
+  setStatus(name, status) {
+    const valid = ['idle', 'busy', 'offline'];
+    if (!valid.includes(status)) return { ok: false, error: `Status must be: ${valid.join(', ')}` };
+    if (!this._agents[name]) return { ok: false, error: 'Agent not registered' };
+
+    this._agents[name].status = status;
+    this._agents[name].last_seen = new Date().toISOString();
+    this._saveJson(AGENTS_FILE, this._agents);
+    this._logEvent('system', 'status_change', { agent: name, status });
+    return { ok: true, status };
+  }
+
+  // ── Direct Messages ─────────────────────────────────────
+
+  sendMessage(from, to, message, metadata = {}) {
+    const msg = {
+      id: this._genId(),
+      from,
+      to,
+      message,
+      metadata,
+      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');
+
+    const outboxDir = path.join(MSGS_DIR, `${from}_outbox`);
+    if (!fs.existsSync(outboxDir)) fs.mkdirSync(outboxDir, { recursive: true });
+    fs.writeFileSync(path.join(outboxDir, `${msg.id}.json`), JSON.stringify(msg, null, 2), 'utf-8');
+
+    this._wakeWaiters(to, msg);
+
+    return { sent: true, message_id: msg.id };
+  }
+
+  broadcastMessage(from, message) {
+    const results = [];
+    for (const agentName of Object.keys(this._agents)) {
+      if (agentName !== from) {
+        const r = this.sendMessage(from, agentName, message, { broadcast: true });
+        results.push({ to: agentName, message_id: r.message_id });
+      }
+    }
+    return { broadcast: true, targets: results.length, results };
+  }
+
+  fetchMessages(agentName, limit = 50, opts = {}) {
+    const inboxDir = path.join(MSGS_DIR, agentName);
+    if (!fs.existsSync(inboxDir)) return [];
+
+    let files = fs.readdirSync(inboxDir)
+      .filter(f => f.endsWith('.json'))
+      .sort();
+
+    if (opts.after_id) {
+      const idx = files.findIndex(f => f.startsWith(opts.after_id));
+      if (idx >= 0) files = files.slice(idx + 1);
+    }
+
+    if (opts.from) {
+      files = files.filter(f => {
+        try {
+          const m = JSON.parse(fs.readFileSync(path.join(inboxDir, f), 'utf-8'));
+          return m.from === opts.from;
+        } catch { return false; }
+      });
+    }
+
+    files = files.slice(-limit);
+
+    return files.map(f => {
+      return JSON.parse(fs.readFileSync(path.join(inboxDir, f), 'utf-8'));
+    });
+  }
+
+  waitForMessages(agentName, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._removeWaiter(agentName);
+        resolve({ timeout: true, messages: this.fetchMessages(agentName, 10) });
+      }, timeoutMs);
+
+      if (!this._waiters[agentName]) this._waiters[agentName] = [];
+      this._waiters[agentName].push({ resolve, timer });
+    });
+  }
+
+  deleteMessages(agentName, messageIds) {
+    const inboxDir = path.join(MSGS_DIR, agentName);
+    if (!fs.existsSync(inboxDir)) return { deleted: 0 };
+
+    let count = 0;
+    for (const id of messageIds) {
+      const filePath = path.join(inboxDir, `${id}.json`);
+      const filePathAlt = path.join(inboxDir, `${id}`);
+      try {
+        if (fs.existsSync(filePath)) { fs.unlinkSync(filePath); count++; }
+        else if (fs.existsSync(filePathAlt)) { fs.unlinkSync(filePathAlt); count++; }
+      } catch {}
+    }
+    return { deleted: count };
+  }
+
+  // ── Channels ────────────────────────────────────────────
+
+  createChannel(channelId, topic = '', createdBy = '') {
+    if (fs.existsSync(path.join(CHANNELS_DIR, `${channelId}.json`))) {
+      return { created: false, error: 'Channel already exists' };
+    }
+    const channel = {
+      id: channelId,
+      topic,
+      created_by: createdBy,
+      created_at: new Date().toISOString(),
+      members: createdBy ? [createdBy] : [],
+    };
+    fs.writeFileSync(path.join(CHANNELS_DIR, `${channelId}.json`), JSON.stringify(channel, null, 2), 'utf-8');
+    this._logEvent('system', 'channel_created', { channel: channelId, by: createdBy });
+    return { created: true, channel };
+  }
+
+  joinChannel(channelId, agentName) {
+    const channelPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+    if (!fs.existsSync(channelPath)) return { ok: false, error: 'Channel not found' };
+    const channel = JSON.parse(fs.readFileSync(channelPath, 'utf-8'));
+    if (!channel.members.includes(agentName)) {
+      channel.members.push(agentName);
+      this._logEvent('system', 'channel_joined', { channel: channelId, agent: agentName });
+    }
+    fs.writeFileSync(channelPath, JSON.stringify(channel, null, 2), 'utf-8');
+    return { joined: true, channel };
+  }
+
+  leaveChannel(channelId, agentName) {
+    const channelPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+    if (!fs.existsSync(channelPath)) return { ok: false, error: 'Channel not found' };
+    const channel = JSON.parse(fs.readFileSync(channelPath, 'utf-8'));
+    channel.members = channel.members.filter(m => m !== agentName);
+    fs.writeFileSync(channelPath, JSON.stringify(channel, null, 2), 'utf-8');
+    this._logEvent('system', 'channel_left', { channel: channelId, agent: agentName });
+    return { left: true, channel };
+  }
+
+  channelSend(channelId, from, message) {
+    const channelPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+    if (!fs.existsSync(channelPath)) return { ok: false, error: 'Channel not found' };
+
+    const msg = {
+      id: this._genId(),
+      channel: channelId,
+      from,
+      message,
+      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');
+
+    const channel = JSON.parse(fs.readFileSync(channelPath, 'utf-8'));
+    for (const member of channel.members) {
+      if (member !== from) {
+        this.sendMessage(from, member, `[${channelId}] ${message}`, { channel: channelId });
+      }
+    }
+
+    return { sent: true, message_id: msg.id };
+  }
+
+  channelHistory(channelId, limit = 50) {
+    const logDir = path.join(CHANNELS_DIR, channelId, 'log');
+    if (!fs.existsSync(logDir)) return [];
+
+    const files = fs.readdirSync(logDir)
+      .filter(f => f.endsWith('.json'))
+      .sort()
+      .slice(-limit);
+
+    return files.map(f => JSON.parse(fs.readFileSync(path.join(logDir, f), 'utf-8')));
+  }
+
+  // ── System Events / Discovery ────────────────────────
+
+  _broadcastSystemMessage(type, fromAgent, data) {
+    const text = JSON.stringify({ type, data });
+    for (const agentName of Object.keys(this._agents)) {
+      if (agentName !== fromAgent && agentName !== 'coco') {
+        this.sendMessage('coco', agentName, text, { type: 'system_event', event_type: type });
+      }
+    }
+  }
+
+  _logEvent(category, type, data) {
+    const event = {
+      id: this._genId(),
+      category,
+      type,
+      data,
+      timestamp: new Date().toISOString(),
+    };
+    const dayFile = path.join(EVENTS_DIR, `${new Date().toISOString().slice(0, 10)}.jsonl`);
+    try {
+      fs.appendFileSync(dayFile, JSON.stringify(event) + '\n', 'utf-8');
+    } catch {}
+    this.emit('event', event);
+    // Wake event waiters
+    this._wakeEventWaiters(event);
+  }
+
+  getEvents(opts = {}) {
+    const { since, category, type, limit = 100 } = opts;
+
+    if (!fs.existsSync(EVENTS_DIR)) return [];
+
+    // Determine which daily files to read
+    const allFiles = fs.readdirSync(EVENTS_DIR).filter(f => f.endsWith('.jsonl')).sort();
+    let filesToRead = allFiles;
+
+    if (since) {
+      const sinceDate = new Date(since).toISOString().slice(0, 10);
+      filesToRead = allFiles.filter(f => f >= sinceDate);
+    } else {
+      // Default: only today (backward compatible)
+      filesToRead = allFiles.slice(-1);
+    }
+
+    let events = [];
+    for (const dayFile of filesToRead) {
+      try {
+        const lines = fs.readFileSync(path.join(EVENTS_DIR, dayFile), 'utf-8').split('\n').filter(Boolean);
+        for (const line of lines) {
+          try { events.push(JSON.parse(line)); } catch {}
+        }
+      } catch {}
+    }
+
+    if (since) {
+      const sinceTs = new Date(since).getTime();
+      events = events.filter(e => e.timestamp && new Date(e.timestamp).getTime() >= sinceTs);
+    }
+    if (category) events = events.filter(e => e.category === category);
+    if (type) events = events.filter(e => e.type === type);
+
+    // Sort by timestamp ascending
+    events.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+
+    return events.slice(-limit);
+  }
+
+  waitForEvents(category, type, timeoutMs = 30000) {
+    return new Promise((resolve) => {
+      const key = `${category || '*'}:${type || '*'}`;
+      const timer = setTimeout(() => {
+        this._removeEventWaiter(key);
+        resolve({ timeout: true, events: [] });
+      }, timeoutMs);
+
+      if (!this._eventWaiters[key]) this._eventWaiters[key] = [];
+      this._eventWaiters[key].push({ resolve, timer, category, type });
+    });
+  }
+
+  _wakeEventWaiters(event) {
+    const keys = [
+      `${event.category}:${event.type}`,
+      `${event.category}:*`,
+      `*:${event.type}`,
+      `*:*`,
+    ];
+    for (const key of keys) {
+      const waiters = this._eventWaiters[key] || [];
+      for (const w of waiters) {
+        clearTimeout(w.timer);
+        w.resolve({ timeout: false, events: [event] });
+      }
+      if (waiters.length > 0) delete this._eventWaiters[key];
+    }
+  }
+
+  _removeEventWaiter(key) {
+    delete this._eventWaiters[key];
+  }
+
+  // ── Stale Agent Detection ────────────────────────────
+
+  _checkStaleAgents() {
+    setInterval(() => {
+      const now = Date.now();
+      for (const [name, agent] of Object.entries(this._agents)) {
+        const lastSeen = new Date(agent.last_seen).getTime();
+        if (now - lastSeen > OFFLINE_TIMEOUT_MS && agent.status !== 'offline') {
+          agent.status = 'offline';
+          this._logEvent('system', 'agent_offline', { agent: name });
+          this._broadcastSystemMessage('system:agent_left', name, {
+            agent: name,
+            reason: 'heartbeat timeout',
+          });
+        }
+      }
+      this._saveJson(AGENTS_FILE, this._agents);
+    }, 60000); // Check every minute
+  }
+
+  _logSystemWelcome(name) {
+    this._logEvent('system', 'welcome_sent', { agent: name });
+  }
+
+  // ── Internal ────────────────────────────────────────────
+
+  _wakeWaiters(agentName, msg) {
+    const waiters = this._waiters[agentName] || [];
+    delete this._waiters[agentName];
+    for (const w of waiters) {
+      clearTimeout(w.timer);
+      w.resolve({ timeout: false, messages: [msg] });
+    }
+  }
+
+  _removeWaiter(agentName) {
+    delete this._waiters[agentName];
+  }
+
+  _genId() {
+    return `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+  }
+
+  _loadJson(filePath, defaultVal) {
+    try {
+      if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      }
+    } catch {}
+    return defaultVal;
+  }
+
+  _saveJson(filePath, data) {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+}
+
+module.exports = { AgentBus };

package/lib/daemon.js

@@ -0,0 +1,96 @@
+/**
+ * Daemon Manager — run MCP CoCo as a background process
+ * with healthcheck, PID tracking, and auto-recovery for Hermes backend.
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const PID_FILE = path.join(__dirname, '..', '.coco-daemon.pid');
+const LOG_FILE = path.join(__dirname, '..', 'coco-daemon.log');
+const HERMES_MCP_PID = path.join(__dirname, '..', '.hermes-mcp.pid');
+
+class Daemon {
+  /**
+   * Start the MCP CoCo daemon in background.
+   * Returns immediately; the child process runs independently.
+   */
+  async start() {
+    // Check if already running
+    if (fs.existsSync(PID_FILE)) {
+      const existingPid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim());
+      try {
+        process.kill(existingPid, 0);
+        console.error(`MCP CoCo already running (PID: ${existingPid})`);
+        process.exit(0);
+        return;
+      } catch {
+        // Stale PID file, remove it
+        fs.unlinkSync(PID_FILE);
+      }
+    }
+
+    // Fork ourselves as daemon
+    const child = spawn(process.execPath, [path.join(__dirname, '..', 'index.js')], {
+      detached: true,
+      stdio: ['ignore', fs.openSync(LOG_FILE, 'a'), fs.openSync(LOG_FILE, 'a')],
+      env: { ...process.env, MCP_COCO_DAEMON: '1' },
+    });
+
+    child.unref();
+
+    // Write PID
+    fs.writeFileSync(PID_FILE, String(child.pid), 'utf-8');
+
+    console.log(`MCP CoCo daemon started (PID: ${child.pid})`);
+    console.log(`Log: ${LOG_FILE}`);
+
+    // Also start Hermes MCP backend
+    await this._startHermesMCP();
+
+    process.exit(0);
+  }
+
+  /**
+   * Start Hermes MCP serve as a subprocess of the daemon.
+   */
+  async _startHermesMCP() {
+    if (fs.existsSync(HERMES_MCP_PID)) {
+      try {
+        const pid = parseInt(fs.readFileSync(HERMES_MCP_PID, 'utf-8').trim());
+        process.kill(pid, 0);
+        return; // already running
+      } catch {
+        fs.unlinkSync(HERMES_MCP_PID);
+      }
+    }
+
+    const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+    const child = spawn('hermes', ['mcp', 'serve', '--accept-hooks'], {
+      detached: true,
+      stdio: ['ignore', logStream, logStream],
+    });
+
+    child.unref();
+    fs.writeFileSync(HERMES_MCP_PID, String(child.pid), 'utf-8');
+  }
+
+  /**
+   * Quick health check — used by --health flag and mcporter probe.
+   */
+  async healthCheck() {
+    // Check if daemon PID is alive
+    if (!fs.existsSync(PID_FILE)) {
+      return false;
+    }
+    try {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim());
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = { Daemon };