memory-privacy 1.1.0 → 1.4.0

package/filters.ts

@@ -116,10 +116,10 @@ function isPathAllowedRelative(
     }
 
     if (identity.type === "peer") {
-      // 私聊中访问群记忆：按 _members.json 时间线过滤
+      // 私聊中访问群记忆：通过 API 获取成员资格，按时间线过滤
       const fileDate = extractDateFromPath(relPath);
       if (!fileDate) return false;
-      return isWithinMembershipPeriod(workspaceDir, groupId, identity.peerId, fileDate);
+      return isWithinMembershipPeriod(groupId, identity.peerId, fileDate);
     }
 
     return false;

package/identity.ts

@@ -10,7 +10,7 @@ export type SessionIdentity =
  *   单聊: agent:{agentId}:palz:direct:{userId}:user_{userID}_lobster_{lobsterID}_release_{releaseName}
  *   群聊: agent:{agentId}:palz:direct:{userId}:user_{userID}_lobster_{lobsterID}_group_{groupID}_release_{releaseName}
  */
-export function resolveSessionIdentity(sessionKey: string | undefined, config: any): SessionIdentity {
+export function resolveSessionIdentity(sessionKey: string | undefined): SessionIdentity {
   const sk = sessionKey ?? "";
   // 取最后一段（会话ID）
   const sessionPart = sk.split(":").pop() || "";
@@ -25,7 +25,7 @@ export function resolveSessionIdentity(sessionKey: string | undefined, config: a
   const peerMatch = sessionPart.match(/user_(.+?)_lobster_(.+?)_release_(.+)$/);
   if (peerMatch) {
     const userID = peerMatch[1];
-    if (isOwner(userID, config)) return { type: "owner", userId: userID };
+    if (isOwner(userID)) return { type: "owner", userId: userID };
     return { type: "peer", peerId: userID };
   }
 
@@ -35,12 +35,10 @@ export function resolveSessionIdentity(sessionKey: string | undefined, config: a
 
 /**
  * 判断 userId 是否是主人
- * 对比 openclaw.json 中的 commands.ownerAllowFrom 列表
+ * 从环境变量 owner_claw_user_id 获取主人 ID
  */
-export function isOwner(userId: string, config: any): boolean {
-  const ownerList: (string | number)[] = config?.commands?.ownerAllowFrom ?? [];
-  return ownerList.some(entry => {
-    const entryStr = String(entry);
-    return entryStr === userId || entryStr === "*";
-  });
+export function isOwner(userId: string): boolean {
+  const ownerUserId = process.env.owner_claw_user_id || "";
+  if (!ownerUserId) return false;
+  return ownerUserId === userId;
 }

package/index.ts

@@ -23,7 +23,7 @@ export default {
     // 钩子 1: before_prompt_build — 用 memory_search 检索相关记忆注入上下文
     // ====================================================================
     api.on("before_prompt_build", async (event: any, ctx: any) => {
-      const identity = resolveSessionIdentity(ctx.sessionKey, config);
+      const identity = resolveSessionIdentity(ctx.sessionKey);
       const wsDir = ctx.workspaceDir || workspaceDir;
 
       // 从 event.messages 提取用户最新消息作为搜索 query
@@ -40,37 +40,35 @@ export default {
 
       let memoryBlock = "";
 
-      if (query) {
-        try {
-          // 用内置 memory_search 搜索相关记忆
-          const searchTool = api.runtime.tools.createMemorySearchTool({
-            config: ctx.config || config,
-            agentSessionKey: ctx.sessionKey,
-          });
-
-          if (searchTool) {
-            const rawResults = await searchTool.execute("prompt-build-search", { query });
-            // 按身份权限过滤结果
-            const filtered = filterResultsByIdentity(rawResults, identity, wsDir);
-            const details = filtered?.details;
-            const results = Array.isArray(details?.results) ? details.results : [];
-            const snippets = results
-              .map((r: any) => r.snippet || "")
-              .filter((s: string) => s.length > 0);
-
-            if (snippets.length > 0) {
-              memoryBlock = `\n\n${snippets.join("\n\n")}`;
+      if (identity.type === "owner") {
+        // owner 使用语义搜索（需要 query）
+        if (query) {
+          try {
+            const searchTool = api.runtime.tools.createMemorySearchTool({
+              config: ctx.config || config,
+              agentSessionKey: ctx.sessionKey,
+            });
+
+            if (searchTool) {
+              const rawResults = await searchTool.execute("prompt-build-search", { query });
+              const details = rawResults?.details;
+              const results = Array.isArray(details?.results) ? details.results : [];
+              const snippets = results
+                .map((r: any) => r.snippet || "")
+                .filter((s: string) => s.length > 0);
+
+              if (snippets.length > 0) {
+                memoryBlock = `\n\n${snippets.join("\n\n")}`;
+              }
             }
-          } else {
-            // memory_search 不可用，回退到全量加载
-            const fallback = loadAllowedMemoryContent(wsDir, identity);
-            if (fallback) memoryBlock = `\n\n${fallback}`;
+          } catch {
+            // owner 搜索失败不回退
           }
-        } catch {
-          // 搜索失败，回退到全量加载
-          const fallback = loadAllowedMemoryContent(wsDir, identity);
-          if (fallback) memoryBlock = `\n\n${fallback}`;
         }
+      } else {
+        // 非 owner（peer / group）：直接全量加载已过滤的记忆，不依赖 query
+        const fallback = loadAllowedMemoryContent(wsDir, identity);
+        if (fallback) memoryBlock = `\n\n${fallback}`;
       }
 
       switch (identity.type) {
@@ -102,7 +100,7 @@ export default {
     // ====================================================================
     api.registerTool(
       (ctx: any) => {
-        const identity = resolveSessionIdentity(ctx.sessionKey, config);
+        const identity = resolveSessionIdentity(ctx.sessionKey);
         const wsDir = ctx.workspaceDir || workspaceDir;
 
         const originalSearchTool = api.runtime.tools.createMemorySearchTool({
@@ -176,7 +174,7 @@ export default {
       const filePath = (event.params?.path || event.params?.filePath || event.params?.file_path || "") as string;
       if (!filePath) return;
 
-      const identity = resolveSessionIdentity(ctx.sessionKey, config);
+      const identity = resolveSessionIdentity(ctx.sessionKey);
       const lowerFilePath = filePath.toLowerCase();
 
       // --- MEMORY.md 写入保护（非 owner 阻止）---
@@ -187,12 +185,15 @@ export default {
         return; // owner 可以正常写 MEMORY.md
       }
 
-      // --- USER.md 写入保护（group session 阻止）---
-      if (lowerFilePath.endsWith("/user.md") || lowerFilePath.endsWith("\\user.md") || lowerFilePath === "user.md") {
-        if (identity.type === "group") {
+      // --- 系统配置文件写入保护（非 owner 一律阻止）---
+      // USER.md / SOUL.md / TOOL.md 等只有 owner 能写，peer/group 只能读
+      const systemFiles = ["/user.md", "/soul.md", "/tool.md"];
+      const isSystemFile = systemFiles.some(f => lowerFilePath.endsWith(f) || lowerFilePath === f.slice(1));
+      if (isSystemFile) {
+        if (identity.type !== "owner") {
           return { block: true, blockReason: "Access denied." };
         }
-        return; // owner / peer 可以写 USER.md
+        return;
       }
 
       // --- 以下只处理 memory/ 目录下的写入 ---
@@ -247,7 +248,7 @@ export default {
       if (!filePath) return;
 
       const wsDir = ctx.workspaceDir || workspaceDir;
-      const identity = resolveSessionIdentity(ctx.sessionKey, config);
+      const identity = resolveSessionIdentity(ctx.sessionKey);
 
       // 拦截 memory/ 路径的读取
       if (filePath.includes("/memory/") || filePath.includes("memory/")) {
@@ -280,12 +281,18 @@ export default {
     api.on("before_tool_call", (event: any, ctx: any) => {
       if (event.toolName !== "exec" && event.toolName !== "process") return;
 
-      const identity = resolveSessionIdentity(ctx.sessionKey, config);
+      const identity = resolveSessionIdentity(ctx.sessionKey);
       if (identity.type === "owner") return;
 
-      const command = (event.params?.command || event.params?.cmd || "") as string;
+      let command = (event.params?.command || event.params?.cmd || "") as string;
       if (!command) return;
 
+      // 展开 ~ 为绝对路径，防止用 ~ 绕过路径检测
+      const homeDir = process.env.HOME || require("os").homedir();
+      if (homeDir) {
+        command = command.replace(/(?<=^|[\s;|&"'(=])~/g, homeDir);
+      }
+
       // MEMORY.md / USER.md 始终拦截非 owner（大小写不敏感）
       const lowerCommand = command.toLowerCase();
       if (lowerCommand.includes("memory.md") || lowerCommand.includes("user.md")) {
@@ -385,7 +392,7 @@ export default {
       const filePath = (event.params?.path || event.params?.filePath || event.params?.file_path || "") as string;
       if (!filePath) return;
 
-      const identity = resolveSessionIdentity(ctx.sessionKey, config);
+      const identity = resolveSessionIdentity(ctx.sessionKey);
       if (identity.type === "owner") return;
 
       // 拦截 MEMORY.md（非 owner 不可读）
@@ -407,11 +414,25 @@ export default {
       }
     }, { priority: 10 });
 
+    // ====================================================================
+    // 钩子 6.5: before_tool_call — 非 owner 禁用 memory_search
+    // 框架不 await async before_tool_call，无法做结果过滤
+    // 直接 block，依赖 hook1 (before_prompt_build) 注入已过滤的记忆
+    // ====================================================================
+    api.on("before_tool_call", (event: any, ctx: any) => {
+      if (event.toolName !== "memory_search") return;
+
+      const identity = resolveSessionIdentity(ctx.sessionKey);
+      if (identity.type === "owner") return;
+
+      return { block: true, blockReason: "No results found." };
+    }, { priority: 10 });
+
     // ====================================================================
     // 钩子 7: agent_end — 将 agent 对话同步到 memory 文件
     // ====================================================================
     api.on("agent_end", (event: any, ctx: any) => {
-      const identity = resolveSessionIdentity(ctx.sessionKey, config);
+      const identity = resolveSessionIdentity(ctx.sessionKey);
       const wsDir = ctx.workspaceDir || workspaceDir;
       const messages = event.messages || [];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-privacy",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "type": "module",
   "main": "index.ts",
   "files": [

package/utils.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
 import type { SessionIdentity } from "./identity.js";
 
 // ========== 类型定义 ==========
@@ -7,17 +8,16 @@ import type { SessionIdentity } from "./identity.js";
 export interface MemberPeriod {
   joined: number;   // Unix 毫秒时间戳
   left: number | null;
-  reason?: string;
 }
 
-export interface MemberInfo {
-  displayName: string;
+export interface MemberGroupInfo {
+  group_id: string;
   periods: MemberPeriod[];
 }
 
-export interface MembersJson {
-  groupName?: string;
-  members: Record<string, MemberInfo>;
+export interface MemberApiResponse {
+  user_id: string;
+  groups: MemberGroupInfo[];
 }
 
 export interface KnowledgeBaseRule {
@@ -67,22 +67,37 @@ export function extractKnowledgeBaseId(filePath: string): string {
   return knowledgeIndex >= 0 && parts[knowledgeIndex + 1] ? parts[knowledgeIndex + 1] : "unknown-kb";
 }
 
-// ========== 文件加载 ==========
+// ========== API 调用 ==========
 
 /**
- * 加载 _members.json
+ * 根据 HELM_ENV 环境变量返回 API base URL
  */
-export function loadMembersRegistry(filePath: string): MembersJson | null {
+export function getApiBaseUrl(): string {
+  const env = (process.env.HELM_ENV || "dev").toLowerCase();
+  switch (env) {
+    case "prod": return "https://claw-server.csagentai.com";
+    case "staging": return "https://claw-server.csjkagent.com";
+    default: return "https://claw-server.csaiagent.com";
+  }
+}
+
+/**
+ * 同步调用 API 获取用户的群成员资格数据
+ * 使用 execSync + curl 实现同步 HTTP 请求
+ */
+export function fetchMemberGroupsSync(userId: string): MemberApiResponse | null {
   try {
-    if (fs.existsSync(filePath)) {
-      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    }
+    const baseUrl = getApiBaseUrl();
+    const url = `${baseUrl}/api/members?user_id=${encodeURIComponent(userId)}`;
+    const result = execSync(`curl -s --max-time 5 "${url}"`, { encoding: "utf-8" });
+    return JSON.parse(result) as MemberApiResponse;
   } catch {
-    // ignore parse errors
+    return null;
   }
-  return null;
 }
 
+// ========== 文件加载 ==========
+
 /**
  * 加载知识库 ACL（带 mtime 缓存）
  */
@@ -111,29 +126,25 @@ export function loadKnowledgeACL(workspaceDir: string): KnowledgeACL {
 /**
  * 检查某个用户在某个日期是否处于群成员期内
  *
+ * 通过外部 API 获取成员资格数据
  * 规则：fileTimestamp >= joined && (left === null || fileTimestamp < left)
  * fileTimestamp = 文件日期 00:00:00 UTC
  */
 export function isWithinMembershipPeriod(
-  workspaceDir: string,
   groupId: string,
   peerId: string,
   fileDate: string // "2026-03-17"
 ): boolean {
-  const registryPath = path.join(workspaceDir, "memory", "groups", groupId, "_members.json");
-  const registry = loadMembersRegistry(registryPath);
-
-  if (!registry) return false;
+  const response = fetchMemberGroupsSync(peerId);
+  if (!response || !response.groups) return false;
 
-  // OpenClaw 把 sessionKey 转小写，但 _members.json 里的 key 保留原始大小写
-  const lowerPeerId = peerId.toLowerCase();
-  const memberKey = Object.keys(registry.members).find(k => k.toLowerCase() === lowerPeerId);
-  const member = memberKey ? registry.members[memberKey] : undefined;
-  if (!member || !member.periods || member.periods.length === 0) return false;
+  const lowerGroupId = groupId.toLowerCase();
+  const group = response.groups.find(g => g.group_id.toLowerCase() === lowerGroupId);
+  if (!group || !group.periods || group.periods.length === 0) return false;
 
   const fileTimestamp = new Date(`${fileDate}T00:00:00Z`).getTime();
 
-  return member.periods.some((period) => {
+  return group.periods.some((period) => {
     const afterJoin = fileTimestamp >= period.joined;
     const beforeLeft = period.left === null || fileTimestamp < period.left;
     return afterJoin && beforeLeft;
@@ -160,7 +171,7 @@ export function toRelativeMemoryPath(absolutePath: string, workspaceDir: string)
 /**
  * 获取某个身份有权限访问的所有 memory 子目录（绝对路径列表）
  *
- * peer: peers/{peerId}/ + _acl.json 中 userids 包含 peerId 的知识库 + _members.json 中当前在群的群组
+ * peer: peers/{peerId}/ + _acl.json 中 userids 包含 peerId 的知识库 + API 返回当前在群的群组
  * group: groups/{groupId}/ + _acl.json 中 allowGroups 包含 groupId 的知识库
  * owner: memory/ 整个目录
  */
@@ -191,29 +202,16 @@ export function getAllowedDirs(wsDir: string, identity: SessionIdentity): string
       }
     }
 
-    // 3. 群组：_members.json 中 members 的 key 匹配且 left === null
-    const groupsDir = path.join(memDir, "groups");
-    try {
-      if (fs.existsSync(groupsDir)) {
-        for (const groupId of fs.readdirSync(groupsDir)) {
-          const groupPath = path.join(groupsDir, groupId);
-          if (!fs.statSync(groupPath).isDirectory()) continue;
-          const membersPath = path.join(groupPath, "_members.json");
-          const registry = loadMembersRegistry(membersPath);
-          if (!registry) continue;
-
-          const memberKey = Object.keys(registry.members)
-            .find(k => k.toLowerCase() === lowerPeerId);
-          if (!memberKey) continue;
-
-          const member = registry.members[memberKey];
-          const lastPeriod = member.periods?.[member.periods.length - 1];
-          if (lastPeriod && lastPeriod.left === null) {
-            dirs.push(groupPath);
-          }
+    // 3. 群组：通过 API 获取当前在群的群组（last period.left === null）
+    const response = fetchMemberGroupsSync(identity.peerId);
+    if (response && response.groups) {
+      for (const group of response.groups) {
+        const lastPeriod = group.periods?.[group.periods.length - 1];
+        if (lastPeriod && lastPeriod.left === null) {
+          dirs.push(path.join(memDir, "groups", group.group_id));
         }
       }
-    } catch { /* ignore fs errors */ }
+    }
   }
 
   if (identity.type === "group") {