@echomem/mcp 1.4.6 → 1.4.7

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
 import { ZodError } from "zod";
-import { canonicalToolNames, deleteMemorySchema, getByContextSchema, keywordsSchema, listToolSpecs, othersSchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, timeRangeSchema, } from "./v1-contract.js";
+import { canonicalToolNames, deleteMemorySchema, getByContextSchema, keywordsSchema, listFriendsSchema, listToolSpecs, othersSchema, publicMemorySchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, searchUsersSchema, sendFriendRequestSchema, timeRangeSchema, } from "./v1-contract.js";
 import { KeyStore } from "./keystore.js";
 import { EventLogger, hashText } from "./events.js";
 import { buildReportText } from "./report.js";
@@ -15,7 +15,6 @@ import { runCli } from "./setup.js";
 import { MCP_PACKAGE_VERSION, MCP_SERVER_INSTRUCTIONS } from "./package-metadata.js";
 import { checkLatestUpdateStatus, formatUpdateNotice, formatUpdateStatusText, startBackgroundUpdateCheck, } from "./update-check.js";
 const ECHO_API_BASE_URL = process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app";
-const MEMORY_FEED_API_URL = process.env.MEMORY_FEED_API_URL || "https://memory-feed.vercel.app";
 /** Thrown when no API token is present yet — the model gets a "run login" nudge, not a hard error. */
 class NoTokenError extends Error {
 }
@@ -379,6 +378,22 @@ function inputAnalyticsForTool(canonicalName, args) {
                 keyword_count: Array.isArray(a.keywords) ? a.keywords.length : 0,
                 limit: numberArg(a, "limit"),
             };
+        case canonicalToolNames.searchUsers: {
+            const query = readString(a, "query");
+            const queryAnalytics = safeTextAnalytics("query", query);
+            return {
+                ...queryAnalytics,
+                query_preview_safe: queryAnalytics.query_preview,
+                query_length: query?.length ?? 0,
+                limit: numberArg(a, "limit"),
+            };
+        }
+        case canonicalToolNames.sendFriendRequest: {
+            const targetUserId = readString(a, "targetUserId");
+            return {
+                target_user_id_hash: targetUserId ? hashText(targetUserId) : undefined,
+            };
+        }
         case canonicalToolNames.others: {
             const query = readString(a, "query");
             const queryAnalytics = safeTextAnalytics("query", query);
@@ -386,6 +401,13 @@ function inputAnalyticsForTool(canonicalName, args) {
                 ...queryAnalytics,
                 query_preview_safe: queryAnalytics.query_preview,
                 query_length: query?.length ?? 0,
+                limit: numberArg(a, "limit"),
+            };
+        }
+        case canonicalToolNames.publicMemory: {
+            const memoryId = readString(a, "memoryId");
+            return {
+                memory_id_hash: memoryId ? hashText(memoryId) : undefined,
             };
         }
         default:
@@ -773,21 +795,73 @@ class EchoMemApiClient {
         });
         return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
     }
