agentlytics 0.2.4 → 0.2.6

package/editors/antigravity.js

@@ -1005,4 +1005,13 @@ function getArtifacts(folder) {
   return artifacts;
 }
 
-module.exports = { name, labels, getChats, getMessages, resetCache, getUsage, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  // Antigravity uses similar config to Windsurf: ~/.codeium/antigravity/mcp_config.json
+  const globalConfig = path.join(HOME, '.codeium', 'antigravity', 'mcp_config.json');
+  return [
+    ...parseMcpConfigFile(globalConfig, { editor: 'antigravity', label: 'Antigravity', scope: 'global' }),
+  ];
+}
+
+module.exports = { name, labels, getChats, getMessages, resetCache, getUsage, getArtifacts, getMCPServers };

package/editors/base.js

@@ -118,7 +118,192 @@ function scanArtifacts(folder, { editor, label, files = [], dirs = [] }) {
   return artifacts;
 }
 
+/**
+ * Parse a standard MCP config JSON file (mcpServers format).
+ * Returns array of { name, command, args, env, envKeys, url, transport, disabled }.
+ */
+function parseMcpConfigFile(filePath, { editor, label, scope }) {
+  const fs = require('fs');
+  if (!filePath || !fs.existsSync(filePath)) return [];
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(raw);
+    const servers = data.mcpServers || data.mcp_servers || data.servers || {};
+    return Object.entries(servers).map(([name, cfg]) => ({
+      name,
+      editor,
+      editorLabel: label,
+      scope,
+      configPath: filePath,
+      command: cfg.command || null,
+      args: cfg.args || [],
+      _env: cfg.env || {},
+      env: cfg.env ? Object.keys(cfg.env) : [],
+      url: cfg.url || null,
+      transport: cfg.url ? (cfg.transport || 'http') : (cfg.transport || 'stdio'),
+      disabled: cfg.disabled || false,
+      disabledTools: cfg.disabledTools || [],
+    }));
+  } catch { return []; }
+}
+
+/**
+ * Query an MCP server for its tools list via JSON-RPC 2.0.
+ * For stdio servers: spawns the command and communicates via stdin/stdout.
+ * For HTTP servers: sends POST to the URL.
+ * Returns a Promise<string[]> of tool names, or [] on failure.
+ * Timeout: 10s per server.
+ */
+function queryMcpServerTools(server) {
+  const TIMEOUT = 10000;
+
+  if (server.url && !server.command) {
+    // HTTP/SSE transport — send JSON-RPC via POST
+    return queryMcpServerToolsHttp(server.url, TIMEOUT);
+  }
+
+  if (!server.command) return Promise.resolve([]);
+
+  // stdio transport — spawn the process
+  return queryMcpServerToolsStdio(server, TIMEOUT);
+}
+
+function queryMcpServerToolsHttp(url, timeout) {
+  return new Promise((resolve) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => { controller.abort(); resolve([]); }, timeout);
+    const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json, text/event-stream' };
+
+    const parseToolsFromResponse = async (r) => {
+      const ct = r.headers.get('content-type') || '';
+      const text = await r.text();
+      if (ct.includes('text/event-stream')) {
+        // Parse SSE: lines starting with "data: "
+        for (const line of text.split('\n')) {
+          if (!line.startsWith('data: ')) continue;
+          try {
+            const msg = JSON.parse(line.slice(6));
+            if (msg.result && msg.result.tools) return msg.result.tools.map(t => t.name);
+          } catch {}
+        }
+        return [];
+      }
+      try {
+        const msg = JSON.parse(text);
+        return (msg.result && msg.result.tools) ? msg.result.tools.map(t => t.name) : [];
+      } catch { return []; }
+    };
+
+    // 1. Initialize
+    fetch(url, {
+      method: 'POST', headers,
+      body: JSON.stringify({
+        jsonrpc: '2.0', id: 1, method: 'initialize',
+        params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'agentlytics', version: '1.0.0' } },
+      }),
+      signal: controller.signal,
+    })
+    .then(async (r) => {
+      const sessionId = r.headers.get('mcp-session-id');
+      const h = { ...headers };
+      if (sessionId) h['mcp-session-id'] = sessionId;
+      await r.text(); // consume body
+
+      // 2. Send initialized notification
+      await fetch(url, {
+        method: 'POST', headers: h,
+        body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }),
+        signal: controller.signal,
+      }).then(r2 => r2.text());
+
+      // 3. Request tools/list
+      const r3 = await fetch(url, {
+        method: 'POST', headers: h,
+        body: JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} }),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timer);
+      resolve(await parseToolsFromResponse(r3));
+    })
+    .catch(() => { clearTimeout(timer); resolve([]); });
+  });
+}
+
+function queryMcpServerToolsStdio(server, timeout) {
+  const { spawn } = require('child_process');
+
+  return new Promise((resolve) => {
+    const env = { ...process.env, ...(server._env || {}) };
+    let child;
+    try {
+      child = spawn(server.command, server.args || [], {
+        env, stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch { return resolve([]); }
+
+    let stdout = '';
+    let done = false;
+    let initReceived = false;
+
+    const finish = (tools) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try { child.kill(); } catch {}
+      resolve(tools);
+    };
+
+    const timer = setTimeout(() => finish([]), timeout);
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+      // Parse newline-delimited JSON-RPC responses
+      const lines = stdout.split('\n');
+      // Keep the last (possibly incomplete) line in the buffer
+      stdout = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed);
+          // Got initialize response — now send initialized + tools/list
+          if (msg.id === 1 && msg.result && !initReceived) {
+            initReceived = true;
+            try {
+              child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
+              child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} }) + '\n');
+            } catch { finish([]); }
+          }
+          // Got tools/list response
+          if (msg.id === 2 && msg.result && msg.result.tools) {
+            finish(msg.result.tools.map(t => t.name));
+            return;
+          }
+        } catch { /* incomplete JSON, skip */ }
+      }
+    });
+
+    child.on('error', () => finish([]));
+    child.on('exit', () => finish([]));
+
+    // Send initialize
+    const initMsg = JSON.stringify({
+      jsonrpc: '2.0', id: 1, method: 'initialize',
+      params: {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'agentlytics', version: '1.0.0' },
+      },
+    }) + '\n';
+
+    try { child.stdin.write(initMsg); } catch { finish([]); }
+  });
+}
+
 module.exports = {
   getAppDataPath,
   scanArtifacts,
+  parseMcpConfigFile,
+  queryMcpServerTools,
 };

