bus-agent 2.3.0

package/coco-tool.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * CoCo Tool Wrapper — Direct bus calls from any tool/exec context
+ *
+ * Acts as a lightweight RPC bridge between tools (OpenClaw, CLI, etc.)
+ * and the CoCo Agent Bus. No MCP needed — direct file access.
+ *
+ * Usage:
+ *   node coco-tool.js <tool> [args...]
+ *
+ * Examples:
+ *   node coco-tool.js agent_list '{"online_only":true}'
+ *   node coco-tool.js agent_get_profile '{"name":"coco"}'
+ *   node coco-tool.js message_send '{"from":"andul","to":"hermes","message":"Hello!"}'
+ *   node coco-tool.js message_fetch '{"agent_name":"andul"}'
+ *   node coco-tool.js agent_search '{"query":"code"}'
+ *   node coco-tool.js agent_register '{"name":"andul","description":"Andul 🐺","capabilities":["chat","code","browsing"]}'
+ *   node coco-tool.js coco_health '{}'
+ */
+const path = require('path');
+const fs = require('fs');
+
+// Load AgentBus
+require('./lib/bus');
+const bus = new (require('./lib/bus').AgentBus)();
+const { HermesBridge } = require('./lib/hermes');
+const bridge = new HermesBridge();
+const { Scheduler } = require('./lib/scheduler');
+const scheduler = new Scheduler(bus);
+const { Orchestrator } = require('./lib/orchestrator');
+const orchestrator = new Orchestrator(bus);
+
+const tool = process.argv[2];
+const argsRaw = process.argv[3] || '{}';
+let args = {};
+try { args = JSON.parse(argsRaw); } catch {}
+
+async function main() {
+  let result;
+
+  switch (tool) {
+    // CoCo Health
+    case 'coco_health':
+      result = await bridge.healthCheck();
+      break;
+
+    // Registrations
+    case 'agent_register': {
+      const meta = {
+        capabilities: args.capabilities || [],
+        model: args.model || null,
+        tags: args.tags || [],
+        version: args.version || '1.0.0',
+        endpoints: args.endpoints || {},
+        tools: args.tools || [],
+        status: args.status || 'idle',
+      };
+      result = bus.registerAgent(args.name, args.description || '', meta);
+      break;
+    }
+    case 'agent_update_profile':
+      result = bus.updateProfile(args.name, args);
+      break;
+    case 'agent_get_profile':
+      result = { agent: bus.getProfile(args.name) };
+      break;
+    case 'agent_list':
+      result = { agents: bus.listAgents(args) };
+      break;
+    case 'agent_search':
+      result = { query: args.query, agents: bus.listAgents({ search: args.query }).slice(0, args.max_results || 20) };
+      break;
+    case 'agent_heartbeat':
+      result = bus.heartbeat(args.name);
+      break;
+    case 'agent_set_status':
+      result = bus.setStatus(args.name, args.status);
+      break;
+
+    // Messages
+    case 'message_send':
+      result = bus.sendMessage(args.from, args.to, args.message, args.metadata);
+      break;
+    case 'message_broadcast':
+      result = bus.broadcastMessage(args.from, args.message);
+      break;
+    case 'message_fetch':
+      result = { messages: bus.fetchMessages(args.agent_name, args.limit) };
+      break;
+    case 'message_delete':
+      result = bus.deleteMessages(args.agent_name, args.message_ids);
+      break;
+
+    // Channels
+    case 'channel_create':
+      result = bus.createChannel(args.channel_id, args.topic, args.created_by);
+      break;
+    case 'channel_join':
+      result = bus.joinChannel(args.channel_id, args.agent_name);
+      break;
+    case 'channel_leave':
+      result = bus.leaveChannel(args.channel_id, args.agent_name);
+      break;
+    case 'channel_send':
+      result = bus.channelSend(args.channel_id, args.from, args.message);
+      break;
+    case 'channel_history':
+      result = { messages: bus.channelHistory(args.channel_id, args.limit) };
+      break;
+
+    // Events
+    case 'system_get_events':
+      result = { events: bus.getEvents(args) };
+      break;
+
+    // Scheduler
+    case 'scheduler_add':
+      result = scheduler.addJob(args);
+      break;
+    case 'scheduler_remove':
+      result = scheduler.removeJob(args.job_id);
+      break;
+    case 'scheduler_list':
+      result = { jobs: scheduler.listJobs() };
+      break;
+
+    // Auto-Reply Rules
+    case 'auto_reply_add':
+      result = orchestrator.addRule(args);
+      break;
+    case 'auto_reply_remove':
+      result = orchestrator.removeRule(args.rule_id);
+      break;
+    case 'auto_reply_list':
+      result = { rules: orchestrator.listRules() };
+      break;
+
+    // Workflows
+    case 'workflow_create':
+      result = orchestrator.createWorkflow(args);
+      break;
+    case 'workflow_run':
+      result = await orchestrator.runWorkflow(args.workflow_id, args.input, args.requester);
+      break;
+    case 'workflow_remove':
+      result = orchestrator.removeWorkflow(args.workflow_id);
+      break;
+    case 'workflow_list':
+      result = { workflows: orchestrator.listWorkflows() };
+      break;
+
+    default:
+      console.error(JSON.stringify({ error: `Unknown tool: ${tool}`, tools: getToolList() }));
+      process.exit(1);
+  }
+
+  process.stdout.write(JSON.stringify(result, null, 2));
+}
+
+function getToolList() {
+  return [
+    'coco_health',
+    'agent_register', 'agent_update_profile', 'agent_get_profile',
+    'agent_list', 'agent_search', 'agent_heartbeat', 'agent_set_status',
+    'message_send', 'message_broadcast', 'message_fetch', 'message_delete',
+    'channel_create', 'channel_join', 'channel_leave', 'channel_send', 'channel_history',
+    'system_get_events',
+    'scheduler_add', 'scheduler_remove', 'scheduler_list',
+    'auto_reply_add', 'auto_reply_remove', 'auto_reply_list',
+    'workflow_create', 'workflow_run', 'workflow_remove', 'workflow_list',
+  ];
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }));
+  process.exit(1);
+});

