@agenticmail/enterprise 0.5.240 → 0.5.242

package/src/engine/agent-routes.ts

@@ -1154,6 +1154,9 @@ export function createAgentRoutes(opts: {
     return c.json({ config: managed.config?.browserConfig || {} });
   });
 
+  // ── In-memory registry of running meeting browsers (survives config save/reload issues) ──
+  const meetingBrowsers = new Map<string, { port: number; cdpUrl: string; pid?: number }>();
+
   /**
    * POST /bridge/agents/:id/browser-config/launch-meeting-browser
    * Launches a meeting-ready headed Chrome instance with virtual display + audio.
@@ -1267,16 +1270,21 @@ export function createAgentRoutes(opts: {
         }, 400);
       }
 
-      // Check if a meeting browser is already running for this agent
-      const existingPort = (managed.config as any)?.meetingBrowserPort;
+      // Check if a meeting browser is already running for this agent (in-memory registry first, then config fallback)
+      const tracked = meetingBrowsers.get(agentId);
+      const existingPort = tracked?.port || (managed.config as any)?.meetingBrowserPort;
       if (existingPort) {
         try {
           const resp = await fetch(`http://127.0.0.1:${existingPort}/json/version`, { signal: AbortSignal.timeout(2000) });
           if (resp.ok) {
             const data = await resp.json() as any;
+            // Ensure registry is up to date
+            meetingBrowsers.set(agentId, { port: existingPort, cdpUrl: data.webSocketDebuggerUrl, pid: tracked?.pid });
             return c.json({ ok: true, alreadyRunning: true, cdpUrl: data.webSocketDebuggerUrl, port: existingPort, browserVersion: data.Browser });
           }
         } catch { /* not running, will launch new one */ }
+        // Was tracked but not responding — clean up
+        meetingBrowsers.delete(agentId);
       }
 
       // ── Create a realistic browser profile using agent identity ──
