@echomem/mcp 1.4.27 → 1.4.28

package/dist/setup.js

@@ -25,8 +25,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import axios from "axios";
 import { KeyStore } from "./keystore.js";
 import { fetchEncryptionConfig, deriveAndVerifyKey, setupNewEncryptionKey, verifyKeyB64 } from "./encryption.js";
-import { collect, runReport, buildStatsPayload } from "./report.js";
-import { cmdMigrate, applyAccountImportStatus, applyFastAccountImportStatus, discoverMigratableFastDiscovery, discoverMigratableSessions, discoverPendingSessionsTargeted, estimateMigrationEta, fetchProcessedImportKeys, isImportStatusUnsupported, markAccountImportStatusFailed, markAccountImportStatusUnavailable, markFastAccountImportStatusUnavailable, startMigration, summarizeFastMigratableDiscovery, MIGRATE_CONCURRENCY, } from "./migrate.js";
+import { runReport, buildStatsPayload } from "./report.js";
+import { cmdMigrate, applyAccountImportStatus, applyFastAccountImportStatus, discoverMigratableSessions, discoverPendingSessionsTargeted, estimateMigrationEta, fetchProcessedImportKeys, isImportStatusUnsupported, markAccountImportStatusFailed, markAccountImportStatusUnavailable, markFastAccountImportStatusUnavailable, startMigration, summarizeFastMigratableDiscovery, MIGRATE_CONCURRENCY, } from "./migrate.js";
 import { syncCodexUsage } from "./codex-sync.js";
 import { renderSetupPage } from "./setup-page.js";
 import { parseSetupPreviewState } from "./setup-preview.js";
@@ -1145,6 +1145,155 @@ function discoverMigratableSessionsOffThread() {
         });
     });
 }
