agentlytics 0.0.10 → 0.1.0

package/mcp-server.js

@@ -0,0 +1,279 @@
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { SSEServerTransport } = require('@modelcontextprotocol/sdk/server/sse.js');
+const { StreamableHTTPServerTransport } = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+const { z } = require('zod');
+const crypto = require('crypto');
+
+/**
+ * Creates an MCP server instance wired to the relay database.
+ * Returns { mcpServer, transports } — caller wires SSE endpoints into Express.
+ */
+function createMcpServer(getDb) {
+  const mcpServer = new McpServer({
+    name: 'agentlytics-relay',
+    version: '1.0.0',
+  });
+
+  // ── Tool: list_users ──
+  mcpServer.tool(
+    'list_users',
+    'List all connected users and their shared projects',
+    {},
+    async () => {
+      const db = getDb();
+      if (!db) return { content: [{ type: 'text', text: 'Relay database not initialized' }] };
+      const users = db.prepare('SELECT username, last_seen, projects FROM users ORDER BY last_seen DESC').all();
+      const result = users.map(u => ({
+        username: u.username,
+        lastSeen: new Date(u.last_seen).toISOString(),
+        projects: JSON.parse(u.projects || '[]'),
+      }));
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+
+  // ── Tool: search_sessions ──
+  mcpServer.tool(
+    'search_sessions',
+    'Search across all users\' chat messages by keyword. Use this to find what someone worked on, or find discussions about a specific file or topic.',
+    {
+      query: z.string().describe('Search query — keyword, file name, or topic'),
+      username: z.string().optional().describe('Filter by specific username'),
+      project: z.string().optional().describe('Filter by project folder path (partial match)'),
+      limit: z.number().optional().describe('Max results (default 20)'),
+    },
+    async ({ query, username, project, limit }) => {
+      const db = getDb();
+      if (!db) return { content: [{ type: 'text', text: 'Relay database not initialized' }] };
+
+      let sql = `
+        SELECT rm.chat_id, rm.username, rm.role, rm.content, rm.model, rm.seq,
+               rc.name as chat_name, rc.source, rc.folder, rc.last_updated_at
+        FROM relay_messages rm
+        JOIN relay_chats rc ON rm.chat_id = rc.id AND rm.username = rc.username
+        WHERE rm.content LIKE ?`;
+      const params = [`%${query}%`];
+
+      if (username) { sql += ' AND rm.username = ?'; params.push(username); }
+      if (project) { sql += ' AND rc.folder LIKE ?'; params.push(`%${project}%`); }
+      sql += ' ORDER BY rc.last_updated_at DESC LIMIT ?';
+      params.push(limit || 20);
+
+      const rows = db.prepare(sql).all(...params);
+
+      if (rows.length === 0) {
+        return { content: [{ type: 'text', text: `No results found for "${query}"` }] };
+      }
+
+      const results = rows.map(r => ({
+        chatId: r.chat_id,
+        chatName: r.chat_name,
+        username: r.username,
+        role: r.role,
+        source: r.source,
+        folder: r.folder,
+        lastUpdated: r.last_updated_at ? new Date(r.last_updated_at).toISOString() : null,
+        model: r.model,
+        content: r.content.length > 300 ? r.content.substring(0, 300) + '...' : r.content,
+      }));
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+      };
+    }
+  );
+
+  // ── Tool: get_user_activity ──
+  mcpServer.tool(
+    'get_user_activity',
+    'Get recent activity for a specific user — their recent sessions, what they worked on, which editors and models they used.',
+    {
+      username: z.string().describe('Username to look up'),
+      project: z.string().optional().describe('Filter by project folder (partial match)'),
+      file_path: z.string().optional().describe('Filter by file path mentioned in messages'),
+      limit: z.number().optional().describe('Max sessions to return (default 20)'),
+    },
+    async ({ username, project, file_path, limit }) => {
+      const db = getDb();
+      if (!db) return { content: [{ type: 'text', text: 'Relay database not initialized' }] };
+
+      // First get sessions
+      let sql = `
+        SELECT rc.*, rcs.total_messages, rcs.models, rcs.tool_calls,
+               rcs.total_input_tokens, rcs.total_output_tokens
+        FROM relay_chats rc
+        LEFT JOIN relay_chat_stats rcs ON rc.id = rcs.chat_id AND rc.username = rcs.username
+        WHERE rc.username = ?`;
+      const params = [username];
+
+      if (project) { sql += ' AND rc.folder LIKE ?'; params.push(`%${project}%`); }
+      sql += ' ORDER BY rc.last_updated_at DESC LIMIT ?';
+      params.push(limit || 20);
+
+      let sessions = db.prepare(sql).all(...params);
+
+      // If file_path filter, narrow down to sessions mentioning that file
+      if (file_path && sessions.length > 0) {
+        const chatIds = sessions.map(s => s.id);
+        const placeholders = chatIds.map(() => '?').join(',');
+        const fileMatches = db.prepare(`
+          SELECT DISTINCT chat_id FROM relay_messages
+          WHERE chat_id IN (${placeholders}) AND username = ? AND content LIKE ?
+        `).all(...chatIds, username, `%${file_path}%`);
+        const matchingIds = new Set(fileMatches.map(m => m.chat_id));
+        sessions = sessions.filter(s => matchingIds.has(s.id));
+      }
+
+      if (sessions.length === 0) {
+        return { content: [{ type: 'text', text: `No activity found for user "${username}"` }] };
+      }
+
+      const result = sessions.map(s => ({
+        id: s.id,
+        name: s.name,
+        source: s.source,
+        mode: s.mode,
+        folder: s.folder,
+        lastUpdated: s.last_updated_at ? new Date(s.last_updated_at).toISOString() : null,
+        totalMessages: s.total_messages,
+        models: s.models ? [...new Set(JSON.parse(s.models))].slice(0, 5) : [],
+        toolCalls: s.tool_calls ? JSON.parse(s.tool_calls).length : 0,
+        totalInputTokens: s.total_input_tokens,
+        totalOutputTokens: s.total_output_tokens,
+      }));
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+      };
+    }
+  );
+
+  // ── Tool: get_session_detail ──
+  mcpServer.tool(
+    'get_session_detail',
+    'Get the full conversation messages for a specific session. Use the session ID from search_sessions or get_user_activity results.',
+    {
+      session_id: z.string().describe('The chat/session ID'),
+      username: z.string().optional().describe('Username who owns the session (optional, auto-detected if unique)'),
+    },
+    async ({ session_id, username }) => {
+      const db = getDb();
+      if (!db) return { content: [{ type: 'text', text: 'Relay database not initialized' }] };
+
+      let chatSql = 'SELECT * FROM relay_chats WHERE id = ?';
+      const chatParams = [session_id];
+      if (username) { chatSql += ' AND username = ?'; chatParams.push(username); }
+      chatSql += ' LIMIT 1';
+
+      const chat = db.prepare(chatSql).get(...chatParams);
+      if (!chat) {
+        return { content: [{ type: 'text', text: `Session "${session_id}" not found` }] };
+      }
+
+      const messages = db.prepare(
+        'SELECT seq, role, content, model FROM relay_messages WHERE chat_id = ? AND username = ? ORDER BY seq'
+      ).all(chat.id, chat.username);
+
+      const formatted = messages.map(m => {
+        const label = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : m.role;
+        const modelTag = m.model ? ` (${m.model})` : '';
+        const content = m.content.length > 2000 ? m.content.substring(0, 2000) + '\n... [truncated]' : m.content;
+        return `## ${label}${modelTag}\n\n${content}`;
+      }).join('\n\n---\n\n');
+
+      const header = `# ${chat.name || 'Untitled Session'}\n**User:** ${chat.username} | **Editor:** ${chat.source} | **Project:** ${chat.folder || 'N/A'}\n\n---\n\n`;
+
+      return {
+        content: [{ type: 'text', text: header + formatted }],
+      };
+    }
+  );
+
+  return mcpServer;
+}
+
+/**
+ * Wire MCP SSE transport into an Express app.
+ * GET /mcp → establishes SSE connection
+ * POST /mcp → receives messages from MCP client
+ */
+function wireMcpToExpress(app, getDb) {
+  const sseTransports = {};
+  const httpTransports = {};
+
+  // SSE: GET /mcp establishes SSE stream
+  app.get('/mcp', async (req, res) => {
+    const sessionId = req.headers['mcp-session-id'];
+
+    // Streamable HTTP GET for SSE stream resumption
+    if (sessionId && httpTransports[sessionId]) {
+      const transport = httpTransports[sessionId];
+      await transport.handleRequest(req, res);
+      return;
+    }
+
+    // Legacy SSE transport
+    const transport = new SSEServerTransport('/mcp', res);
+    sseTransports[transport.sessionId] = transport;
+
+    const mcpServer = createMcpServer(getDb);
+
+    res.on('close', () => {
+      delete sseTransports[transport.sessionId];
+      mcpServer.close().catch(() => {});
+    });
+
+    await mcpServer.connect(transport);
+  });
+
+  // POST /mcp handles both SSE messages and Streamable HTTP
+  app.post('/mcp', async (req, res) => {
+    // Check for SSE session first
+    const sseSessionId = req.query.sessionId;
+    if (sseSessionId && sseTransports[sseSessionId]) {
+      await sseTransports[sseSessionId].handlePostMessage(req, res);
+      return;
+    }
+
+    // Streamable HTTP: check for existing session
+    const sessionId = req.headers['mcp-session-id'];
+    if (sessionId && httpTransports[sessionId]) {
+      await httpTransports[sessionId].handleRequest(req, res, req.body);
+      return;
+    }
+
+    // New Streamable HTTP session (initialization request)
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => crypto.randomUUID(),
+      onsessioninitialized: (id) => {
+        httpTransports[id] = transport;
+      },
+    });
+
+    transport.onclose = () => {
+      if (transport.sessionId) {
+        delete httpTransports[transport.sessionId];
+      }
+    };
+
+    const mcpServer = createMcpServer(getDb);
+    await mcpServer.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  });
+
+  // DELETE /mcp for session cleanup
+  app.delete('/mcp', async (req, res) => {
+    const sessionId = req.headers['mcp-session-id'];
+    if (sessionId && httpTransports[sessionId]) {
+      await httpTransports[sessionId].handleRequest(req, res);
+      return;
+    }
+    res.status(404).end();
+  });
+
+  return { sseTransports, httpTransports };
+}
+
+module.exports = { createMcpServer, wireMcpToExpress };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlytics",
-  "version": "0.0.10",
+  "version": "0.1.0",
   "description": "Comprehensive analytics dashboard for AI coding agents — Cursor, Windsurf, Claude Code, VS Code Copilot, Zed, Antigravity, OpenCode, Command Code",
   "main": "index.js",
   "bin": {
@@ -11,6 +11,9 @@
     "cache.js",
     "server.js",
     "share-image.js",
+    "relay-server.js",
+    "relay-client.js",
+    "mcp-server.js",
     "editors/",
     "ui/src/",
     "ui/index.html",
@@ -46,10 +49,12 @@
     "url": "https://github.com/f/agentlytics"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "better-sqlite3": "^12.6.2",
     "chalk": "^4.1.2",
     "commander": "^14.0.3",
     "express": "^4.22.1",
+    "inquirer": "^13.3.0",
     "open": "^8.4.2"
   }
 }