package/editors/claude.js

@@ -204,8 +204,18 @@ function extractAssistantContent(content) {
 // Usage / quota data from Anthropic OAuth API
 // ============================================================
 
+function isKeychainAccessAllowed() {
+  try {
+    const configPath = path.join(os.homedir(), '.agentlytics', 'config.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return config.allowKeychainAccess === true;
+  } catch { return false; }
+}
+
 function getClaudeCredentials() {
   // macOS: Keychain; Linux: secret-tool; Windows: not yet supported
+  // Requires explicit user permission (allowKeychainAccess in config)
+  if (!isKeychainAccessAllowed()) return null;
   try {
     const { execSync } = require('child_process');
     let raw;
@@ -311,4 +321,14 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  const results = [];
+  // Global: ~/.claude.json (has mcpServers key)
+  const globalFile = path.join(os.homedir(), '.claude.json');
+  results.push(...parseMcpConfigFile(globalFile, { editor: 'claude-code', label: 'Claude Code', scope: 'global' }));
+  // Project-level: .mcp.json (scanned per-project later via getAllMCPServers)
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };

package/editors/codex.js

@@ -519,6 +519,11 @@ function getArtifacts(folder) {
   });
 }
 
+function getMCPServers() {
+  // Codex doesn't have native MCP server configuration
+  return [];
+}
+
 module.exports = {
   name,
   labels,
@@ -526,4 +531,5 @@ module.exports = {
   getChats,
   getMessages,
   getUsage,
+  getMCPServers,
 };

package/editors/commandcode.js

@@ -158,4 +158,9 @@ function extractAssistantContent(content) {
 
 const labels = { 'commandcode': 'Command Code' };
 
-module.exports = { name, labels, getChats, getMessages };
+function getMCPServers() {
+  // CommandCode uses Claude's .mcp.json format (project-level, handled by claude.js)
+  return [];
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };

package/editors/copilot.js

@@ -250,4 +250,9 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts };
+function getMCPServers() {
+  // Copilot CLI shares MCP config with VS Code (handled by vscode.js)
+  return [];
+}
+
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };

package/editors/cursor-agent.js

@@ -194,4 +194,9 @@ function getMessages(chat) {
 
 const labels = { 'cursor-agent': 'Cursor Agent' };
 
-module.exports = { name, labels, getChats, getMessages };
+function getMCPServers() {
+  // Cursor Agent shares MCP config with Cursor (handled by cursor.js)
+  return [];
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };

package/editors/cursor.js

@@ -425,4 +425,12 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  const globalConfig = path.join(HOME, '.cursor', 'mcp.json');
+  return [
+    ...parseMcpConfigFile(globalConfig, { editor: 'cursor', label: 'Cursor', scope: 'global' }),
+  ];
+}
+
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };

