let-them-talk 2.0.0

package/dashboard.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = parseInt(process.env.AGENT_BRIDGE_PORT || '3000', 10);
+const DEFAULT_DATA_DIR = process.env.AGENT_BRIDGE_DATA || path.join(process.cwd(), '.agent-bridge');
+const HTML_FILE = path.join(__dirname, 'dashboard.html');
+const PROJECTS_FILE = path.join(__dirname, 'projects.json');
+
+// --- Multi-project support ---
+
+function getProjects() {
+  if (!fs.existsSync(PROJECTS_FILE)) return [];
+  try { return JSON.parse(fs.readFileSync(PROJECTS_FILE, 'utf8')); } catch { return []; }
+}
+
+function saveProjects(projects) {
+  fs.writeFileSync(PROJECTS_FILE, JSON.stringify(projects, null, 2));
+}
+
+// Check if a directory has actual data files (not just an empty dir)
+function hasDataFiles(dir) {
+  if (!fs.existsSync(dir)) return false;
+  try {
+    const files = fs.readdirSync(dir);
+    return files.some(f => f.endsWith('.jsonl') || f === 'agents.json');
+  } catch { return false; }
+}
+
+// Resolve data dir: explicit project path > env var > cwd > legacy fallback
+// Prefers directories with actual data files over empty ones
+function resolveDataDir(projectPath) {
+  if (projectPath) {
+    const dir = path.join(projectPath, '.agent-bridge');
+    const dataDir = path.join(projectPath, 'data');
+    // Prefer whichever has data
+    if (hasDataFiles(dir)) return dir;
+    if (hasDataFiles(dataDir)) return dataDir;
+    if (fs.existsSync(dir)) return dir;
+    if (fs.existsSync(dataDir)) return dataDir;
+    return dir;
+  }
+  const legacyDir = path.join(__dirname, 'data');
+  // Prefer dir with actual data files
+  if (hasDataFiles(DEFAULT_DATA_DIR)) return DEFAULT_DATA_DIR;
+  if (hasDataFiles(legacyDir)) return legacyDir;
+  if (fs.existsSync(DEFAULT_DATA_DIR)) return DEFAULT_DATA_DIR;
+  if (fs.existsSync(legacyDir)) return legacyDir;
+  return DEFAULT_DATA_DIR;
+}
+
+function filePath(name, projectPath) {
+  return path.join(resolveDataDir(projectPath), name);
+}
+
+// --- Shared helpers ---
+
+function readJsonl(file) {
+  if (!fs.existsSync(file)) return [];
+  const content = fs.readFileSync(file, 'utf8').trim();
+  if (!content) return [];
+  return content.split('\n').map(line => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+function readJson(file) {
+  if (!fs.existsSync(file)) return {};
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return {}; }
+}
+
+function isPidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+// --- API handlers ---
+
+function apiHistory(query) {
+  const projectPath = query.get('project') || null;
+  const history = readJsonl(filePath('history.jsonl', projectPath));
+  const acks = readJson(filePath('acks.json', projectPath));
+  const limit = parseInt(query.get('limit') || '500', 10);
+  const threadId = query.get('thread_id');
+
+  let messages = history;
+  if (threadId) {
+    messages = messages.filter(m => m.thread_id === threadId || m.id === threadId);
+  }
+  messages = messages.slice(-limit);
+  messages.forEach(m => { m.acked = !!acks[m.id]; });
+  return messages;
+}
+
+function apiAgents(query) {
+  const projectPath = query.get('project') || null;
+  const agents = readJson(filePath('agents.json', projectPath));
+  const history = readJsonl(filePath('history.jsonl', projectPath));
+  const result = {};
+
+  // Build last message timestamp per agent from history
+  const lastMessageTime = {};
+  for (const m of history) {
+    lastMessageTime[m.from] = m.timestamp;
+  }
+
+  for (const [name, info] of Object.entries(agents)) {
+    const alive = isPidAlive(info.pid);
+    const lastActivity = info.last_activity || info.timestamp;
+    const idleSeconds = Math.floor((Date.now() - new Date(lastActivity).getTime()) / 1000);
+    result[name] = {
+      pid: info.pid,
+      alive,
+      registered_at: info.timestamp,
+      last_activity: lastActivity,
+      last_message: lastMessageTime[name] || null,
+      idle_seconds: alive ? idleSeconds : null,
+      status: !alive ? 'dead' : idleSeconds > 60 ? 'sleeping' : 'active',
+      listening_since: info.listening_since || null,
+      is_listening: !!(info.listening_since && alive),
+    };
+  }
+  return result;
+}
+
+function apiStatus(query) {
+  const projectPath = query.get('project') || null;
+  const history = readJsonl(filePath('history.jsonl', projectPath));
+  const agents = readJson(filePath('agents.json', projectPath));
+  const threads = new Set();
+  history.forEach(m => { if (m.thread_id) threads.add(m.thread_id); });
+
+  const agentEntries = Object.entries(agents);
+  const aliveCount = agentEntries.filter(([, a]) => isPidAlive(a.pid)).length;
+  const sleepingCount = agentEntries.filter(([, a]) => {
+    if (!isPidAlive(a.pid)) return false;
+    const lastActivity = a.last_activity || a.timestamp;
+    const idleSeconds = Math.floor((Date.now() - new Date(lastActivity).getTime()) / 1000);
+    return idleSeconds > 60;
+  }).length;
+
+  return {
+    messageCount: history.length,
+    agentCount: agentEntries.length,
+    aliveCount,
+    sleepingCount,
+    threadCount: threads.size,
+  };
+}
+
+function apiReset(query) {
+  const projectPath = query.get('project') || null;
+  const dataDir = resolveDataDir(projectPath);
+  const fixedFiles = ['messages.jsonl', 'history.jsonl', 'agents.json', 'acks.json'];
+  for (const f of fixedFiles) {
+    const p = path.join(dataDir, f);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  }
+  if (fs.existsSync(dataDir)) {
+    for (const f of fs.readdirSync(dataDir)) {
+      if (f.startsWith('consumed-') && f.endsWith('.json')) {
+        fs.unlinkSync(path.join(dataDir, f));
+      }
+    }
+  }
+  return { success: true };
+}
+
+// Inject a message from the dashboard (system message or nudge to an agent)
+function apiInjectMessage(body, query) {
+  const projectPath = query.get('project') || null;
+  const dataDir = resolveDataDir(projectPath);
+  const messagesFile = path.join(dataDir, 'messages.jsonl');
+  const historyFile = path.join(dataDir, 'history.jsonl');
+
+  if (!body.to || !body.content) {
+    return { error: 'Missing "to" and/or "content" fields' };
+  }
+
+  if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+  const fromName = body.from || 'Dashboard';
+  const now = new Date().toISOString();
+
+  // Broadcast to all agents
+  if (body.to === '__all__') {
+    const agents = readJson(path.join(dataDir, 'agents.json'));
+    const ids = [];
+    for (const name of Object.keys(agents)) {
+      const msg = {
+        id: Date.now().toString(36) + Math.random().toString(36).slice(2, 8),
+        from: fromName,
+        to: name,
+        content: body.content,
+        timestamp: now,
+        system: true,
+      };
+      fs.appendFileSync(messagesFile, JSON.stringify(msg) + '\n');
+      fs.appendFileSync(historyFile, JSON.stringify(msg) + '\n');
+      ids.push(msg.id);
+    }
+    return { success: true, messageIds: ids, broadcast: true };
+  }
+
+  const msg = {
+    id: Date.now().toString(36) + Math.random().toString(36).slice(2, 8),
+    from: fromName,
+    to: body.to,
+    content: body.content,
+    timestamp: now,
+    system: true,
+  };
+
+  fs.appendFileSync(messagesFile, JSON.stringify(msg) + '\n');
+  fs.appendFileSync(historyFile, JSON.stringify(msg) + '\n');
+
+  return { success: true, messageId: msg.id };
+}
+
+// Multi-project management
+function apiProjects() {
+  return getProjects();
+}
+
+function apiAddProject(body) {
+  if (!body.path) return { error: 'Missing "path" field' };
+  const absPath = path.resolve(body.path);
+  if (!fs.existsSync(absPath)) return { error: `Path does not exist: ${absPath}` };
+
+  const projects = getProjects();
+  const name = body.name || path.basename(absPath);
+  if (projects.find(p => p.path === absPath)) return { error: 'Project already added' };
+
+  projects.push({ name, path: absPath, added_at: new Date().toISOString() });
+  saveProjects(projects);
+  return { success: true, project: { name, path: absPath } };
+}
+
+function apiRemoveProject(body) {
+  if (!body.path) return { error: 'Missing "path" field' };
+  const absPath = path.resolve(body.path);
+  let projects = getProjects();
+  const before = projects.length;
+  projects = projects.filter(p => p.path !== absPath);
+  if (projects.length === before) return { error: 'Project not found' };
+  saveProjects(projects);
+  return { success: true };
+}
+
+// --- HTTP Server ---
+
+// Load HTML at startup (re-read on each request in dev for hot-reload)
+let htmlContent = fs.readFileSync(HTML_FILE, 'utf8');
+
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', chunk => { data += chunk; });
+    req.on('end', () => {
+      try { resolve(JSON.parse(data)); } catch { reject(new Error('Invalid JSON body')); }
+    });
+    req.on('error', reject);
+  });
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, 'http://localhost:' + PORT);
+
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  try {
+    // Serve dashboard HTML (re-read in dev mode for hot reload)
+    if (url.pathname === '/' || url.pathname === '/index.html') {
+      const html = process.env.NODE_ENV === 'development'
+        ? fs.readFileSync(HTML_FILE, 'utf8')
+        : htmlContent;
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(html);
+    }
+    // Existing APIs (now with ?project= param support)
+    else if (url.pathname === '/api/history' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiHistory(url.searchParams)));
+    }
+    else if (url.pathname === '/api/agents' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiAgents(url.searchParams)));
+    }
+    else if (url.pathname === '/api/status' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiStatus(url.searchParams)));
+    }
+    else if (url.pathname === '/api/reset' && req.method === 'POST') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiReset(url.searchParams)));
+    }
+    // Message injection
+    else if (url.pathname === '/api/inject' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const result = apiInjectMessage(body, url.searchParams);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    // Multi-project management
+    else if (url.pathname === '/api/projects' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiProjects()));
+    }
+    else if (url.pathname === '/api/projects' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const result = apiAddProject(body);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    else if (url.pathname === '/api/projects' && req.method === 'DELETE') {
+      const body = await parseBody(req);
+      const result = apiRemoveProject(body);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    else {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found' }));
+    }
+  } catch (err) {
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: err.message }));
+  }
+});
+
+server.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    console.error(`\n  Error: Port ${PORT} is already in use.`);
+    console.error(`  Another dashboard may be running. Try:`);
+    console.error(`    - Kill it: npx kill-port ${PORT}`);
+    console.error(`    - Or use a different port: AGENT_BRIDGE_PORT=3001 npx let-them-talk dashboard\n`);
+    process.exit(1);
+  }
+  throw err;
+});
+
+server.listen(PORT, () => {
+  const dataDir = resolveDataDir();
+  console.log('');
+  console.log('  Let Them Talk - Agent Bridge Dashboard v2.0');
+  console.log('  ============================================');
+  console.log('  Dashboard:  http://localhost:' + PORT);
+  console.log('  Data dir:   ' + dataDir);
+  console.log('  Projects:   ' + getProjects().length + ' registered');
+  console.log('  Polling:    every 2s');
+  console.log('');
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "let-them-talk",
+  "version": "2.0.0",
+  "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
+  "main": "server.js",
+  "bin": {
+    "agent-bridge": "./cli.js",
+    "let-them-talk": "./cli.js"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dashboard": "node dashboard.js"
+  },
+  "files": [
+    "server.js",
+    "dashboard.js",
+    "dashboard.html",
+    "cli.js"
+  ],
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "gemini-cli",
+    "codex-cli",
+    "agent",
+    "multi-agent",
+    "communication",
+    "message-broker",
+    "ai-agents",
+    "let-them-talk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dekelelz/let-them-talk.git"
+  },
+  "homepage": "https://github.com/Dekelelz/let-them-talk",
+  "bugs": {
+    "url": "https://github.com/Dekelelz/let-them-talk/issues"
+  },
+  "author": "Dekelelz",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}