package/relay-client.js

@@ -0,0 +1,307 @@
+const chalk = require('chalk');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const readline = require('readline');
+const crypto = require('crypto');
+
+const cache = require('./cache');
+
+const SYNC_INTERVAL_MS = 30000; // 30 seconds
+
+const EDITOR_LABELS = {
+  'cursor': 'Cursor',
+  'windsurf': 'Windsurf',
+  'windsurf-next': 'Windsurf Next',
+  'antigravity': 'Antigravity',
+  'claude-code': 'Claude Code',
+  'claude': 'Claude Code',
+  'vscode': 'VS Code',
+  'vscode-insiders': 'VS Code Insiders',
+  'zed': 'Zed',
+  'opencode': 'OpenCode',
+  'codex': 'Codex CLI',
+  'gemini-cli': 'Gemini CLI',
+  'copilot-cli': 'Copilot CLI',
+  'cursor-agent': 'Cursor (Background Agent)',
+  'commandcode': 'CommandCode',
+};
+
+/**
+ * Interactive project picker using readline (no external deps beyond Node built-ins).
+ * Returns an array of selected folder paths.
+ */
+async function pickProjects() {
+  cache.initDb();
+
+  // Scan to populate cache
+  console.log(chalk.dim('  Scanning local sessions...'));
+  cache.scanAll(() => {});
+
+  const db = cache.getDb();
+  const projects = db.prepare(`
+    SELECT folder, COUNT(*) as count
+    FROM chats WHERE folder IS NOT NULL
+    GROUP BY folder ORDER BY count DESC
+  `).all();
+
+  if (projects.length === 0) {
+    console.log(chalk.yellow('  No projects found in local cache.'));
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  const cwdMatch = projects.find(p => p.folder === cwd);
+
+  // If cwd is a known project, offer quick share
+  if (cwdMatch) {
+    const name = cwdMatch.folder.split('/').pop();
+    const editors = db.prepare(`
+      SELECT source, COUNT(*) as count FROM chats
+      WHERE folder = ? AND source IS NOT NULL
+      GROUP BY source ORDER BY count DESC
+    `).all(cwdMatch.folder);
+    console.log('');
+    console.log(chalk.cyan(`    ${name}`) + chalk.dim(` — ${cwdMatch.count} sessions`));
+    for (const e of editors) {
+      console.log(chalk.yellow(`      • ${EDITOR_LABELS[e.source] || e.source}`) + chalk.dim(` (${e.count} sessions)`));
+    }
+    console.log('');
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(r => {
+      rl.question(chalk.bold('  Share your sessions with your team? ') + chalk.dim('(Y/n) '), r);
+    });
+    rl.close();
+
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === '' || trimmed === 'y' || trimmed === 'yes') {
+      return [cwdMatch.folder];
+    }
+    // Fall through to full picker
+  }
+
+  console.log('');
+  console.log(chalk.bold('  Select projects to share (comma-separated numbers, or "all"):'));
+  console.log('');
+  projects.forEach((p, i) => {
+    const name = p.folder.split('/').pop();
+    console.log(chalk.cyan(`  ${i + 1}.`) + ` ${name} ${chalk.dim(`(${p.count} sessions) — ${p.folder}`)}`);
+  });
+  console.log('');
+
+  const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  return new Promise((resolve) => {
+    rl2.question(chalk.bold('  > '), (answer) => {
+      rl2.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === 'all' || trimmed === '*') {
+        resolve(projects.map(p => p.folder));
+        return;
+      }
+      const indices = trimmed.split(/[,\s]+/).map(s => parseInt(s.trim()) - 1).filter(i => i >= 0 && i < projects.length);
+      if (indices.length === 0) {
+        console.log(chalk.red('  No valid selection. Exiting.'));
+        process.exit(1);
+      }
+      resolve(indices.map(i => projects[i].folder));
+    });
+  });
+}
+
+/**
+ * Collect data for selected projects from local cache DB.
+ */
+function collectProjectData(selectedFolders) {
+  const db = cache.getDb();
+  if (!db) return { chats: [], messages: [], stats: [] };
+
+  const allChats = [];
+  const allMessages = [];
+  const allStats = [];
+
+  for (const folder of selectedFolders) {
+    // Get chats for this project
+    const chats = db.prepare(`
+      SELECT id, source, name, mode, folder, created_at, last_updated_at, bubble_count
+      FROM chats WHERE folder = ?
+    `).all(folder);
+
+    for (const chat of chats) {
+      allChats.push({
+        id: chat.id,
+        source: chat.source,
+        name: chat.name,
+        mode: chat.mode,
+        folder: chat.folder,
+        created_at: chat.created_at,
+        last_updated_at: chat.last_updated_at,
+        bubble_count: chat.bubble_count,
+      });
+
+      // Get messages
+      const messages = db.prepare(
+        'SELECT chat_id, seq, role, content, model FROM messages WHERE chat_id = ? ORDER BY seq'
+      ).all(chat.id);
+      for (const m of messages) {
+        allMessages.push({
+          chat_id: m.chat_id,
+          seq: m.seq,
+          role: m.role,
+          content: m.content,
+          model: m.model,
+        });
+      }
+
+      // Get stats
+      const stat = db.prepare(
+        'SELECT * FROM chat_stats WHERE chat_id = ?'
+      ).get(chat.id);
+      if (stat) {
+        allStats.push({
+          chat_id: stat.chat_id,
+          total_messages: stat.total_messages,
+          user_messages: stat.user_messages,
+          assistant_messages: stat.assistant_messages,
+          tool_calls: JSON.parse(stat.tool_calls || '[]'),
+          models: JSON.parse(stat.models || '[]'),
+          total_input_tokens: stat.total_input_tokens,
+          total_output_tokens: stat.total_output_tokens,
+        });
+      }
+    }
+  }
+
+  return { chats: allChats, messages: allMessages, stats: allStats };
+}
+
+/**
+ * POST data to relay server.
+ */
+function postToRelay(host, port, username, data, authToken) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({
+      username,
+      projects: data.projects,
+      chats: data.chats,
+      messages: data.messages,
+      stats: data.stats,
+    });
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(payload),
+    };
+    if (authToken) headers['Authorization'] = `Bearer ${authToken}`;
+
+    const options = {
+      hostname: host,
+      port: port,
+      path: '/relay/sync',
+      method: 'POST',
+      headers,
+    };
+
+    const req = http.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          resolve({ raw: body });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(15000, () => {
+      req.destroy(new Error('Request timed out'));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * Main join client entry point.
+ */
+async function startJoinClient(relayAddress, username) {
+  console.log('');
+  console.log(chalk.bold('  ⚡ Agentlytics Relay — Join'));
+  console.log(chalk.dim(`  Connecting to relay at ${relayAddress}`));
+  console.log(chalk.dim(`  Username: ${username}`));
+  console.log('');
+
+  // Parse host:port
+  const parts = relayAddress.replace(/^https?:\/\//, '').split(':');
+  const host = parts[0] || 'localhost';
+  const port = parseInt(parts[1]) || 4638;
+
+  // Auth token from RELAY_PASSWORD env
+  const relayPassword = process.env.RELAY_PASSWORD || null;
+  const authToken = relayPassword
+    ? crypto.createHmac('sha256', 'agentlytics-relay').update(relayPassword).digest('hex')
+    : null;
+
+  // Test connection
+  try {
+    const testResult = await postToRelay(host, port, username, { projects: [], chats: [], messages: [], stats: [] }, authToken);
+    if (!testResult.ok) {
+      const msg = testResult.error || 'unknown error';
+      if (msg === 'Unauthorized') {
+        console.log(chalk.red('  ✗ Relay requires a password. Set RELAY_PASSWORD env variable.'));
+      } else {
+        console.log(chalk.red(`  ✗ Failed to connect: ${msg}`));
+      }
+      process.exit(1);
+    }
+    console.log(chalk.green('  ✓ Connected to relay'));
+  } catch (err) {
+    console.log(chalk.red(`  ✗ Cannot reach relay at ${host}:${port}`));
+    console.log(chalk.dim(`    ${err.message}`));
+    process.exit(1);
+  }
+
+  // Pick projects
+  const selectedFolders = await pickProjects();
+  console.log('');
+  console.log(chalk.green(`  ✓ Sharing ${selectedFolders.length} project(s):`));
+  for (const f of selectedFolders) {
+    console.log(chalk.dim(`    • ${f.split('/').pop()} — ${f}`));
+  }
+  console.log('');
+
+  // Initial sync
+  async function sync() {
+    try {
+      // Rescan editors to pick up new/updated sessions (reset caches so fresh LS data is obtained)
+      cache.scanAll(() => {}, { resetCaches: true });
+      const data = collectProjectData(selectedFolders);
+      data.projects = selectedFolders;
+      const result = await postToRelay(host, port, username, data, authToken);
+      if (result.ok) {
+        const s = result.synced || {};
+        process.stdout.write(chalk.dim(`\r  ⟳ Synced: ${s.chats || 0} chats, ${s.messages || 0} messages — ${new Date().toLocaleTimeString()}    `));
+      } else {
+        process.stdout.write(chalk.yellow(`\r  ⚠ Sync issue: ${result.error || 'unknown'}    `));
+      }
+    } catch (err) {
+      process.stdout.write(chalk.red(`\r  ✗ Sync failed: ${err.message}    `));
+    }
+  }
+
+  console.log(chalk.cyan(`  ⟳ Syncing every ${SYNC_INTERVAL_MS / 1000}s (Ctrl+C to stop)`));
+  console.log('');
+
+  // Do first sync immediately
+  await sync();
+
+  // Then sync periodically
+  setInterval(sync, SYNC_INTERVAL_MS);
+}
+
+module.exports = { startJoinClient };