package/editors/gemini.js

@@ -183,4 +183,13 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  // Global: ~/.gemini/settings.json (mcpServers key)
+  const globalSettings = path.join(os.homedir(), '.gemini', 'settings.json');
+  return [
+    ...parseMcpConfigFile(globalSettings, { editor: 'gemini-cli', label: 'Gemini CLI', scope: 'global' }),
+  ];
+}
+
+module.exports = { name, labels, getChats, getMessages, getArtifacts, getMCPServers };

package/editors/goose.js

@@ -306,4 +306,53 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, resetCache, getArtifacts };
+function getMCPServers() {
+  const results = [];
+  // Goose stores MCP config in ~/.config/goose/config.yaml under extensions
+  // Also check profiles.yaml for MCP server entries
+  const configFiles = [CONFIG_PATH, path.join(os.homedir(), '.config', 'goose', 'profiles.yaml')];
+  for (const cfgPath of configFiles) {
+    if (!fs.existsSync(cfgPath)) continue;
+    try {
+      const raw = fs.readFileSync(cfgPath, 'utf-8');
+      // Simple YAML parsing for mcpServers / extensions blocks
+      let currentServer = null;
+      let inMcp = false;
+      for (const line of raw.split('\n')) {
+        if (line.match(/^\s*(mcpServers|extensions):/)) { inMcp = true; continue; }
+        if (inMcp && line.match(/^\s{2}\w/) && !line.match(/^\s{4}/)) {
+          // New top-level key under mcpServers
+          if (currentServer) results.push(currentServer);
+          const nameMatch = line.match(/^\s{2}(\S+):/);
+          if (nameMatch) {
+            currentServer = {
+              name: nameMatch[1],
+              editor: 'goose',
+              editorLabel: 'Goose',
+              scope: 'global',
+              configPath: cfgPath,
+              command: null, args: [], env: [], url: null,
+              transport: 'stdio', disabled: false, disabledTools: [],
+            };
+          }
+          continue;
+        }
+        if (inMcp && currentServer) {
+          const cmdMatch = line.match(/^\s+command:\s*(.+)/);
+          if (cmdMatch) currentServer.command = cmdMatch[1].trim();
+          const urlMatch = line.match(/^\s+url:\s*(.+)/);
+          if (urlMatch) { currentServer.url = urlMatch[1].trim(); currentServer.transport = 'http'; }
+        }
+        if (line.match(/^\S/) && !line.match(/^\s/) && inMcp) {
+          if (currentServer) results.push(currentServer);
+          currentServer = null;
+          inMcp = false;
+        }
+      }
+      if (currentServer) results.push(currentServer);
+    } catch {}
+  }
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, resetCache, getArtifacts, getMCPServers };

package/editors/index.js

@@ -119,4 +119,55 @@ function getAllArtifacts(folder) {
   return Array.from(seen.values());
 }
 
