@echomem/mcp 1.4.20 → 1.4.22

package/README.md

@@ -66,7 +66,7 @@ HUD; the granular commands below still work.
 | `npx -y @echomem/mcp@latest setup` | One-off setup without keeping a global CLI command |
 | `echomem-mcp setup [--client cursor\|windsurf\|claude-desktop\|claude-code\|codex]` | Write client config + log in |
 | `echomem-mcp setup --skip-login [--client cursor\|windsurf\|claude-desktop\|claude-code\|codex]` | Write client config without opening the browser or changing credentials |
-| `npx -y @echomem/mcp@latest update --all` | One-shot update: repoint detected client configs to the latest bridge, with no browser login |
+| `npx -y @echomem/mcp@latest update --all` | One-shot update: install the latest bridge durably and repoint detected client configs, with no browser login |
 | `npx -y @echomem/mcp@latest update --client codex` | Update one client only |
 | `echomem-mcp setup --with-hud [--client codex]` | Write client config + log in + launch the EchoMem context HUD |
 | `echomem-mcp login` | Approve device in browser (or use `--token` / `--passphrase`) |

package/dist/crypto.js

@@ -95,6 +95,10 @@ export async function decrypt(ciphertext, key) {
     const plainBuffer = await subtle.decrypt({ name: ALGORITHM, iv }, key, data);
     return new TextDecoder().decode(plainBuffer);
 }
