bus-agent 2.3.0

package/bridge.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * CoCo External Bridge — Connect external platforms to the Agent Bus
+ *
+ * Generic bridge pattern that can be adapted for:
+ * - Slack (Web API + Events API)
+ * - Discord (Webhook + Gateway)
+ * - Matrix, IRC, Telegram, etc.
+ *
+ * Each bridge runs as a bus agent, forwarding messages between
+ * the bus and the external platform.
+ *
+ * Usage:
+ *   node bridge.js slack    # Start Slack bridge (configured via .bridge.json)
+ *   node bridge.js discord  # Start Discord bridge
+ *   node bridge.js generic  # Start generic webhook bridge
+ *   node bridge.js --help   # Show config help
+ */
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+
+const BUS_DIR = path.join(__dirname, '.bus');
+const MSGS_DIR = path.join(BUS_DIR, 'messages');
+const CHANNEL_MAP_FILE = path.join(BUS_DIR, 'channel-map.json');
+const BRIDGE_CONFIG = path.join(__dirname, 'bridge-config.json');
+
+// ── Bridge Registry ────────────────────────────────────
+
+const bridges = {};
+
+class GenericBridge {
+  constructor(type, config) {
+    this.type = type;
+    this.config = config;
+    this.agentName = `bridge:${type}`;
+    this.mappings = this._loadMappings();
+    this._running = false;
+    this._server = null;
+  }
+
+  _loadMappings() {
+    try {
+      if (fs.existsSync(CHANNEL_MAP_FILE)) {
+        return JSON.parse(fs.readFileSync(CHANNEL_MAP_FILE, 'utf-8'));
+      }
+    } catch {}
+    return { channels: {}, dms: {} };
+  }
+
+  _saveMappings() {
+    fs.writeFileSync(CHANNEL_MAP_FILE, JSON.stringify(this.mappings, null, 2), 'utf-8');
+  }
+
+  registerAgent(description) {
+    const agentsFile = path.join(BUS_DIR, 'agents.json');
+    const agents = fs.existsSync(agentsFile) ? JSON.parse(fs.readFileSync(agentsFile, 'utf-8')) : {};
+    agents[this.agentName] = {
+      name: this.agentName,
+      description,
+      capabilities: ['bridge', this.type, 'messaging'],
+      tags: ['bridge', this.type],
+      status: 'idle',
+      version: '1.0.0',
+      last_seen: new Date().toISOString(),
+      registered_at: agents[this.agentName]?.registered_at || new Date().toISOString(),
+    };
+    fs.writeFileSync(agentsFile, JSON.stringify(agents, null, 2), 'utf-8');
+    console.log(`  ✅ Registered as "${this.agentName}" on CoCo Bus`);
+  }
+
+  // Map external channel → bus channel
+  mapChannel(externalId, busChannelId) {
+    this.mappings.channels[externalId] = busChannelId;
+    this._saveMappings();
+    console.log(`  🔗 Mapped ${this.type}:${externalId} → #${busChannelId}`);
+  }
+
+  getBusChannel(externalId) {
+    return this.mappings.channels[externalId] || null;
+  }
+
+  // Send a message TO the bus
+  postToBus(channelId, from, message, metadata = {}) {
+    const chPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+    if (!fs.existsSync(chPath)) return { ok: false, error: 'Channel not found' };
+
+    const ch = JSON.parse(fs.readFileSync(chPath, 'utf-8'));
+    const msg = {
+      id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+      channel: channelId,
+      from: `${this.agentName}:${from}`,
+      message,
+      metadata: { ...metadata, source: this.type },
+      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 ch.members) {
+      if (member !== this.agentName) {
+        const inboxDir = path.join(MSGS_DIR, member);
+        if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+        fs.writeFileSync(path.join(inboxDir, `${msg.id}.json`), JSON.stringify({ ...msg, to: member }, null, 2), 'utf-8');
+      }
+    }
+
+    return { ok: true, message_id: msg.id };
+  }
+
+  // Watch bus channel → forward to external (override in subclasses)
+  start() {
+    this._running = true;
+    console.log(`  👂 Bridge "${this.type}" watching...`);
+  }
+
+  stop() {
+    this._running = false;
+    if (this._server) this._server.close();
+  }
+}
+
+// ── Slack Bridge (Web API via outgoing webhook) ────────
+
+class SlackBridge extends GenericBridge {
+  constructor(config) {
+    super('slack', config);
+    this.webhookUrl = config.webhook_url || null;
+    this.signingSecret = config.signing_secret || '';
+  }
+
+  postToSlack(channel, text) {
+    if (!this.webhookUrl) return;
+    // In production, use @slack/web-api or fetch
+    console.log(`  📤 [Slack → ${channel}] ${text.substring(0, 60)}`);
+  }
+
+  postToBusFromSlack(channelId, userId, text) {
+    return this.postToBus(channelId, userId, text);
+  }
+}
+
+// ── Discord Bridge (Webhook) ───────────────────────────
+
+class DiscordBridge extends GenericBridge {
+  constructor(config) {
+    super('discord', config);
+    this.webhookUrl = config.webhook_url || null;
+    this.botToken = config.bot_token || null;
+  }
+
+  postToDiscord(channel, text) {
+    if (!this.webhookUrl) return;
+    console.log(`  📤 [Discord → ${channel}] ${text.substring(0, 60)}`);
+  }
+}
+
+// ── HTTP Bridge Server ──────────────────────────────────
+
+function startBridgeListener(bridge, port = 9090) {
+  const server = http.createServer((req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+
+    if (req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        bridge: bridge.type,
+        mappings: bridge.mappings,
+        status: 'running',
+      }));
+      return;
+    }
+
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', c => body += c);
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          const { action, ...params } = data;
+
+          switch (action) {
+            case 'map':
+              bridge.mapChannel(params.external_id, params.bus_channel);
+              res.writeHead(200);
+              res.end(JSON.stringify({ ok: true }));
+              break;
+
+            case 'send':
+              bridge.postToBusFromSlack
+                ? bridge.postToBusFromSlack(params.channel, params.user, params.text)
+                : bridge.postToBus(params.channel, params.user, params.text);
+              res.writeHead(200);
+              res.end(JSON.stringify({ ok: true }));
+              break;
+
+            default:
+              res.writeHead(400);
+              res.end(JSON.stringify({ error: 'Unknown action' }));
+          }
+        } catch (err) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+  });
+
+  bridge._server = server;
+  server.listen(port, () => {
+    console.log(`  🌐 ${bridge.type} bridge listening on :${port}`);
+  });
+}
+
+// ── Main ──
+
+const CHANNELS_DIR = path.join(BUS_DIR, 'channels');
+
+function help() {
+  console.log(`
+╔═══════════════════════════════════════════════╗
+║   MCP CoCo — External Platform Bridge        ║
+╚═══════════════════════════════════════════════╝
+
+Usage:
+  node bridge.js slack [port]    Start Slack webhook bridge
+  node bridge.js discord [port]  Start Discord webhook bridge
+  node bridge.js generic [port]  Start generic webhook bridge
+
+Configuration (bridge-config.json):
+  {
+    "slack": {
+      "webhook_url": "https://hooks.slack.com/...",
+      "signing_secret": "..."
+    },
+    "discord": {
+      "webhook_url": "https://discord.com/api/webhooks/...",
+      "bot_token": "..."
+    }
+  }
+
+Channel Mapping:
+  POST /api/map -d '{"action":"map","external_id":"C123","bus_channel":"dev"}'
+  POST /api/send -d '{"action":"send","channel":"dev","user":"john","text":"Hello"}"
+`);
+}
+
+async function main() {
+  const type = process.argv[2];
+  const port = parseInt(process.argv[3], 10) || 9090;
+
+  if (!type || type === '--help') {
+    help();
+    return;
+  }
+
+  // Load config
+  const config = fs.existsSync(BRIDGE_CONFIG)
+    ? JSON.parse(fs.readFileSync(BRIDGE_CONFIG, 'utf-8'))
+    : {};
+
+  let bridge;
+  switch (type) {
+    case 'slack':
+      bridge = new SlackBridge(config.slack || {});
+      break;
+    case 'discord':
+      bridge = new DiscordBridge(config.discord || {});
+      break;
+    case 'generic':
+      bridge = new GenericBridge('generic', config.generic || {});
+      break;
+    default:
+      console.error(`Unknown bridge type: ${type}`);
+      help();
+      process.exit(1);
+  }
+
+  console.log(`
+╔══════════════════════════════════════════════╗
+║  MCP CoCo — ${type.padEnd(22)}║
+╚══════════════════════════════════════════════╝
+`);
+
+  bridge.registerAgent(`${type} bridge — connects ${type} to CoCo Bus`);
+  startBridgeListener(bridge, port);
+  bridge.start();
+
+  // Watch bus for outgoing messages (poll)
+  const inboxDir = path.join(MSGS_DIR, bridge.agentName);
+  if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+  let lastCount = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json')).length;
+
+  setInterval(() => {
+    if (!fs.existsSync(inboxDir)) return;
+    const files = fs.readdirSync(inboxDir).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(inboxDir, f), 'utf-8'));
+          // Forward to external platform
+          if (bridge.type === 'slack') {
+            console.log(`  📬 [Bus → Slack/${msg.metadata?.channel || 'DM'}] ${msg.message.substring(0, 80)}`);
+          } else if (bridge.type === 'discord') {
+            console.log(`  📬 [Bus → Discord/${msg.metadata?.channel || 'DM'}] ${msg.message.substring(0, 80)}`);
+          } else {
+            console.log(`  📬 [Bus → External] ${msg.message.substring(0, 80)}`);
+          }
+        } catch {}
+      }
+      lastCount = files.length;
+    }
+  }, 3000);
+
+  console.log(`\n  Press Ctrl+C to stop\n`);
+}
+
+main().catch(err => {
+  console.error('FATAL:', err.message);
+  process.exit(1);
+});

