feat: enhance log ingestion and discovery features in MCP server

- Added environment variable exposure for ingest discovery in both owner and non-owner instances.
- Implemented project-local discovery file creation for frameworks/tools to locate the ingest endpoint.
- Updated `clearLogs` and `getLogs` tools to support HTTP proxying for log clearing and retrieval when not the ingest owner.
- Improved error handling for log operations to ensure fallback to local store when proxying fails.

Author: regenrek

packages/mcp/src/server.ts

@@ -2,6 +2,8 @@ import { createServer as createNodeServer } from 'node:http';
 import { randomUUID } from 'node:crypto';
 
 import { createApp, createRouter, defineEventHandler, getQuery, readRawBody, setResponseStatus, toNodeListener } from 'h3';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -278,6 +280,12 @@ export async function startHttpServer(
   console.log(`MCP (Streamable HTTP) listening → http://${opts.host}:${opts.port}${opts.endpoint}`);
   // eslint-disable-next-line no-console
   console.log(`Log ingest endpoint        → http://${opts.host}:${opts.port}${opts.logsRoute}`);
+  // Expose ingest discovery for other MCP instances in the same process tree
+  try {
+    process.env.BROWSER_ECHO_INGEST_BASE = `http://${opts.host}:${opts.port}`;
+    process.env.BROWSER_ECHO_LOGS_ROUTE = String(opts.logsRoute);
+    process.env.BROWSER_ECHO_INGEST_OWNER = '1';
+  } catch {}
 }
 
 /** Start a minimal HTTP server exposing ONLY:
@@ -365,6 +373,12 @@ export async function startIngestOnlyServer(
           if (res && res.ok) {
             // eslint-disable-next-line no-console
             console.error(`Ingest server already running at ${base}${opts.logsRoute}. Reusing existing instance.`);
+            // Expose discovery for non-owner instances
+            try {
+              process.env.BROWSER_ECHO_INGEST_BASE = base;
+              process.env.BROWSER_ECHO_LOGS_ROUTE = String(opts.logsRoute);
+              process.env.BROWSER_ECHO_INGEST_OWNER = '0';
+            } catch {}
             return; // Treat as success
           }
         } catch {}
@@ -376,6 +390,18 @@ export async function startIngestOnlyServer(
 
   // eslint-disable-next-line no-console
   console.error(`Log ingest endpoint        → http://${opts.host}:${actualPort}${opts.logsRoute}`);
+  // Write project-local discovery file for frameworks/tools to find ingest
+  try {
+    const discPath = join(process.cwd(), '.browser-echo-mcp.json');
+    const payload = { url: `http://${opts.host}:${actualPort}`, route: String(opts.logsRoute), timestamp: Date.now() };
+    writeFileSync(discPath, JSON.stringify(payload));
+  } catch {}
+  // Expose discovery for owner instance
+  try {
+    process.env.BROWSER_ECHO_INGEST_BASE = `http://${opts.host}:${actualPort}`;
+    process.env.BROWSER_ECHO_LOGS_ROUTE = String(opts.logsRoute);
+    process.env.BROWSER_ECHO_INGEST_OWNER = '1';
+  } catch {}
 }
 
 // Removed project JSON discovery in single-server mode
@@ -409,6 +435,13 @@ function createLogIngestRoutes(store: LogStore, logsRoute: `/${string}`) {
       const hdrs = event.node.req.headers;
       const projectHeader = (hdrs['x-browser-echo-project-name'] || hdrs['x-project-name'] || hdrs['x-project'] || '') as string | string[] | undefined;
       const projectName = Array.isArray(projectHeader) ? String(projectHeader[0] || '') : String(projectHeader || '');
+      // Special command: remote clear request
+      const isClear = payload.entries.length === 1 && String(payload.entries[0]?.text || '') === '__BROWSER_ECHO_CLEAR__';
+      if (isClear) {
+        store.clear({ session: sid ? String(sid).slice(0,8) : undefined, scope: 'hard', project: projectName || undefined });
+        setResponseStatus(event, 204);
+        return '';
+      }
       for (const entry of payload.entries as Array<{ level: BrowserLogLevel | string; text: string; time?: number; stack?: string; source?: string; }>) {
         const level = normalizeLevel(entry.level);
         store.append({

packages/mcp/src/tools/clearLogs.ts

@@ -14,6 +14,21 @@ export function registerClearLogsTool(ctx: McpToolContext) {
       const { session, project } = safeArgs as typeof ClearLogsSchema['_output'];
       const validSession = validateSessionId(session);
 
+      // If this instance is not the ingest owner but a global ingest exists, proxy via HTTP by posting a special clear payload
+      const ingestBase = (process.env.BROWSER_ECHO_INGEST_BASE || '').replace(/\/$/, '');
+      const logsRoute = process.env.BROWSER_ECHO_LOGS_ROUTE || '/__client-logs';
+      const ingestOwner = String(process.env.BROWSER_ECHO_INGEST_OWNER || '1') === '1';
+      if (!ingestOwner && ingestBase) {
+        try {
+          const payload = { sessionId: validSession || 'anon', entries: [{ level: 'debug', text: '__BROWSER_ECHO_CLEAR__', time: Date.now(), source: project ? `project:${project}` : undefined }] };
+          await fetch(`${ingestBase}${logsRoute}`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(payload) });
+          const msg = 'Browser log buffer clear requested via global ingest.' + (project ? ` for project ${project}.` : validSession ? ` for session ${validSession}.` : '');
+          return { content: [{ type: 'text' as const, text: msg }] };
+        } catch {
+          // fall through to local clear
+        }
+      }
+
       store.clear({ session: validSession, scope: 'hard', project });
 
       let message = 'Browser log buffer cleared';

packages/mcp/src/tools/getLogs.ts

@@ -26,7 +26,37 @@ export function registerGetLogsTool(ctx: McpToolContext) {
       const validSession = validateSessionId(session);
       const validSince = typeof sinceMs === 'number' && sinceMs >= 0 ? sinceMs : undefined;
 
-      // Get logs with optional session filter
+      // If this instance is not the ingest owner but a global ingest exists, proxy via HTTP
+      const ingestBase = (process.env.BROWSER_ECHO_INGEST_BASE || '').replace(/\/$/, '');
+      const logsRoute = process.env.BROWSER_ECHO_LOGS_ROUTE || '/__client-logs';
+      const ingestOwner = String(process.env.BROWSER_ECHO_INGEST_OWNER || '1') === '1';
+
+      if (!ingestOwner && ingestBase) {
+        try {
+          const url = new URL(`${ingestBase}${logsRoute}`);
+          if (validSession) url.searchParams.set('session', validSession);
+          const res = await fetch(url.toString(), { method: 'GET', cache: 'no-store' as any });
+          const text = await res.text();
+          // Basic line filtering client-side when proxying (best-effort)
+          let lines = text.split(/\r?\n/g).filter(Boolean);
+          if (level?.length) {
+            const levelSet = new Set(level.map(l => String(l).toUpperCase()));
+            lines = lines.filter(l => {
+              const m = l.match(/\]\s+([A-Z]+):\s/);
+              return m ? levelSet.has(m[1]) : true;
+            });
+          }
+          if (contains) lines = lines.filter(l => l.includes(contains));
+          // Apply simple limit from the end
+          if (limit && lines.length > limit) lines = lines.slice(-limit);
+          const body = lines.join('\n');
+          return { content: [{ type: 'text' as const, text: body || 'No logs available yet.' }] };
+        } catch {
+          // Fall back to local store if proxy fails
+        }
+      }
+
+      // Get logs with optional session filter from local store
       let items = store.snapshot(validSession);
       if (validSince) items = items.filter(e => !e.time || e.time >= validSince);
       if (level?.length) items = items.filter(e => level.includes(e.level));