@echomem/mcp 1.4.7 → 1.4.8

package/dist/hud/server.js

@@ -6,7 +6,10 @@ import { fileURLToPath } from "node:url";
 import { HudMonitor } from "./monitor.js";
 import { HUD_HTML } from "./web.js";
 import { buildCapsuleText } from "./capsule.js";
-import { homePath } from "./fs.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;
@@ -154,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) {
@@ -191,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);