package/claude-mcp.json

@@ -0,0 +1,10 @@
+{
+  "mcpServers": {
+    "coco": {
+      "command": "node",
+      "args": [
+        "E:\\_system\\.openclaw\\workspace\\repos\\mcp-coco\\index.js"
+      ]
+    }
+  }
+}

package/clients/coco-client.ts

@@ -0,0 +1,245 @@
+/**
+ * CoCo Bus Client — TypeScript/JS SDK for Agent Bus
+ *
+ * Direct file-based access to the CoCo Agent Bus. No MCP needed.
+ * Works in Node.js. For browser, use the WebSocket/proxy approach.
+ *
+ * Usage:
+ *   import { CoCoClient } from './coco-client.js';
+ *
+ *   const bus = new CoCoClient('/path/to/.bus', 'my-agent');
+ *   await bus.register({ description: 'My agent' });
+ *   await bus.send('hermes', 'Hello!');
+ *   const msgs = await bus.fetchMessages();
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+
+interface AgentProfile {
+  name: string;
+  description?: string;
+  capabilities?: string[];
+  model?: { provider?: string; name?: string; context_window?: number };
+  tags?: string[];
+  status?: 'idle' | 'busy' | 'offline';
+  version?: string;
+  endpoints?: Record<string, string>;
+  tools?: string[];
+  metadata?: Record<string, unknown>;
+  last_seen?: string;
+  registered_at?: string;
+}
+
+interface BusMessage {
+  id: string;
+  from: string;
+  to?: string;
+  channel?: string;
+  message: string;
+  metadata?: Record<string, unknown>;
+  timestamp: string;
+}
+
+export class CoCoClient {
+  private busDir: string;
+  private msgsDir: string;
+  private agentsFile: string;
+  private channelsDir: string;
+  agentName: string;
+
+  constructor(busDir: string, agentName?: string) {
+    this.busDir = busDir;
+    this.msgsDir = path.join(busDir, 'messages');
+    this.agentsFile = path.join(busDir, 'agents.json');
+    this.channelsDir = path.join(busDir, 'channels');
+    this.agentName = agentName || process.env.COCO_AGENT || process.env.USER || 'ts-agent';
+    this._ensureDirs();
+  }
+
+  private _ensureDirs() {
+    for (const d of [this.busDir, this.msgsDir, this.channelsDir]) {
+      if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    }
+  }
+
+  private _genId(): string {
+    return `${Date.now()}_${randomUUID().slice(0, 8)}`;
+  }
+
+  private _loadAgents(): Record<string, AgentProfile> {
+    try {
+      if (fs.existsSync(this.agentsFile)) {
+        return JSON.parse(fs.readFileSync(this.agentsFile, 'utf-8'));
+      }
+    } catch {}
+    return {};
+  }
+
+  private _saveAgents(agents: Record<string, AgentProfile>) {
+    fs.writeFileSync(this.agentsFile, JSON.stringify(agents, null, 2), 'utf-8');
+  }
+
+  // ── Registration ──
+
+  register(profile: {
+    description?: string;
+    capabilities?: string[];
+    model?: { provider?: string; name?: string };
+    tags?: string[];
+    version?: string;
+    status?: string;
+  }): { registered: boolean; is_new: boolean } {
+    const agents = this._loadAgents();
+    const existing = agents[this.agentName];
+    agents[this.agentName] = {
+      name: this.agentName,
+      description: profile.description || '',
+      capabilities: profile.capabilities || [],
+      model: profile.model || null as any,
+      tags: profile.tags || [],
+      status: (profile.status as any) || 'idle',
+      version: profile.version || '1.0.0',
+      endpoints: {},
+      tools: [],
+      metadata: {},
+      last_seen: new Date().toISOString(),
+      registered_at: existing?.registered_at || new Date().toISOString(),
+    };
+    this._saveAgents(agents);
+    return { registered: true, is_new: !existing };
+  }
+
+  heartbeat(): boolean {
+    const agents = this._loadAgents();
+    if (agents[this.agentName]) {
+      agents[this.agentName].last_seen = new Date().toISOString();
+      agents[this.agentName].status = 'idle';
+      this._saveAgents(agents);
+      return true;
+    }
+    return false;
+  }
+
+  setStatus(status: 'idle' | 'busy' | 'offline'): boolean {
+    const agents = this._loadAgents();
+    if (agents[this.agentName]) {
+      agents[this.agentName].status = status;
+      agents[this.agentName].last_seen = new Date().toISOString();
+      this._saveAgents(agents);
+      return true;
+    }
+    return false;
+  }
+
+  listAgents(onlineOnly = false): Record<string, AgentProfile> {
+    const agents = this._loadAgents();
+    if (onlineOnly) {
+      const cutoff = Date.now() - 300000;
+      return Object.fromEntries(
+        Object.entries(agents).filter(([, a]) => new Date(a.last_seen!).getTime() > cutoff)
+      );
+    }
+    return agents;
+  }
+
+  // ── Messaging ──
+
+  send(to: string, message: string, metadata?: Record<string, unknown>): string {
+    const msg: BusMessage = {
+      id: this._genId(),
+      from: this.agentName,
+      to,
+      message,
+      metadata: metadata || {},
+      timestamp: new Date().toISOString(),
+    };
+
+    const inboxDir = path.join(this.msgsDir, 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');
+
+    // Outbox
+    const outboxDir = path.join(this.msgsDir, `${this.agentName}_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');
+
+    return msg.id;
+  }
+
+  broadcast(message: string): Array<{ to: string; message_id: string }> {
+    const agents = this._loadAgents();
+    return Object.keys(agents)
+      .filter(name => name !== this.agentName)
+      .map(name => ({ to: name, message_id: this.send(name, message, { broadcast: true }) }));
+  }
+
+  fetchMessages(limit = 50, fromAgent?: string): BusMessage[] {
+    const inboxDir = path.join(this.msgsDir, this.agentName);
+    if (!fs.existsSync(inboxDir)) return [];
+
+    const files = fs.readdirSync(inboxDir)
+      .filter(f => f.endsWith('.json'))
+      .sort()
+      .slice(-limit);
+
+    return files
+      .map(f => {
+        try {
+          const msg: BusMessage = JSON.parse(fs.readFileSync(path.join(inboxDir, f), 'utf-8'));
+          if (fromAgent && msg.from !== fromAgent) return null;
+          return msg;
+        } catch { return null; }
+      })
+      .filter(Boolean) as BusMessage[];
+  }
+
+  reply(originalMsg: BusMessage, text: string): string {
+    return this.send(originalMsg.from, text, { in_reply_to: originalMsg.id });
+  }
+
+  // ── Channels ──
+
+  channelSend(channelId: string, message: string): string {
+    const chPath = path.join(this.channelsDir, `${channelId}.json`);
+    if (!fs.existsSync(chPath)) throw new Error(`Channel "${channelId}" not found`);
+
+    const msg: BusMessage = {
+      id: this._genId(),
+      channel: channelId,
+      from: this.agentName,
+      message,
+      timestamp: new Date().toISOString(),
+    };
+
+    const logDir = path.join(this.channelsDir, 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');
+
+    // DM members
+    const channel = JSON.parse(fs.readFileSync(chPath, 'utf-8'));
+    for (const member of channel.members || []) {
+      if (member !== this.agentName) {
+        this.send(member, `[${channelId}] ${message}`, { channel: channelId });
+      }
+    }
+
+    return msg.id;
+  }
+
+  channelHistory(channelId: string, limit = 20): BusMessage[] {
+    const logDir = path.join(this.channelsDir, channelId, 'log');
+    if (!fs.existsSync(logDir)) return [];
+
+    return fs.readdirSync(logDir)
+      .filter(f => f.endsWith('.json'))
+      .sort()
+      .slice(-limit)
+      .map(f => {
+        try { return JSON.parse(fs.readFileSync(path.join(logDir, f), 'utf-8')); }
+        catch { return null; }
+      })
+      .filter(Boolean) as BusMessage[];
+  }
+}