package/coco.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * CoCo — Convenience entry point for CLI agents
+ *
+ * Usage:
+ *   node coco.js agents          # List agents
+ *   node coco.js inbox           # Check your messages
+ *   node coco.js send "message"  # Send to last reply-to agent
+ *   node coco.js send <to> msg   # Send to specific agent
+ *   node coco.js watch           # Watch for new messages
+ */
+const { execSync } = require('child_process');
+const path = require('path');
+
+const CLI = path.join(__dirname, 'coco-cli.js');
+const args = process.argv.slice(2).join(' ');
+
+try {
+  const result = execSync(`node "${CLI}" ${args}`, {
+    encoding: 'utf-8',
+    stdio: 'inherit',
+    env: { ...process.env },
+  });
+} catch (e) {
+  // errors already shown via stdio
+}

package/cursor-mcp.json

@@ -0,0 +1,3 @@
+{
+  "E:\\_system\\.openclaw\\workspace\\repos\\mcp-coco\\index.js": true
+}

package/doctor.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * CoCo Doctor — Diagnostics CLI Wrapper
+ *
+ * Thin wrapper around lib/doctor.js
+ * Usage: node doctor.js [--quick] [--fix] [--report] [--watch]
+ */
+const path = require('path');
+const { runDiagnostics, watchDiagnostics } = require('./lib/doctor');
+
+const args = process.argv.slice(2);
+const opts = {
+  busDir: path.join(__dirname, '.bus'),
+  quick: args.includes('--quick'),
+  fix: args.includes('--fix'),
+  report: args.includes('--report'),
+  watch: args.includes('--watch'),
+};
+
+if (opts.watch) {
+  watchDiagnostics(opts);
+} else {
+  runDiagnostics(opts);
+}

