@echomem/mcp 1.4.3 → 1.4.5

package/dist/hud/monitor.js

@@ -1,17 +1,36 @@
 import { execFileSync } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { adapterList } from "./adapters.js";
-import { statSignature } from "./fs.js";
+import fs from "node:fs";
+import path from "node:path";
+import { adapterList, adapters } from "./adapters.js";
+import { homePath, newestFile, walkFiles } from "./fs.js";
+const LIVE_WINDOW_MS = 45_000;
+const ONGOING_WINDOW_MS = 300_000; // a thread counts as "ongoing" if its log was written in the last 5 min
+const FOCUS_GRACE_MS = 8_000; // keep the last-known frontmost client this long when detection momentarily misses
+const RECENT_WINDOW_MS = 12 * 60 * 60 * 1000; // a session is a "recent tab" if its log was touched in the last 12h
+const RECENT_CAP = 16; // most-recent N sessions kept as switchable tabs
 export class HudMonitor extends EventEmitter {
     mode;
     pollMs;
     timer = null;
     signatures = new Map();
     scores = new Map();
+    mtimes = new Map();
+    labelCache = new Map();
     missing = [];
     frontmostCheckedAt = 0;
+    frontmostSeenAt = 0;
     frontmostClient = null;
     lastActiveClient = null;
+    threadCounts = {};
+    threadCountsAt = 0;
+    recentSessions = [];
+    codexTitles = new Map();
+    codexTitlesSig = "";
+    claudeTitleCache = new Map();
+    lastPersistedRecent = "";
+    pinnedId = null;
+    pinnedScore = null;
     constructor(mode = "auto", pollMs = 750) {
         super();
         this.mode = mode;
@@ -30,45 +49,297 @@ export class HudMonitor extends EventEmitter {
         this.timer = null;
     }
     snapshot() {
-        const preferred = this.frontmostPreferredClient();
-        const scores = [...this.scores.values()].sort((a, b) => {
-            if (preferred && a.client === preferred && b.client !== preferred)
-                return -1;
-            if (preferred && b.client === preferred && a.client !== preferred)
-                return 1;
-            return Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+        const focused = this.frontmostPreferredClient();
+        this.refreshRecent();
+        const now = Date.now();
+        const sessions = [...this.scores.values()].map((score) => {
+            // Liveness uses file mtime (real last write), not score.updatedAt — the Claude cache stamps
+            // updatedAt = now on every read, which would make an idle session look permanently live.
+            const mtimeMs = this.mtimes.get(score.client) ?? (Date.parse(score.updatedAt) || now);
+            const lastActiveMs = Math.max(0, now - mtimeMs);
+            return {
+                ...score,
+                live: lastActiveMs < LIVE_WINDOW_MS,
+                focused: focused === score.client,
+                label: this.labelFor(score),
+                lastActiveMs,
+            };
+        });
+        // focused first, then live (most-recent first), then idle (most-recent first).
+        sessions.sort((a, b) => {
+            if (a.focused !== b.focused)
+                return a.focused ? -1 : 1;
+            if (a.live !== b.live)
+                return a.live ? -1 : 1;
+            return a.lastActiveMs - b.lastActiveMs;
         });
+        // A user-pinned tab overrides auto-selection: it becomes the primary and never flips away.
+        const pinned = this.pinnedView(now);
+        const ordered = pinned ? [pinned, ...sessions.filter((s) => s.sourcePath !== pinned.sourcePath)] : sessions;
         return {
             mode: this.mode,
-            active: scores[0] || null,
-            scores,
+            active: ordered[0] || null,
+            scores: ordered,
+            sessions: ordered,
+            threadCounts: this.threadCounts,
+            recentSessions: this.recentSessions,
             missing: this.missing,
             updatedAt: new Date().toISOString(),
         };
     }
+    labelFor(score) {
+        const cached = this.labelCache.get(score.sourcePath);
+        if (cached)
+            return cached;
+        const label = sessionLabel(score.sourcePath, score.client);
+        this.labelCache.set(score.sourcePath, label);
+        return label;
+    }
+    // Pin a recent-session id as the primary view (or null to return to auto-selection).
+    pin(id) {
+        if (id === this.pinnedId)
+            return;
+        this.pinnedId = id;
+        this.pinnedScore = null;
+    }
+    // The user-selected tab, scored on demand (cached by file signature). null if nothing is pinned or
+    // the pinned session has aged out of the recent list.
+    pinnedView(now) {
+        if (!this.pinnedId)
+            return null;
+        const rec = this.recentSessions.find((r) => r.id === this.pinnedId);
+        if (!rec)
+            return null;
+        let stat = null;
+        try {
+            stat = fs.statSync(rec.sourcePath);
+        }
+        catch {
+            return null;
+        }
+        const sig = `${rec.sourcePath}:${stat.size}:${stat.mtimeMs}`;
+        if (!this.pinnedScore || this.pinnedScore.sig !== sig) {
+            try {
+                this.pinnedScore = { sig, score: adapters[rec.client].score(rec.sourcePath) };
+            }
+            catch {
+                return null;
+            }
+        }
+        const lastActiveMs = Math.max(0, now - stat.mtimeMs);
+        return { ...this.pinnedScore.score, live: lastActiveMs < LIVE_WINDOW_MS, focused: true, label: rec.title, lastActiveMs };
+    }
     frontmostPreferredClient() {
         if (this.mode !== "auto" && this.mode !== "both")
             return null;
         const now = Date.now();
         if (now - this.frontmostCheckedAt > 1500) {
             this.frontmostCheckedAt = now;
-            this.frontmostClient = detectFrontmostClient();
+            const detected = detectFrontmostClient();
+            if (detected) {
+                // Positive detection wins immediately (real focus switch, e.g. Codex → Claude Desktop).
+                this.frontmostClient = detected;
+                this.frontmostSeenAt = now;
+            }
+            else if (now - this.frontmostSeenAt > FOCUS_GRACE_MS) {
+                // Detection missed (osascript timeout, or a non-agent app like a browser is front). Hold the
+                // last-known focus for a grace window so the active slot doesn't flip to a background client
+                // just because it's writing — then release once the grace expires.
+                this.frontmostClient = null;
+            }
         }
         return this.frontmostClient && this.scores.has(this.frontmostClient) ? this.frontmostClient : null;
     }
+    // One throttled walk over every session file per client → both the ongoing-thread counts and the
+    // "recent tabs" list (touched in the last RECENT_WINDOW_MS), which is persisted to disk so the tab
+    // set survives HUD restarts. Cheap at a few-second cadence; too heavy for the 750ms tick.
+    refreshRecent() {
+        const now = Date.now();
+        if (this.threadCountsAt && now - this.threadCountsAt < 2500)
+            return;
+        this.threadCountsAt = now;
+        this.loadCodexTitles();
+        const counts = {};
+        const recent = [];
+        const newestByClient = new Map();
+        for (const adapter of adapterList(this.mode)) {
+            let n = 0;
+            for (const file of adapter.findAll()) {
+                let mtimeMs = 0;
+                try {
+                    mtimeMs = fs.statSync(file).mtimeMs;
+                }
+                catch {
+                    continue; // vanished mid-walk
+                }
+                const age = now - mtimeMs;
+                if (age < ONGOING_WINDOW_MS)
+                    n += 1;
+                const newest = newestByClient.get(adapter.client);
+                if (!newest || mtimeMs > newest.mtimeMs)
+                    newestByClient.set(adapter.client, { file, mtimeMs });
+                if (age < RECENT_WINDOW_MS)
+                    recent.push(this.buildRecent(adapter.client, file, age));
+            }
+            counts[adapter.client] = n;
+        }
+        recent.sort((a, b) => a.lastActiveMs - b.lastActiveMs); // newest first
+        const list = recent.slice(0, RECENT_CAP);
+        // Always keep each agent's latest session reachable as a tab (so you can switch to "my last Codex"
+        // even if it's been idle longer than the window). Appended if the window didn't already include it.
+        for (const [client, info] of newestByClient) {
+            if (!list.some((r) => r.client === client))
+                list.push(this.buildRecent(client, info.file, now - info.mtimeMs));
+        }
+        this.threadCounts = counts;
+        this.recentSessions = list;
+        this.persistRecent();
+    }
+    buildRecent(client, file, age) {
+        return {
+            id: sessionIdFromPath(file),
+            client,
+            title: this.titleFor(client, file),
+            sourcePath: file,
+            lastActiveMs: age,
+            live: age < LIVE_WINDOW_MS,
+        };
+    }
+    titleFor(client, file) {
+        if (client === "codex") {
+            const uuid = codexUuidFromPath(file);
+            const title = uuid && this.codexTitles.get(uuid);
+            if (title)
+                return title;
+        }
+        else {
+            const title = this.claudeTitle(file);
+            if (title)
+                return title;
+        }
+        return sessionLabel(file, client); // repo/cwd basename fallback
+    }
+    // Claude has no title index, so derive one from the thread's first real user message (cached per file
+    // — the first message never changes). Distinguishes two threads in the same repo.
+    claudeTitle(file) {
+        const cached = this.claudeTitleCache.get(file);
+        if (cached !== undefined)
+            return cached;
+        let title = "";
+        try {
+            const fd = fs.openSync(file, "r");
+            try {
+                const buf = Buffer.alloc(64 * 1024);
+                const bytes = fs.readSync(fd, buf, 0, buf.length, 0);
+                for (const line of buf.toString("utf8", 0, bytes).split("\n")) {
+                    if (!line.includes('"user"'))
+                        continue;
+                    let obj;
+                    try {
+                        obj = JSON.parse(line);
+                    }
+                    catch {
+                        continue; // partial/last line
+                    }
+                    if (!isRecord(obj) || obj.type !== "user")
+                        continue;
+                    const message = isRecord(obj.message) ? obj.message : null;
+                    const content = message ? message.content : undefined;
+                    let body = "";
+                    if (typeof content === "string")
+                        body = content;
+                    else if (Array.isArray(content))
+                        body = content.map((b) => (isRecord(b) && typeof b.text === "string" ? b.text : "")).join(" ");
+                    body = body.replace(/\s+/g, " ").trim();
+                    if (!body || body.startsWith("<") || /^#\s*claudeMd\b/i.test(body) || body.startsWith("Caveat:"))
+                        continue;
+                    title = body.length > 48 ? `${body.slice(0, 47)}…` : body;
+                    break;
+                }
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            /* unreadable → falls back to repo label */
+        }
+        this.claudeTitleCache.set(file, title);
+        return title;
+    }
+    // Codex writes a lightweight index of every thread (id + human title). Load it (mtime-cached) so tabs
+    // show real titles like "Verify file state" instead of a UUID.
+    loadCodexTitles() {
+        const indexPath = homePath(".codex", "session_index.jsonl");
+        let sig = "";
+        try {
+            const stat = fs.statSync(indexPath);
+            sig = `${stat.size}:${stat.mtimeMs}`;
+        }
+        catch {
+            return;
+        }
+        if (sig === this.codexTitlesSig)
+            return;
+        this.codexTitlesSig = sig;
+        const map = new Map();
+        try {
+            for (const line of fs.readFileSync(indexPath, "utf8").split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj && typeof obj.id === "string" && typeof obj.thread_name === "string")
+                        map.set(obj.id, obj.thread_name);
+                }
+                catch {
+                    /* skip malformed line */
+                }
+            }
+        }
+        catch {
+            /* index unreadable — titles fall back to labels */
+        }
+        this.codexTitles = map;
+    }
+    persistRecent() {
+        const signature = JSON.stringify(this.recentSessions.map((s) => `${s.id}:${s.live}`));
+        if (signature === this.lastPersistedRecent)
+            return; // only rewrite when the set/liveness changes
+        this.lastPersistedRecent = signature;
+        try {
+            const dir = homePath(".echomem");
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, "hud-recent-sessions.json"), JSON.stringify({ updatedAt: new Date().toISOString(), sessions: this.recentSessions }, null, 2));
+        }
+        catch {
+            /* best-effort — persistence never blocks the HUD */
+        }
+    }
     tick() {
         const missing = [];
         let changed = false;
         for (const adapter of adapterList(this.mode)) {
             const file = adapter.findActive();
-            if (!file) {
+            let stat = null;
+            if (file) {
+                try {
+                    stat = fs.statSync(file);
+                }
+                catch {
+                    stat = null;
+                }
+            }
+            if (!file || !stat) {
                 missing.push(adapter.client);
                 if (this.scores.delete(adapter.client))
                     changed = true;
+                this.mtimes.delete(adapter.client);
                 continue;
             }
-            const signature = statSignature(file);
-            if (!signature || signature === this.signatures.get(adapter.client))
+            this.mtimes.set(adapter.client, liveMtime(adapter.client, file, stat.mtimeMs));
+            const signature = `${file}:${stat.size}:${stat.mtimeMs}`;
+            if (signature === this.signatures.get(adapter.client))
                 continue;
             this.signatures.set(adapter.client, signature);
             try {
@@ -104,3 +375,70 @@ function detectFrontmostClient() {
     }
     return null;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sessionIdFromPath(file) {
+    return codexUuidFromPath(file) || path.basename(file).replace(/\.jsonl$|\.json$/, "");
+}
+function codexUuidFromPath(file) {
+    const match = path.basename(file).match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
+    return match ? match[0] : "";
+}
+function defaultLabel(client) {
+    if (client === "codex")
+        return "Codex";
+    if (client === "claude-code")
+        return "Claude Code";
+    return "Claude Desktop";
+}
+// Recognizable label = basename of the session's cwd. Both Codex rollouts and Claude transcripts
+// carry a "cwd" field; the Claude Code active source is the echo-ctx cache (<sessionId>.json, no cwd),
+// so resolve its transcript by sessionId first. Falls back to the client name when cwd is absent.
+function sessionLabel(file, client) {
+    const target = resolveClaudeTranscript(file) ?? file;
+    const cwd = peekCwd(target);
+    return cwd ? path.basename(cwd) : defaultLabel(client);
+}
+// The Claude Code active source is the echo-ctx cache (<sessionId>.json), whose mtime only bumps when
+// the statusline re-renders — stale during a long turn. The transcript grows every tool call, so it's
+// the true liveness signal. Take the fresher of the two. Cached per cache-file (paths are stable).
+function liveMtime(client, file, cacheMtimeMs) {
+    const transcript = client === "claude-code" ? resolveClaudeTranscript(file) : null;
+    if (!transcript)
+        return cacheMtimeMs;
+    try {
+        return Math.max(cacheMtimeMs, fs.statSync(transcript).mtimeMs);
+    }
+    catch {
+        return cacheMtimeMs;
+    }
+}
+const transcriptCache = new Map();
+function resolveClaudeTranscript(cacheFile) {
+    if (!cacheFile.endsWith(".json") || !cacheFile.includes(`${path.sep}echo-ctx${path.sep}`))
+        return null;
+    if (transcriptCache.has(cacheFile))
+        return transcriptCache.get(cacheFile) ?? null;
+    const sessionId = path.basename(cacheFile, ".json");
+    const transcript = newestFile(walkFiles(homePath(".claude", "projects"), (f) => path.basename(f) === `${sessionId}.jsonl`));
+    transcriptCache.set(cacheFile, transcript);
+    return transcript;
+}
+function peekCwd(file) {
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(256 * 1024);
+            const bytes = fs.readSync(fd, buf, 0, buf.length, 0);
+            const match = buf.toString("utf8", 0, bytes).match(/"cwd"\s*:\s*"([^"]+)"/);
+            return match ? match[1].replace(/\\\//g, "/") : null;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return null;
+    }
+}

package/dist/hud/server.js

@@ -36,6 +36,31 @@ export async function createHudServer(opts = {}) {
             res.end(JSON.stringify(latest, null, 2));
             return;
         }
+        if (url.pathname === "/select") {
+            const id = url.searchParams.get("id");
+            monitor.pin(id && id !== "auto" ? id : null);
+            latest = monitor.snapshot();
+            const payload = `data: ${JSON.stringify(latest)}\n\n`;
+            for (const client of clients)
+                client.write(payload);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, pinned: id && id !== "auto" ? id : null }));
+            return;
+        }
+        if (url.pathname === "/reveal") {
+            const target = url.searchParams.get("path") || "";
+            // Only reveal paths we actually track — never open an arbitrary path from a query string.
+            const known = new Set([
+                ...(latest.recentSessions || []).map((s) => s.sourcePath),
+                ...(latest.sessions || []).map((s) => s.sourcePath),
+            ]);
+            const canReveal = Boolean(target) && known.has(target) && typeof opts.onReveal === "function";
+            if (canReveal)
+                opts.onReveal(target);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: canReveal, reason: canReveal ? undefined : opts.onReveal ? "unknown_path" : "no_desktop" }));
+            return;
+        }
         if (url.pathname === "/capsule") {
             const active = latest.active;
             if (!active) {