-module.exports = { getAllChats, getMessages, editors, editorLabels, resetCaches, getAllUsage, getAllArtifacts };
+/**
+ * Get all MCP servers from all editors.
+ * Also scans project folders for project-level MCP configs (.mcp.json, .cursor/mcp.json, etc.)
+ */
+function getAllMCPServers(projectFolders = []) {
+  const { parseMcpConfigFile } = require('./base');
+  const path = require('path');
+  const fs = require('fs');
+  const servers = [];
+
+  // 1. Collect global MCP servers from each editor
+  for (const editor of editors) {
+    if (typeof editor.getMCPServers !== 'function') continue;
+    try {
+      servers.push(...editor.getMCPServers());
+    } catch { /* skip broken adapters */ }
+  }
+
+  // 2. Scan project folders for project-level MCP configs
+  const projectConfigs = [
+    { file: '.mcp.json', editor: 'claude-code', label: 'Claude Code' },
+    { file: '.cursor/mcp.json', editor: 'cursor', label: 'Cursor' },
+    { file: '.vscode/mcp.json', editor: 'vscode', label: 'VS Code' },
+    { file: '.gemini/settings.json', editor: 'gemini-cli', label: 'Gemini CLI' },
+    { file: '.kiro/settings/mcp.json', editor: 'kiro', label: 'Kiro' },
+  ];
+
+  const seenProjects = new Set();
+  for (const folder of projectFolders) {
+    if (!folder || seenProjects.has(folder)) continue;
+    seenProjects.add(folder);
+    for (const pc of projectConfigs) {
+      const configPath = path.join(folder, pc.file);
+      if (!fs.existsSync(configPath)) continue;
+      const found = parseMcpConfigFile(configPath, { editor: pc.editor, label: pc.label, scope: 'project' });
+      for (const s of found) {
+        s.projectFolder = folder;
+      }
+      servers.push(...found);
+    }
+  }
+
+  // 3. Deduplicate by name+editor (keep first occurrence, prefer global over project)
+  const seen = new Map();
+  for (const s of servers) {
+    const key = `${s.name}::${s.editor}::${s.scope}`;
+    if (!seen.has(key)) seen.set(key, s);
+  }
+  return Array.from(seen.values());
+}
+
+module.exports = { getAllChats, getMessages, editors, editorLabels, resetCaches, getAllUsage, getAllArtifacts, getAllMCPServers };

package/editors/kiro.js

@@ -303,4 +303,13 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  // Global: ~/.kiro/settings/mcp.json
+  const globalConfig = path.join(os.homedir(), '.kiro', 'settings', 'mcp.json');
+  return [
+    ...parseMcpConfigFile(globalConfig, { editor: 'kiro', label: 'Kiro', scope: 'global' }),
+  ];
+}
+
+module.exports = { name, labels, getChats, getMessages, getArtifacts, getMCPServers };

package/editors/opencode.js

@@ -313,4 +313,35 @@ function getMessages(chat) {
 
 const labels = { 'opencode': 'OpenCode' };
 
-module.exports = { name, labels, getChats, getMessages };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  // OpenCode: ~/.config/opencode/opencode.json (mcp key maps to mcpServers format)
+  const globalConfig = path.join(os.homedir(), '.config', 'opencode', 'opencode.json');
+  const results = [];
+  if (fs.existsSync(globalConfig)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(globalConfig, 'utf-8'));
+      const servers = data.mcp || {};
+      for (const [name, cfg] of Object.entries(servers)) {
+        if (typeof cfg !== 'object') continue;
+        results.push({
+          name,
+          editor: 'opencode',
+          editorLabel: 'OpenCode',
+          scope: 'global',
+          configPath: globalConfig,
+          command: cfg.command || null,
+          args: cfg.args || [],
+          env: cfg.env ? Object.keys(cfg.env) : [],
+          url: cfg.url || null,
+          transport: cfg.type || (cfg.url ? 'http' : 'stdio'),
+          disabled: false,
+          disabledTools: [],
+        });
+      }
+    } catch {}
+  }
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };

package/editors/vscode.js

@@ -396,4 +396,16 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  const results = [];
+  for (const variant of VARIANTS) {
+    if (!fs.existsSync(variant.appSupport)) continue;
+    // User-level: <appSupport>/User/mcp.json
+    const userMcp = path.join(variant.appSupport, 'User', 'mcp.json');
+    results.push(...parseMcpConfigFile(userMcp, { editor: variant.id, label: variant.id === 'vscode' ? 'VS Code' : 'VS Code Insiders', scope: 'global' }));
+  }
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers };

package/editors/windsurf.js

@@ -588,4 +588,17 @@ function getArtifacts(folder) {
   });
 }
 
