@echomem/mcp 1.2.0 → 1.3.1

package/README.md

@@ -6,11 +6,12 @@ This package implements a stateless, cloud-first [Model Context Protocol (MCP)](
 
 This MCP Server bridges local tools and your EchoMem Cloud API entirely via authenticated REST `fetch()` calls. 
 
-- `search_memories`: Connects to `POST /api/extension/memories/search`
+- `search_memories`: Calls the deep-search candidate phase, resolves the retrieved memory rows, and returns those memories only by default
 - `save_conversation`: Connects to `POST /api/extension/memories/ingest`
 - `get_memories_by_time_range`: Connects to `POST /api/extension/memories/time-range`
 - `search_memories_by_keywords`: Connects to `POST /api/extension/memories/keywords`
-- `search_others_memories`: Connects to MemoryFeed search after resolving the authenticated Echo user id
+- `search_others_memories`: Connects to MemoryFeed public search without sending the authenticated Echo user id
+- `delete_memory`: Previews one personal memory and returns a confirmation token; only deletes after a second confirmed call
 
 No direct access to the `IndexedDB` or local files is required.
 
@@ -27,7 +28,9 @@ For **zero-knowledge accounts**, the key never leaves your machine. The bridge h
 - **locked state:** if the key is absent or past its TTL (7 days, matching the extension), tools
   return a `🔒 locked` nudge to run `echomem-mcp unlock` — **ciphertext is never handed to the model**.
 
-Unencrypted accounts are unaffected and use the tuned two-phase retriever as before.
+Unencrypted accounts are unaffected. `search_memories` returns retrieved memories by default so
+your MCP client does the final answer generation; pass `includeAnswer: true` only if you need the
+legacy EchoMem-synthesized recall answer.
 
 ## Quick start (recommended)
 
@@ -142,11 +145,12 @@ ECHO_API_TOKEN="your_token" ECHO_API_BASE_URL="http://localhost:3000" npm run st
 
 ## Available Tools
 
-* **`search_memories`**: Perform semantic searches against your personal memory vault using cloud embeddings.
+* **`search_memories`**: Retrieve ranked personal memories for a query. Defaults to memory-only output and skips EchoMem answer generation; set `includeAnswer: true` for the legacy synthesized recall.
 * **`save_conversation`**: Ingest and structure a conversation directly into your EchoMem timeline.
 * **`get_memories_by_time_range`**: Retrieve memories between explicit start/end timestamps.
 * **`search_memories_by_keywords`**: Retrieve memories by matching the `keys` field.
-* **`search_others_memories`**: Search other users' public memories through MemoryFeed.
+* **`search_others_memories`**: Search other users' public memories through MemoryFeed public search.
+* **`delete_memory`**: Delete a single personal memory through a two-step confirmation flow. First call with `memoryId` only to preview the target and receive `confirmationToken`; after the user explicitly confirms, call again with `confirmed: true` and that exact token. This deletes the memory row only and preserves raw `source_of_truth` conversation records.
 
 Legacy aliases are preserved for compatibility:
 

package/dist/codex-sync.js

@@ -0,0 +1,469 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { createHash } from "node:crypto";
+import axios from "axios";
+import { KeyStore } from "./keystore.js";
+const API_BASE_URL = (process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app").replace(/\/$/, "");
+const DEFAULT_DAYS = 7;
+const DEFAULT_LIMIT = 50;
+const URL_RE = /\bhttps?:\/\/[^\s<>"')\]]+/i;
+const SECRET_LIKE_RE = /(sk-[A-Za-z0-9_-]{20,}|xox[baprs]-[A-Za-z0-9-]+|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{20,}|-----BEGIN [A-Z ]+PRIVATE KEY-----|\b(api[_-]?key|token|secret|password)\s*[:=])/i;
+const CODE_LIKE_RE = /(```|^\s*(import|export|const|let|var|function|class|interface|type)\s|\b(def|async|await)\s+\w+)/m;
+function hashText(text) {
+    return `sha256:${createHash("sha256").update(text).digest("hex")}`;
+}
+function shortHash(text) {
+    return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function redactText(text) {
+    return text
+        .replace(URL_RE, "[url]")
+        .replace(SECRET_LIKE_RE, "[secret-like-text]")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function safeText(prefix, text, previewChars = 300) {
+    if (typeof text !== "string" || text.length === 0) {
+        return {
+            [`${prefix}_available`]: false,
+            [`${prefix}_length`]: 0,
+        };
+    }
+    return {
+        [`${prefix}_available`]: true,
+        [`${prefix}_preview`]: redactText(text).slice(0, previewChars),
+        [`${prefix}_length`]: text.length,
+        [`${prefix}_hash`]: hashText(text),
+        [`${prefix}_contains_url`]: URL_RE.test(text),
+        [`${prefix}_contains_code`]: CODE_LIKE_RE.test(text),
+        [`${prefix}_contains_secret_like_text`]: SECRET_LIKE_RE.test(text),
+    };
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseArgs(value) {
+    if (typeof value === "string") {
+        try {
+            return asRecord(JSON.parse(value));
+        }
+        catch {
+            return {};
+        }
+    }
+    return asRecord(value);
+}
+function contentToText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value))
+        return "";
+    return value
+        .map((part) => {
+        const rec = asRecord(part);
+        return asString(rec.text) || asString(rec.content) || "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function conversationAnalyticsFromMessages(value) {
+    if (!Array.isArray(value))
+        return {};
+    const records = value.map(asRecord).filter((record) => Object.keys(record).length > 0);
+    const userMessages = records
+        .filter((record) => ["user", "human"].includes(String(record.role ?? "").toLowerCase()) && asString(record.content))
+        .map((record) => asString(record.content) ?? "");
+    const assistantMessages = records
+        .filter((record) => ["assistant", "ai"].includes(String(record.role ?? "").toLowerCase()) && asString(record.content))
+        .map((record) => asString(record.content) ?? "");
+    const conversationText = records
+        .map((record) => `${asString(record.role) ?? "unknown"}: ${asString(record.content) ?? ""}`)
+        .join("\n\n");
+    return {
+        conversation_length: conversationText.length,
+        conversation_hash: conversationText ? hashText(conversationText) : undefined,
+        conversation_message_count: value.length,
+        user_message_count: userMessages.length,
+        assistant_message_count: assistantMessages.length,
+        ...safeText("first_user_message", userMessages[0]),
+        ...safeText("last_user_message", userMessages.at(-1)),
+    };
+}
+function summarizeToolArgs(toolName, args) {
+    if (toolName === "search_memories" || toolName === "search_memories_by_description_semantic") {
+        const query = asString(args.query);
+        return {
+            ...safeText("query", query, 160),
+            query_preview_safe: query ? redactText(query).slice(0, 160) : undefined,
+            query_length: query?.length ?? 0,
+            limit: asNumber(args.limit) ?? asNumber(args.k),
+            threshold: asNumber(args.threshold),
+            time_frame_days: asNumber(args.timeFrameDays),
+            include_answer: typeof args.includeAnswer === "boolean" ? args.includeAnswer : undefined,
+        };
+    }
+    if (toolName === "save_conversation") {
+        const messages = Array.isArray(args.messages) ? args.messages : undefined;
+        const conversation = asString(args.conversation);
+        return {
+            input_mode: messages?.length ? "messages" : "conversation",
+            message_count: messages?.length,
+            content_length: messages?.reduce((sum, item) => sum + String(asRecord(item).content ?? "").length, 0) ??
+                conversation?.length ??
+                0,
+            ...(messages?.length
+                ? conversationAnalyticsFromMessages(messages)
+                : {
+                    conversation_length: conversation?.length ?? 0,
+                    conversation_hash: conversation ? hashText(conversation) : undefined,
+                }),
+            has_title: !!asString(args.title),
+            title_length: asString(args.title)?.length,
+            has_url: !!asString(args.url),
+            has_source: !!asString(args.source),
+            tag_count: Array.isArray(args.tags) ? args.tags.length : undefined,
+        };
+    }
+    if (toolName === "get_memories_by_time_range" || toolName === "search_memories_by_time_range") {
+        return {
+            has_start_date: !!asString(args.startDate),
+            has_end_date: !!asString(args.endDate),
+            limit: asNumber(args.limit),
+        };
+    }
+    if (toolName === "search_memories_by_keywords") {
+        return {
+            keyword_count: Array.isArray(args.keywords) ? args.keywords.length : 0,
+            limit: asNumber(args.limit),
+        };
+    }
+    if (toolName === "search_others_memories") {
+        const query = asString(args.query);
+        return {
+            ...safeText("query", query, 160),
+            query_preview_safe: query ? redactText(query).slice(0, 160) : undefined,
+            query_length: query?.length ?? 0,
+        };
+    }
+    return {};
+}
+function summarizeResult(value) {
+    const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
+    const found = text.match(/Found\s+(\d+)\s+(?:relevant\s+)?memories/i) || text.match(/Retrieved\s+(\d+)\s+memories/i);
+    const extracted = text.match(/Extracted\s+(\d+)\s+memory distinct events/i);
+    return {
+        result_count: found ? Number(found[1]) : undefined,
+        extracted_memory_count: extracted ? Number(extracted[1]) : undefined,
+        returned_text_length: text.length,
+    };
+}
+function eachJsonLine(file, fn) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return;
+    }
+    try {
+        const decoder = new StringDecoder("utf8");
+        const buf = Buffer.allocUnsafe(1 << 20);
+        let leftover = "";
+        let lineNo = 0;
+        const flush = (chunk) => {
+            const lines = (leftover + chunk).split("\n");
+            leftover = lines.pop() ?? "";
+            for (const line of lines) {
+                lineNo++;
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    fn(asRecord(JSON.parse(trimmed)), lineNo);
+                }
+                catch {
+                    /* skip malformed lines */
+                }
+            }
+        };
+        let bytes = 0;
+        while ((bytes = fs.readSync(fd, buf, 0, buf.length, null)) > 0) {
+            flush(decoder.write(buf.subarray(0, bytes)));
+        }
+        const last = (leftover + decoder.end()).trim();
+        if (last) {
+            lineNo++;
+            try {
+                fn(asRecord(JSON.parse(last)), lineNo);
+            }
+            catch {
+                /* skip malformed final line */
+            }
+        }
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
+function walk(dir, out = []) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            walk(full, out);
+        else if (/rollout-.*\.jsonl$/.test(entry.name))
+            out.push(full);
+    }
+    return out;
+}
+function sessionIdFromPath(file) {
+    const match = path.basename(file).match(/(019[a-f0-9-]+)/i);
+    return match?.[1] ?? shortHash(file);
+}
+function baseSessionProperties(meta, file) {
+    const cwd = meta.cwd;
+    const startedAt = meta.timestamp;
+    return {
+        surface: "codex",
+        event_family: "codex_session",
+        telemetry_source: "codex_jsonl_sync",
+        codex_session_id: meta.id ?? sessionIdFromPath(file),
+        codex_session_file_date: startedAt?.slice(0, 10),
+        session_started_at: startedAt,
+        project_name: cwd ? path.basename(cwd) : undefined,
+        cwd_hash: cwd ? hashText(cwd) : undefined,
+        originator: meta.originator,
+        codex_source: meta.source,
+        cli_version: meta.cliVersion,
+        model_provider: meta.modelProvider,
+        model: meta.model,
+    };
+}
+function parseCodexSession(file) {
+    const events = [];
+    const meta = { id: sessionIdFromPath(file) };
+    let lastUser = null;
+    let userTurnIndex = 0;
+    let userMessageCount = 0;
+    let assistantMessageCount = 0;
+    let functionCallCount = 0;
+    let mcpToolCallCount = 0;
+    let echomemToolCallCount = 0;
+    let startedAt;
+    let endedAt;
+    const echomemTriggerTurns = new Set();
+    let lastTokenUsage = {};
+    const functionCallsById = new Map();
+    eachJsonLine(file, (obj, lineNo) => {
+        const timestamp = asString(obj.timestamp);
+        if (!startedAt && timestamp)
+            startedAt = timestamp;
+        if (timestamp)
+            endedAt = timestamp;
+        const payload = asRecord(obj.payload);
+        const payloadType = asString(payload.type);
+        if (obj.type === "session_meta") {
+            const p = payload;
+            meta.id = asString(p.id) ?? meta.id;
+            meta.timestamp = asString(p.timestamp) ?? timestamp;
+            meta.cwd = asString(p.cwd);
+            meta.originator = asString(p.originator);
+            meta.cliVersion = asString(p.cli_version);
+            meta.source = asString(p.source);
+            meta.modelProvider = asString(p.model_provider);
+            meta.model = asString(p.model);
+            return;
+        }
+        if (payloadType === "user_message") {
+            const text = asString(payload.message) ?? contentToText(payload.content);
+            lastUser = {
+                index: ++userTurnIndex,
+                line: lineNo,
+                timestamp,
+                text,
+            };
+            userMessageCount++;
+            return;
+        }
+        if (payloadType === "agent_message" || (payloadType === "message" && payload.role === "assistant")) {
+            assistantMessageCount++;
+            return;
+        }
+        if (payloadType === "token_count") {
+            lastTokenUsage = asRecord(asRecord(payload.info).total_token_usage);
+            return;
+        }
+        if (payloadType === "function_call") {
+            functionCallCount++;
+            const callId = asString(payload.call_id);
+            const toolName = asString(payload.name) ?? "unknown";
+            if (callId) {
+                functionCallsById.set(callId, { args: parseArgs(payload.arguments), toolName, user: lastUser });
+            }
+            return;
+        }
+        if (payloadType !== "mcp_tool_call_end")
+            return;
+        mcpToolCallCount++;
+        const invocation = asRecord(payload.invocation);
+        const server = asString(invocation.server) ?? "unknown";
+        const toolName = asString(invocation.tool) ?? "unknown";
+        const callId = asString(invocation.call_id) ?? asString(invocation.id);
+        const matchedCall = callId ? functionCallsById.get(callId) : undefined;
+        const args = parseArgs(invocation.arguments ?? matchedCall?.args);
+        const triggerUser = matchedCall?.user ?? lastUser;
+        const durationMs = asNumber(payload.duration_ms);
+        const result = payload.result;
+        const base = baseSessionProperties({ ...meta, timestamp: meta.timestamp ?? startedAt }, file);
+        const eventBase = {
+            ...base,
+            timestamp,
+            event_line: lineNo,
+            turn_index: triggerUser?.index,
+            trigger_user_line: triggerUser?.line,
+            trigger_user_timestamp: triggerUser?.timestamp,
+            mcp_server: server,
+            tool_name: toolName,
+            canonical_tool_name: toolName,
+            duration_ms: durationMs,
+            success: true,
+            ...safeText("trigger_message", triggerUser?.text),
+            ...summarizeToolArgs(toolName, args),
+            ...summarizeResult(result),
+        };
+        const stableId = `${meta.id}:${lineNo}:${server}:${toolName}:${timestamp ?? ""}`;
+        events.push({
+            eventType: "[Codex] MCP Tool Used",
+            insertId: shortHash(`codex-mcp:${stableId}`),
+            eventProperties: eventBase,
+        });
+        if (server === "echomem") {
+            echomemToolCallCount++;
+            if (triggerUser)
+                echomemTriggerTurns.add(triggerUser.index);
+            events.push({
+                eventType: "[Codex] EchoMem Triggered",
+                insertId: shortHash(`codex-echomem:${stableId}`),
+                eventProperties: {
+                    ...eventBase,
+                    event_family: "codex_echomem",
+                    integration: "echomem_mcp",
+                },
+            });
+        }
+    });
+    if (startedAt) {
+        const summaryBase = baseSessionProperties({ ...meta, timestamp: meta.timestamp ?? startedAt }, file);
+        events.push({
+            eventType: "[Codex] Session Summary",
+            insertId: shortHash(`codex-summary:${meta.id ?? sessionIdFromPath(file)}`),
+            eventProperties: {
+                ...summaryBase,
+                session_ended_at: endedAt,
+                user_message_count: userMessageCount,
+                assistant_message_count: assistantMessageCount,
+                function_call_count: functionCallCount,
+                mcp_tool_call_count: mcpToolCallCount,
+                echomem_tool_call_count: echomemToolCallCount,
+                echomem_triggering_user_turn_count: echomemTriggerTurns.size,
+                token_input: asNumber(lastTokenUsage.input_tokens),
+                token_output: asNumber(lastTokenUsage.output_tokens),
+                token_cached: asNumber(lastTokenUsage.cached_input_tokens),
+                total_tokens: asNumber(lastTokenUsage.total_tokens),
+            },
+        });
+    }
+    return events;
+}
+function parseFlags(argv) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith("--"))
+            continue;
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("--")) {
+            flags[key] = next;
+            i++;
+        }
+        else {
+            flags[key] = true;
+        }
+    }
+    return flags;
+}
+async function uploadEvent(token, event) {
+    await axios.post(`${API_BASE_URL}/api/extension/mcp/events`, {
+        eventType: event.eventType,
+        insertId: event.insertId,
+        eventProperties: event.eventProperties,
+    }, {
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        timeout: 5000,
+    });
+}
+export async function syncCodexUsage(argv) {
+    const flags = parseFlags(argv);
+    const days = flags.all ? Number.POSITIVE_INFINITY : Number(flags.days ?? DEFAULT_DAYS);
+    const limit = Number(flags.limit ?? DEFAULT_LIMIT);
+    const dryRun = flags["dry-run"] === true;
+    const root = typeof flags.root === "string" ? flags.root : path.join(os.homedir(), ".codex", "sessions");
+    const token = new KeyStore().getToken();
+    if (!dryRun && !token) {
+        console.error("Not logged in. Run `echomem-mcp login` first, or re-run with --dry-run.");
+        process.exitCode = 1;
+        return;
+    }
+    const cutoff = Number.isFinite(days) ? Date.now() - days * 24 * 60 * 60 * 1000 : 0;
+    const files = walk(root)
+        .map((file) => ({ file, stat: fs.statSync(file) }))
+        .filter(({ stat }) => stat.mtimeMs >= cutoff)
+        .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+        .slice(0, Number.isFinite(limit) ? limit : DEFAULT_LIMIT)
+        .map(({ file }) => file);
+    const events = files.flatMap(parseCodexSession);
+    if (dryRun) {
+        console.log(JSON.stringify({
+            dryRun: true,
+            files: files.length,
+            events: events.length,
+            eventTypes: events.reduce((acc, event) => {
+                acc[event.eventType] = (acc[event.eventType] ?? 0) + 1;
+                return acc;
+            }, {}),
+            sample: events.slice(0, 5),
+        }, null, 2));
+        return;
+    }
+    let uploaded = 0;
+    for (const event of events) {
+        try {
+            await uploadEvent(token, event);
+            uploaded++;
+        }
+        catch (error) {
+            console.error(`Failed to upload ${event.eventType}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    console.log(`Synced ${uploaded}/${events.length} Codex usage events from ${files.length} session files.`);
+}

package/dist/encryption.js

@@ -1,7 +1,9 @@
 import { deriveKey, exportKeyToBase64, importKeyFromBase64, decrypt, verifyKey, saltFromBase64 } from "./crypto.js";
 /** GET the account's encryption status from the EchoMem backend using the bridge's authed client. */
 export async function fetchEncryptionConfig(axios) {
-    const res = await axios.get("/api/extension/account/encryption");
+    // Bounded: this is on the startup/tool-listing path; an unbounded call on a flaky network would hang
+    // the MCP handshake and freeze the whole agent (the "connection timed out after 30000ms" symptom).
+    const res = await axios.get("/api/extension/account/encryption", { timeout: 6000 });
     const data = res.data ?? {};
     return {
         enabled: !!data.enabled,