bus-agent 2.3.0

package/lib/tunnel.js

@@ -0,0 +1,317 @@
+/**
+ * CoCo Tunnel — Cross-machine Bus Proxy Module
+ *
+ * Export functions, no process.exit, accepts busDir as parameter.
+ * Used by: coco-cli.js, tunnel.js (thin CLI wrapper)
+ */
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function loadAgents(busDir) {
+  const p = path.join(busDir, 'agents.json');
+  if (!fs.existsSync(p)) return {};
+  return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+
+function hashSecret(secret) {
+  return crypto.createHash('sha256').update(secret).digest('hex');
+}
+
+function authenticate(req, secret) {
+  if (!secret) return true;
+  const provided = req.headers['x-coco-token'];
+  return provided && hashSecret(provided) === hashSecret(secret);
+}
+
+function readBusFile(busDir, filename) {
+  const p = path.join(busDir, filename);
+  if (!fs.existsSync(p)) return null;
+  try { return fs.readFileSync(p, 'utf-8'); } catch { return null; }
+}
+
+function writeBusFile(busDir, filename, data) {
+  const p = path.join(busDir, filename);
+  const dir = path.dirname(p);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(p, data, 'utf-8');
+  return true;
+}
+
+/**
+ * Start tunnel server
+ */
+function startServer(opts = {}) {
+  const busDir = opts.busDir || path.join(process.cwd(), '.bus');
+  const port = opts.port || 9090;
+  const secret = opts.secret || null;
+
+  console.log(`\n  CoCo Tunnel — Server (receiving end)`);
+  console.log(`  Listening on :${port}`);
+  console.log(`  Auth: ${secret ? 'enabled' : 'disabled (INSECURE)'}`);
+  console.log(`  Bus:  ${busDir}\n`);
+
+  const server = http.createServer((req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Coco-Token');
+    if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+    if (secret && !authenticate(req, secret)) { res.writeHead(401); res.end(JSON.stringify({ error: 'Unauthorized' })); return; }
+
+    const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+    const pathname = url.pathname;
+
+    if (req.method === 'GET' && pathname === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ service: 'coco-tunnel', role: 'server', bus: busDir, agents: Object.keys(loadAgents(busDir)).length, uptime: process.uptime() }));
+      return;
+    }
+
+    if (req.method === 'GET' && pathname === '/bus/agents') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(loadAgents(busDir)));
+      return;
+    }
+
+    const fileMatch = pathname.match(/^\/bus\/file\/(.+)$/);
+    if (req.method === 'GET' && fileMatch) {
+      const content = readBusFile(busDir, fileMatch[1]);
+      if (content === null) { res.writeHead(404); res.end(JSON.stringify({ error: 'Not found' })); return; }
+      res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(content);
+      return;
+    }
+
+    if (req.method === 'POST' && pathname === '/bus/send') {
+      let body = '';
+      req.on('data', c => body += c);
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          if (!data.to || !data.message) { res.writeHead(400); res.end(JSON.stringify({ error: 'Missing "to" or "message"' })); return; }
+          const msg = { id: `${Date.now()}_${crypto.randomBytes(4).toString('hex')}`, from: data.from || 'tunnel', to: data.to, message: data.message, metadata: { source: 'tunnel', tunnel_host: req.headers['host'] || 'unknown' }, timestamp: new Date().toISOString() };
+          const inboxDir = path.join(busDir, 'messages', data.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');
+          res.writeHead(200); res.end(JSON.stringify({ sent: true, message_id: msg.id }));
+        } catch (err) { res.writeHead(400); res.end(JSON.stringify({ error: err.message })); }
+      });
+      return;
+    }
+
+    if (req.method === 'POST' && pathname === '/bus/write') {
+      let body = '';
+      req.on('data', c => body += c);
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          if (!data.filepath || data.content === undefined) { res.writeHead(400); res.end(JSON.stringify({ error: 'Missing "filepath" or "content"' })); return; }
+          writeBusFile(busDir, data.filepath, typeof data.content === 'string' ? data.content : JSON.stringify(data.content, null, 2));
+          res.writeHead(200); res.end(JSON.stringify({ written: true, filepath: data.filepath }));
+        } catch (err) { res.writeHead(400); res.end(JSON.stringify({ error: err.message })); }
+      });
+      return;
+    }
+
+    if (req.method === 'POST' && pathname === '/bus/register') {
+      let body = '';
+      req.on('data', c => body += c);
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          if (!data.name) { res.writeHead(400); res.end(JSON.stringify({ error: 'Missing "name"' })); return; }
+          const agents = loadAgents(busDir);
+          agents[data.name] = { name: data.name, description: data.description || 'Remote tunnel agent', capabilities: data.capabilities || [], tags: ['tunnel', 'remote'], status: 'idle', version: '1.0.0', last_seen: new Date().toISOString(), registered_at: agents[data.name]?.registered_at || new Date().toISOString() };
+          fs.writeFileSync(path.join(busDir, 'agents.json'), JSON.stringify(agents, null, 2), 'utf-8');
+          res.writeHead(200); res.end(JSON.stringify({ registered: true, agent: data.name }));
+        } catch (err) { res.writeHead(400); res.end(JSON.stringify({ error: err.message })); }
+      });
+      return;
+    }
+
+    res.writeHead(404); res.end(JSON.stringify({ error: 'Not found' }));
+  });
+
+  server.listen(port);
+  return server;
+}
+
+// HTTP fetch helper
+function httpFetch(url, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const options = {
+      hostname: u.hostname, port: u.port, path: u.pathname + u.search,
+      method: opts.method || 'GET', headers: opts.headers || {}, timeout: 10000,
+    };
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) { try { resolve(JSON.parse(data)); } catch { resolve(data); } }
+        else reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 100)}`));
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    if (opts.body) req.write(opts.body);
+    req.end();
+  });
+}
+
+/**
+ * Start tunnel client
+ */
+async function startClient(opts = {}) {
+  const busDir = opts.busDir || path.join(process.cwd(), '.bus');
+  const host = opts.host || 'localhost';
+  const port = opts.port || 9090;
+  const secret = opts.secret || null;
+  const interval = opts.interval || 10000;
+  const baseUrl = `http://${host}:${port}`;
+  const headers = {};
+  if (secret) headers['X-Coco-Token'] = secret;
+
+  console.log(`\n  CoCo Tunnel — Client (sending end)`);
+  console.log(`  Remote: ${baseUrl}`);
+  console.log(`  Sync:   Every ${interval}ms\n`);
+
+  // Test connection
+  try {
+    const health = await httpFetch(`${baseUrl}/health`, { headers });
+    console.log(`  Connection: ✅ remote bus has ${health.agents} agent(s)`);
+  } catch (err) {
+    console.log(`  Connection: ❌ ${err.message}`);
+    throw err;
+  }
+
+  // Register this machine
+  const hostname = require('os').hostname();
+  try {
+    await httpFetch(`${baseUrl}/bus/register`, {
+      method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: `tunnel:${hostname}`, description: `Tunnel client from ${hostname}:${busDir}`, capabilities: ['tunnel', 'remote-sync'] }),
+    });
+    console.log(`  Registered as "tunnel:${hostname}" on remote bus`);
+  } catch (err) {
+    console.log(`  Register: ❌ ${err.message}`);
+  }
+
+  // Sync loop
+  const syncInterval = setInterval(async () => {
+    try {
+      const localAgents = loadAgents(busDir);
+      for (const [name, profile] of Object.entries(localAgents)) {
+        await httpFetch(`${baseUrl}/bus/register`, {
+          method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name, description: profile.description, capabilities: profile.capabilities }),
+        });
+      }
+
+      const msgsDir = path.join(busDir, 'messages');
+      if (fs.existsSync(msgsDir)) {
+        for (const inbox of fs.readdirSync(msgsDir).filter(d => fs.statSync(path.join(msgsDir, d)).isDirectory() && !d.endsWith('_outbox'))) {
+          for (const f of fs.readdirSync(path.join(msgsDir, inbox)).filter(f => f.endsWith('.json')).slice(-5)) {
+            try {
+              const msg = JSON.parse(fs.readFileSync(path.join(msgsDir, inbox, f), 'utf-8'));
+              if (msg.tunnel_pushed) continue;
+              await httpFetch(`${baseUrl}/bus/send`, {
+                method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ from: msg.from, to: msg.to, message: msg.message }),
+              });
+              msg.tunnel_pushed = true;
+              fs.writeFileSync(path.join(msgsDir, inbox, f), JSON.stringify(msg, null, 2), 'utf-8');
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }, interval);
+
+  return { syncInterval, stop: () => clearInterval(syncInterval) };
+}
+
+/**
+ * Bidirectional sync
+ */
+async function startSync(opts = {}) {
+  const busDir = opts.busDir || path.join(process.cwd(), '.bus');
+  const remote = opts.remote || 'http://localhost:9090';
+  const secret = opts.secret || null;
+  const interval = opts.interval || 10000;
+  const headers = {};
+  if (secret) headers['X-Coco-Token'] = secret;
+
+  console.log(`\n  CoCo Tunnel — Bidirectional Sync`);
+  console.log(`  Remote: ${remote}`);
+  console.log(`  Local:  ${busDir}`);
+  console.log(`  Sync:   Every ${interval}ms\n`);
+
+  try {
+    const health = await httpFetch(`${remote}/health`, { headers });
+    console.log(`  Remote: ✅ ${health.agents} agent(s)`);
+  } catch (err) {
+    console.log(`  Remote: ❌ ${err.message}`);
+    throw err;
+  }
+
+  function mergeAgents(local, remote) {
+    const merged = { ...local };
+    for (const [name, profile] of Object.entries(remote)) {
+      if (!merged[name]) merged[name] = profile;
+      else {
+        const l = new Date(merged[name].last_seen || 0).getTime();
+        const r = new Date(profile.last_seen || 0).getTime();
+        if (r > l) merged[name] = profile;
+      }
+    }
+    return merged;
+  }
+
+  const sync = setInterval(async () => {
+    try {
+      const remoteAgents = await httpFetch(`${remote}/bus/agents`, { headers });
+      const merged = mergeAgents(loadAgents(busDir), remoteAgents);
+      fs.writeFileSync(path.join(busDir, 'agents.json'), JSON.stringify(merged, null, 2), 'utf-8');
+      for (const [name, profile] of Object.entries(loadAgents(busDir))) {
+        if (!remoteAgents[name] || remoteAgents[name].last_seen !== profile.last_seen) {
+          await httpFetch(`${remote}/bus/register`, {
+            method: 'POST', headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name, description: profile.description, capabilities: profile.capabilities }),
+          });
+        }
+      }
+    } catch {}
+  }, interval);
+
+  return { sync, stop: () => clearInterval(sync) };
+}
+
+/**
+ * SSH tunnel instructions
+ */
+function printSSHHelp(opts = {}) {
+  const remote = opts.remote || 'user@remote-host';
+  const port = opts.port || 9090;
+
+  console.log(`\n╔═══════════════════════════════════════════════╗\n║  CoCo Tunnel — SSH Port Forwarding             ║\n╚═══════════════════════════════════════════════╝\n`);
+  console.log(`To expose your local CoCo bus to a remote machine:\n`);
+  console.log(`1. On THIS machine, start the tunnel server:`);
+  console.log(`   node tunnel.js server --port ${port} --secret ***\n`);
+  console.log(`2. On the REMOTE machine, create an SSH reverse tunnel:`);
+  console.log(`   ssh -R ${port}:localhost:${port} ${remote}\n`);
+  console.log(`3. On the REMOTE machine, connect as client:`);
+  console.log(`   node tunnel.js client --host localhost --port ${port} --secret ***\n`);
+  console.log(`Alternative: forward the other way:\n`);
+  console.log(`1. On the REMOTE machine, start tunnel server:`);
+  console.log(`   node tunnel.js server --port ${port} --secret ***\n`);
+  console.log(`2. On THIS machine:`);
+  console.log(`   ssh -L ${port}:localhost:${port} ${remote}\n`);
+  console.log(`3. On THIS machine, connect as client:`);
+  console.log(`   node tunnel.js client --host localhost --port ${port} --secret ***\n`);
+  console.log(`To keep the tunnel alive:`);
+  console.log(`   autossh -M 0 -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3" \\`);
+  console.log(`     -R ${port}:localhost:${port} ${remote}\n`);
+}
+
+module.exports = { startServer, startClient, startSync, printSSHHelp };

