@echomem/mcp 1.4.6 → 1.4.8

package/dist/hud/server.js

@@ -1,9 +1,15 @@
 import http from "node:http";
 import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { HudMonitor } from "./monitor.js";
 import { HUD_HTML } from "./web.js";
 import { buildCapsuleText } from "./capsule.js";
+import { homePath, newestFile, walkFiles } from "./fs.js";
+import { KeyStore } from "../keystore.js";
+import { assembleCodex, assembleClaude } from "../migrate.js";
+const API_BASE = (process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app").replace(/\/$/, "");
 export async function createHudServer(opts = {}) {
     const mode = opts.mode || "auto";
     const port = opts.port ?? 17377;
@@ -47,6 +53,96 @@ export async function createHudServer(opts = {}) {
             res.end(JSON.stringify({ ok: true, pinned: id && id !== "auto" ? id : null }));
             return;
         }
+        if (url.pathname === "/viewer") {
+            const viewerPath = fileURLToPath(new URL("../../assets/hud/session-viewer.html", import.meta.url));
+            if (!fs.existsSync(viewerPath)) {
+                res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+                res.end("session viewer not found");
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            fs.createReadStream(viewerPath).pipe(res);
+            return;
+        }
+        if (url.pathname === "/session-raw") {
+            // Serve a tracked session's raw log so the viewer can fetch it same-origin. Path-validated.
+            const target = url.searchParams.get("path") || "";
+            const known = new Set([
+                ...(latest.recentSessions || []).map((s) => s.sourcePath),
+                ...(latest.sessions || []).map((s) => s.sourcePath),
+            ]);
+            if (!target || !known.has(target) || !fs.existsSync(target)) {
+                res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+                res.end("not a tracked session");
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
+            fs.createReadStream(target).pipe(res);
+            return;
+        }
+        if (url.pathname === "/session-payload") {
+            // The REAL context window: Codex logs each API request (websocket request:) in logs_2.sqlite.
+            // Return one payload per line (NDJSON) so the same viewer can render them like records.
+            const target = url.searchParams.get("path") || "";
+            const known = new Set([
+                ...(latest.recentSessions || []).map((s) => s.sourcePath),
+                ...(latest.sessions || []).map((s) => s.sourcePath),
+            ]);
+            res.writeHead(200, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
+            if (!target || !known.has(target)) {
+                res.end(JSON.stringify({ note: "not a tracked session" }));
+                return;
+            }
+            // Real request payloads are only logged by Codex (logs_2.sqlite). Claude sessions have none.
+            if (!path.basename(target).startsWith("rollout-")) {
+                res.end(JSON.stringify({ note: "This is a Claude session — the real request payload (context window) is only recorded for Codex. Switch to a Codex tab in the HUD, then open the viewer." }));
+                return;
+            }
+            const uuid = (path.basename(target).match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/) || [])[0] || "";
+            const db = homePath(".codex", "logs_2.sqlite");
+            if (!uuid || !fs.existsSync(db)) {
+                res.end(JSON.stringify({ note: "no Codex request-payload log found (logs_2.sqlite missing or no thread id)" }));
+                return;
+            }
+            try {
+                const query = `SELECT feedback_log_body FROM logs WHERE thread_id='${uuid}' AND feedback_log_body LIKE '%websocket request: %' ORDER BY ts LIMIT 500;`;
+                const out = execFileSync("sqlite3", ["-json", db, query], { maxBuffer: 256 * 1024 * 1024 }).toString();
+                const rows = JSON.parse(out || "[]");
+                const lines = [];
+                for (const row of rows) {
+                    const body = row.feedback_log_body || "";
+                    const at = body.indexOf("websocket request: ");
+                    if (at < 0)
+                        continue;
+                    try {
+                        lines.push(JSON.stringify(JSON.parse(body.slice(at + "websocket request: ".length))));
+                    }
+                    catch {
+                        /* skip unparseable payload */
+                    }
+                }
+                res.end(lines.length ? lines.join("\n") : JSON.stringify({ note: "no request payloads found for this thread" }));
+            }
+            catch (error) {
+                res.end(JSON.stringify({ note: "payload query failed", error: error instanceof Error ? error.message : String(error) }));
+            }
+            return;
+        }
+        if (url.pathname === "/open-viewer") {
+            const target = url.searchParams.get("path") || "";
+            const known = new Set([
+                ...(latest.recentSessions || []).map((s) => s.sourcePath),
+                ...(latest.sessions || []).map((s) => s.sourcePath),
+            ]);
+            const canOpen = Boolean(target) && known.has(target) && typeof opts.onOpenExternal === "function";
+            if (canOpen) {
+                const host = req.headers.host || `127.0.0.1:${port}`;
+                opts.onOpenExternal(`http://${host}/viewer?path=${encodeURIComponent(target)}`);
+            }
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: canOpen, reason: canOpen ? undefined : opts.onOpenExternal ? "unknown_path" : "no_desktop" }));
+            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.
@@ -61,6 +157,28 @@ export async function createHudServer(opts = {}) {
             res.end(JSON.stringify({ ok: canReveal, reason: canReveal ? undefined : opts.onReveal ? "unknown_path" : "no_desktop" }));
             return;
         }
+        if (url.pathname === "/renew") {
+            handleRenew(latest, 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 : "renew failed" }));
+            });
+            return;
+        }
+        if (url.pathname === "/checkpoint-status") {
+            handleCheckpointStatus(latest, 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 : "checkpoint status failed" }));
+            });
+            return;
+        }
+        if (url.pathname === "/renew-estimate") {
+            handleRenewEstimate(latest, res);
+            return;
+        }
         if (url.pathname === "/capsule") {
             const active = latest.active;
             if (!active) {
@@ -98,21 +216,313 @@ export async function createHudServer(opts = {}) {
         }),
     };
 }
