feat: enhance log store functionality with project-specific operations

regenrek · regenrek · commit e6d7f9835b9a · 2025-08-25T21:41:58.000+02:00
- Updated the `clear` method in `LogStore` to support project-based clearing alongside session-based operations.
- Introduced `baselineProject` and `baselineGlobal` methods for setting baselines specific to projects and globally.
- Modified log retrieval to consider project-specific baselines, improving log filtering accuracy.
- Updated `clearLogs` and `getLogs` tools to utilize new project parameters for enhanced log management.
diff --git a/packages/mcp/src/store.ts b/packages/mcp/src/store.ts
@@ -33,30 +33,61 @@ export class LogStore {
     this.entries.push(entry);
   }
 
-  clear(options?: { session?: string; scope?: 'soft' | 'hard' }) {
+  clear(options?: { session?: string; scope?: 'soft' | 'hard'; project?: string }) {
     const scope = options?.scope || 'hard';
     const session = options?.session;
+    const project = options?.project;
 
     if (scope === 'soft') {
-      const key = session || '__global__';
-      this.baselineTimestamps.set(key, Date.now());
-    } else {
-      if (session) {
-        this.entries = this.entries.filter(e => (e.sessionId || '').slice(0, 8) !== session);
-        this.baselineTimestamps.delete(session);
+      if (project && project.trim()) {
+        this.baselineTimestamps.set(`project:${project}`, Date.now());
+      } else if (session && session.trim()) {
+        this.baselineTimestamps.set(`session:${session.slice(0, 8)}`, Date.now());
       } else {
-        this.entries.length = 0;
-        this.baselineTimestamps.clear();
+        // Global soft baseline (discouraged for multi-project, kept for backward compat)
+        this.baselineTimestamps.set('__global__', Date.now());
       }
+      return;
     }
+
+    // Hard clear
+    if (project && project.trim()) {
+      // Remove only entries for this project and drop its baseline
+      const p = project;
+      this.entries = this.entries.filter(e => (e.project || '') !== p);
+      this.baselineTimestamps.delete(`project:${p}`);
+      return;
+    }
+
+    if (session && session.trim()) {
+      const s = session.slice(0, 8);
+      this.entries = this.entries.filter(e => (e.sessionId || '').slice(0, 8) !== s);
+      this.baselineTimestamps.delete(`session:${s}`);
+      return;
+    }
+
+    // Global hard clear
+    this.entries.length = 0;
+    this.baselineTimestamps.clear();
   }
 
   /** Set a baseline timestamp without deleting entries. If session omitted, use global baseline. */
   baseline(session?: string, when: number = Date.now()) {
-    const key = session || '__global__';
+    const key = session ? `session:${session.slice(0, 8)}` : '__global__';
     this.baselineTimestamps.set(key, when);
   }
 
+  /** Set a baseline for a specific project (recommended for multi-project use). */
+  baselineProject(project: string, when: number = Date.now()) {
+    if (!project || !project.trim()) return;
+    this.baselineTimestamps.set(`project:${project}`, when);
+  }
+
+  /** Set a global baseline (discouraged for multi-project; kept for backward compatibility). */
+  baselineGlobal(when: number = Date.now()) {
+    this.baselineTimestamps.set('__global__', when);
+  }
+
   toText(session?: string): string {
     return this.snapshot(session).map((e) => {
       const sid = (e.sessionId || 'anon').slice(0, 8);
@@ -76,17 +107,23 @@ export class LogStore {
     let items = this.entries.slice();
     if (session) items = items.filter(e => (e.sessionId || '').slice(0, 8) === session);
 
-    const baselineKey = session || '__global__';
-    const baseline = this.baselineTimestamps.get(baselineKey);
-    if (baseline) {
-      items = items.filter(e => !e.time || e.time >= baseline);
-      if (items.length === 0 && this.entries.length > 0) {
-        // eslint-disable-next-line no-console
-        console.warn(`All ${this.entries.length} logs filtered out by baseline. Check timestamp format.`);
-      }
+    const globalTs = this.baselineTimestamps.get('__global__') || 0;
+    const sessionTs = session ? (this.baselineTimestamps.get(`session:${session}`) || 0) : 0;
+
+    const filtered = items.filter((e) => {
+      const t = e.time || 0;
+      const projectTs = e.project ? (this.baselineTimestamps.get(`project:${e.project}`) || 0) : 0;
+      // Session baseline only applies when caller filtered by that session.
+      const threshold = Math.max(globalTs, sessionTs, projectTs);
+      return t === 0 || t >= threshold;
+    });
+
+    if (filtered.length === 0 && this.entries.length > 0 && (globalTs || sessionTs)) {
+      // eslint-disable-next-line no-console
+      console.warn(`All ${this.entries.length} logs filtered out by baseline. Check timestamp format or baseline scope.`);
     }
 
-    return items;
+    return filtered;
   }
 }
 
diff --git a/packages/mcp/src/tools/clearLogs.ts b/packages/mcp/src/tools/clearLogs.ts
@@ -13,23 +13,8 @@ export function registerClearLogsTool(ctx: McpToolContext) {
       const safeArgs = args || {} as any;
       const { session, scope = 'hard', project } = safeArgs as typeof ClearLogsSchema['_output'];
       const validSession = validateSessionId(session);
-      if (project) {
-        // Project-scoped hard clear by filtering entries not matching the project
-        // For soft clear, set baseline without deleting
-        if (scope === 'soft') {
-          // Use global baseline for project-scoped soft clear by current time; retrieval filters by project
-          // This keeps implementation simple while honoring freshness for the project
-          store.clear({ scope: 'soft' });
-        } else {
-          // Rebuild entries array excluding the project. Since entries is private, leverage snapshot and re-append
-          const remaining = store.snapshot().filter(e => (e.project || '') !== project);
-          // Replace internal state: simulate with hard clear then re-append
-          store.clear({ scope: 'hard' });
-          for (const e of remaining) store.append(e);
-        }
-      } else {
-        store.clear({ session: validSession, scope });
-      }
+
+      store.clear({ session: validSession, scope, project });
 
       let message = 'Browser log buffer ';
       message += scope === 'soft' ? 'baseline set' : 'cleared';
diff --git a/packages/mcp/src/tools/getLogs.ts b/packages/mcp/src/tools/getLogs.ts
@@ -111,12 +111,17 @@ export function registerGetLogsTool(ctx: McpToolContext) {
         }).join('\n');
       }
 
-      // Auto-baseline unless stackedMode
+      // Auto-baseline unless stackedMode (prefer project/session scopes; avoid global)
       try {
         if (autoBaseline && !stackedMode) {
-          // baseline per project if selected; else by session or global
-          const baselineSession = validSession;
-          store.baseline(baselineSession);
+          if (project) {
+            store.baselineProject(project);
+          } else if (autoProject) {
+            store.baselineProject(autoProject);
+          } else if (validSession) {
+            store.baseline(validSession);
+          }
+          // No global baseline by default to avoid cross-project interference
         }
       } catch {}
 
diff --git a/packages/next/src/route.ts b/packages/next/src/route.ts
@@ -1,6 +1,28 @@
 import type { NextRequest } from 'next/server';
 import { NextResponse } from 'next/server';
 
+const MCP_BASE = (process.env.BROWSER_ECHO_MCP_URL || 'http://127.0.0.1:5179').replace(/\/$/, '').replace(/\/mcp$/i, '');
+let __probeStarted = false;
+async function __probeHealthOnce(): Promise<boolean> {
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 400);
+    const res = await fetch(`${MCP_BASE}/health`, { signal: ctrl.signal as any, cache: 'no-store' as any });
+    clearTimeout(t);
+    return !!res && res.ok;
+  } catch { return false; }
+}
+function __startHealthProbe() {
+  if (__probeStarted) return;
+  __probeStarted = true;
+  setInterval(async () => {
+    if (__hasForwardedOnce) return;
+    const ok = await __probeHealthOnce();
+    if (ok) __hasForwardedOnce = true;
+  }, 1500);
+}
+__startHealthProbe();
+
 // Simplified: fixed single-server URL or env override
 
 export type BrowserLogLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
@@ -19,10 +41,8 @@ export async function POST(req: NextRequest) {
   catch { return new NextResponse('invalid JSON', { status: 400 }); }
   if (!payload || !Array.isArray(payload.entries)) return new NextResponse('invalid payload', { status: 400 });
 
-  // Fixed resolution (single-server): env or default localhost:5179 (strip optional /mcp suffix)
-  const baseUrl = (process.env.BROWSER_ECHO_MCP_URL || 'http://127.0.0.1:5179').replace(/\/$/, '').replace(/\/mcp$/i, '');
+  const baseUrl = MCP_BASE;
   const mcp = { url: baseUrl, routeLogs: '/__client-logs' } as const;
-  // No background probes; only flip after a successful POST
 
   // Forward to MCP server (fire-and-forget) and update connection state
   try {
diff --git a/packages/nuxt/src/runtime/server/handler.ts b/packages/nuxt/src/runtime/server/handler.ts
@@ -1,5 +1,27 @@
 import { defineEventHandler, readBody, setResponseStatus } from 'h3';
 
+const MCP_BASE = (process.env.BROWSER_ECHO_MCP_URL || 'http://127.0.0.1:5179').replace(/\/$/, '').replace(/\/mcp$/i, '');
+let __probeStarted = false;
+async function __probeHealthOnce(): Promise<boolean> {
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 400);
+    const res = await fetch(`${MCP_BASE}/health`, { signal: ctrl.signal as any, cache: 'no-store' as any });
+    clearTimeout(t);
+    return !!res && res.ok;
+  } catch { return false; }
+}
+function __startHealthProbe() {
+  if (__probeStarted) return;
+  __probeStarted = true;
+  setInterval(async () => {
+    if (__hasForwardedOnce) return;
+    const ok = await __probeHealthOnce();
+    if (ok) __hasForwardedOnce = true;
+  }, 1500);
+}
+__startHealthProbe();
+
 // Simplified: fixed single-server URL or env override
 
 // Simplified: resolve MCP from project-local JSON once; no fallback
@@ -19,10 +41,8 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 400); return 'invalid payload';
   }
 