package/mcporter.example.json

@@ -0,0 +1,14 @@
+{
+  "servers": {
+    "coco": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["C:\\Users\\Administrator\\.openclaw\\workspace\\mcp-coco\\index.js"]
+    },
+    "hermes": {
+      "type": "stdio",
+      "command": "hermes",
+      "args": ["mcp", "serve", "--accept-hooks"]
+    }
+  }
+}

package/opencode-mcp.json

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

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "bus-agent",
+  "version": "2.3.0",
+  "description": "Universal Agent Communication Hub — Connect any AI agent to any other. MCP bus with messaging, channels, memory, scheduling, workflows, and diagnostics.",
+  "main": "index.js",
+  "bin": {
+    "coco": "./coco-cli.js",
+    "bus-agent": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "daemon": "node index.js --daemon",
+    "health": "node index.js --health",
+    "doctor": "node doctor.js",
+    "doctor:fix": "node doctor.js --fix",
+    "backup": "node backup.js",
+    "backup:list": "node backup.js --list",
+    "tunnel": "node tunnel.js server",
+    "memory": "node coco-cli.js memory"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ClewCode/mcp-coco.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ClewCode/mcp-coco/issues"
+  },
+  "homepage": "https://github.com/ClewCode/mcp-coco#readme",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "agent-bus",
+    "agent-communication",
+    "multi-agent",
+    "hermes",
+    "openclaw",
+    "ai-agents",
+    "message-bus",
+    "scheduler",
+    "workflow",
+    "memory",
+    "vector-search"
+  ],
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "lib/",
+    "clients/",
+    "index.js",
+    "coco-cli.js",
+    "coco-tool.js",
+    "doctor.js",
+    "backup.js",
+    "tunnel.js",
+    "bridge.js",
+    "webhook-gateway.js",
+    "hermes-forwarder.js",
+    "setup.js",
+    "coco.js",
+    ".env.coco",
+    "AGENTS.md",
+    "README.md",
+    "SKILL.md",
+    "LICENSE",
+    "claude-mcp.json",
+    "cursor-mcp.json",
+    "opencode-mcp.json",
+    "mcporter.example.json",
+    "hermes.example.json",
+    "coco-aliases.sh",
+    "scripts/"
+  ]
+}

