@echomem/mcp 1.4.17 → 1.4.19

package/dist/hud/monitor.js

@@ -30,9 +30,9 @@ export class HudMonitor extends EventEmitter {
     claudeTitlesCheckedAt = 0;
     claudeTitleCache = new Map();
     lastPersistedRecent = "";
-    pinnedId = null;
-    pinnedScore = null;
-    pinnedFromFamily = null;
+    responseTimes = new Map();
+    expandedId = null;
+    expandedScore = null;
     constructor(mode = "auto", pollMs = 750) {
         super();
         this.mode = mode;
@@ -53,37 +53,37 @@ export class HudMonitor extends EventEmitter {
     snapshot() {
         const focusedFamily = this.frontmostPreferredFamily();
         this.refreshRecent();
-        this.releasePinAfterForegroundSwitch(focusedFamily);
         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);
+            const responseAtMs = this.responseTimeFor(score.client, score.sourcePath, mtimeMs);
+            const lastActiveMs = Math.max(0, now - responseAtMs);
             return {
                 ...score,
-                live: lastActiveMs < LIVE_WINDOW_MS,
+                live: Math.max(0, now - mtimeMs) < LIVE_WINDOW_MS,
                 focused: focusedFamily === agentFamily(score.client),
                 label: this.labelFor(score),
                 lastActiveMs,
             };
         });
-        // The user's foreground agent is the primary truth. Background agents can keep writing logs, but
-        // they should never steal the main HUD away from Codex/Claude while that app is what the user opened.
-        sessions.sort((a, b) => hudSelectionRank(a) - hudSelectionRank(b) || a.lastActiveMs - b.lastActiveMs);
-        // A pin selects one session while the user remains in the same agent. Crossing to the other
-        // foreground agent releases it so Auto can follow the workflow again.
-        const pinned = this.pinnedView(now);
-        const ordered = pinned ? [pinned, ...sessions.filter((s) => s.sourcePath !== pinned.sourcePath)] : sessions;
-        const pinnedId = pinned ? this.pinnedId : null;
+        // Only a newer assistant response can promote a conversation. Focus, clicks, and expansion are
+        // view state and must never rewrite chronology; sourcePath is only a deterministic exact-tie key.
+        sessions.sort((a, b) => a.lastActiveMs - b.lastActiveMs || a.sourcePath.localeCompare(b.sourcePath));
+        const expanded = this.expandedView(now);
+        const views = expanded
+            ? [expanded, ...sessions.filter((s) => s.sourcePath !== expanded.sourcePath)]
+            : sessions;
         return {
             mode: this.mode,
-            active: ordered[0] || null,
-            scores: ordered,
-            sessions: ordered,
+            active: sessions[0] || null,
+            expanded,
+            expandedId: expanded ? this.expandedId : null,
+            scores: views,
+            sessions: views,
             threadCounts: this.threadCounts,
             recentSessions: this.recentSessions,
-            pinnedId,
             missing: this.missing,
             updatedAt: new Date().toISOString(),
         };
@@ -96,29 +96,20 @@ export class HudMonitor extends EventEmitter {
         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)
+    // Expand one recent-session row in place (or null to collapse it). This deliberately does not
+    // participate in active-session selection, so inspecting history cannot move the timeline.
+    expand(id) {
+        if (id === this.expandedId)
             return;
-        this.pinnedId = id;
-        this.pinnedScore = null;
-        this.pinnedFromFamily = id ? this.frontmostPreferredFamily() : null;
+        this.expandedId = id;
+        this.expandedScore = null;
     }
-    releasePinAfterForegroundSwitch(focusedFamily) {
-        if (!this.pinnedId || !this.pinnedFromFamily || !focusedFamily)
-            return;
-        if (focusedFamily === this.pinnedFromFamily)
-            return;
-        this.pinnedId = null;
-        this.pinnedScore = null;
-        this.pinnedFromFamily = 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)
+    // The expanded history row, scored on demand (cached by file signature). null if nothing is
+    // expanded or the session has aged out of the recent list.
+    expandedView(now) {
+        if (!this.expandedId)
             return null;
-        const rec = this.recentSessions.find((r) => r.id === this.pinnedId);
+        const rec = this.recentSessions.find((r) => r.id === this.expandedId);
         if (!rec)
             return null;
         let stat = null;
@@ -129,16 +120,23 @@ export class HudMonitor extends EventEmitter {
             return null;
         }
         const sig = `${rec.sourcePath}:${stat.size}:${stat.mtimeMs}`;
-        if (!this.pinnedScore || this.pinnedScore.sig !== sig) {
+        if (!this.expandedScore || this.expandedScore.sig !== sig) {
             try {
-                this.pinnedScore = { sig, score: adapters[rec.client].score(rec.sourcePath) };
+                this.expandedScore = { 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.label || rec.title, lastActiveMs };
+        const activityMtimeMs = liveMtime(rec.client, rec.sourcePath, stat.mtimeMs);
+        const lastActiveMs = Math.max(0, now - this.responseTimeFor(rec.client, rec.sourcePath, activityMtimeMs));
+        return {
+            ...this.expandedScore.score,
+            live: Math.max(0, now - activityMtimeMs) < LIVE_WINDOW_MS,
+            focused: false,
+            label: rec.label || rec.title,
+            lastActiveMs,
+        };
     }
     frontmostPreferredFamily() {
         if (this.mode !== "auto" && this.mode !== "both")
@@ -189,8 +187,10 @@ export class HudMonitor extends EventEmitter {
                 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));
+                if (age < RECENT_WINDOW_MS) {
+                    const responseAtMs = this.responseTimeFor(adapter.client, file, mtimeMs);
+                    recent.push(this.buildRecent(adapter.client, file, age, Math.max(0, now - responseAtMs)));
+                }
             }
             counts[adapter.client] = n;
         }
@@ -199,24 +199,44 @@ export class HudMonitor extends EventEmitter {
         // 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));
+            if (!list.some((r) => r.client === client)) {
+                const activityAgeMs = now - info.mtimeMs;
+                const responseAgeMs = Math.max(0, now - this.responseTimeFor(client, info.file, info.mtimeMs));
+                list.push(this.buildRecent(client, info.file, activityAgeMs, responseAgeMs));
+            }
         }
         this.threadCounts = counts;
         this.recentSessions = list;
         this.persistRecent();
     }
-    buildRecent(client, file, age) {
+    buildRecent(client, file, activityAgeMs, responseAgeMs) {
         return {
-            id: sessionIdFromPath(file),
+            id: recentSessionId(client, file),
             client,
             title: this.titleFor(client, file),
             label: sessionLabel(file, client),
             sourcePath: file,
-            lastActiveMs: age,
-            live: age < LIVE_WINDOW_MS,
+            lastActiveMs: responseAgeMs,
+            live: activityAgeMs < LIVE_WINDOW_MS,
         };
     }
+    responseTimeFor(client, file, fallbackMtimeMs) {
+        const transcript = client === "codex" ? file : resolveClaudeTranscript(file) ?? file;
+        let signature = "";
+        try {
+            const stat = fs.statSync(transcript);
+            signature = `${transcript}:${stat.size}:${stat.mtimeMs}`;
+        }
+        catch {
+            return fallbackMtimeMs;
+        }
+        const cached = this.responseTimes.get(transcript);
+        if (cached?.signature === signature)
+            return cached.timestampMs;
+        const timestampMs = latestAssistantResponseAt(transcript, client) || cached?.timestampMs || fallbackMtimeMs;
+        this.responseTimes.set(transcript, { signature, timestampMs });
+        return timestampMs;
+    }
     titleFor(client, file) {
         if (client === "codex") {
             const uuid = codexUuidFromPath(file);
@@ -414,12 +434,106 @@ export function agentFamilyForApplication(name, bundleId = "") {
 export function agentFamily(client) {
     return client === "codex" ? "codex" : "claude";
 }
+// Return the timestamp of the newest assistant text response, ignoring user turns, tool calls,
+// tool results, and other transcript writes. Scanning backwards keeps the common path cheap while
+// making ordering depend on conversation responses instead of filesystem activity.
+export function latestAssistantResponseAt(file, client) {
+    const chunkSize = 256 * 1024;
+    const maxScanBytes = 8 * 1024 * 1024;
+    let fd = null;
+    try {
+        fd = fs.openSync(file, "r");
+        const size = fs.fstatSync(fd).size;
+        let position = size;
+        let scanned = 0;
+        let carry = "";
+        while (position > 0 && scanned < maxScanBytes) {
+            const bytes = Math.min(chunkSize, position, maxScanBytes - scanned);
+            position -= bytes;
+            scanned += bytes;
+            const buffer = Buffer.allocUnsafe(bytes);
+            fs.readSync(fd, buffer, 0, bytes, position);
+            const lines = (buffer.toString("utf8") + carry).split("\n");
+            carry = lines.shift() || "";
+            for (let i = lines.length - 1; i >= 0; i -= 1) {
+                const timestampMs = assistantResponseTimestamp(lines[i], client);
+                if (timestampMs !== null)
+                    return timestampMs;
+            }
+        }
+        return assistantResponseTimestamp(carry, client);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+}
+function assistantResponseTimestamp(line, client) {
+    if (!line.trim())
+        return null;
+    let row;
+    try {
+        row = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(row))
+        return null;
+    const payload = isRecord(row.payload) ? row.payload : {};
+    const timestamp = typeof row.timestamp === "string"
+        ? Date.parse(row.timestamp)
+        : typeof payload.timestamp === "string"
+            ? Date.parse(payload.timestamp)
+            : Number.NaN;
+    if (!Number.isFinite(timestamp))
+        return null;
+    if (client === "codex") {
+        const type = typeof payload.type === "string" ? payload.type : "";
+        if ((type === "agent_message" || type === "assistant_message") && hasText(payload.message ?? payload.content)) {
+            return timestamp;
+        }
+        if (type === "message" && payload.role === "assistant" && hasText(payload.content ?? payload.message)) {
+            return timestamp;
+        }
+        return null;
+    }
+    if (row.type !== "assistant")
+        return null;
+    const message = isRecord(row.message) ? row.message : {};
+    if (message.role !== undefined && message.role !== "assistant")
+        return null;
+    return hasText(message.content) ? timestamp : null;
+}
+function hasText(value) {
+    if (typeof value === "string")
+        return Boolean(value.trim());
+    if (!Array.isArray(value))
+        return false;
+    return value.some((block) => {
+        if (typeof block === "string")
+            return Boolean(block.trim());
+        if (!isRecord(block))
+            return false;
+        const type = typeof block.type === "string" ? block.type : "";
+        return (type === "text" || type === "output_text") && typeof block.text === "string" && Boolean(block.text.trim());
+    });
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sessionIdFromPath(file) {
     return codexUuidFromPath(file) || path.basename(file).replace(/\.jsonl$|\.json$/, "");
 }
+// Provider-qualified identity keeps one combined session feed safe when two clients reuse the same
+// UUID (for example, a Claude Code session mirrored into Claude Desktop). The source id remains
+// recoverable from sourcePath for provider-specific deep links and title metadata joins.
+export function recentSessionId(client, file) {
+    return `${client}:${sessionIdFromPath(file)}`;
+}
 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] : "";

package/dist/hud/server.js

@@ -11,6 +11,7 @@ import { homePath, newestFile, walkFiles } from "./fs.js";
 import { KeyStore } from "../keystore.js";
 import { assembleCodex, assembleClaude } from "../migrate.js";
 import { readBillingAlert } from "../billing-alert.js";
+import { readSessionWorkingDirectory, } from "./session-launcher.js";
 const API_BASE = (process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app").replace(/\/$/, "");
 const PRICING_URL = (process.env.ECHO_PRICING_URL || "https://echoknows.com/pricing").replace(/\/$/, "");
 export async function createHudServer(opts = {}) {
@@ -89,15 +90,17 @@ export async function createHudServer(opts = {}) {
             });
             return;
         }
-        if (url.pathname === "/select") {
+        if (url.pathname === "/expand" || url.pathname === "/select") {
             const id = url.searchParams.get("id");
-            monitor.pin(id && id !== "auto" ? id : null);
+            // /select remains as a compatibility alias, but selection no longer replaces the top card:
+            // it only expands that timeline row in place.
+            monitor.expand(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 }));
+            res.end(JSON.stringify({ ok: true, expanded: id && id !== "auto" ? id : null }));
             return;
         }
         if (url.pathname === "/viewer") {
@@ -242,6 +245,15 @@ export async function createHudServer(opts = {}) {
             });
             return;
         }
+        if (url.pathname === "/launch") {
+            handleLaunch(req, latest, opts.onLaunchSession, res).catch((error) => {
+                if (res.writableEnded)
+                    return;
+                res.writeHead(200, { "content-type": "application/json" });
+                res.end(JSON.stringify({ ok: false, reason: error instanceof Error ? error.message : "launch_failed" }));
+            });
+            return;
+        }
         if (url.pathname === "/checkpoint-status") {
             handleCheckpointStatus(latest, res).catch((error) => {
                 if (res.writableEnded)
@@ -307,6 +319,9 @@ async function handleBillingStatus(res) {
     }
     let plan = "unknown";
     let paid = false;
+    let historicalConversationQuota = null;
+    let memoryProcessingQuota = null;
+    let memorySearchQuota = null;
     try {
         const response = await fetch(`${API_BASE}/api/extension/account/bootstrap`, {
             headers: { Authorization: `Bearer ${token}` },
@@ -315,34 +330,35 @@ async function handleBillingStatus(res) {
         if (response.ok) {
             plan = typeof data.plan === "string" ? data.plan.toLowerCase() : "free";
             paid = ["pro", "power", "team", "enterprise"].includes(plan);
+            historicalConversationQuota = data.historicalConversationQuota ?? null;
+            memoryProcessingQuota = data.memoryProcessingQuota ?? null;
+            memorySearchQuota = data.memorySearchQuota ?? null;
         }
     }
     catch {
         /* Local alert still gives the HUD something useful. */
     }
-    if (alert && (alert.kind === "quota_exceeded" || !paid)) {
+    const quotaPayload = {
+        historicalConversationQuota,
+        memoryProcessingQuota,
+        memorySearchQuota,
+    };
+    // Free now includes recall. Ignore old plan_required alerts that may still
+    // be present on disk from a previous bridge version.
+    if (alert && (alert.kind === "quota_exceeded" || alert.kind === "billing_attention")) {
         return respond({
             ok: true,
             state: alert.kind,
             plan: alert.plan || plan,
-            message: alert.kind === "quota_exceeded" ? "Recall limit reached." : "Recall needs a plan.",
+            message: alert.kind === "quota_exceeded" ? "Plan limit reached." : "Billing needs attention.",
             detail: alert.message,
             code: alert.code,
             pricingUrl: appendSource(alert.pricingUrl || pricingUrl, "hud"),
             updatedAt: alert.updatedAt,
+            ...quotaPayload,
         });
     }
-    if (!paid && plan === "free") {
-        return respond({
-            ok: true,
-            state: "plan_required",
-            plan,
-            message: "Recall needs a plan.",
-            detail: "Search and recall require Echo Pro or Power. Saving conversations keeps working.",
-            pricingUrl,
-        });
-    }
-    respond({ ok: true, state: "ok", plan, paid, pricingUrl });
+    respond({ ok: true, state: "ok", plan, paid, pricingUrl, ...quotaPayload });
 }
 function appendSource(url, source) {
     try {
@@ -355,6 +371,44 @@ function appendSource(url, source) {
         return url;
     }
 }
+async function handleLaunch(req, latest, launch, res) {
+    const respond = (obj) => {
+        if (res.writableEnded)
+            return;
+        res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+        res.end(JSON.stringify(obj));
+    };
+    if (req.method !== "POST")
+        return respond({ ok: false, reason: "method_not_allowed" });
+    const origin = req.headers.origin;
+    if (origin && !/^http:\/\/(?:127\.0\.0\.1|localhost)(?::\d+)?$/.test(origin)) {
+        return respond({ ok: false, reason: "origin_not_allowed" });
+    }
+    if (!launch)
+        return respond({ ok: false, reason: "no_desktop" });
+    const active = latest.active;
+    if (!active || !active.sourcePath)
+        return respond({ ok: false, reason: "no_active_session" });
+    const body = await readRequestJson(req, 600_000);
+    const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+    const expectedSource = typeof body.sourcePath === "string" ? body.sourcePath : "";
+    if (!prompt || prompt.length > 512_000)
+        return respond({ ok: false, reason: "invalid_context" });
+    if (!expectedSource || expectedSource !== active.sourcePath)
+        return respond({ ok: false, reason: "session_changed" });
+    const sessionFile = resolveSessionFile(active.client, active.sourcePath);
+    const assembled = active.client === "codex" ? assembleCodex(sessionFile) : assembleClaude(sessionFile);
+    const cwd = readSessionWorkingDirectory(sessionFile) || (assembled?.cwd && path.isAbsolute(assembled.cwd) ? assembled.cwd : "");
+    if (!assembled || !cwd)
+        return respond({ ok: false, reason: "workspace_missing" });
+    const result = await launch({
+        client: active.client,
+        cwd,
+        prompt,
+        title: assembled.title,
+    });
+    respond(result);
+}
 async function handleCheckpointStatus(latest, res) {
     const respond = (obj) => {
         if (res.writableEnded)
@@ -668,3 +722,29 @@ function serveHudAsset(pathname, res) {
     fs.createReadStream(assetPath).pipe(res);
     return true;
 }
+function readRequestJson(req, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            size += buffer.length;
+            if (size > maxBytes) {
+                reject(new Error("request_too_large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(buffer);
+        });
+        req.on("end", () => {
+            try {
+                const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+                resolve(typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {});
+            }
+            catch {
+                reject(new Error("invalid_json"));
+            }
+        });
+        req.on("error", reject);
+    });
+}