+export function discoverMigratableFastOffThread(opts = {}) {
+    const migrateUrl = runtimeModuleUrl("migrate");
+    const serializedOpts = JSON.stringify(opts);
+    const code = `
+    import { parentPort } from "node:worker_threads";
+    import { discoverMigratableFastDiscovery } from ${JSON.stringify(migrateUrl)};
+
+    try {
+      parentPort?.postMessage({ ok: true, discovery: discoverMigratableFastDiscovery(${serializedOpts}) });
+    } catch (error) {
+      parentPort?.postMessage({
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
+    }
+  `;
+    const worker = new Worker(new URL(`data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        worker.once("message", (message) => {
+            settled = true;
+            const msg = message;
+            if (msg.ok === true && msg.discovery && typeof msg.discovery === "object") {
+                resolve(msg.discovery);
+                return;
+            }
+            const err = new Error(typeof msg.message === "string" ? msg.message : "Quick local discovery failed");
+            if (typeof msg.stack === "string")
+                err.stack = msg.stack;
+            reject(err);
+        });
+        worker.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+        worker.once("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`Quick local discovery worker exited (code ${code}) without a result`));
+        });
+    });
+}
+/** Build the full local-history dashboard payload away from the callback server's event loop.
+ * `collect()` can synchronously parse hundreds of JSONL files for tens of seconds; doing that on
+ * the bridge thread prevents even localhost actions such as account switch from receiving a reply. */
+export function buildCollectedStatsPayloadOffThread(inject) {
+    const reportUrl = runtimeModuleUrl("report");
+    const serializedInject = JSON.stringify(inject);
+    const code = `
+    import { parentPort } from "node:worker_threads";
+    import { collect, buildStatsPayload } from ${JSON.stringify(reportUrl)};
+
+    try {
+      const payload = await buildStatsPayload(collect(), ${serializedInject});
+      parentPort?.postMessage({ ok: true, payload });
+    } catch (error) {
+      parentPort?.postMessage({
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
+    }
+  `;
+    const worker = new Worker(new URL(`data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            void worker.terminate();
+            if (result.ok)
+                resolve(result.payload);
+            else
+                reject(result.error);
+        };
+        worker.once("message", (message) => {
+            const msg = message;
+            if (msg.ok === true) {
+                finish({ ok: true, payload: msg.payload });
+                return;
+            }
+            const error = new Error(typeof msg.message === "string" ? msg.message : "Full local stats worker failed");
+            if (typeof msg.stack === "string")
+                error.stack = msg.stack;
+            finish({ ok: false, error });
+        });
+        worker.once("error", (error) => {
+            finish({ ok: false, error });
+        });
+        worker.once("exit", (code) => {
+            if (settled)
+                return;
+            finish({ ok: false, error: new Error(`Full local stats worker exited (code ${code}) without a result`) });
+        });
+    });
+}
+export function createLocalDiscoveryCache(loaders = {}) {
+    const loadQuick = loaders.loadQuick ?? (() => discoverMigratableFastOffThread());
+    const loadExact = loaders.loadExact ?? (() => discoverMigratableSessionsOffThread());
+    let quick = null;
+    let quickPromise = null;
+    let exact = null;
+    let exactPromise = null;
+    return {
+        getQuick() {
+            if (quick)
+                return Promise.resolve(quick);
+            if (quickPromise)
+                return quickPromise;
+            quickPromise = loadQuick()
+                .then((discovery) => {
+                quick = discovery;
+                return discovery;
+            })
+                .catch((error) => {
+                quickPromise = null;
+                throw error;
+            });
+            return quickPromise;
+        },
+        getExact() {
+            if (exact)
+                return Promise.resolve(exact);
+            if (exactPromise)
+                return exactPromise;
+            exactPromise = loadExact()
+                .then((discovery) => {
+                exact = discovery;
+                return discovery;
+            })
+                .catch((error) => {
+                exactPromise = null;
+                throw error;
+            });
+            return exactPromise;
+        },
+        peekExact() {
+            return exact;
+        },
+        pendingExact() {
+            return exactPromise;
+        },
+    };
+}
 function forensicStageLabel(stage) {
     if (stage === "reading-transcripts")
         return "Reading transcript files";
@@ -1166,7 +1315,9 @@ export function buildForensicReportOffThread(onProgress, options = {}) {
     try {
       const report = await buildForensicReport({
         includeLegacyGoldenStandard: false,
-        onProgress: (done, total, stage, detail, overall) => parentPort?.postMessage({ progress: { done, total, stage, detail, overall } }),
+        onProgress: (done, total, stage, detail, overall, stageDone, stageTotal) => parentPort?.postMessage({
+          progress: { done, total, stage, detail, overall, stageDone, stageTotal },
+        }),
       });
       parentPort?.postMessage({ ok: true, report });
     } catch (error) {
@@ -1259,6 +1410,7 @@ function publicRunningForensicProgress(value) {
         ? Math.min(1, Math.max(0, candidate))
         : 0);
     const total = safeCount(progress.total);
+    const stageTotal = safeCount(progress.stageTotal);
     const rawStage = typeof progress.stage === "string" ? progress.stage : "starting";
     const stage = ["starting", "reading-transcripts", "building-summary", "classifying-repeated-context", "finalizing-report"].includes(rawStage)
         ? rawStage
@@ -1269,6 +1421,8 @@ function publicRunningForensicProgress(value) {
         total,
         stage,
         label: forensicStageLabel(stage),
+        stageDone: stageTotal > 0 ? Math.min(safeCount(progress.stageDone), stageTotal) : 0,
+        stageTotal,
         overall: safeFraction(progress.overall),
         elapsedMs: safeDuration(progress.elapsedMs),
         stageElapsedMs: safeDuration(progress.stageElapsedMs),
@@ -1303,6 +1457,7 @@ export function startCallbackServer(opts = {}) {
         let switchAccountUrl = "";
         let connected = Boolean(opts.initialToken?.token);
         let activeDeviceToken = opts.initialToken?.token || "";
+        let activeAccountEmail = "";
         let pendingLocalAuth = null;
         let reportConsentGranted = !requiresReportConsent;
         let progress = { status: "idle", total: 0, completed: 0, running: 0, queued: 0, failed: 0, extracted: 0 };
@@ -1337,8 +1492,8 @@ export function startCallbackServer(opts = {}) {
                 return false;
             return revokeDeviceToken(pending.token);
         };
-        const completeDeviceLogin = async (token) => {
-            await authedAxios(token).post("/api/extension/mcp/local-auth/complete-device", {}, { timeout: 10_000 });
+        const completeDeviceLogin = async (token, encryptionPreference = "maximum") => {
+            await authedAxios(token).post("/api/extension/mcp/local-auth/complete-device", { encryptionPreference }, { timeout: 10_000 });
         };
         const close = () => {
             if (timer)
@@ -1414,6 +1569,7 @@ export function startCallbackServer(opts = {}) {
             const firstToken = !onToken.settled();
             connected = true;
             activeDeviceToken = token;
+            activeAccountEmail = pendingLocalAuth?.email || activeAccountEmail;
             pendingLocalAuth = null;
             const callbackToken = { token, key };
             if (firstToken) {
@@ -1571,6 +1727,38 @@ export function startCallbackServer(opts = {}) {
                 json(res, detail.status, { ok: false, error: detail.message });
             }
         };
+        const handleLocalSkipEncryption = async (res, body) => {
+            if (rejectIfLocalAuthBlocked(res, asString(body.nonce)))
+                return;
+            if (!pendingLocalAuth || pendingLocalAuth.expiresAtMs <= Date.now()) {
+                await revokePendingLocalAuth();
+                return void json(res, 409, {
+                    ok: false,
+                    error: "This local login expired. Send a new verification code.",
+                    reset: true,
+                });
+            }
+            if (pendingLocalAuth.mode !== "setup") {
+                return void json(res, 409, {
+                    ok: false,
+                    error: "This account already uses encrypted memory. Enter the vault passphrase to continue.",
+                });
+            }
+            try {
+                await completeDeviceLogin(pendingLocalAuth.token, "standard");
+                resolveLocalToken(pendingLocalAuth.token, undefined);
+                json(res, 200, {
+                    ok: true,
+                    connected: true,
+                    encryptionEnabled: false,
+                    encryptionPreference: "standard",
+                });
+            }
+            catch (error) {
+                const detail = publicAxiosError(error, "Failed to continue without encryption");
+                json(res, detail.status, { ok: false, error: detail.message });
+            }
+        };
         server = http.createServer((req, res) => {
             res.setHeader("Access-Control-Allow-Origin", "*");
             res.setHeader("Access-Control-Allow-Headers", "Content-Type");
@@ -1635,6 +1823,18 @@ export function startCallbackServer(opts = {}) {
                     });
                     return;
                 }
+                if (route === "/local-auth/skip-encryption" && req.method === "POST") {
+                    let body;
+                    try {
+                        body = await readJsonBody(req);
+                    }
+                    catch {
+                        text(res, 400, "bad json");
+                        return;
+                    }
+                    await handleLocalSkipEncryption(res, body);
+                    return;
+                }
                 if (route === "/launch-agent" && req.method === "POST") {
                     let body;
                     try {
@@ -1771,6 +1971,9 @@ export function startCallbackServer(opts = {}) {
                         const plan = (asString(response.data?.plan) || "free").toLowerCase();
                         const trialUsed = response.data?.billing?.trialUsed === true;
                         const trialAvailable = response.data?.billing?.trialAvailable !== false;
+                        const accountEmail = asString(profileResponse?.data?.email) || activeAccountEmail;
+                        if (accountEmail)
+                            activeAccountEmail = accountEmail;
                         json(res, 200, {
                             plan,
                             paid: ["pro", "power", "team", "enterprise"].includes(plan),
@@ -1785,10 +1988,9 @@ export function startCallbackServer(opts = {}) {
                             memoryProcessingQuota: response.data?.memoryProcessingQuota ?? null,
                             memorySearchQuota: response.data?.memorySearchQuota ?? null,
                             activation: response.data?.activation ?? null,
-                            account: profileResponse ? {
-                                displayName: asString(profileResponse.data?.displayName) || "EchoMem user",
-                                email: asString(profileResponse.data?.email) || "",
-                                avatarUrl: asString(profileResponse.data?.avatarUrl) || "",
+                            account: accountEmail ? {
+                                email: accountEmail,
+                                avatarUrl: asString(profileResponse?.data?.avatarUrl) || "",
                             } : null,
                             pricingUrl,
                         });
@@ -2083,22 +2285,25 @@ export function startCallbackServer(opts = {}) {
                     }
                     connected = false;
                     activeDeviceToken = "";
+                    activeAccountEmail = "";
                     const revokedPendingCredential = await revokePendingLocalAuth();
                     stats = null;
                     migrateStarted = false;
                     progress = { status: "idle", total: 0, completed: 0, running: 0, queued: 0, failed: 0, extracted: 0 };
+                    try {
+                        await logoutHandler?.();
+                    }
+                    catch (e) {
+                        console.error(`Could not reset local login state: ${e instanceof Error ? e.message : String(e)}`);
+                    }
                     json(res, 200, {
                         ok: true,
+                        connected: false,
                         authUrl,
                         switchAccountUrl: switchAccountUrl || authUrl,
                         localOnly: true,
                         revokedPendingCredential,
                     });
-                    Promise.resolve()
-                        .then(() => logoutHandler?.())
-                        .catch((e) => {
-                        console.error(`Could not reset local login state: ${e instanceof Error ? e.message : String(e)}`);
-                    });
                     return;
                 }
                 if (route === "/migrate" && req.method === "POST") {
@@ -2665,6 +2870,8 @@ async function cmdOnboarding(flags) {
         total: 0,
         stage: forensicStage,
         label: forensicStageLabel(forensicStage),
+        stageDone: 0,
+        stageTotal: 0,
         overall: 0,
         elapsedMs: 0,
         stageElapsedMs: 0,
@@ -2678,7 +2885,18 @@ async function cmdOnboarding(flags) {
         requireReportConsent: true,
         getStats: () => stats,
         getReport: () => forensicReport,
-        getReportProgress: () => forensicProgress,
+        getReportProgress: () => {
+            if (forensicProgress.status !== "running")
+                return forensicProgress;
+            const now = Date.now();
+            const sinceWorkerUpdate = Math.max(0, now - forensicProgress.updatedAt);
+            return {
+                ...forensicProgress,
+                elapsedMs: forensicProgress.elapsedMs + sinceWorkerUpdate,
+                stageElapsedMs: forensicProgress.stageElapsedMs + sinceWorkerUpdate,
+                updatedAt: now,
+            };
+        },
         onReportConsent: (allowed) => {
             if (!allowed) {
                 forensicConsent = "declined";
@@ -2688,6 +2906,8 @@ async function cmdOnboarding(flags) {
                     total: 0,
                     stage: "failed",
                     label: "Local scan skipped",
+                    stageDone: 0,
+                    stageTotal: 0,
                     overall: 0,
                     elapsedMs: Date.now() - forensicStartedAt,
                     stageElapsedMs: Date.now() - forensicStageStartedAt,
@@ -2710,6 +2930,8 @@ async function cmdOnboarding(flags) {
                 total: 0,
                 stage: forensicStage,
                 label: forensicStageLabel(forensicStage),
+                stageDone: 0,
+                stageTotal: 0,
                 overall: 0,
                 elapsedMs: now - forensicStartedAt,
                 stageElapsedMs: 0,
@@ -2744,6 +2966,12 @@ async function cmdOnboarding(flags) {
                 stage: forensicStage,
                 label: forensicStageLabel(forensicStage),
                 detail: progress.detail,
+                stageDone: typeof progress.stageDone === "number" && Number.isFinite(progress.stageDone)
+                    ? Math.max(0, Math.floor(progress.stageDone))
+                    : 0,
+                stageTotal: typeof progress.stageTotal === "number" && Number.isFinite(progress.stageTotal)
+                    ? Math.max(0, Math.floor(progress.stageTotal))
+                    : 0,
                 overall: forensicOverall,
                 elapsedMs: now - forensicStartedAt,
                 stageElapsedMs: now - forensicStageStartedAt,
@@ -2761,6 +2989,8 @@ async function cmdOnboarding(flags) {
                 total: forensicProgress.total,
                 stage: "failed",
                 label: "Local scan failed",
+                stageDone: forensicProgress.stageDone,
+                stageTotal: forensicProgress.stageTotal,
                 overall: forensicOverall,
                 elapsedMs: now - forensicStartedAt,
                 stageElapsedMs: now - forensicStageStartedAt,
@@ -2799,13 +3029,22 @@ async function cmdOnboarding(flags) {
     let exactDiscovery = Promise.resolve(null);
     let refreshGeneration = 0;
     let latestPendingEstimate = 0;
+    // Local discovery is account-independent. Keep one snapshot for this onboarding process and
+    // overlay each connected account's processed keys instead of rereading every JSONL on switch.
+    const localDiscovery = createLocalDiscoveryCache({
+        loadExact: async () => {
+            // Publish the quick metadata result before starting the heavier exact worker.
+            await delay(250);
+            return discoverMigratableSessionsOffThread();
+        },
+    });
     // The account's already-imported keys, shared so the /migrate sizing can assemble ONLY pending sessions.
     let lastProcessedImportKeys = null;
     const resetLocalLoginState = () => {
         refreshGeneration++;
         stats = null;
         disc = null;
-        exactDiscovery = Promise.resolve(null);
+        exactDiscovery = localDiscovery.pendingExact() ?? Promise.resolve(localDiscovery.peekExact());
         latestPendingEstimate = 0;
         lastProcessedImportKeys = null;
         srv.setStats(null);
@@ -2823,7 +3062,9 @@ async function cmdOnboarding(flags) {
         const generation = ++refreshGeneration;
         lastProcessedImportKeys = null; // shared with /migrate so it can assemble only the pending sessions
         let importStatusUnavailable = false;
-        const quickDiscovery = discoverMigratableFastDiscovery();
+        const quickDiscovery = await localDiscovery.getQuick();
+        if (generation !== refreshGeneration)
+            return;
         const quick = summarizeFastMigratableDiscovery(quickDiscovery);
         let migratable = migratableFromFastSummary(quick);
         latestPendingEstimate = migratable.pending;
@@ -2931,23 +3172,7 @@ async function cmdOnboarding(flags) {
                 console.error(`Could not check this EchoMem account's import status quickly: ${e instanceof Error ? e.message : String(e)}`);
             }
         });
-        exactDiscovery = new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                void (async () => {
-                    try {
-                        // Start the local sizing pass without waiting on cloud/account status. The
-                        // account check is useful for tighter counts, but extraction can safely start
-                        // from local candidates because the import path skips true duplicates.
-                        await delay(250);
-                        resolve(await discoverMigratableSessionsOffThread());
-                    }
-                    catch (e) {
-                        reject(e instanceof Error ? e : new Error(String(e)));
-                    }
-                })();
-            }, 250);
-            timer.unref?.();
-        }).then(async (exact) => {
+        exactDiscovery = localDiscovery.getExact().then(async (exact) => {
             if (generation !== refreshGeneration)
                 return disc;
             const initialExact = lastProcessedImportKeys
@@ -3029,7 +3254,7 @@ async function cmdOnboarding(flags) {
                     failed: 0,
                     extracted: 0,
                 });
-                const fullPayload = withCandidateSessions(await buildStatsPayload(collect(), {
+                const fullPayload = withCandidateSessions(await buildCollectedStatsPayloadOffThread({
                     sessions: sessionSummary,
                     migratable,
                     discovery: { phase: "full", exact: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.27",
+  "version": "1.4.28",
   "description": "EchoMem MCP bridge: cloud-first memory tools, local context HUD, and the Agent Doctor workspace forensics report (cost ledger + 3D repo city)",
   "main": "dist/index.js",
   "type": "module",