package/hermes-forwarder.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * Hermes Auto-Forwarder — automatically forwards DMs to Hermes Agent
+ *
+ * Watches the bus for messages addressed to "hermes", sends them
+ * through Hermes CLI (ask_hermes), and posts the reply back
+ * to the sender's inbox.
+ *
+ * Usage:
+ *   node hermes-forwarder.js
+ *
+ * Set up as Scheduled Task for auto-start:
+ *   See scripts/install.ps1 or register manually:
+ *   New-ScheduledTaskAction -Execute "node.exe" -Argument "...\hermes-forwarder.js"
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const BUS_DIR = path.join(__dirname, '.bus');
+const MSGS_DIR = path.join(BUS_DIR, 'messages');
+const AGENTS_FILE = path.join(BUS_DIR, 'agents.json');
+const TARGET = 'hermes';
+const POLL_MS = 3000;
+const HERMES_TIMEOUT = 190000;
+
+// Track processed message IDs
+const processed = new Set();
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function register() {
+  const agents = fs.existsSync(AGENTS_FILE)
+    ? JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf-8'))
+    : {};
+  agents['hermes-fwd'] = {
+    name: 'hermes-fwd',
+    description: 'Hermes Auto-Forwarder — relays DMs to Hermes Agent and replies back',
+    last_seen: new Date().toISOString(),
+    registered_at: agents['hermes-fwd']?.registered_at || new Date().toISOString(),
+  };
+  fs.writeFileSync(AGENTS_FILE, JSON.stringify(agents, null, 2), 'utf-8');
+}
+
+/**
+ * Send a prompt to Hermes CLI (async with timeout).
+ * Returns the cleaned response string.
+ */
+function askHermes(prompt) {
+  return new Promise((resolve) => {
+    const escapedPrompt = prompt.replace(/"/g, '\\"');
+    const child = spawn(
+      'cmd.exe',
+      ['/c', `hermes chat -q "${escapedPrompt}" --quiet --source tool 2>&1`],
+      { windowsHide: true, shell: true }
+    );
+
+    let output = '';
+    child.stdout.on('data', (d) => { output += d.toString(); });
+    child.stderr.on('data', (d) => { output += d.toString(); });
+
+    child.on('close', () => {
+      const clean = output.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+      const lines = clean.split('\n').filter((l) => {
+        const s = l.trim();
+        if (!s) return false;
+        if (s.startsWith('Query:') || s.startsWith('Resume') || s.startsWith('session_id:')) return false;
+        if (s.includes('Normalized model') || s.includes('Initializing')) return false;
+        if (s.includes('opencode') || s.includes('deepseek')) return false;
+        if (s.startsWith('⚠')) return false;
+        return true;
+      });
+      resolve(lines.join('\n').trim() || '(empty response)');
+    });
+
+    child.on('error', (e) => resolve(`[Hermes error: ${e.message.substring(0, 60)}]`));
+
+    // Safety timeout
+    setTimeout(() => {
+      child.kill();
+      resolve('[Hermes timeout]');
+    }, HERMES_TIMEOUT);
+  });
+}
+
+function sendReply(to, originalMsg, replyText) {
+  const inboxDir = path.join(MSGS_DIR, to);
+  ensureDir(inboxDir);
+
+  const msg = {
+    id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+    from: TARGET,
+    to,
+    message: replyText,
+    in_reply_to: originalMsg.id,
+    timestamp: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(path.join(inboxDir, `${msg.id}.json`), JSON.stringify(msg, null, 2), 'utf-8');
+  console.log(`  📬 Reply sent to "${to}" (id: ${msg.id})`);
+}
+
+async function poll() {
+  const inboxDir = path.join(MSGS_DIR, TARGET);
+  if (!fs.existsSync(MSGS_DIR) || !fs.existsSync(inboxDir)) return;
+
+  const files = fs.readdirSync(inboxDir).filter((f) => f.endsWith('.json'));
+
+  for (const f of files) {
+    if (processed.has(f)) continue;
+    processed.add(f);
+
+    try {
+      const msg = JSON.parse(fs.readFileSync(path.join(inboxDir, f), 'utf-8'));
+
+      // Skip messages from bots/self
+      if (['hermes', 'hermes-fwd', 'coco', 'webhook'].includes(msg.from)) continue;
+
+      console.log(`\n[${new Date().toISOString()}] 📩 DM from "${msg.from}": ${msg.message.substring(0, 80)}`);
+
+      console.log(`  🤖 Forwarding to Hermes...`);
+      const reply = await askHermes(msg.message);
+      console.log(`  💬 Hermes: ${reply.substring(0, 80)}`);
+
+      sendReply(msg.from, msg, reply);
+    } catch (err) {
+      console.error(`  ❌ Error processing ${f}: ${err.message}`);
+    }
+  }
+}
+
+// ── Main ──
+
+console.log(`
+╔══════════════════════════════════════════╗
+║  MCP CoCo — Hermes Auto-Forwarder       ║
+║                                          ║
+║  Any DM to "hermes" →                   ║
+║    ask_hermes(prompt) → reply back       ║
+║                                          ║
+║  Polling every ${POLL_MS}ms                   ║
+╚══════════════════════════════════════════╝
+`);
+
+register();
+ensureDir(path.join(MSGS_DIR, TARGET));
+
+// Register as forwarder on the webhook gateway too via agents.json
+poll();
+setInterval(poll, POLL_MS);

package/hermes.example.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "coco": {
+      "command": "node",
+      "args": ["C:\\Users\\Administrator\\.openclaw\\workspace\\mcp-coco\\index.js"],
+      "env": {}
+    }
+  }
+}

package/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * Bus Agent v2.3 — Universal Agent Communication Hub
+ *
+ * Usage:
+ *   node index.js              # stdio MCP server (for mcporter)
+ *   node index.js --daemon     # background daemon + scheduler
+ *   node index.js --health     # one-shot health check
+ *   node index.js --scheduler  # Run scheduler standalone
+ */
+
+const { runStdio } = require('./lib/mcp');
+const { Daemon } = require('./lib/daemon');
+const { AgentBus } = require('./lib/bus');
+const { Scheduler } = require('./lib/scheduler');
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--daemon')) {
+    const daemon = new Daemon();
+    await daemon.start();
+    return;
+  }
+
+  if (args.includes('--health')) {
+    const daemon = new Daemon();
+    const ok = await daemon.healthCheck();
+    process.exit(ok ? 0 : 1);
+  }
+
+  if (args.includes('--scheduler')) {
+    const bus = new AgentBus();
+    const scheduler = new Scheduler(bus);
+    scheduler.start();
+    console.log('CoCo Scheduler running. Press Ctrl+C to stop.');
+    // Keep alive
+    process.on('SIGINT', () => { scheduler.stop(); process.exit(0); });
+    process.on('SIGTERM', () => { scheduler.stop(); process.exit(0); });
+    // Hang around
+    setInterval(() => {}, 60000);
+    return;
+  }
+
+  // Default: stdio MCP server
+  await runStdio();
+}
+
+main().catch(err => {
+  console.error('FATAL:', err.message);
+  process.exit(1);
+});