agmon 0.2.0 → 0.2.2

package/src/lib/watchers/antigravityWatcher.js

@@ -183,6 +183,8 @@ export async function getAntigravityTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
     const traces = [];
     const seenConvIds = new Set();
 
+    const candidates = [];
+
     for (const { dir: brainDir, source } of searchDirs) {
       let entries;
       try {
@@ -195,13 +197,26 @@ export async function getAntigravityTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
         if (!ent.isDirectory()) continue;
         const convId = ent.name;
         if (seenConvIds.has(convId)) continue;
+        seenConvIds.add(convId);
         const transcriptPath = path.join(brainDir, convId, ".system_generated", "logs", "transcript.jsonl");
 
         try {
           const stat = await fs.stat(transcriptPath);
           const mtime = stat.mtimeMs;
           if (now - mtime > maxAgeMs) continue;
+          candidates.push({ transcriptPath, mtime, convId, source, stat });
+        } catch {}
+      }
+    }
 
+    // Sort candidate transcripts by mtime descending (most recent first)
+    candidates.sort((a, b) => b.mtime - a.mtime);
+
+    // Limit parsing to the most recent 100 sessions to avoid unbounded disk I/O
+    const toProcess = candidates.slice(0, 100);
+
+    for (const { transcriptPath, mtime, convId, source, stat } of toProcess) {
+      try {
         const content = await fs.readFile(transcriptPath, "utf-8");
         const lines = content.trim().split("\n");
         if (lines.length === 0) continue;
@@ -383,7 +398,6 @@ export async function getAntigravityTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
         // file missing or unreadable
       }
     }
