chrome-ai-bridge 2.0.19 → 2.3.0

package/build/src/fast-cdp/session-manager.js

@@ -0,0 +1,214 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Session Manager for Agent Teams support.
+ *
+ * Manages per-agent sessions with:
+ * - V2 session format with agent isolation
+ * - Automatic migration from V1 format
+ * - TTL-based cleanup of stale sessions
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getSessionConfig } from '../config.js';
+import { getAgentId, hasAgentId } from './agent-context.js';
+/**
+ * Get the session file path.
+ * Uses project-local .local/ directory.
+ */
+function getSessionPath() {
+    return path.join(process.cwd(), '.local', 'chrome-ai-bridge', 'sessions.json');
+}
+/**
+ * Load raw sessions from file (any version).
+ */
+async function loadRawSessions() {
+    const sessionPath = getSessionPath();
+    try {
+        const data = await fs.readFile(sessionPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            // File exists but is corrupted or unreadable
+            console.error(`[session-manager] Failed to load ${sessionPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { projects: {} };
+    }
+}
+/**
+ * Save sessions to file.
+ */
+async function saveRawSessions(sessions) {
+    const targetPath = getSessionPath();
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, JSON.stringify(sessions, null, 2), 'utf-8');
+}
+/**
+ * Check if sessions are V2 format.
+ */
+function isV2Format(sessions) {
+    return 'version' in sessions && sessions.version === 2;
+}
+/**
+ * Migrate V1 sessions to V2 format.
+ * Creates a "legacy-default" agent from V1 project data.
+ */
+async function migrateToV2(v1) {
+    const config = getSessionConfig();
+    const v2 = {
+        version: 2,
+        agents: {},
+        config: {
+            sessionTtlMinutes: config.sessionTtlMinutes,
+            maxAgents: config.maxAgents,
+        },
+    };
+    // Migrate each project as a legacy agent
+    for (const [projectName, projectSessions] of Object.entries(v1.projects)) {
+        // Sanitize project name for use as agent ID key
+        const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+        const agentId = `legacy-${safeName}`;
+        v2.agents[agentId] = {
+            lastAccess: new Date().toISOString(),
+            chatgpt: projectSessions.chatgpt || null,
+            gemini: projectSessions.gemini || null,
+        };
+    }
+    console.error(`[session-manager] Migrated ${Object.keys(v1.projects).length} projects to V2 format`);
+    return v2;
+}
+/**
+ * Load sessions, auto-migrating if needed.
+ */
+export async function loadSessions() {
+    const raw = await loadRawSessions();
+    if (isV2Format(raw)) {
+        return raw;
+    }
+    // Migrate V1 to V2
+    const v2 = await migrateToV2(raw);
+    await saveRawSessions(v2);
+    return v2;
+}
+/**
+ * Get or create session for the current agent.
+ * Always updates lastAccess to keep session alive for TTL.
+ */
+export async function getAgentSession() {
+    const agentId = hasAgentId() ? getAgentId() : 'default';
+    const sessions = await loadSessions();
+    let needsSave = false;
+    if (!sessions.agents[agentId]) {
+        sessions.agents[agentId] = {
+            lastAccess: new Date().toISOString(),
+            chatgpt: null,
+            gemini: null,
+        };
+        needsSave = true;
+    }
+    else {
+        // Update lastAccess for existing sessions (keeps TTL alive)
+        sessions.agents[agentId].lastAccess = new Date().toISOString();
+        needsSave = true;
+    }
+    if (needsSave) {
+        await saveRawSessions(sessions);
+    }
+    return sessions.agents[agentId];
+}
+/**
+ * Save session for the current agent.
+ */
+export async function saveAgentSession(kind, url, tabId) {
+    const agentId = hasAgentId() ? getAgentId() : 'default';
+    const sessions = await loadSessions();
+    if (!sessions.agents[agentId]) {
+        sessions.agents[agentId] = {
+            lastAccess: new Date().toISOString(),
+            chatgpt: null,
+            gemini: null,
+        };
+    }
+    const session = sessions.agents[agentId];
+    session.lastAccess = new Date().toISOString();
+    session[kind] = {
+        url,
+        tabId,
+        lastUsed: new Date().toISOString(),
+    };
+    await saveRawSessions(sessions);
+}
+/**
+ * Clear session for the current agent.
+ */
+export async function clearAgentSession(kind) {
+    const agentId = hasAgentId() ? getAgentId() : 'default';
+    const sessions = await loadSessions();
+    if (sessions.agents[agentId]) {
+        sessions.agents[agentId][kind] = null;
+        await saveRawSessions(sessions);
+        console.error(`[session-manager] Cleared ${kind} session for agent: ${agentId}`);
+    }
+}
+/**
+ * Remove stale sessions that exceed TTL.
+ *
+ * @returns Number of agents removed
+ */
+export async function cleanupStaleSessions() {
+    const config = getSessionConfig();
+    const sessions = await loadSessions();
+    const now = Date.now();
+    const ttlMs = config.sessionTtlMinutes * 60 * 1000;
+    let removedCount = 0;
+    for (const [agentId, session] of Object.entries(sessions.agents)) {
+        const lastAccess = new Date(session.lastAccess).getTime();
+        const age = now - lastAccess;
+        if (age > ttlMs) {
+            delete sessions.agents[agentId];
+            removedCount++;
+            console.error(`[session-manager] Removed stale agent: ${agentId} (${Math.round(age / 60000)}min old)`);
+        }
+    }
+    // Enforce maxAgents limit
+    const agentIds = Object.keys(sessions.agents);
+    if (agentIds.length > config.maxAgents) {
+        // Sort by lastAccess (oldest first)
+        const sorted = agentIds.sort((a, b) => {
+            const aTime = new Date(sessions.agents[a].lastAccess).getTime();
+            const bTime = new Date(sessions.agents[b].lastAccess).getTime();
+            return aTime - bTime;
+        });
+        // Remove oldest until under limit
+        const toRemove = sorted.slice(0, agentIds.length - config.maxAgents);
+        for (const agentId of toRemove) {
+            delete sessions.agents[agentId];
+            removedCount++;
+            console.error(`[session-manager] Removed agent (over limit): ${agentId}`);
+        }
+    }
+    if (removedCount > 0) {
+        await saveRawSessions(sessions);
+    }
+    return removedCount;
+}
+/**
+ * Get preferred session (URL and tabId) for the current agent.
+ * Used by fast-chat.ts for connection reuse.
+ */
+export async function getPreferredSessionV2(kind) {
+    const session = await getAgentSession();
+    const entry = session[kind];
+    if (entry && typeof entry.url === 'string' && entry.url.length > 0) {
+        return {
+            url: entry.url,
+            tabId: typeof entry.tabId === 'number' ? entry.tabId : undefined,
+        };
+    }
+    return { url: null };
+}

package/build/src/main.js

@@ -8,6 +8,9 @@
  *
  * This MCP server provides ChatGPT/Gemini integration via Chrome extension.
  * Puppeteer has been removed - all browser interaction is via WebSocket relay.
+ *
+ * Multi-client: The first instance becomes Primary (stdio + IPC HTTP).
+ * Subsequent instances become Proxies that forward stdio to the Primary via HTTP.
  */
 import assert from 'node:assert';
 import fs from 'node:fs';
@@ -26,6 +29,11 @@ import { ToolRegistry, PluginLoader } from './plugin-api.js';
 import { registerOptionalTools, WEB_LLM_TOOLS_INFO, } from './tools/optional-tools.js';
 import { getFastContext } from './fast-cdp/fast-context.js';
 import { cleanupAllConnections } from './fast-cdp/fast-chat.js';
+import { generateAgentId, setAgentId } from './fast-cdp/agent-context.js';
+import { cleanupStaleSessions } from './fast-cdp/session-manager.js';
+import { getSessionConfig, IPC_CONFIG } from './config.js';
+import { acquireLock, releaseLock, killSiblings, checkExistingPrimary, updateLockPort } from './process-lock.js';
+import { checkPrimaryHealth, startProxyMode } from './stdio-http-proxy.js';
 function readPackageJson() {
     const currentDir = import.meta.dirname;
     const packageJsonPath = path.join(currentDir, '..', '..', 'package.json');
@@ -45,6 +53,45 @@ const version = readPackageJson().version ?? 'unknown';
 export const args = parseArguments(version);
 const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 logger(`Starting Chrome AI Bridge v${version} (Extension-only mode)`);
+// Initialize agent ID for Agent Teams support
+const agentId = generateAgentId();
+setAgentId(agentId);
+// ─── Multi-client routing ───
+// Check if a Primary instance is already running.
+// If yes and healthy, enter proxy mode (never returns).
+const existingPrimary = checkExistingPrimary();
+if (existingPrimary && existingPrimary.port > 0) {
+    const healthy = await checkPrimaryHealth(existingPrimary.port);
+    if (healthy) {
+        logger(`[main] Primary is healthy (port=${existingPrimary.port}). Entering proxy mode.`);
+        await startProxyMode(existingPrimary.port); // never returns
+    }
+    logger(`[main] Primary (port=${existingPrimary.port}) not healthy. Starting as Primary.`);
+}
+// ─── Primary mode ───
+// Kill all stale sibling processes first
+const killed = await killSiblings();
+if (killed > 0) {
+    logger(`[process-lock] Killed ${killed} stale sibling process(es)`);
+}
+// Generate a unique instance ID (survives PID reuse)
+const instanceId = randomUUID();
+// Acquire exclusive process lock (writes port + instanceId to lock file)
+await acquireLock(IPC_CONFIG.port, instanceId);
+// Start session cleanup timer
+const sessionConfig = getSessionConfig();
+const cleanupTimer = setInterval(async () => {
+    try {
+        const removed = await cleanupStaleSessions();
+        if (removed > 0) {
+            logger(`[session] Cleaned up ${removed} stale sessions`);
+        }
+    }
+    catch (error) {
+        logger(`[session] Cleanup error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}, sessionConfig.cleanupIntervalMinutes * 60 * 1000);
+cleanupTimer.unref(); // Don't keep process alive for cleanup
 const server = new McpServer({
     name: 'chrome-ai-bridge',
     title: 'Chrome AI Bridge - ChatGPT/Gemini via Extension',
@@ -141,6 +188,145 @@ const transport = new StdioServerTransport();
 await server.connect(transport);
 logger('Chrome AI Bridge MCP Server connected');
 logDisclaimers();
+// ─── IPC HTTP server (for proxy clients) ───
+{
+    const ipcTransports = {};
+    const ipcServer = http.createServer(async (req, res) => {
+        if (!req.url || !req.method) {
+            res.writeHead(400).end();
+            return;
+        }
+        const url = new URL(req.url, `http://${IPC_CONFIG.host}:${IPC_CONFIG.port}`);
+        // Health endpoint
+        if (url.pathname === IPC_CONFIG.healthPath) {
+            res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ status: 'ok', pid: process.pid, version, instanceId }));
+            return;
+        }
+        // MCP endpoint
+        if (url.pathname !== IPC_CONFIG.mcpPath) {
+            res.writeHead(404).end();
+            return;
+        }
+        // CORS for local usage
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Headers', 'content-type,mcp-session-id');
+        res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204).end();
+            return;
+        }
+        const sessionId = req.headers['mcp-session-id'];
+        if (req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk;
+            });
+            req.on('end', async () => {
+                let json;
+                try {
+                    json = body ? JSON.parse(body) : null;
+                }
+                catch {
+                    res.writeHead(400).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32700, message: 'Parse error' },
+                        id: null,
+                    }));
+                    return;
+                }
+                let ipcTransport;
+                if (sessionId && ipcTransports[sessionId]) {
+                    ipcTransport = ipcTransports[sessionId];
+                }
+                else if (!sessionId && isInitializeRequest(json)) {
+                    ipcTransport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => randomUUID(),
+                        onsessioninitialized: newSessionId => {
+                            ipcTransports[newSessionId] = ipcTransport;
+                        },
+                    });
+                    ipcTransport.onclose = () => {
+                        if (ipcTransport?.sessionId) {
+                            delete ipcTransports[ipcTransport.sessionId];
+                        }
+                    };
+                    await server.connect(ipcTransport);
+                }
+                else {
+                    res.writeHead(400).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: No valid session ID provided',
+                        },
+                        id: null,
+                    }));
+                    return;
+                }
+                try {
+                    await ipcTransport.handleRequest(req, res, json);
+                }
+                catch (error) {
+                    if (!res.headersSent) {
+                        res.writeHead(500).end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            error: {
+                                code: -32603,
+                                message: error instanceof Error
+                                    ? error.message
+                                    : String(error),
+                            },
+                            id: null,
+                        }));
+                    }
+                }
+            });
+            return;
+        }
+        if (req.method === 'GET' || req.method === 'DELETE') {
+            if (!sessionId || !ipcTransports[sessionId]) {
+                res.writeHead(400).end('Invalid or missing session ID');
+                return;
+            }
+            try {
+                await ipcTransports[sessionId].handleRequest(req, res);
+            }
+            catch (error) {
+                if (!res.headersSent) {
+                    res.writeHead(500).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                        id: null,
+                    }));
+                }
+            }
+            return;
+        }
+        res.writeHead(405).end();
+    });
+    function onListening() {
+        const addr = ipcServer.address();
+        const actualPort = typeof addr === 'object' && addr ? addr.port : IPC_CONFIG.port;
+        if (actualPort !== IPC_CONFIG.port) {
+            logger(`[ipc] Configured port ${IPC_CONFIG.port} was unavailable. Using dynamic port ${actualPort}.`);
+            updateLockPort(actualPort);
+        }
+        logger(`[ipc] IPC HTTP listening on http://${IPC_CONFIG.host}:${actualPort} (health: ${IPC_CONFIG.healthPath}, mcp: ${IPC_CONFIG.mcpPath})`);
+    }
+    ipcServer.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            logger(`[ipc] Port ${IPC_CONFIG.port} in use. Retrying with dynamic port...`);
+            ipcServer.listen(0, IPC_CONFIG.host, onListening);
+        }
+        else {
+            logger(`[ipc] IPC server error: ${err.message}`);
+        }
+    });
+    ipcServer.listen(IPC_CONFIG.port, IPC_CONFIG.host, onListening);
+}
 // Graceful shutdown handler with timeout
 // Based on review: タイムアウト必須、強制終了タイマー必要
 let isShuttingDown = false;
@@ -159,6 +345,8 @@ async function shutdown(reason) {
         return;
     isShuttingDown = true;
     logger(`Shutting down: ${reason}`);
+    // Release lock early so a new instance can start immediately
+    releaseLock();
     // Force exit timer (5 seconds) - prevents zombie if cleanup hangs
     const forceExitTimer = setTimeout(() => {
         logger('Graceful shutdown timed out. Forcing exit.');
@@ -187,10 +375,12 @@ process.on('SIGTERM', () => shutdown('SIGTERM'));
 process.on('SIGINT', () => shutdown('SIGINT'));
 // Keep beforeExit for edge cases where stdin doesn't close
 process.on('beforeExit', () => {
+    releaseLock();
     if (logFile) {
         logFile.close();
     }
 });
+// ─── Optional: User-configured external HTTP server (MCP_HTTP_PORT) ───
 const httpPortRaw = process.env.MCP_HTTP_PORT;
 if (httpPortRaw) {
     const httpPort = Number(httpPortRaw);