+async function handleCheckpointStatus(latest, res) {
+    const respond = (obj) => {
+        if (res.writableEnded)
+            return;
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(obj));
+    };
+    const active = latest.active;
+    if (!active || !active.sourcePath)
+        return respond({ ok: false, reason: "no_active_session" });
+    const token = new KeyStore().getToken();
+    if (!token)
+        return respond({ ok: false, reason: "not_logged_in" });
+    const sessionFile = resolveSessionFile(active.client, active.sourcePath);
+    const assembled = active.client === "codex" ? assembleCodex(sessionFile) : assembleClaude(sessionFile);
+    if (!assembled || !assembled.conversationKey) {
+        return respond({ ok: false, reason: "empty_session" });
+    }
+    const response = await fetch(`${API_BASE}/api/extension/memories/session-status`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ conversationKey: assembled.conversationKey }),
+    });
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok || data.success === false) {
+        return respond({ ok: false, reason: data.error || `HTTP ${response.status}` });
+    }
+    respond({
+        ok: true,
+        hasCheckpoint: Boolean(data.hasCheckpoint ?? data.exists),
+        contextId: typeof data.contextId === "string" ? data.contextId : undefined,
+        checkpointMemoryId: typeof data.checkpointMemoryId === "string" ? data.checkpointMemoryId : undefined,
+        renewedAt: typeof data.renewedAt === "string" ? data.renewedAt : undefined,
+        memoryCount: typeof data.memoryCount === "number" ? data.memoryCount : 0,
+    });
+}
+// Renew = the core loop: extract the active coding session into checkpoint memories (cloud, coding
+// prompt) and hand back a "carryover" the user pastes into a fresh session.
+async function handleRenew(latest, res) {
+    const respond = (obj) => {
+        if (res.writableEnded)
+            return;
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(obj));
+    };
+    const active = latest.active;
+    if (!active || !active.sourcePath)
+        return respond({ ok: false, reason: "no_active_session" });
+    const token = new KeyStore().getToken();
+    if (!token)
+        return respond({ ok: false, reason: "not_logged_in" });
+    const sessionFile = resolveSessionFile(active.client, active.sourcePath);
+    const assembled = active.client === "codex" ? assembleCodex(sessionFile) : assembleClaude(sessionFile);
+    if (!assembled || !assembled.rawData || assembled.rawData.length < 20) {
+        return respond({ ok: false, reason: "empty_session" });
+    }
+    const body = JSON.stringify({
+        rawData: assembled.rawData,
+        source: active.client,
+        sessionType: "coding",
+        cleanCarry: true, // → the GetCleanCarryPrompt path: EXACTLY ONE resumption capsule
+        conversationKey: assembled.conversationKey,
+        title: assembled.title,
+    });
+    const post = (extra) => fetch(`${API_BASE}/api/extension/memories/ingest`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}`, ...extra },
+        body,
+    });
+    let response = await post({});
+    if (response.status === 422) {
+        const key = new KeyStore().getKey();
+        if (key)
+            response = await post({ "X-Encryption-Key": key });
+    }
+    const data = (await response.json().catch(() => ({})));
+    if (!response.ok || data.success === false) {
+        const err = data.error || `HTTP ${response.status}`;
+        const vaultLocked = /ENCRYPTION_KEY_REQUIRED|encrypted/i.test(err);
+        return respond({ ok: false, reason: vaultLocked ? "vault_locked" : err, hint: vaultLocked ? "Run `echomem-mcp unlock` to enable cloud checkpoint extraction." : undefined });
+    }
+    const contextId = typeof data.contextId === "string" ? data.contextId : undefined;
+    // How many memories this session has in EchoMem, so the fresh agent can judge whether to fetch.
+    let sessionMemoryCount = data.memoriesExtracted || 0;
+    if (contextId) {
+        try {
+            const countRes = await fetch(`${API_BASE}/api/extension/memories/by-context`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+                body: JSON.stringify({ contextId, limit: 200 }),
+            });
+            const countData = (await countRes.json().catch(() => ({})));
+            if (typeof countData.count === "number")
+                sessionMemoryCount = countData.count;
+        }
+        catch {
+            /* count is best-effort */
+        }
+    }
+    respond({
+        ok: true,
+        carryover: formatCarryover(data.extractedMemories || [], assembled.title, contextId, sessionMemoryCount),
+        saved: data.memoriesExtracted || 0,
+        sessionMemoryCount,
+        contextId,
+    });
+}
+function handleRenewEstimate(latest, res) {
+    const respond = (obj) => {
+        if (res.writableEnded)
+            return;
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(obj));
+    };
+    const active = latest.active;
+    if (!active || !active.sourcePath)
+        return respond({ ok: false, reason: "no_active_session" });
+    const sessionFile = resolveSessionFile(active.client, active.sourcePath);
+    const assembled = active.client === "codex" ? assembleCodex(sessionFile) : assembleClaude(sessionFile);
+    if (!assembled || !assembled.rawData || assembled.rawData.length < 20) {
+        return respond({ ok: false, reason: "empty_session" });
+    }
+    respond({ ok: true, ...estimateRenewDuration(assembled.rawData, active.client) });
+}
+function estimateRenewDuration(rawData, client) {
+    const approxInputTokens = Math.max(1, Math.ceil(rawData.length / 4));
+    const history = readRenewMetrics().filter((m) => sourceMatchesClient(m.source, client));
+    const candidates = history.length >= 5 ? history : readRenewMetrics();
+    const bucket = tokenBucket(approxInputTokens);
+    let basis = "bucket";
+    let samples = candidates.filter((m) => {
+        const n = Number(m.approxInputTokens) || 0;
+        return n > bucket.min && n <= bucket.max;
+    });
+    if (samples.length < 5) {
+        basis = "nearest";
+        samples = candidates
+            .slice()
+            .sort((a, b) => tokenDistance(Number(a.approxInputTokens) || 0, approxInputTokens) - tokenDistance(Number(b.approxInputTokens) || 0, approxInputTokens))
+            .slice(0, Math.min(20, candidates.length));
+    }
+    if (!samples.length) {
+        basis = "fallback";
+        const etaMs = fallbackRenewEtaMs(approxInputTokens);
+        return { etaMs, approxInputTokens, sampleCount: 0, historyCount: candidates.length, basis };
+    }
+    const durations = samples.map((m) => Number(m.durationMs)).filter((n) => Number.isFinite(n) && n > 0);
+    if (!durations.length) {
+        basis = "fallback";
+        const etaMs = fallbackRenewEtaMs(approxInputTokens);
+        return { etaMs, approxInputTokens, sampleCount: 0, historyCount: candidates.length, basis };
+    }
+    const p50Ms = percentile(durations, 0.5);
+    const p75Ms = percentile(durations, 0.75);
+    return {
+        etaMs: clampMs(p50Ms),
+        approxInputTokens,
+        sampleCount: samples.length,
+        historyCount: candidates.length,
+        basis,
+        p50Ms,
+        p75Ms,
+    };
+}
+function readRenewMetrics() {
+    const file = homePath(".echomem", "migrate-metrics.jsonl");
+    let lines;
+    try {
+        lines = fs.readFileSync(file, "utf8").split("\n");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of lines.slice(-600)) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            const m = JSON.parse(s);
+            if (m.status === "completed" &&
+                !m.duplicate &&
+                !m.alreadyDone &&
+                typeof m.durationMs === "number" &&
+                m.durationMs > 0 &&
+                typeof m.approxInputTokens === "number" &&
+                m.approxInputTokens > 0) {
+                out.push(m);
+            }
+        }
+        catch {
+            /* ignore malformed metrics */
+        }
+    }
+    return out;
+}
+function sourceMatchesClient(source, client) {
+    if (!source)
+        return false;
+    if (client === "codex")
+        return source === "codex";
+    if (client.startsWith("claude"))
+        return source.startsWith("claude");
+    return source === client;
+}
+function tokenBucket(tokens) {
+    if (tokens <= 5_000)
+        return { min: 0, max: 5_000 };
+    if (tokens <= 10_000)
+        return { min: 5_000, max: 10_000 };
+    if (tokens <= 25_000)
+        return { min: 10_000, max: 25_000 };
+    if (tokens <= 50_000)
+        return { min: 25_000, max: 50_000 };
+    if (tokens <= 100_000)
+        return { min: 50_000, max: 100_000 };
+    return { min: 100_000, max: Number.POSITIVE_INFINITY };
+}
+function tokenDistance(a, b) {
+    return Math.abs(Math.log((Math.max(1, a) + 1000) / (Math.max(1, b) + 1000)));
+}
+function percentile(values, p) {
+    const xs = values.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+    if (!xs.length)
+        return 0;
+    return xs[Math.min(xs.length - 1, Math.floor((xs.length - 1) * p))];
+}
+function clampMs(ms) {
+    return Math.max(6_000, Math.min(180_000, Math.round(ms)));
+}
+function fallbackRenewEtaMs(tokens) {
+    if (tokens <= 5_000)
+        return 10_000;
+    if (tokens <= 10_000)
+        return 12_000;
+    if (tokens <= 25_000)
+        return 15_000;
+    if (tokens <= 50_000)
+        return 18_000;
+    if (tokens <= 100_000)
+        return 20_000;
+    return 45_000;
+}
+// Claude Code's active source is the echo-ctx cache (no turns) — resolve its transcript for assembly.
+function resolveSessionFile(client, sourcePath) {
+    if (client === "codex" || !sourcePath.endsWith(".json") || !sourcePath.includes(`${"/"}echo-ctx${"/"}`))
+        return sourcePath;
+    const sessionId = sourcePath.split("/").pop()?.replace(/\.json$/, "") || "";
+    const transcript = newestFile(walkFiles(homePath(".claude", "projects"), (f) => f.split("/").pop() === `${sessionId}.jsonl`));
+    return transcript || sourcePath;
+}
+function formatCarryover(memories, title, contextId, sessionMemoryCount) {
+    const str = (m, k) => (typeof m[k] === "string" ? m[k] : "");
+    const clean = memories.find((m) => /^clean[ -]?carry/i.test(str(m, "description")));
+    const others = memories.filter((m) => m !== clean);
+    // STATE, not INSTRUCTIONS: the receiving agent should orient, then ASK — never start verifying
+    // files or "continuing" a task the user may not want. (A real test showed "Verify anything that
+    // references file state" became the agent's task: it ran 15 commands before the user said a word.)
+    const lines = [
+        "Here is a snapshot of my previous coding session, for context. It is point-in-time: work may have continued after it was taken, so treat file/state references as possibly stale.",
+        "Use it to orient yourself in a clean context window. It is context, not a command.",
+        "If my current message gives a clear request, respond to that request using this snapshot as background. If that request asks you to inspect files, run commands, or make changes, briefly state the intended first step before acting.",
+        "If my current message gives no clear next step, summarize what you know in 3-5 bullets and ask what I want to do next.",
+        "",
+    ];
+    if (clean) {
+        lines.push("## Where I left off", str(clean, "description"));
+        if (str(clean, "details"))
+            lines.push(str(clean, "details"));
+        lines.push("");
+    }
+    if (others.length) {
+        lines.push("## Checkpoints from this session");
+        for (const m of others)
+            lines.push(`- ${str(m, "keys") || "checkpoint"}: ${str(m, "description")}`);
+        lines.push("");
+    }
+    if (!clean && !others.length) {
+        lines.push(`(${title || "This session"} had no clear decision or state to carry — nothing was extracted.)`);
+    }
+    // Tell the fresh agent exactly how much is in EchoMem for this session, so it can decide whether to fetch.
+    if (contextId && typeof sessionMemoryCount === "number") {
+        const n = sessionMemoryCount;
+        lines.push(`(EchoMem has ${n} ${n === 1 ? "memory" : "memories"} saved for this checkpoint. If you need more than this snapshot, pull the decision trail with get_checkpoint_by_context({ contextId: "${contextId}" }) — otherwise just work from the above.)`);
+    }
+    else {
+        lines.push("(Recalled from EchoMem — call search_memories or get_checkpoint_by_context for more checkpoint context.)");
+    }
+    return lines.join("\n");
+}
 function serveHudAsset(pathname, res) {
     const assets = {
-        "/assets/hud/echo-face-cutout.png": "../../assets/hud/echo-face-cutout.png",
+        "/assets/hud/echo-face-cutout.png": { path: "../../assets/hud/echo-face-cutout.png", type: "image/png" },
+        "/assets/hud/claude.svg": { path: "../../assets/hud/claude.svg", type: "image/svg+xml; charset=utf-8" },
+        "/assets/hud/codex.svg": { path: "../../assets/hud/codex.svg", type: "image/svg+xml; charset=utf-8" },
     };
     const asset = assets[pathname];
     if (!asset)
         return false;
-    const assetPath = fileURLToPath(new URL(asset, import.meta.url));
+    const assetPath = fileURLToPath(new URL(asset.path, import.meta.url));
     if (!fs.existsSync(assetPath)) {
         res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
         res.end("HUD asset not found");
         return true;
     }
     res.writeHead(200, {
-        "content-type": "image/png",
+        "content-type": asset.type,
         "cache-control": "public, max-age=31536000, immutable",
     });
     fs.createReadStream(assetPath).pipe(res);