package/scripts/install.bat

@@ -0,0 +1,5 @@
+@REM MCP CoCo — Windows install script
+@REM Run as Administrator:  powershell -File scripts\install.ps1
+
+@echo off
+powershell -ExecutionPolicy Bypass -File "%~dp0install.ps1"

package/scripts/install.ps1

@@ -0,0 +1,100 @@
+# MCP CoCo — Windows Install Script
+# Run as Administrator to install Scheduled Task + mcporter config
+
+$ErrorActionPreference = "Stop"
+$RepoDir = Split-Path -Parent $PSScriptRoot
+
+Write-Host "╔══════════════════════════════════════════╗" -ForegroundColor Cyan
+Write-Host "║        MCP CoCo — Windows Install       ║" -ForegroundColor Cyan
+Write-Host "╚══════════════════════════════════════════╝" -ForegroundColor Cyan
+Write-Host ""
+
+# 1. Verify Hermes is installed
+Write-Host "🔍 Checking Hermes..." -ForegroundColor Yellow
+try {
+    $hermesVer = & hermes --version 2>&1
+    Write-Host "   ✅ Hermes $hermesVer" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Hermes not found. Install with: pip install hermes-agent" -ForegroundColor Red
+    exit 1
+}
+
+# 2. Verify Node.js
+Write-Host "🔍 Checking Node.js..." -ForegroundColor Yellow
+try {
+    $nodeVer = node --version
+    Write-Host "   ✅ Node.js $nodeVer" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Node.js not found." -ForegroundColor Red
+    exit 1
+}
+
+# 3. Test MCP CoCo
+Write-Host "🧪 Testing MCP CoCo..." -ForegroundColor Yellow
+try {
+    $result = node "$RepoDir\bin\cli.js" --health 2>&1
+    Write-Host "   ✅ MCP CoCo works" -ForegroundColor Green
+} catch {
+    Write-Host "   ⚠️  First run - testing..." -ForegroundColor Yellow
+}
+
+# 4. Stop any existing daemon
+Write-Host "🛑 Stopping existing daemon..." -ForegroundColor Yellow
+try {
+    node "$RepoDir\index.js" --daemon 2>&1 | Out-Null
+} catch {}
+
+# 5. Register Scheduled Task for auto-start
+$taskName = "MCP_CoCo_Daemon"
+$taskExists = Get-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue
+
+Write-Host "⚙️  Scheduled Task: $taskName" -ForegroundColor Yellow
+if ($taskExists) {
+    Write-Host "   ⚠️  Already exists, updating..." -ForegroundColor Yellow
+}
+
+$action = New-ScheduledTaskAction -Execute "node.exe" `
+    -Argument "$RepoDir\index.js --daemon" `
+    -WorkingDirectory $RepoDir
+
+$trigger = New-ScheduledTaskTrigger -AtStartup
+$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
+$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable
+
+try {
+    Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force
+    Write-Host "   ✅ Scheduled Task registered" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Failed to register task: $_" -ForegroundColor Red
+    Write-Host "   Run this script as Administrator" -ForegroundColor Red
+}
+
+# 6. Start daemon
+Write-Host "🚀 Starting MCP CoCo daemon..." -ForegroundColor Yellow
+try {
+    Start-ScheduledTask -TaskName $taskName
+    Write-Host "   ✅ Daemon started via Scheduled Task" -ForegroundColor Green
+} catch {
+    Write-Host "   ⚠️  Could not start task: $_" -ForegroundColor Yellow
+    Write-Host "   Start manually: node `"$RepoDir\index.js --daemon`"" -ForegroundColor Yellow
+}
+
+# 7. Verify
+Start-Sleep -Seconds 2
+$health = & node "$RepoDir\bin\cli.js" --health 2>&1
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "   ✅ Daemon health check passed" -ForegroundColor Green
+} else {
+    Write-Host "   ⚠️  Daemon may still be starting..." -ForegroundColor Yellow
+}
+
+Write-Host ""
+Write-Host "╔══════════════════════════════════════════╗" -ForegroundColor Cyan
+Write-Host "║         MCP CoCo Installation Done       ║" -ForegroundColor Cyan
+Write-Host "╚══════════════════════════════════════════╝" -ForegroundColor Cyan
+Write-Host ""
+Write-Host "To use from OpenClaw, add to mcporter config:" -ForegroundColor White
+Write-Host "  mcporter add coco --stdio `"node $RepoDir\index.js`"" -ForegroundColor Gray
+Write-Host ""
+Write-Host "Then call:" -ForegroundColor White
+Write-Host "  mcporter call coco.ask_hermes prompt=`"Hello`"" -ForegroundColor Gray