+    async listFriends(args) {
+        listFriendsSchema.parse(args);
+        try {
+            const response = await this.axios.get("/api/extension/social/friends");
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`list_friends failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
+    async searchUsers(args) {
+        const parsed = searchUsersSchema.parse(args);
+        try {
+            const response = await this.axios.post("/api/extension/social/users/search", {
+                query: parsed.query,
+                limit: parsed.limit,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`search_users failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
+    async sendFriendRequest(args) {
+        const parsed = sendFriendRequestSchema.parse(args);
+        try {
+            const response = await this.axios.post("/api/extension/social/friend-requests", {
+                receiverUserId: parsed.targetUserId,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`send_friend_request failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
     async searchOthersMemories(args) {
         const parsed = othersSchema.parse(args);
         try {
-            const response = await axios.post(`${MEMORY_FEED_API_URL.replace(/\/$/, "")}/api/search/public`, {
+            const response = await this.axios.post("/api/extension/social/public-memories/search", {
                 query: parsed.query,
-                excludedMemoryIds: [],
-            }, {
-                headers: {
-                    "Content-Type": "application/json",
-                },
+                limit: parsed.limit,
+                target: parsed.target,
+                ownerUserId: parsed.ownerUserId,
+                ownerName: parsed.ownerName,
+                targetFriendIds: parsed.targetFriendIds,
+                targetFriendNames: parsed.targetFriendNames,
+                recordAccess: parsed.recordAccess,
+                kPerUser: parsed.kPerUser,
+                similarityThreshold: parsed.similarityThreshold,
+                timeFrameDays: parsed.timeFrameDays,
+                requestId: this.sessionId,
+                source: "mcp_friend_public_memory_search",
             });
             return response.data;
         }
         catch (error) {
-            throw new Error(`search_others_memories failed against ${MEMORY_FEED_API_URL}: ${describeError(error)}`);
+            throw new Error(`search_others_memories failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
+    async getPublicMemory(args) {
+        const parsed = publicMemorySchema.parse(args);
+        try {
+            const response = await this.axios.get(`/api/extension/social/public-memories/${encodeURIComponent(parsed.memoryId)}?requestId=${encodeURIComponent(this.sessionId)}&source=mcp_friend_public_memory_fetch`);
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`get_public_memory failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
         }
     }
 }
@@ -954,8 +1028,16 @@ class EchoMemMCPServer {
                         return await this.handleGetByContext(request.params.arguments);
                     case canonicalToolNames.keywords:
                         return await this.handleKeywords(request.params.arguments);
+                    case canonicalToolNames.friends:
+                        return await this.handleFriends(request.params.arguments);
+                    case canonicalToolNames.searchUsers:
+                        return await this.handleSearchUsers(request.params.arguments);
+                    case canonicalToolNames.sendFriendRequest:
+                        return await this.handleSendFriendRequest(request.params.arguments);
                     case canonicalToolNames.others:
                         return await this.handleOthers(request.params.arguments);
+                    case canonicalToolNames.publicMemory:
+                        return await this.handlePublicMemory(request.params.arguments);
                     case canonicalToolNames.delete:
                         return await this.handleDelete(request.params.arguments, rec);
                     default:
@@ -1251,26 +1333,177 @@ Details: ${m.details || "N/A"}`)
         const payload = await this.client.searchOthersMemories(args);
         const memories = payload?.memories ?? [];
         if (!memories.length) {
+            const scope = parsed.ownerUserId
+                ? ` for friend ${parsed.ownerUserId}`
+                : parsed.ownerName
+                    ? ` for friend ${parsed.ownerName}`
+                    : parsed.target
+                        ? ` for friend ${parsed.target}`
+                        : parsed.targetFriendIds?.length
+                            ? ` for ${parsed.targetFriendIds.length} selected friends`
+                            : parsed.targetFriendNames?.length
+                                ? ` for ${parsed.targetFriendNames.length} named friends`
+                                : "";
+            const queryLabel = parsed.query?.trim() ? ` matching the query: ${parsed.query}` : "";
             return {
-                content: [{ type: "text", text: `No others' memories found matching the query: ${parsed.query}` }],
+                content: [{ type: "text", text: `No others' public memories found${scope}${queryLabel}` }],
             };
         }
+        const metadata = [
+            typeof payload?.friendCount === "number" ? `friendCount=${payload.friendCount}` : "",
+            typeof payload?.searchedFriendCount === "number" ? `searchedFriendCount=${payload.searchedFriendCount}` : "",
+            typeof payload?.memoryViewsInserted === "number" ? `memoryViewsInserted=${payload.memoryViewsInserted}` : "",
+        ].filter(Boolean).join(", ");
         const formattedResults = memories
-            .map((m, idx) => `[${idx + 1}] User Name: ${m.user_name || "Anonymous"}
+            .map((m, idx) => {
+            const score = typeof m.final_score === "number"
+                ? m.final_score
+                : typeof m.similarity_score === "number"
+                    ? m.similarity_score
+                    : undefined;
+            return `[${idx + 1}] Memory ID: ${m.id || "unknown"}
+User ID: ${m.user_id || "unknown"}
+User Name: ${m.username || m.user_name || m.name || "Anonymous"}
 Time: ${m.time} | Location: ${m.location}
 Category: ${m.category} | Object: ${m.object}
-Description: ${m.description}
-Details: ${m.details || "N/A"}`)
+${typeof score === "number" ? `Score: ${score}\n` : ""}Description: ${m.description}
+Details: ${m.details || "N/A"}`;
+        })
             .join("\n\n");
         return {
             content: [
                 {
                     type: "text",
-                    text: `Found ${memories.length} others' memories:\n\n${formattedResults}`,
+                    text: `Found ${memories.length} others' public memories${metadata ? ` (${metadata})` : ""}:\n\n${formattedResults}`,
                 },
             ],
         };
     }
+    async handleFriends(args) {
+        listFriendsSchema.parse(args);
+        const payload = await this.client.listFriends(args);
+        const friends = Array.isArray(payload?.friends) ? payload.friends : [];
+        if (!friends.length) {
+            return {
+                content: [{ type: "text", text: "No accepted EchoMem friends found." }],
+            };
+        }
+        const formatted = friends
+            .map((friend, idx) => {
+            const name = typeof friend.name === "string" && friend.name.trim()
+                ? friend.name.trim()
+                : "Unnamed friend";
+            const userId = typeof friend.user_id === "string" ? friend.user_id : "unknown";
+            const publicMemoryCount = typeof friend.publicMemoryCount === "number"
+                ? friend.publicMemoryCount
+                : 0;
+            return `[${idx + 1}] ${name}\nUser ID: ${userId}\nPublic memories: ${publicMemoryCount}`;
+        })
+            .join("\n\n");
+        const total = typeof payload?.totalPublicMemoryCount === "number"
+            ? payload.totalPublicMemoryCount
+            : friends.reduce((sum, friend) => sum + (typeof friend.publicMemoryCount === "number" ? friend.publicMemoryCount : 0), 0);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Found ${friends.length} accepted friends (totalPublicMemoryCount=${total}):\n\n${formatted}`,
+                }],
+        };
+    }
+    async handleSearchUsers(args) {
+        const parsed = searchUsersSchema.parse(args);
+        const payload = await this.client.searchUsers(args);
+        const users = Array.isArray(payload?.users) ? payload.users : [];
+        if (!users.length) {
+            return {
+                content: [{ type: "text", text: `No EchoMem users found matching "${parsed.query}".` }],
+            };
+        }
+        const formatted = users
+            .map((user, idx) => {
+            const displayName = typeof user.displayName === "string" && user.displayName.trim()
+                ? user.displayName.trim()
+                : typeof user.username === "string" && user.username.trim()
+                    ? user.username.trim()
+                    : "Unnamed user";
+            const userId = typeof user.userId === "string" ? user.userId : "unknown";
+            const totalMemoryCount = typeof user.totalMemoryCount === "number" ? user.totalMemoryCount : 0;
+            const publicMemoryCount = typeof user.publicMemoryCount === "number" ? user.publicMemoryCount : 0;
+            const relationship = typeof user.relationshipStatus === "string" ? user.relationshipStatus : "none";
+            const pendingRequestId = typeof user.pendingRequestId === "string" && user.pendingRequestId
+                ? `\nPending request ID: ${user.pendingRequestId}`
+                : "";
+            return `[${idx + 1}] ${displayName}\nUser ID: ${userId}\nTotal memories: ${totalMemoryCount}\nPublic memories: ${publicMemoryCount}\nRelationship: ${relationship}${pendingRequestId}`;
+        })
+            .join("\n\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: `Found ${users.length} EchoMem users matching "${parsed.query}":\n\n${formatted}\n\nUse send_friend_request with the exact User ID to send a pending friend request.`,
+                }],
+        };
+    }
+    async handleSendFriendRequest(args) {
+        sendFriendRequestSchema.parse(args);
+        const payload = await this.client.sendFriendRequest(args);
+        const result = isRecord(payload) ? payload : {};
+        const targetUser = isRecord(result.targetUser) ? result.targetUser : {};
+        const confirmation = isRecord(result.confirmation) ? result.confirmation : {};
+        const request = isRecord(result.request) ? result.request : {};
+        const created = result.created === true;
+        const displayName = readString(targetUser, "displayName") ?? readString(targetUser, "username") ?? "Unnamed user";
+        const userId = readString(targetUser, "userId") ?? "unknown";
+        const relationship = readString(targetUser, "relationshipStatus") ?? "pending_sent";
+        const requestId = readString(request, "id") ?? readString(targetUser, "pendingRequestId") ?? "unknown";
+        const status = readString(confirmation, "status") ?? "pending";
+        const requiresApproval = confirmation.requiresApproval === true;
+        const message = readString(confirmation, "message") ?? "Friend request is pending approval.";
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        created ? "Friend request sent." : "Friend request was not duplicated.",
+                        "",
+                        `Target: ${displayName}`,
+                        `Target User ID: ${userId}`,
+                        `Relationship: ${relationship}`,
+                        `Request ID: ${requestId}`,
+                        `Status: ${status}`,
+                        `Requires approval: ${requiresApproval ? "yes" : "no"}`,
+                        "",
+                        `Confirmation: ${message}`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    async handlePublicMemory(args) {
+        const parsed = publicMemorySchema.parse(args);
+        const payload = await this.client.getPublicMemory(args);
+        const memory = payload?.memory;
+        if (!memory) {
+            return {
+                content: [{ type: "text", text: `Public memory ${parsed.memoryId} was not found or is not accessible.` }],
+            };
+        }
+        const text = [
+            `Memory ID: ${memory.id || parsed.memoryId}`,
+            `Owner User ID: ${memory.owner_user_id || memory.user_id || "Unknown"}`,
+            memory.time ? `Time: ${memory.time}` : "",
+            memory.location ? `Location: ${memory.location}` : "",
+            memory.category ? `Category: ${memory.category}` : "",
+            memory.object ? `Object: ${memory.object}` : "",
+            memory.emotion ? `Emotion: ${memory.emotion}` : "",
+            memory.keys ? `Keys: ${memory.keys}` : "",
+            `Description: ${memory.description || ""}`,
+            memory.details ? `Details: ${memory.details}` : "",
+            typeof payload.accessRecordsInserted === "number"
+                ? `Access records inserted: ${payload.accessRecordsInserted}`
+                : "",
+        ].filter(Boolean).join("\n");
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
     async handleDelete(args, rec) {
         const parsed = deleteMemorySchema.parse(args);
         if (rec) {

package/dist/setup.js

@@ -275,8 +275,8 @@ export function resolveServerEntryVersion(entry) {
     }
     const candidates = [...args, command].filter((value) => typeof value === "string");
     for (const candidate of candidates) {
-        // Direct local/dev entries often look like ".../packages/mcp-server/dist/index.js";
-        // they do not contain the published package name, but walking upward still finds package.json.
+        if (!candidate.includes(MCP_PACKAGE_NAME) && !candidate.includes(`${path.sep}echomem-mcp`))
+            continue;
         const resolved = packageVersionFromPath(candidate);
         if (resolved)
             return resolved;

package/dist/v1-contract.js

@@ -5,7 +5,11 @@ export const canonicalToolNames = {
     save: "save_conversation",
     timeRange: "get_memories_by_time_range",
     keywords: "search_memories_by_keywords",
+    friends: "list_friends",
+    searchUsers: "search_users",
+    sendFriendRequest: "send_friend_request",
     others: "search_others_memories",
+    publicMemory: "get_public_memory",
     report: "echomem_usage_report",
     updateStatus: "echomem_update_status",
     contextHealth: "echo_context_health",
@@ -59,9 +63,35 @@ export const keywordsSchema = z.object({
     keywords: z.array(z.string()),
     limit: z.number().optional().default(10),
 });
+export const listFriendsSchema = z.object({
+    ...triggerMetadataSchema,
+});
+export const searchUsersSchema = z.object({
+    ...triggerMetadataSchema,
+    query: z.string().min(1),
+    limit: z.number().optional().default(10),
+});
+export const sendFriendRequestSchema = z.object({
+    ...triggerMetadataSchema,
+    targetUserId: z.string().min(1),
+});
 export const othersSchema = z.object({
     ...triggerMetadataSchema,
-    query: z.string(),
+    query: z.string().optional().default(""),
+    limit: z.number().optional().default(10),
+    target: z.string().optional(),
+    ownerUserId: z.string().optional(),
+    ownerName: z.string().optional(),
+    targetFriendIds: z.array(z.string()).optional(),
+    targetFriendNames: z.array(z.string()).optional(),
+    recordAccess: z.boolean().optional(),
+    kPerUser: z.number().optional(),
+    similarityThreshold: z.number().optional(),
+    timeFrameDays: z.number().optional(),
+});
+export const publicMemorySchema = z.object({
+    ...triggerMetadataSchema,
+    memoryId: z.string().min(1),
 });
 export const deleteMemorySchema = z.object({
     memoryId: z.string().min(1),
@@ -196,20 +226,121 @@ export function listToolSpecs(opts = {}) {
                 required: ["keywords"],
             },
         },
+        {
+            name: canonicalToolNames.friends,
+            description: "Friends: list accepted EchoMem friends with each friend's public memory count. Use this before asking a specific friend by name.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this friend-list lookup. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+            },
+        },
+        {
+            name: canonicalToolNames.searchUsers,
+            description: "Search EchoMem users by display name/username before sending a friend request. Results include total memories, public memories, and current relationship state.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Name or username fragment to search, e.g. Kobe.",
+                    },
+                    limit: { type: "number", default: 10 },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this user search. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: canonicalToolNames.sendFriendRequest,
+            description: "Send a pending EchoMem friend request to an exact user id returned by search_users. The other user must approve before friend-gated memory access is allowed.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    targetUserId: {
+                        type: "string",
+                        description: "Exact target user id from search_users.",
+                    },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this friend request. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["targetUserId"],
+            },
+        },
         {
             name: canonicalToolNames.others,
-            description: "Search other users' public memories.",
+            description: "Search accepted friends' public memories. Returned memories are recorded in the existing memory_views pipeline for the memory owners.",
             inputSchema: {
                 type: "object",
                 properties: {
                     query: { type: "string" },
+                    limit: { type: "number", default: 10 },
+                    target: {
+                        type: "string",
+                        description: "Accepted-friend user id or exact display name/username. Prefer this for @Name asks.",
+                    },
+                    ownerUserId: {
+                        type: "string",
+                        description: "Optional accepted-friend user id to scope the search to one friend.",
+                    },
+                    ownerName: {
+                        type: "string",
+                        description: "Optional accepted-friend display name/username to scope the search to one friend.",
+                    },
+                    targetFriendIds: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional accepted-friend user ids to scope the search.",
+                    },
+                    targetFriendNames: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional accepted-friend display names/usernames to scope the search.",
+                    },
+                    recordAccess: {
+                        type: "boolean",
+                        description: "Defaults true. When true, returned public memories are recorded in memory_views.",
+                    },
+                    kPerUser: { type: "number", default: 5 },
+                    similarityThreshold: { type: "number", default: 0.1 },
+                    timeFrameDays: { type: "number" },
                     triggerMessage: {
                         type: "string",
                         description: "Optional: the user's message that caused this public-memory search. EchoMem stores only a redacted analytics preview and hash.",
                     },
                     triggerMessageRole: { type: "string", default: "user" },
                 },
-                required: ["query"],
+            },
+        },
+        {
+            name: canonicalToolNames.publicMemory,
+            description: "Fetch one accepted friend's public memory by id. If the caller is not the owner, EchoMem records the access in the existing memory_views pipeline.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    memoryId: {
+                        type: "string",
+                        description: "The public memory id to fetch.",
+                    },
+                    triggerMessage: {
+                        type: "string",
+                        description: "Optional: the user's message that caused this public-memory fetch. EchoMem stores only a redacted analytics preview and hash.",
+                    },
+                    triggerMessageRole: { type: "string", default: "user" },
+                },
+                required: ["memoryId"],
             },
         },
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "EchoMem Cloud-First MCP Server",
   "main": "dist/index.js",
   "type": "module",