-  }
 
     // Sort: active (streaming/pending) first, then by most recent startedAt
     traces.sort((a, b) => {

package/src/lib/watchers/claudeWatcher.js

@@ -67,6 +67,20 @@ function normalizeClaudeTool(name, input = {}) {
   return { type: "mcp", detail: name };
 }
 
+/**
+ * Claude Code records where a session was started in `entrypoint`. A session
+ * can carry more than one (a desktop session that later continues in the CLI
+ * logs both), so desktop wins over the generic `cli` value.
+ *
+ * @returns {{ clientType: string, label: string }}
+ */
+function classifyClaudeEntrypoint(...entrypoints) {
+  const seen = new Set(entrypoints.filter(Boolean));
+  if (seen.has("claude-desktop")) return { clientType: "desktop", label: "Claude Desktop" };
+  if (seen.has("claude-vscode") || seen.has("vscode")) return { clientType: "extension", label: "Claude Extension" };
+  return { clientType: "cli", label: "Claude" };
+}
+
 function detectProvider(modelName, clientType = "cli") {
   const m = String(modelName || "").toLowerCase();
   let base = null;
@@ -113,7 +127,7 @@ async function parseClaudeTranscript(transcriptPath) {
     lastTimestamp: 0,
     toolInvocations: [],
     recentLogs: [],
-    entrypoint: null,
+    entrypoints: new Set(),
     cwd: null,
     slug: null,
     sessionId: null,
@@ -131,7 +145,7 @@ async function parseClaudeTranscript(transcriptPath) {
         const entryTime = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
         if (entry.timestamp) result.lastTimestamp = entryTime;
         if (entry.sessionId && !result.sessionId) result.sessionId = entry.sessionId;
-        if (entry.entrypoint && !result.entrypoint) result.entrypoint = entry.entrypoint;
+        if (entry.entrypoint) result.entrypoints.add(entry.entrypoint);
         if (entry.cwd && !result.cwd) result.cwd = entry.cwd;
         if (entry.slug && !result.slug) result.slug = entry.slug;
 
@@ -281,12 +295,10 @@ export async function getClaudeTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
 
         const parsed = transcriptPath ? await parseClaudeTranscript(transcriptPath) : {};
 
-        const isExtension =
-          entrypoint === "claude-vscode" ||
-          entrypoint === "vscode" ||
-          parsed.entrypoint === "claude-vscode";
-
-        const clientType = isExtension ? "extension" : "cli";
+        const { clientType, label } = classifyClaudeEntrypoint(
+          entrypoint,
+          ...(parsed.entrypoints || [])
+        );
 
         let state = "done";
         if (alive) {
@@ -313,9 +325,8 @@ export async function getClaudeTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
           workspaceName;
 
         const model = parsed.model || null;
-        const connectionId = isExtension
-          ? `Claude Extension (${name || pid || (sessionId ? sessionId.slice(0, 6) : "ext")})`
-          : `Claude (${name || pid || (sessionId ? sessionId.slice(0, 6) : "cli")})`;
+        const sessionLabel = name || pid || (sessionId ? sessionId.slice(0, 6) : "session");
+        const connectionId = `${label} (${sessionLabel})`;
 
         traces.push(normalizeTrace({
           traceId: `claude-${pid || (sessionId ? sessionId.slice(0, 6) : "session")}`,
@@ -357,6 +368,8 @@ export async function getClaudeTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
   // Catches all project-level active & historical sessions within the time window
   try {
     const projectFolders = await fs.readdir(projectsDir).catch(() => []);
+    const projectCandidates = [];
+
     for (const pf of projectFolders) {
       const folderPath = path.join(projectsDir, pf);
       let files = [];
@@ -376,66 +389,69 @@ export async function getClaudeTraces(maxAgeMs = 24 * 60 * 60 * 1000) {
           const stat = await fs.stat(transcriptPath);
           const mtime = stat.mtimeMs;
           if (now - mtime > maxAgeMs) continue;
-
           seenSessionIds.add(fileSessionId);
-          const parsed = await parseClaudeTranscript(transcriptPath);
-
-          const isRecent = (now - mtime) < 90 * 1000;
-          const isPending = (now - mtime) < 15 * 60 * 1000;
-          const state = isRecent ? "streaming" : isPending ? "idle" : "done";
-
-          const isExtension =
-            parsed.entrypoint === "claude-vscode" ||
-            parsed.entrypoint === "vscode";
-
-          const clientType = isExtension ? "extension" : "cli";
-          const workspaceName = parsed.cwd
-            ? path.basename(parsed.cwd)
-            : (extractWorkspaceFromFolder(pf) || fallbackWorkspace);
-
-          const elapsedMs = Math.max(0, (parsed.lastTimestamp || mtime) - stat.birthtimeMs);
-
-          const sessionTitle =
-            parsed.sessionTitle ||
-            (parsed.slug ? parsed.slug.replace(/-/g, " ") : null) ||
-            workspaceName;
-
-          const model = parsed.model || null;
-          const connectionId = isExtension
-            ? `Claude Extension (${parsed.slug || fileSessionId.slice(0, 6)})`
-            : `Claude (${parsed.slug || fileSessionId.slice(0, 6)})`;
-
-          traces.push(normalizeTrace({
-            traceId: `claude-${fileSessionId.slice(0, 6)}`,
-            cli: "claude",
-            clientType,
-            source: clientType,
-            connectionId,
-            account: workspaceName,
-            model,
-            provider: detectProvider(model, clientType),
-            state,
-            startedAt: stat.birthtimeMs || null,
-            elapsedMs: stat.birthtimeMs ? elapsedMs : null,
-            tokens: {
-              input: parsed.totalIn || null,
-              output: parsed.totalOut || null,
-              cached: parsed.totalCached || null,
-            },
-            cost: null,
-            status: parsed.isLooping ? "error" : null,
-            tools: Array.from(parsed.toolSet || []),
-            activeTool: parsed.activeTool || null,
-            currentCommand: parsed.activeCommand || null,
-            sessionTitle,
-            lastText: parsed.lastText || null,
-            lastTextRole: parsed.lastTextRole || null,
-            isLooping: parsed.isLooping || false,
-            logs: (parsed.recentLogs || []).slice(-25),
-          }));
-        } catch {
-          // ignore unreadable project file
-        }
+          projectCandidates.push({ transcriptPath, mtime, stat, fileSessionId, pf });
+        } catch {}
+      }
+    }
+
+    // Sort by mtime descending (most recent first) and cap to top 100
+    projectCandidates.sort((a, b) => b.mtime - a.mtime);
+    const toProcess = projectCandidates.slice(0, 100);
+
+    for (const { transcriptPath, mtime, stat, fileSessionId, pf } of toProcess) {
+      try {
+        const parsed = await parseClaudeTranscript(transcriptPath);
+
+        const isRecent = (now - mtime) < 90 * 1000;
+        const isPending = (now - mtime) < 15 * 60 * 1000;
+        const state = isRecent ? "streaming" : isPending ? "idle" : "done";
+
+        const { clientType, label } = classifyClaudeEntrypoint(...(parsed.entrypoints || []));
+        const workspaceName = parsed.cwd
+          ? path.basename(parsed.cwd)
+          : (extractWorkspaceFromFolder(pf) || fallbackWorkspace);
+
+        const elapsedMs = Math.max(0, (parsed.lastTimestamp || mtime) - stat.birthtimeMs);
+
+        const sessionTitle =
+          parsed.sessionTitle ||
+          (parsed.slug ? parsed.slug.replace(/-/g, " ") : null) ||
+          workspaceName;
+
+        const model = parsed.model || null;
+        const connectionId = `${label} (${parsed.slug || fileSessionId.slice(0, 6)})`;
+
+        traces.push(normalizeTrace({
+          traceId: `claude-${fileSessionId.slice(0, 6)}`,
+          cli: "claude",
+          clientType,
+          source: clientType,
+          connectionId,
+          account: workspaceName,
+          model,
+          provider: detectProvider(model, clientType),
+          state,
+          startedAt: stat.birthtimeMs || null,
+          elapsedMs: stat.birthtimeMs ? elapsedMs : null,
+          tokens: {
+            input: parsed.totalIn || null,
+            output: parsed.totalOut || null,
+            cached: parsed.totalCached || null,
+          },
+          cost: null,
+          status: parsed.isLooping ? "error" : null,
+          tools: Array.from(parsed.toolSet || []),
+          activeTool: parsed.activeTool || null,
+          currentCommand: parsed.activeCommand || null,
+          sessionTitle,
+          lastText: parsed.lastText || null,
+          lastTextRole: parsed.lastTextRole || null,
+          isLooping: parsed.isLooping || false,
+          logs: (parsed.recentLogs || []).slice(-25),
+        }));
+      } catch {
+        // ignore unreadable project file
       }
     }
   } catch {