@@ -1398,12 +1406,13 @@ export function createAgentRoutes(opts: {
         return c.json({ error: 'Chrome launched but CDP not responding after 15s' });
       }
 
-      // Save port to agent config for reuse
+      // Save to in-memory registry (primary) and agent config (backup)
+      meetingBrowsers.set(agentId, { port, cdpUrl, pid: child.pid });
       if (!managed.config) managed.config = {} as any;
       (managed.config as any).meetingBrowserPort = port;
       (managed.config as any).meetingBrowserCdpUrl = cdpUrl;
       managed.updatedAt = new Date().toISOString();
-      await lifecycle.saveAgent(agentId);
+      try { await lifecycle.saveAgent(agentId); } catch (e) { console.warn('[meeting-browser] Config save failed (non-fatal):', e); }
 
       return c.json({ ok: true, cdpUrl, port, browserVersion, pid: child.pid });
     } catch (e: any) {
@@ -1421,7 +1430,8 @@ export function createAgentRoutes(opts: {
     if (!managed) return c.json({ error: 'Agent not found' }, 404);
 
     try {
-      const port = (managed.config as any)?.meetingBrowserPort;
+      const tracked = meetingBrowsers.get(agentId);
+      const port = tracked?.port || (managed.config as any)?.meetingBrowserPort;
       if (!port) return c.json({ error: 'No meeting browser is tracked for this agent' }, 400);
 
       // Try to close gracefully via CDP
@@ -1440,20 +1450,28 @@ export function createAgentRoutes(opts: {
         }
       } catch { /* not running or not reachable */ }
 
-      // Fallback: kill by port
+      // Fallback: kill by PID first (most reliable), then by port
+      if (!closed && tracked?.pid) {
+        try { process.kill(tracked.pid, 'SIGTERM'); closed = true; } catch { /* already dead */ }
+      }
       if (!closed) {
         try {
           const { execSync } = await import('node:child_process');
-          execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || true`, { timeout: 5000 });
+          if (process.platform === 'win32') {
+            execSync(`for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port}') do taskkill /PID %a /F 2>nul`, { timeout: 5000 });
+          } else {
+            execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || fuser -k ${port}/tcp 2>/dev/null || true`, { timeout: 5000 });
+          }
           closed = true;
         } catch { /* already dead */ }
       }
 
-      // Clear config
+      // Clear from registry and config
+      meetingBrowsers.delete(agentId);
       delete (managed.config as any).meetingBrowserPort;
       delete (managed.config as any).meetingBrowserCdpUrl;
       managed.updatedAt = new Date().toISOString();
-      await lifecycle.saveAgent(agentId);
+      try { await lifecycle.saveAgent(agentId); } catch (e) { console.warn('[meeting-browser] Config save failed (non-fatal):', e); }
 
       return c.json({ ok: true, stopped: true, port });
     } catch (e: any) {

package/src/engine/routes.ts

@@ -341,6 +341,219 @@ engine.get('/hierarchy/escalations/:agentId', async (c) => {
   }
 });
 
+// ─── MCP Server Management ──────────────────────────────────────────
+// CRUD for external MCP server connections (stdio, SSE, HTTP)
+engine.get('/mcp-servers', async (c) => {
+  try {
+    const rows = await engineDb.query(`SELECT * FROM mcp_servers WHERE org_id = $1 ORDER BY created_at DESC`, ['default']);
+    const servers = (rows || []).map((r: any) => {
+      const config = typeof r.config === 'string' ? JSON.parse(r.config) : (r.config || {});
+      return { id: r.id, ...config, status: r.status || 'unknown', toolCount: r.tool_count || 0, tools: r.tools ? (typeof r.tools === 'string' ? JSON.parse(r.tools) : r.tools) : [] };
+    });
+    return c.json({ servers });
+  } catch (e: any) {
+    // Table may not exist yet
+    if (e.message?.includes('does not exist') || e.message?.includes('no such table')) {
+      return c.json({ servers: [] });
+    }
+    return c.json({ error: e.message }, 500);
+  }
+});
+
+engine.post('/mcp-servers', async (c) => {
+  try {
+    await engineDb.exec(`CREATE TABLE IF NOT EXISTS mcp_servers (
+      id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      config JSONB NOT NULL DEFAULT '{}',
+      status TEXT DEFAULT 'unknown',
+      tool_count INTEGER DEFAULT 0,
+      tools JSONB DEFAULT '[]',
+      created_at TIMESTAMPTZ DEFAULT NOW(),
+      updated_at TIMESTAMPTZ DEFAULT NOW()
+    )`);
+    const body = await c.req.json();
+    const id = crypto.randomUUID();
+    await engineDb.exec(`INSERT INTO mcp_servers (id, org_id, config) VALUES ($1, $2, $3)`, [id, 'default', JSON.stringify(body)]);
+    return c.json({ ok: true, id });
+  } catch (e: any) { return c.json({ error: e.message }, 500); }
+});
+
+engine.put('/mcp-servers/:id', async (c) => {
+  try {
+    const id = c.req.param('id');
+    const body = await c.req.json();
+    // Merge with existing config
+    const rows = await engineDb.query(`SELECT config FROM mcp_servers WHERE id = $1`, [id]);
+    if (!rows?.length) return c.json({ error: 'Server not found' }, 404);
+    const existing = typeof rows[0].config === 'string' ? JSON.parse(rows[0].config) : (rows[0].config || {});
+    const merged = { ...existing, ...body };
+    await engineDb.exec(`UPDATE mcp_servers SET config = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(merged), id]);
+    return c.json({ ok: true });
+  } catch (e: any) { return c.json({ error: e.message }, 500); }
+});
+
+engine.delete('/mcp-servers/:id', async (c) => {
+  try {
+    await engineDb.exec(`DELETE FROM mcp_servers WHERE id = $1`, [c.req.param('id')]);
+    return c.json({ ok: true });
+  } catch (e: any) { return c.json({ error: e.message }, 500); }
+});
+
+engine.post('/mcp-servers/:id/test', async (c) => {
+  try {
+    const id = c.req.param('id');
+    const rows = await engineDb.query(`SELECT config FROM mcp_servers WHERE id = $1`, [id]);
+    if (!rows?.length) return c.json({ error: 'Server not found' }, 404);
+    const config = typeof rows[0].config === 'string' ? JSON.parse(rows[0].config) : (rows[0].config || {});
+
+    if (config.type === 'stdio') {
+      // Test stdio: spawn process, send initialize, read response
+      const { spawn } = await import('node:child_process');
+      const args = config.args || [];
+      const env = { ...process.env, ...(config.env || {}) };
+      const child = spawn(config.command, args, { stdio: ['pipe', 'pipe', 'pipe'], env, timeout: (config.timeout || 30) * 1000 });
+
+      const initMsg = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'AgenticMail', version: '1.0' } } });
+      child.stdin.write(initMsg + '\n');
+
+      const result: any = await new Promise((resolve) => {
+        let buf = '';
+        const timer = setTimeout(() => { child.kill(); resolve({ error: 'Timeout after ' + (config.timeout || 30) + 's' }); }, (config.timeout || 30) * 1000);
+        child.stdout.on('data', (chunk: Buffer) => {
+          buf += chunk.toString();
+          try {
+            const parsed = JSON.parse(buf.trim());
+            clearTimeout(timer);
+            child.kill();
+            resolve(parsed);
+          } catch { /* wait for more data */ }
+        });
+        child.on('error', (err: any) => { clearTimeout(timer); resolve({ error: err.message }); });
+        child.on('exit', (code: number) => { if (!buf) { clearTimeout(timer); resolve({ error: 'Process exited with code ' + code }); } });
+      });
+
+      if (result.error) return c.json({ error: typeof result.error === 'string' ? result.error : result.error.message || 'Unknown error' });
+
+      // Now list tools
+      const listMsg = JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+      const child2 = spawn(config.command, args, { stdio: ['pipe', 'pipe', 'pipe'], env, timeout: 15000 });
+      child2.stdin.write(initMsg + '\n');
+
+      const tools: any[] = await new Promise((resolve) => {
+        let phase = 'init';
+        let buf2 = '';
+        const timer2 = setTimeout(() => { child2.kill(); resolve([]); }, 15000);
+        child2.stdout.on('data', (chunk: Buffer) => {
+          buf2 += chunk.toString();
+          const lines = buf2.split('\n');
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const parsed = JSON.parse(line.trim());
+              if (phase === 'init' && parsed.id === 1) {
+                phase = 'tools';
+                buf2 = '';
+                child2.stdin.write(listMsg + '\n');
+              } else if (phase === 'tools' && parsed.id === 2) {
+                clearTimeout(timer2);
+                child2.kill();
+                resolve(parsed.result?.tools || []);
+                return;
+              }
+            } catch { /* partial line */ }
+          }
+        });
+        child2.on('error', () => { clearTimeout(timer2); resolve([]); });
+      });
+
+      // Save discovered tools
+      await engineDb.exec(`UPDATE mcp_servers SET status = 'connected', tool_count = $1, tools = $2, updated_at = NOW() WHERE id = $3`,
+        [tools.length, JSON.stringify(tools.map((t: any) => ({ name: t.name, description: t.description }))), id]);
+
+      return c.json({ ok: true, tools: tools.length, serverInfo: result.result?.serverInfo });
+
+    } else {
+      // Test HTTP/SSE: send initialize via HTTP
+      const url = config.url;
+      const headers: Record<string, string> = { 'Content-Type': 'application/json', ...(config.headers || {}) };
+      if (config.apiKey) headers['Authorization'] = `Bearer ${config.apiKey}`;
+
+      const resp = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'AgenticMail', version: '1.0' } } }),
+        signal: AbortSignal.timeout((config.timeout || 30) * 1000),
+      });
+
+      if (!resp.ok) return c.json({ error: `Server returned ${resp.status}` });
+      const data = await resp.json() as any;
+      if (data.error) return c.json({ error: data.error.message || 'Server error' });
+
+      // List tools
+      const toolResp = await fetch(url, {
+        method: 'POST', headers,
+        body: JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} }),
+        signal: AbortSignal.timeout(15000),
+      });
+      let tools: any[] = [];
+      if (toolResp.ok) {
+        const td = await toolResp.json() as any;
+        tools = td.result?.tools || [];
+      }
+
+      await engineDb.exec(`UPDATE mcp_servers SET status = 'connected', tool_count = $1, tools = $2, updated_at = NOW() WHERE id = $3`,
+        [tools.length, JSON.stringify(tools.map((t: any) => ({ name: t.name, description: t.description }))), id]);
+
+      return c.json({ ok: true, tools: tools.length, serverInfo: data.result?.serverInfo });
+    }
+  } catch (e: any) {
+    // Update status to error
+    try { await engineDb.exec(`UPDATE mcp_servers SET status = 'error', updated_at = NOW() WHERE id = $1`, [c.req.param('id')]); } catch {}
+    return c.json({ error: e.message });
+  }
+});
+
+// ─── Integration Credentials Management ─────────────────
+engine.put('/integrations/:skillId/credentials', async (c) => {
+  try {
+    const skillId = c.req.param('skillId');
+    const body = await c.req.json();
+    const orgId = c.req.query('orgId') || 'default';
+    // Store each credential field as a vault secret
+    for (const [key, value] of Object.entries(body)) {
+      if (!value) continue;
+      const secretName = `skill:${skillId}:${key}`;
+      // Check if exists, update or create
+      try {
+        const entries = await vault.getSecretsByOrg(orgId, 'skill_credential');
+        const existing = entries.find((e: any) => e.name === secretName);
+        if (existing) {
+          await vault.updateSecret(existing.id, { value: value as string });
+        } else {
+          await vault.storeSecret({ name: secretName, value: value as string, category: 'skill_credential', orgId });
+        }
+      } catch {
+        await vault.storeSecret({ name: secretName, value: value as string, category: 'skill_credential', orgId });
+      }
+    }
+    return c.json({ ok: true });
+  } catch (e: any) { return c.json({ error: e.message }, 500); }
+});
+
+engine.delete('/integrations/:skillId/credentials', async (c) => {
+  try {
+    const skillId = c.req.param('skillId');
+    const orgId = c.req.query('orgId') || 'default';
+    const entries = await vault.getSecretsByOrg(orgId, 'skill_credential');
+    const matching = entries.filter((e: any) => e.name?.startsWith(`skill:${skillId}:`));
+    for (const entry of matching) {
+      await vault.deleteSecret(entry.id);
+    }
+    return c.json({ ok: true });
+  } catch (e: any) { return c.json({ error: e.message }, 500); }
+});
+
 // ─── Integration catalog (serves all 144 MCP adapter integrations) ──
 engine.get('/integrations/catalog', async (c) => {
   try {