+/** Create a server-verifiable token for a newly configured encryption key. */
+export async function createVerification(key) {
+    return encrypt(VERIFICATION_PLAINTEXT, key);
+}
 /** Verify a key against a stored verification token (current + legacy plaintexts). */
 export async function verifyKey(key, token) {
     try {

package/dist/encryption.js

@@ -1,4 +1,5 @@
-import { deriveKey, exportKeyToBase64, importKeyFromBase64, decrypt, verifyKey, saltFromBase64 } from "./crypto.js";
+import { createVerification, deriveKey, exportKeyToBase64, generateSalt, importKeyFromBase64, decrypt, saltFromBase64, saltToBase64, verifyKey, } from "./crypto.js";
+const DEFAULT_KEY_ITERATIONS = 600_000;
 /** GET the account's encryption status from the EchoMem backend using the bridge's authed client. */
 export async function fetchEncryptionConfig(axios) {
     // Bounded: this is on the startup/tool-listing path; an unbounded call on a flaky network would hang
@@ -21,11 +22,22 @@ export async function deriveAndVerifyKey(passphrase, config) {
     if (!config.enabled || !config.salt || !config.verification)
         return null;
     const salt = saltFromBase64(config.salt);
-    const key = await deriveKey(passphrase, salt, config.iterations ?? 600_000);
+    const key = await deriveKey(passphrase, salt, config.iterations ?? DEFAULT_KEY_ITERATIONS);
     if (!(await verifyKey(key, config.verification)))
         return null;
     return exportKeyToBase64(key);
 }
+/** Create a fresh account encryption config locally. The passphrase/key never leaves the device. */
+export async function setupNewEncryptionKey(passphrase, iterations = DEFAULT_KEY_ITERATIONS) {
+    const salt = generateSalt();
+    const key = await deriveKey(passphrase, salt, iterations);
+    return {
+        keyBase64: await exportKeyToBase64(key),
+        saltBase64: saltToBase64(salt),
+        verification: await createVerification(key),
+        iterations,
+    };
+}
 /** Verify an already-exported base64 key against the server's verification token. */
 export async function verifyKeyB64(keyBase64, config) {
     if (!config.enabled || !config.verification)

package/dist/index.js

@@ -10,7 +10,7 @@ import { EventLogger, hashText } from "./events.js";
 import { buildReportText } from "./report.js";
 import { contextHealthMarkdown, recomposeCapsuleMarkdown } from "./hud/api.js";
 import { createHash, randomUUID } from "node:crypto";
-import { fetchEncryptionConfig, decryptMemoryFields } from "./encryption.js";
+import { fetchEncryptionConfig, decryptMemoryFields, verifyKeyB64, } from "./encryption.js";
 import { runCli } from "./setup.js";
 import { MCP_PACKAGE_VERSION, MCP_SERVER_INSTRUCTIONS } from "./package-metadata.js";
 import { clearBillingAlert, writeBillingAlert } from "./billing-alert.js";
@@ -23,6 +23,9 @@ class NoTokenError extends Error {
 /** Thrown when an encrypted account has no usable key — the model gets an unlock nudge, never ciphertext. */
 class LockedError extends Error {
 }
+/** Thrown when the bridge cannot prove whether the account is encrypted. */
+class EncryptionStatusUnavailableError extends Error {
+}
 function stringifyErrorValue(value) {
     if (value == null) {
         return "";
@@ -121,7 +124,7 @@ function formatUpgradeRequiredResult(error) {
         pricingUrl,
     });
     return [
-        "ACTION REQUIRED: tell the user to start a 7-day Pro trial or choose a subscription at this exact URL:",
+        "ACTION REQUIRED: tell the user to start a 14-day Pro trial or choose a subscription at this exact URL:",
         pricingUrl,
         "When replying, include the exact URL above. Do not reply only with \"connect\" or \"upgrade\".",
         "",
@@ -130,6 +133,15 @@ function formatUpgradeRequiredResult(error) {
         code ? `Reason: ${code}.` : "",
     ].filter(Boolean).join("\n");
 }
+function formatReconnectRequiredResult(error) {
+    if (!axios.isAxiosError(error) || error.response?.status !== 401)
+        return null;
+    return [
+        "🔌 EchoMem's saved login is no longer accepted (Unauthorized, HTTP 401).",
+        "Action required from the user: run `echomem-mcp login` in a terminal to reconnect this device, then retry this action.",
+        "No editor restart is needed. Keep all credentials out of chat.",
+    ].join("\n");
+}
 /** Map a thrown error to the telemetry error_kind taxonomy. */
 function classifyError(error) {
     if (error instanceof NoTokenError)
@@ -564,8 +576,8 @@ class EchoMemApiClient {
         if (!this.encConfigPromise) {
             this.encConfigPromise = fetchEncryptionConfig(this.axios).catch((error) => {
                 this.encConfigPromise = null; // allow retry next call
-                console.error(`[encryption] config fetch failed: ${describeError(error)} — proceeding as unencrypted`);
-                return { enabled: false };
+                console.error(`[encryption] config fetch failed: ${describeError(error)} — refusing memory access`);
+                throw new EncryptionStatusUnavailableError("EchoMem could not verify the account encryption state");
             });
         }
         return this.encConfigPromise;
@@ -576,18 +588,20 @@ class EchoMemApiClient {
      * handing the model ciphertext. For unencrypted accounts it returns `{ enabled: false }`.
      */
     async encState() {
-        // A stored key ONLY exists because the user unlocked an ENCRYPTED vault, so treat it as
-        // authoritative: a flaky/failed `/account/encryption` fetch (which defaults to enabled:false) must
-        // NOT downgrade an unlocked encrypted account to plaintext — that causes a 422 on save and leaks
-        // ciphertext on read. So if we hold a usable key, we're encrypted-and-unlocked, period.
-        const key = this.store.getKey();
-        if (key)
-            return { enabled: true, key };
-        // No usable key: consult the server to tell "unencrypted" apart from "encrypted but locked/expired".
         const cfg = await this.getEncryptionConfig();
-        if (cfg.enabled)
+        if (!cfg.enabled)
+            return { enabled: false };
+        const key = this.store.getKey();
+        if (!key)
             throw new LockedError("EchoMem vault locked");
-        return { enabled: false };
+        if (!(await verifyKeyB64(key, cfg))) {
+            // A file-backed stale key can be removed safely; environment-provided
+            // keys remain under the caller's control and are ignored until corrected.
+            if (!process.env.ECHO_ENCRYPTION_KEY)
+                this.store.clearKey();
+            throw new LockedError("EchoMem vault key is invalid");
+        }
+        return { enabled: true, key };
     }
     pruneDeleteConfirmations(now = Date.now()) {
         for (const [memoryId, confirmation] of this.deleteConfirmations) {
@@ -608,13 +622,6 @@ class EchoMemApiClient {
         }
         return this.whoamiCache;
     }
-    cleanMemoryDescription(desc) {
-        if (!desc)
-            return "";
-        // The tuned snapshot wraps text as "Here is a memory: …Content: <text>".
-        const idx = desc.indexOf("Content:");
-        return (idx >= 0 ? desc.slice(idx + "Content:".length) : desc).trim();
-    }
     async fetchMemoryById(id, enc) {
         try {
             const response = await this.axios.get(`/api/extension/memories/${encodeURIComponent(id)}`, {
@@ -630,34 +637,6 @@ class EchoMemApiClient {
             throw error;
         }
     }
-    async searchMemoriesRaw(query, opts, enc, retrievalOnly = false, trace) {
-        const endpoint = "/api/extension/memories/search";
-        let response;
-        try {
-            response = await this.axios.post(endpoint, {
-                query,
-                k: opts.limit,
-                similarityThreshold: opts.threshold,
-                timeFrameDays: opts.timeFrameDays,
-                requestId: opts.requestId,
-                sessionId: this.sessionId,
-            });
-            trace?.({ requestId: opts.requestId, endpoint, httpStatus: response.status });
-        }
-        catch (error) {
-            trace?.({
-                requestId: opts.requestId,
-                endpoint,
-                httpStatus: axios.isAxiosError(error) ? error.response?.status : undefined,
-                errorCode: axios.isAxiosError(error) ? errorCodeFrom(error.response?.data) : undefined,
-            });
-            throw error;
-        }
-        const data = enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
-        return retrievalOnly && isRecord(data)
-            ? { ...data, retrievalOnly: true, tuned: false }
-            : data;
-    }
     async searchMemoriesRetrieved(query, opts, enc, trace) {
         const endpoint = "/api/extension/memories/deep-search/candidates";
         let response;
@@ -732,48 +711,6 @@ class EchoMemApiClient {
             memories,
         };
     }
-    // Tuned recall. Routes through echo-mem-chrome's AUTHENTICATED deep-search proxy
-    // (the same route the Chrome extension uses): it verifies our ec_ token, derives
-    // user_id server-side, and forwards to dg-web's two-phase retriever. The bridge
-    // never hits dg-web directly, so no new auth is needed and no other caller is
-    // disrupted. NOTE: encrypted users still get server-side plaintext only; the
-    // phase-1 + bridge-local-decrypt + phase-2 flow (spec §11) is the remaining work.
-    async searchMemoriesTuned(query, requestId, trace) {
-        const endpoint = "/api/extension/memories/deep-search";
-        let response;
-        try {
-            response = await this.axios.post(endpoint, {
-                query,
-                requestId,
-                logicalRequestId: requestId,
-                sessionId: this.sessionId,
-                userTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
-            });
-            trace?.({ requestId, endpoint, httpStatus: response.status });
-        }
-        catch (error) {
-            trace?.({
-                requestId,
-                endpoint,
-                httpStatus: axios.isAxiosError(error) ? error.response?.status : undefined,
-                errorCode: axios.isAxiosError(error) ? errorCodeFrom(error.response?.data) : undefined,
-            });
-            throw error;
-        }
-        const data = response.data ?? {};
-        if (data.success === false) {
-            trace?.({ requestId, endpoint, httpStatus: response.status, errorCode: errorCodeFrom(data) });
-            throw new Error(`deep-search proxy error: ${data.error || "unknown"}`);
-        }
-        const primary = (data.retrievedMemorySnapshot?.primary ?? []);
-        const memories = primary.map((m) => ({
-            key: String(m.key ?? ""),
-            description: this.cleanMemoryDescription(String(m.description ?? "")),
-            time: m.time,
-            similarity: typeof m.similarity_score === "number" ? m.similarity_score : undefined,
-        }));
-        return { success: true, tuned: true, answer: String(data.answer || data.response || "").trim(), memories };
-    }
     async searchMemories(args, trace) {
         const parsed = searchMemoriesSchema.parse(args ?? {});
         const query = parsed.query?.trim();
@@ -800,18 +737,11 @@ class EchoMemApiClient {
             timeFrameDays: parsed.timeFrameDays,
             requestId: randomUUID(),
         };
-        if (!parsed.includeAnswer) {
-            return this.searchMemoriesRetrieved(query, searchOpts, enc, trace);
-        }
-        // Encrypted account: the server can't synthesize over plaintext it doesn't hold, so use the raw
-        // retriever (returns ciphertext) and decrypt locally — zero-knowledge preserved end-to-end.
-        if (enc.enabled) {
-            return await this.searchMemoriesRaw(query, searchOpts, enc, false, trace);
-        }
-        // A synthesized answer is metered through the legacy route. Do not fall
-        // back to raw retrieval after a ledger outage: that would return a result
-        // without a durable usage fact.
-        return this.searchMemoriesTuned(query, searchOpts.requestId, trace);
+        // MCP recall is retrieval-only. `includeAnswer` remains accepted by the
+        // parser for older clients, but it must never select an EchoMem/dg-web LLM
+        // path. The MCP host model receives the ranked memories and writes the
+        // final answer itself.
+        return this.searchMemoriesRetrieved(query, searchOpts, enc, trace);
     }
     /** Decrypt the model-visible fields on a `{ memories: [...] }` response locally. */
     async decryptResult(data, key) {
@@ -1227,12 +1157,31 @@ class EchoMemMCPServer {
                         ],
                     };
                 }
+                if (error instanceof EncryptionStatusUnavailableError) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: [
+                                    "⚠️ EchoMem could not verify whether this account's vault is encrypted.",
+                                    "No memory data was returned. Retry this action after the service recovers.",
+                                ].join("\n"),
+                            }],
+                        isError: true,
+                    };
+                }
                 if (error instanceof ZodError) {
                     throw new McpError(ErrorCode.InvalidParams, `Invalid arguments: ${error.message}`);
                 }
                 if (error instanceof McpError) {
                     throw error;
                 }
+                const reconnectRequired = formatReconnectRequiredResult(error);
+                if (reconnectRequired) {
+                    return {
+                        content: [{ type: "text", text: reconnectRequired }],
+                        isError: true,
+                    };
+                }
                 const upgradeRequired = formatUpgradeRequiredResult(error);
                 if (upgradeRequired) {
                     return {
@@ -1345,20 +1294,6 @@ class EchoMemMCPServer {
                 .join("\n\n");
             return { content: [{ type: "text", text: `Retrieved ${memories.length} memories:\n\n${formattedResults}` }] };
         }
-        // Tuned two-phase path: synthesized brief + ranked source memories.
-        if (result?.tuned) {
-            const { answer, memories } = result;
-            if (!answer && !memories?.length) {
-                return { content: [{ type: "text", text: "No relevant memories found." }] };
-            }
-            const sources = (memories || [])
-                .map((m, idx) => `[${idx + 1}] ${m.key}${typeof m.similarity === "number" ? ` (sim ${m.similarity.toFixed(3)})` : ""}\n${m.description}`)
-                .join("\n\n");
-            const text = [answer && `Recall:\n${answer}`, sources && `---\nSource memories:\n\n${sources}`]
-                .filter(Boolean)
-                .join("\n\n");
-            return { content: [{ type: "text", text }] };
-        }
         // Fallback: untuned / time-range shape.
         const { success, memories, error } = result;
         if (!success)

package/dist/migrate.js

@@ -525,6 +525,37 @@ export async function cancelQueuedImportSession(client, sessionId) {
         throw new Error("IMPORT_SESSION_ID_REQUIRED");
     await client.patch(`/api/extension/import-sessions/${encodeURIComponent(sessionId)}`, { action: "cancel" });
 }
+async function findRecoverableImportSession(client, sessions, bareConversationId, signal) {
+    const items = sessions.map((session) => ({
+        conversationId: bareConversationId(session),
+        platform: session.source,
+        sourceDate: session.firstTs,
+    }));
+    const response = await client.post("/api/extension/import-sessions/status", { items }, signal ? { signal } : undefined);
+    const data = response.data && typeof response.data === "object"
+        ? response.data
+        : {};
+    const required = new Set(sessions.map((session) => mapKey(session.source, bareConversationId(session))));
+    for (const candidate of data.recoverableSessions ?? []) {
+        const id = typeof candidate.id === "string" ? candidate.id : "";
+        const jobs = Array.isArray(candidate.jobs)
+            ? candidate.jobs
+                .filter((job) => typeof job.id === "string"
+                && typeof job.platform === "string"
+                && typeof job.conversation_id === "string")
+                .map((job) => ({
+                id: job.id,
+                platform: job.platform,
+                conversation_id: job.conversation_id,
+            }))
+            : [];
+        const covered = new Set(jobs.map((job) => mapKey(job.platform, job.conversation_id)));
+        if (id && required.size === jobs.length && [...required].every((key) => covered.has(key))) {
+            return { id, concurrency: MIGRATE_CONCURRENCY, jobs };
+        }
+    }
+    return null;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -984,7 +1015,13 @@ export async function startMigration(opts) {
             throw codedError("FORBIDDEN_SCOPE");
         const data = responseData(e);
         const max = Number(data.maxConversations);
-        if (responseStatus(e) === 422 && data.error === "IMPORT_LIMIT_EXCEEDED" && max > 0) {
+        if (responseStatus(e) === 409 && data.error === "IMPORT_ALREADY_IN_PROGRESS") {
+            const recovered = await findRecoverableImportSession(client, toImport, bareId, opts.signal);
+            if (!recovered)
+                throw e;
+            session = recovered;
+        }
+        else if (responseStatus(e) === 422 && data.error === "IMPORT_LIMIT_EXCEEDED" && max > 0) {
             capped = max;
             toImport = opts.pending.slice(0, max);
             try {