bus-agent 2.3.0

package/lib/doctor.js

@@ -0,0 +1,333 @@
+/**
+ * CoCo Doctor — Diagnostics & Health Check Module
+ *
+ * Export functions, no process.exit, accepts busDir as parameter.
+ * Used by: coco-cli.js, doctor.js (thin CLI wrapper)
+ */
+const fs = require('fs');
+const path = require('path');
+
+const REPORT_FILE = 'diagnostic-report.json';
+
+function defaults(opts = {}) {
+  return {
+    busDir: opts.busDir || path.join(process.cwd(), '.bus'),
+    fix: !!opts.fix,
+    quick: !!opts.quick,
+    report: !!opts.report,
+    watch: !!opts.watch,
+  };
+}
+
+function runDiagnostics(opts = {}) {
+  const cfg = defaults(opts);
+  const BUS_DIR = cfg.busDir;
+  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 SCHEDULE_FILE = path.join(BUS_DIR, 'schedule.json');
+  const RULES_FILE = path.join(BUS_DIR, 'auto-reply-rules.json');
+  const WORKFLOWS_FILE = path.join(BUS_DIR, 'workflows.json');
+
+  const tests = [];
+  let passed = 0, failed = 0, warnings = 0, fixes = 0;
+  const log = [];
+
+  function emit(line) { log.push(line); if (!cfg.quick) console.log(line); }
+
+  function check(name, fn) { tests.push({ name, fn }); }
+  function ok(name, detail) { passed++; emit(`  ✅ ${name}${detail ? ' — ' + detail : ''}`); }
+  function warn(name, detail) { warnings++; emit(`  ⚠️  ${name}${detail ? ' — ' + detail : ''}`); }
+  function fail(name, detail) { failed++; emit(`  ❌ ${name}${detail ? ' — ' + detail : ''}`); }
+  function fix(name, detail) { fixes++; emit(`     🔧 Fixed: ${name}${detail ? ' — ' + detail : ''}`); }
+
+  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`;
+  }
+
+  // ── Bus Directory ──
+  check('Bus directory exists', () => {
+    if (!fs.existsSync(BUS_DIR)) { fail('Bus directory missing', BUS_DIR); return false; }
+    ok('Bus directory', BUS_DIR); return true;
+  });
+
+  check('Required subdirectories', () => {
+    let allOk = true;
+    for (const dir of [MSGS_DIR, CHANNELS_DIR, EVENTS_DIR]) {
+      if (!fs.existsSync(dir)) {
+        if (cfg.fix) { fs.mkdirSync(dir, { recursive: true }); fix(`Created ${path.basename(dir)}`); }
+        else { warn(`Missing ${path.basename(dir)} directory`); allOk = false; }
+      }
+    }
+    if (allOk) ok('All required subdirectories exist');
+    return allOk;
+  });
+
+  check('Bus directory permissions', () => {
+    try {
+      const testFile = path.join(BUS_DIR, '.doctor-test');
+      fs.writeFileSync(testFile, 'test', 'utf-8'); fs.unlinkSync(testFile);
+      ok('Read/Write permissions'); return true;
+    } catch { fail('Cannot write to bus directory — check permissions'); return false; }
+  });
+
+  // ── Agent Registry ──
+  check('Agent registry file', () => {
+    if (!fs.existsSync(AGENTS_FILE)) { warn('No agents registered yet'); return true; }
+    try {
+      const agents = JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf-8'));
+      const count = Object.keys(agents).length;
+      ok('Agent registry', `${count} agent(s) registered`);
+      let issues = 0;
+      for (const [name, profile] of Object.entries(agents)) {
+        const missing = [];
+        if (!profile.last_seen) missing.push('last_seen');
+        if (!profile.registered_at) missing.push('registered_at');
+        if (missing.length > 0) { warn(`Agent "${name}" missing fields: ${missing.join(', ')}`); issues++; }
+        if (profile.last_seen) {
+          const age = Date.now() - new Date(profile.last_seen).getTime();
+          if (age > 86400000) { warn(`Agent "${name}" not seen for ${msAgo(age)}`); issues++; }
+        }
+      }
+      if (issues === 0) ok('All agent profiles valid');
+      return true;
+    } catch (err) { fail('Agent registry corrupted', err.message); return false; }
+  });
+
+  // ── Orphaned Agents ──
+  check('Orphaned agents', () => {
+    if (!fs.existsSync(AGENTS_FILE)) return true;
+    const agents = JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf-8'));
+    const orphans = [];
+    for (const [name] of Object.entries(agents)) {
+      const hasInbox = fs.existsSync(path.join(MSGS_DIR, name));
+      const hasOutbox = fs.existsSync(path.join(MSGS_DIR, `${name}_outbox`));
+      if (!hasInbox && !hasOutbox) {
+        const age = Date.now() - new Date(agents[name].last_seen).getTime();
+        if (age > 604800000) orphans.push(name);
+      }
+    }
+    if (orphans.length > 0) {
+      warn(`${orphans.length} orphaned agent(s)`, orphans.join(', '));
+      if (cfg.fix) {
+        for (const name of orphans) { delete agents[name]; fix(`Removed orphaned agent "${name}" from registry`); }
+        fs.writeFileSync(AGENTS_FILE, JSON.stringify(agents, null, 2), 'utf-8');
+      }
+    } else ok('No orphaned agents');
+    return true;
+  });
+
+  // ── Messages ──
+  check('Message inboxes', () => {
+    if (!fs.existsSync(MSGS_DIR)) return true;
+    const inboxes = fs.readdirSync(MSGS_DIR).filter(d => fs.statSync(path.join(MSGS_DIR, d)).isDirectory());
+    if (inboxes.length === 0) { ok('No message inboxes'); return true; }
+    let total = 0, largest = { name: '', count: 0 }, old = 0;
+    for (const inbox of inboxes) {
+      const dir = path.join(MSGS_DIR, inbox);
+      const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+      total += files.length;
+      if (files.length > largest.count) largest = { name: inbox, count: files.length };
+      for (const f of files) {
+        try {
+          const msg = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+          if (Date.now() - new Date(msg.timestamp).getTime() > 604800000) old++;
+        } catch {}
+      }
+    }
+    ok('Message system', `${total} messages across ${inboxes.length} inboxes`);
+    if (old > 0) warn(`${old} message(s) older than 7 days`, 'Consider archiving or cleanup');
+    if (largest.count > 100) warn(`Inbox "${largest.name}" has ${largest.count} messages`, 'Consider reading and deleting old ones');
+    return true;
+  });
+
+  check('Message file integrity', () => {
+    if (!fs.existsSync(MSGS_DIR)) return true;
+    let corrupted = 0;
+    const dirs = fs.readdirSync(MSGS_DIR).filter(d => fs.statSync(path.join(MSGS_DIR, d)).isDirectory());
+    for (const dir of dirs) {
+      const fullDir = path.join(MSGS_DIR, dir);
+      for (const f of fs.readdirSync(fullDir).filter(f => f.endsWith('.json'))) {
+        try { JSON.parse(fs.readFileSync(path.join(fullDir, f), 'utf-8')); }
+        catch { corrupted++; if (cfg.fix) { fs.unlinkSync(path.join(fullDir, f)); fix(`Removed corrupted message: ${dir}/${f}`); } }
+      }
+    }
+    if (corrupted > 0) warn(`${corrupted} corrupted message file(s)`);
+    else ok('All message files valid JSON');
+    return true;
+  });
+
+  // ── Channels ──
+  check('Channels', () => {
+    if (!fs.existsSync(CHANNELS_DIR)) return true;
+    const files = fs.readdirSync(CHANNELS_DIR).filter(f => f.endsWith('.json'));
+    if (files.length === 0) { ok('No channels'); return true; }
+    let valid = 0, issues = 0;
+    for (const f of files) {
+      try {
+        const ch = JSON.parse(fs.readFileSync(path.join(CHANNELS_DIR, f), 'utf-8'));
+        valid++;
+        const logDir = path.join(CHANNELS_DIR, ch.id, 'log');
+        if (fs.existsSync(logDir)) {
+          for (const lf of fs.readdirSync(logDir).filter(lf => lf.endsWith('.json'))) {
+            try { JSON.parse(fs.readFileSync(path.join(logDir, lf), 'utf-8')); }
+            catch {
+              if (cfg.fix) { fs.unlinkSync(path.join(logDir, lf)); fix(`Removed corrupted log entry: ${ch.id}/${lf}`); }
+              issues++;
+            }
+          }
+        }
+      } catch { warn(`Channel file corrupted: ${f}`); issues++; }
+    }
+    if (issues === 0) ok(`${valid} channel(s)`, 'All valid');
+    return true;
+  });
+
+  // ── Scheduler ──
+  check('Schedule file', () => {
+    if (!fs.existsSync(SCHEDULE_FILE)) { ok('No scheduled jobs'); return true; }
+    try {
+      const jobs = JSON.parse(fs.readFileSync(SCHEDULE_FILE, 'utf-8'));
+      ok('Schedule', `${jobs.length} job(s), ${jobs.filter(j => j.enabled !== false).length} enabled`);
+      let issues = 0;
+      for (const job of jobs) {
+        if (!job.message) { warn(`Job "${job.id}" has no message`); issues++; }
+        if (!job.cron && !job.at) { warn(`Job "${job.id}" has no cron or at`); issues++; }
+      }
+      if (issues === 0) ok('All jobs valid');
+      return true;
+    } catch (err) { fail('Schedule file corrupted', err.message); return false; }
+  });
+
+  // ── Auto-Reply Rules ──
+  check('Auto-reply rules', () => {
+    if (!fs.existsSync(RULES_FILE)) { ok('No auto-reply rules'); return true; }
+    try {
+      const rules = JSON.parse(fs.readFileSync(RULES_FILE, 'utf-8'));
+      ok('Auto-reply rules', `${rules.length} rule(s), ${rules.filter(r => r.enabled !== false).length} enabled`);
+      let issues = 0;
+      for (const rule of rules) {
+        if (!rule.match || !rule.action) { warn(`Rule "${rule.id}" missing match or action`); issues++; }
+      }
+      if (issues === 0) ok('All rules valid');
+      return true;
+    } catch (err) { fail('Auto-reply rules file corrupted', err.message); return false; }
+  });
+
+  // ── Workflows ──
+  check('Workflows', () => {
+    if (!fs.existsSync(WORKFLOWS_FILE)) { ok('No workflows'); return true; }
+    try {
+      const wfs = JSON.parse(fs.readFileSync(WORKFLOWS_FILE, 'utf-8'));
+      ok(`${wfs.length} workflow(s) defined`);
+      let issues = 0;
+      for (const wf of wfs) { if (!wf.steps || wf.steps.length === 0) { warn(`Workflow "${wf.id}" has no steps`); issues++; } }
+      if (issues === 0) ok('All workflows valid');
+      return true;
+    } catch (err) { fail('Workflows file corrupted', err.message); return false; }
+  });
+
+  // ── Disk Usage ──
+  check('Disk usage', () => {
+    function getSize(dir) {
+      if (!fs.existsSync(dir)) return 0;
+      let total = 0;
+      try {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, e.name);
+          total += e.isDirectory() ? getSize(full) : fs.statSync(full).size;
+        }
+      } catch {}
+      return total;
+    }
+    const sizeMB = (getSize(BUS_DIR) / 1024 / 1024).toFixed(2);
+    ok('Bus storage', `${sizeMB} MB`);
+    if (parseFloat(sizeMB) > 50) warn('Bus directory exceeds 50 MB', 'Consider cleaning old messages and events');
+    return true;
+  });
+
+  // ── Stale PID Files ──
+  check('Stale PID files', () => {
+    const pidFiles = ['.coco-daemon.pid', '.hermes-mcp.pid'];
+    let found = 0;
+    for (const pf of pidFiles) {
+      const p = path.join(path.dirname(BUS_DIR), pf);
+      if (fs.existsSync(p)) {
+        try {
+          const pid = parseInt(fs.readFileSync(p, 'utf-8').trim());
+          try { process.kill(pid, 0); } catch {
+            warn(`Stale PID file: ${pf} (PID ${pid} not running)`); found++;
+            if (cfg.fix) { fs.unlinkSync(p); fix(`Removed stale PID file: ${pf}`); }
+          }
+        } catch { warn(`Corrupted PID file: ${pf}`); found++; if (cfg.fix) { fs.unlinkSync(p); fix(`Removed corrupted PID file: ${pf}`); } }
+      }
+    }
+    if (found === 0) ok('No stale PID files');
+    return true;
+  });
+
+  // ── Event Logs ──
+  check('Event logs', () => {
+    if (!fs.existsSync(EVENTS_DIR)) return true;
+    const files = fs.readdirSync(EVENTS_DIR).filter(f => f.endsWith('.jsonl'));
+    if (files.length === 0) { ok('No event logs'); return true; }
+    let totalLines = 0, corruptedLines = 0;
+    for (const f of files) {
+      try {
+        const content = fs.readFileSync(path.join(EVENTS_DIR, f), 'utf-8');
+        for (const line of content.split('\n').filter(Boolean)) {
+          totalLines++;
+          try { JSON.parse(line); } catch { corruptedLines++; }
+        }
+      } catch {}
+    }
+    ok('Event logs', `${files.length} file(s), ${totalLines} events`);
+    if (corruptedLines > 0) warn(`${corruptedLines} corrupted event log line(s)`);
+    return true;
+  });
+
+  // ── Run ──
+  if (!cfg.quick) {
+    console.log(`\n╔═══════════════════════════════════════════════╗\n║     CoCo — Diagnostic Report                 ║\n╚═══════════════════════════════════════════════╝`);
+  }
+  for (const test of tests) test.fn();
+  const summary = summaryText(passed, failed, warnings, fixes);
+  if (!cfg.quick) {
+    console.log(`\n  ───────────────────────────────────────\n  ${summary}${fixes > 0 ? `\n  🔧 Auto-fixes applied: ${fixes}` : ''}\n`);
+  } else console.log(summary);
+
+  // Write report
+  if (cfg.report) {
+    const report = {
+      timestamp: new Date().toISOString(), passed, failed, warnings, fixes, summary,
+      bus_dir: BUS_DIR, log,
+    };
+    const reportPath = path.join(BUS_DIR, REPORT_FILE);
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+    console.log(`\n  Report saved: ${reportPath}`);
+  }
+
+  return { passed, failed, warnings, fixes, summary, log };
+}
+
+function summaryText(passed, failed, warnings, fixes) {
+  if (failed === 0 && warnings === 0) return `✅ All ${passed} checks passed. Bus is healthy.`;
+  if (failed === 0) return `⚠️  ${passed} passed, ${warnings} warnings. Bus is running with minor issues.`;
+  return `❌ ${passed} passed, ${warnings} warnings, ${failed} failed. Bus needs attention.`;
+}
+
+// Watch mode (blocking)
+function watchDiagnostics(opts = {}) {
+  const cfg = defaults(opts);
+  setInterval(() => {
+    console.log(`\n[${new Date().toISOString()}] Running diagnostics...`);
+    runDiagnostics(cfg);
+  }, 30000);
+}
+
+module.exports = { runDiagnostics, watchDiagnostics, REPORT_FILE };

package/lib/hermes.js

@@ -0,0 +1,162 @@
+/**
+ * Hermes Integration — bridges to Hermes Agent via CLI
+ * 
+ * Uses cmd.exe /c wrapper on Windows to provide a real console
+ * for prompt_toolkit (required by hermes chat).
+ */
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const HERMES_SESSION_DIR = path.join(__dirname, '..', '.sessions');
+
+class HermesBridge {
+  constructor() {
+    if (!fs.existsSync(HERMES_SESSION_DIR)) {
+      fs.mkdirSync(HERMES_SESSION_DIR, { recursive: true });
+    }
+  }
+
+  /**
+   * Send a prompt to Hermes Agent and get the response.
+   * Supports multi-turn via session_key.
+   */
+  async askHermes(prompt, sessionKey = '') {
+    const cmd = this._buildChatCommand(prompt, sessionKey);
+    const result = this._run(cmd);
+
+    const clean = this._cleanOutput(result.stdout);
+
+    // Parse session key
+    let newSessionKey = '';
+    const sessionMatch = clean.match(/session_id:\s*(\S+)/);
+    if (sessionMatch) {
+      newSessionKey = sessionMatch[1].trim();
+      if (newSessionKey) {
+        fs.writeFileSync(
+          path.join(HERMES_SESSION_DIR, newSessionKey),
+          new Date().toISOString(),
+          'utf-8'
+        );
+      }
+    }
+
+    // Extract just the response
+    const response = this._extractResponse(result.stdout);
+
+    return {
+      response,
+      session_key: newSessionKey,
+      had_session: !!sessionKey,
+    };
+  }
+
+  /**
+   * Send a message through Hermes to a chat platform.
+   */
+  async sendMessage(target, message) {
+    try {
+      const result = this._run(`hermes send --to "${target}" "${this._escape(message)}"`);
+      return { success: true, output: (result.stdout || '').trim() };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * List available Hermes messaging channels.
+   */
+  async listChannels(platform = '') {
+    try {
+      const args = platform ? `send --list ${platform}` : 'send --list';
+      const result = this._run(`hermes ${args}`);
+      return { channels: (result.stdout || '').trim() };
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+
+  /**
+   * Full health check: Hermes gateway + CLI availability.
+   */
+  async healthCheck() {
+    const checks = {};
+
+    try {
+      const result = this._run('hermes --version');
+      checks.cli = { ok: true, version: (result.stdout || '').trim() };
+    } catch (err) {
+      checks.cli = { ok: false, error: err.message };
+    }
+
+    try {
+      const result = this._run('hermes gateway status');
+      const out = (result.stdout || '') + (result.stderr || '');
+      checks.gateway = { ok: out.includes('Running'), status: out.trim() };
+    } catch (err) {
+      checks.gateway = { ok: false, error: err.message };
+    }
+
+    checks.timestamp = new Date().toISOString();
+    checks.all_ok = checks.cli.ok && checks.gateway.ok;
+    return checks;
+  }
+
+  _buildChatCommand(prompt, sessionKey) {
+    let cmd = `hermes chat -q "${this._escape(prompt)}" --quiet --source tool`;
+    if (sessionKey) {
+      const resumePath = path.join(HERMES_SESSION_DIR, sessionKey);
+      if (fs.existsSync(resumePath)) {
+        cmd += ` --resume ${sessionKey}`;
+      }
+    }
+    return cmd;
+  }
+
+  _run(cmd) {
+    // 2>&1: merge stderr into stdout (session_id is on stderr)
+    const wrapped = `cmd.exe /c ${cmd} 2>&1`;
+    try {
+      const stdout = execSync(wrapped, {
+        encoding: 'utf-8',
+        timeout: 180000,
+        windowsHide: true,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+      return { stdout, stderr: '' };
+    } catch (e) {
+      const stdout = e.stdout ? e.stdout.toString() : '';
+      const stderr = e.stderr ? e.stderr.toString() : '';
+      if (!stdout || stdout.trim().length < 2) throw e;
+      return { stdout, stderr };
+    }
+  }
+
+  _escape(str) {
+    return str.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+  }
+
+  _cleanOutput(text) {
+    return text ? text.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '') : '';
+  }
+
+  _extractResponse(text) {
+    const clean = this._cleanOutput(text || '');
+    const lines = clean.split('\n');
+    const result = [];
+
+    for (const line of lines) {
+      const s = line.trim();
+      if (!s) continue;
+      if (s.startsWith('Query:') || s.startsWith('Resume') || s.startsWith('session_id:')) continue;
+      if (s.includes('Normalized model') || s.includes('Initializing') || s.includes('Initialising')) continue;
+      if (s.includes('opencode') || s.includes('deepseek')) continue;
+      if (s.startsWith('⚠')) continue;
+      result.push(s);
+    }
+
+    return result.join('\n').trim();
+  }
+}
+
+module.exports = { HermesBridge };