-module.exports = { name, sources, labels, getChats, getMessages, resetCache, getUsage, getArtifacts };
+function getMCPServers() {
+  const { parseMcpConfigFile } = require('./base');
+  const results = [];
+  const configs = [
+    { file: path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'), editor: 'windsurf', label: 'Windsurf' },
+    { file: path.join(os.homedir(), '.codeium', 'windsurf-next', 'mcp_config.json'), editor: 'windsurf-next', label: 'Windsurf Next' },
+  ];
+  for (const c of configs) {
+    results.push(...parseMcpConfigFile(c.file, { editor: c.editor, label: c.label, scope: 'global' }));
+  }
+  return results;
+}
+
+module.exports = { name, sources, labels, getChats, getMessages, resetCache, getUsage, getArtifacts, getMCPServers };

package/editors/zed.js

@@ -180,4 +180,34 @@ function extractContent(content) {
 
 const labels = { 'zed': 'Zed' };
 
-module.exports = { name, labels, getChats, getMessages };
+function getMCPServers() {
+  const results = [];
+  // Zed stores MCP servers in ~/.config/zed/settings.json under context_servers key
+  const settingsPath = path.join(getZedDataPath(), 'settings.json');
+  if (!fs.existsSync(settingsPath)) return results;
+  try {
+    const data = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    const servers = data.context_servers || {};
+    for (const [name, cfg] of Object.entries(servers)) {
+      if (typeof cfg !== 'object') continue;
+      const settings = cfg.settings || {};
+      results.push({
+        name,
+        editor: 'zed',
+        editorLabel: 'Zed',
+        scope: 'global',
+        configPath: settingsPath,
+        command: settings.command || cfg.command || null,
+        args: settings.args || cfg.args || [],
+        env: settings.env ? Object.keys(settings.env) : [],
+        url: settings.url || cfg.url || null,
+        transport: (settings.url || cfg.url) ? 'http' : 'stdio',
+        disabled: false,
+        disabledTools: [],
+      });
+    }
+  } catch {}
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };

package/index.js

@@ -253,6 +253,39 @@ const BOT_STYLES = [
 ];
 
 (async () => {
+  // ── Ask for keychain access permission (first run only) ──
+  const CONFIG_DIR = path.join(os.homedir(), '.agentlytics');
+  const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+  let agentConfig = {};
+  try { agentConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')); } catch {}
+
+  if (agentConfig.allowKeychainAccess === undefined) {
+    // Only relevant on macOS / Linux where keychain/secret-tool is used
+    if (process.platform === 'darwin' || process.platform === 'linux') {
+      const storeName = process.platform === 'darwin' ? 'Keychain' : 'secret store';
+      console.log(chalk.yellow(`  ⚠ Some subscription details (e.g. Claude Code) require ${storeName} access.`));
+      console.log(chalk.dim(`    This reads stored credentials to show plan/usage info.`));
+      console.log('');
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise(r => {
+        rl.question(chalk.bold(`  Allow ${storeName} access for subscription details? (y/N) `), (a) => {
+          rl.close();
+          r(a.trim().toLowerCase());
+        });
+      });
+      agentConfig.allowKeychainAccess = answer === 'y' || answer === 'yes';
+      if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(agentConfig, null, 2));
+      if (agentConfig.allowKeychainAccess) {
+        console.log(chalk.green(`  ✓ ${storeName} access enabled`));
+      } else {
+        console.log(chalk.dim(`  – ${storeName} access skipped (subscription details won't be collected)`));
+      }
+      console.log('');
+    }
+  }
+
   let tick = 0;
   const startTime = Date.now();
   const result = await cache.scanAllAsync((p) => {
@@ -282,6 +315,11 @@ const BOT_STYLES = [
   const http = require('http');
   const net = require('net');
 
+  // Pre-cache MCP server tool lists (runs in background, non-blocking)
+  app.initMcpToolsCache().then(() => {
+    console.log(chalk.green('  ✓ MCP tools cached'));
+  }).catch(() => {});
+
   function isPortFree(port) {
     return new Promise((resolve) => {
       const tester = net.createServer()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlytics",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Comprehensive analytics dashboard for AI coding agents — Cursor, Windsurf, Claude Code, VS Code Copilot, Zed, Antigravity, OpenCode, Command Code",
   "main": "index.js",
   "bin": {