-  // Fixed single-server: env or default localhost:5179 (strip optional /mcp suffix)
-  const baseUrl = (process.env.BROWSER_ECHO_MCP_URL || 'http://127.0.0.1:5179').replace(/\/$/, '').replace(/\/mcp$/i, '');
+  const baseUrl = MCP_BASE;
   const mcp = { url: baseUrl, routeLogs: '/__client-logs' } as const;
-  // No background probe
 
   // Forward to MCP server (fire-and-forget) and update connection state
   try {
diff --git a/packages/vite/src/index.ts b/packages/vite/src/index.ts
@@ -120,7 +120,36 @@ function attachMiddleware(server: any, options: ResolvedOptions) {
 
   computeBaseOnce();
 
-  // No background probes; start printing locally until a forward succeeds
+  // Start a small background probe to detect MCP coming online after Vite
+  startHealthProbe();
+
+  async function probeHealth(): Promise<boolean> {
+    try {
+      const ctrl = new AbortController();
+      const t = setTimeout(() => ctrl.abort(), 400);
+      const res = await fetch(`${resolvedBase}/health`, { signal: ctrl.signal as any, cache: 'no-store' as any });
+      clearTimeout(t);
+      return !!res && res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  function startHealthProbe() {
+    // Only starts once per dev server process
+    let started = false;
+    if (started) return;
+    started = true;
+    const interval = setInterval(async () => {
+      if (hasForwardedSuccessfully) return; // already forwarding
+      const ok = await probeHealth();
+      if (ok) {
+        hasForwardedSuccessfully = true;
+        announce(`${options.tag} forwarding logs to MCP ingest at ${resolvedIngest}`);
+      }
+    }, 1500);
+    // NOTE: we intentionally do not clear the interval; it's cheap and guarded above.
+  }
 
   server.middlewares.use(options.route, (req: import('http').IncomingMessage, res: import('http').ServerResponse, next: Function) => {
     if (req.method !== 'POST') return next();
