memory-gateway-sync 0.7.0 → 0.8.0

package/index.js

@@ -0,0 +1,287 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import os from "node:os";
+var index_default = definePluginEntry({
+  id: "memory-gateway-sync",
+  name: "Memory Gateway Sync",
+  description: "fs.watch \u76D1\u542C\u591A workspace \u7684 MEMORY \u6587\u4EF6\u53D8\u5316\uFF0C\u53CC\u5199\u5230\u5916\u90E8 Gateway\uFF08\u652F\u6301 peers/groups/knowledge \u5B50\u76EE\u5F55\uFF09",
+  kind: "generic",
+  register(api) {
+    const cfg = api.pluginConfig ?? {};
+    const gatewayUrl = cfg.gatewayUrl;
+    const gatewayToken = cfg.gatewayToken;
+    const debounceMs = cfg.debounceMs ?? 1500;
+    const defaultAgentId = cfg.agentId ?? "default";
+    const ownerClawUserId = (() => {
+      const token = process.env.OPENCLAW_GATEWAY_TOKEN ?? "";
+      const parts = token.split("-");
+      return parts.length >= 3 ? parts[parts.length - 1] : null;
+    })();
+    const podReleaseName = process.env.botID ?? null;
+    if (!gatewayUrl || !gatewayToken) {
+      api.logger.warn(
+        "memory-gateway-sync: gatewayUrl \u6216 gatewayToken \u672A\u914D\u7F6E\uFF0C\u63D2\u4EF6\u4E0D\u542F\u52A8"
+      );
+      return;
+    }
+    api.registerService({
+      id: "memory-gateway-sync",
+      start: async () => {
+        const openclawDir = path.join(os.homedir(), ".openclaw");
+        const debounceTimers = /* @__PURE__ */ new Map();
+        const lastSyncedHash = /* @__PURE__ */ new Map();
+        const parseReleaseName = (content) => {
+          const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+          if (!match) return null;
+          const nameMatch = match[1].match(/^name:\s*(.+)$/m);
+          return nameMatch ? nameMatch[1].trim() : null;
+        };
+        const registeredWorkspaces = /* @__PURE__ */ new Map();
+        const registeredRealPaths = /* @__PURE__ */ new Set();
+        const discoveredDataDirs = /* @__PURE__ */ new Set();
+        const findWorkspace = (absPath) => {
+          for (const [wsDir, ctx] of registeredWorkspaces) {
+            if (absPath.startsWith(wsDir + path.sep) || absPath === wsDir) {
+              return ctx;
+            }
+          }
+          return null;
+        };
+        const resolveAgentId = (dirName) => {
+          if (dirName === "workspace") {
+            return defaultAgentId;
+          }
+          if (dirName.startsWith("workspace-")) {
+            return dirName.substring("workspace-".length);
+          }
+          return defaultAgentId;
+        };
+        const syncFile = async (absPath, eventType) => {
+          const ws = findWorkspace(absPath);
+          if (!ws) {
+            api.logger.warn(
+              `memory-gateway-sync: \u627E\u4E0D\u5230\u6240\u5C5E workspace: ${absPath}`
+            );
+            return;
+          }
+          let content;
+          try {
+            content = await fs.promises.readFile(absPath, "utf-8");
+          } catch (err) {
+            api.logger.warn(
+              `memory-gateway-sync: \u8BFB\u53D6\u6587\u4EF6\u5931\u8D25 ${absPath}: ${String(err)}`
+            );
+            return;
+          }
+          const contentHash = crypto.createHash("md5").update(content).digest("hex");
+          if (lastSyncedHash.get(absPath) === contentHash) {
+            return;
+          }
+          const relativePath = path.relative(ws.dir, absPath);
+          let userId = null;
+          const parts = relativePath.replace(/\\/g, "/").split("/");
+          if (relativePath === "MEMORY.md" || parts[0] === "memory" && parts[1] === "owner") {
+            userId = ownerClawUserId;
+          } else if (parts[0] === "memory" && parts[1] === "peers" && parts.length >= 3) {
+            userId = parts[2];
+          }
+          const payload = {
+            path: relativePath,
+            content,
+            release_name: parseReleaseName(content) ?? podReleaseName,
+            agentId: ws.agentId,
+            userId,
+            workspaceDir: ws.dir,
+            eventType,
+            syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3e4);
+            const res = await fetch(gatewayUrl, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${gatewayToken}`
+              },
+              body: JSON.stringify(payload),
+              signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (res.ok) {
+              lastSyncedHash.set(absPath, contentHash);
+              api.logger.info?.(
+                `memory-gateway-sync: [${ws.agentId}] \u540C\u6B65\u6210\u529F ${relativePath} (${content.length} chars)`
+              );
+              if (relativePath === "MEMORY.md" && content.trim().length > 0) {
+                try {
+                  const backupPath = absPath + ".bak";
+                  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+                  const section = `
+<!-- backup ${timestamp} -->
+${content}
+`;
+                  await fs.promises.appendFile(backupPath, section, "utf-8");
+                  await fs.promises.writeFile(absPath, "", "utf-8");
+                  const emptyHash = crypto.createHash("md5").update("").digest("hex");
+                  lastSyncedHash.set(absPath, emptyHash);
+                  api.logger.info?.(
+                    `memory-gateway-sync: [${ws.agentId}] MEMORY.md \u5DF2\u5907\u4EFD\u5230 .bak \u5E76\u6E05\u7A7A`
+                  );
+                } catch (err) {
+                  api.logger.warn(
+                    `memory-gateway-sync: [${ws.agentId}] \u5907\u4EFD/\u6E05\u7A7A MEMORY.md \u5931\u8D25: ${String(err)}`
+                  );
+                }
+              }
+            } else {
+              const body = await res.text().catch(() => "");
+              api.logger.warn(
+                `memory-gateway-sync: [${ws.agentId}] Gateway \u8FD4\u56DE ${res.status} for ${relativePath}: ${body}`
+              );
+            }
+          } catch (err) {
+            api.logger.warn(
+              `memory-gateway-sync: [${ws.agentId}] POST \u5931\u8D25 ${relativePath}: ${String(err)}`
+            );
+          }
+        };
+        const scheduleSync = (absPath, eventType) => {
+          const existing = debounceTimers.get(absPath);
+          if (existing) clearTimeout(existing);
+          debounceTimers.set(
+            absPath,
+            setTimeout(() => {
+              debounceTimers.delete(absPath);
+              syncFile(absPath, eventType);
+            }, debounceMs)
+          );
+        };
+        const registerWorkspace = async (wsDir, wsAgentId) => {
+          const realDir = await fs.promises.realpath(wsDir).catch(() => wsDir);
+          if (registeredRealPaths.has(realDir)) return;
+          registeredRealPaths.add(realDir);
+          registeredWorkspaces.set(realDir, { dir: realDir, agentId: wsAgentId });
+          const memoryMdPath = path.join(realDir, "MEMORY.md");
+          try {
+            await fs.promises.writeFile(memoryMdPath, "", { flag: "a" });
+            fs.watch(memoryMdPath, (eventType) => {
+              scheduleSync(memoryMdPath, eventType ?? "change");
+            });
+            api.logger.info?.(
+              `memory-gateway-sync: [${wsAgentId}] \u5F00\u59CB\u76D1\u542C MEMORY.md`
+            );
+          } catch (err) {
+            api.logger.warn(
+              `memory-gateway-sync: [${wsAgentId}] \u65E0\u6CD5\u76D1\u542C MEMORY.md: ${String(err)}`
+            );
+          }
+          api.logger.info(
+            `memory-gateway-sync: [${wsAgentId}] workspace \u6CE8\u518C\u5B8C\u6210 \u2192 ${wsDir}`
+          );
+        };
+        const scanWorkspaces = async () => {
+          try {
+            const entries = await fs.promises.readdir(openclawDir, {
+              withFileTypes: true
+            });
+            for (const entry of entries) {
+              if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+              const name = entry.name;
+              if (name !== "workspace" && !name.startsWith("workspace-")) continue;
+              const wsDir = path.join(openclawDir, name);
+              if (entry.isSymbolicLink()) {
+                try {
+                  const stat = await fs.promises.stat(wsDir);
+                  if (!stat.isDirectory()) continue;
+                  const realTarget = await fs.promises.realpath(wsDir);
+                  discoveredDataDirs.add(path.dirname(realTarget));
+                } catch {
+                  continue;
+                }
+              }
+              const wsAgentId = resolveAgentId(name);
+              await registerWorkspace(wsDir, wsAgentId);
+            }
+          } catch (err) {
+            api.logger.warn(
+              `memory-gateway-sync: \u626B\u63CF workspace \u5931\u8D25: ${String(err)}`
+            );
+          }
+          for (const dataDir of discoveredDataDirs) {
+            if (dataDir === openclawDir) continue;
+            try {
+              const entries = await fs.promises.readdir(dataDir, {
+                withFileTypes: true
+              });
+              for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                const name = entry.name;
+                if (name !== "workspace" && !name.startsWith("workspace-")) continue;
+                const wsDir = path.join(dataDir, name);
+                const wsAgentId = resolveAgentId(name);
+                await registerWorkspace(wsDir, wsAgentId);
+              }
+            } catch (err) {
+              api.logger.warn(
+                `memory-gateway-sync: \u626B\u63CF\u6570\u636E\u76EE\u5F55 ${dataDir} \u5931\u8D25: ${String(err)}`
+              );
+            }
+          }
+        };
+        const watchDirForWorkspaces = (dir) => {
+          try {
+            fs.watch(dir, async (eventType, filename) => {
+              if (!filename) return;
+              if (filename !== "workspace" && !filename.startsWith("workspace-")) {
+                return;
+              }
+              const wsDir = path.join(dir, filename);
+              try {
+                const stat = await fs.promises.stat(wsDir);
+                if (!stat.isDirectory()) return;
+                const realDir = await fs.promises.realpath(wsDir).catch(() => wsDir);
+                if (registeredRealPaths.has(realDir)) return;
+                const wsAgentId = resolveAgentId(filename);
+                api.logger.info(
+                  `memory-gateway-sync: \u53D1\u73B0\u65B0 workspace \u2192 ${filename} (agentId=${wsAgentId}) in ${dir}`
+                );
+                await registerWorkspace(wsDir, wsAgentId);
+                const parentDir = path.dirname(realDir);
+                if (!discoveredDataDirs.has(parentDir) && parentDir !== openclawDir) {
+                  discoveredDataDirs.add(parentDir);
+                  watchDirForWorkspaces(parentDir);
+                }
+              } catch {
+              }
+            });
+          } catch (err) {
+            api.logger.warn(
+              `memory-gateway-sync: \u65E0\u6CD5\u76D1\u542C ${dir}: ${String(err)}`
+            );
+          }
+        };
+        watchDirForWorkspaces(openclawDir);
+        await scanWorkspaces();
+        for (const dataDir of discoveredDataDirs) {
+          if (dataDir !== openclawDir) {
+            watchDirForWorkspaces(dataDir);
+          }
+        }
+        const wsCount = registeredWorkspaces.size;
+        const wsIds = Array.from(registeredWorkspaces.values()).map((w) => w.agentId).join(", ");
+        api.logger.info(
+          `memory-gateway-sync: \u542F\u52A8\u5B8C\u6210 \u2192 ${gatewayUrl} (\u9632\u6296 ${debounceMs}ms, ${wsCount} \u4E2A workspace: ${wsIds})`
+        );
+      },
+      stop: () => {
+        api.logger.info("memory-gateway-sync: \u505C\u6B62");
+      }
+    });
+  }
+});
+export {
+  index_default as default
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "memory-gateway-sync",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Memory 双写插件：fs.watch 感知变化后同步到外部 Gateway",
   "type": "module",
+  "main": "index.js",
   "openclaw": {
     "extensions": [
-      "./src/index.ts"
+      "./index.js"
     ]
   },
   "devDependencies": {

package/src/index.ts

@@ -83,6 +83,10 @@ export default definePluginEntry({
 
         // 已注册的 workspace 集合（避免重复注册）
         const registeredWorkspaces = new Map<string, WorkspaceContext>();
+        // 用 realpath 去重，防止同一目录通过 symlink 和真实路径重复注册
+        const registeredRealPaths = new Set<string>();
+        // 从 symlink 目标发现的数据目录（如 /data/），用于扫描未建立 symlink 的 workspace
+        const discoveredDataDirs = new Set<string>();
 
         // ── 根据文件路径找到所属 workspace ────────────────────────────────
 
@@ -232,12 +236,14 @@ export default definePluginEntry({
         // ── 注册单个 workspace ───────────────────────────────────────────
 
         const registerWorkspace = async (wsDir: string, wsAgentId: string): Promise<void> => {
-          if (registeredWorkspaces.has(wsDir)) return;
+          const realDir = await fs.promises.realpath(wsDir).catch(() => wsDir);
+          if (registeredRealPaths.has(realDir)) return;
+          registeredRealPaths.add(realDir);
 
-          registeredWorkspaces.set(wsDir, { dir: wsDir, agentId: wsAgentId });
+          registeredWorkspaces.set(realDir, { dir: realDir, agentId: wsAgentId });
 
-          // 监听 MEMORY.md
-          const memoryMdPath = path.join(wsDir, "MEMORY.md");
+          // 监听 MEMORY.md（使用真实路径，确保 symlink 场景下 fs.watch 正常工作）
+          const memoryMdPath = path.join(realDir, "MEMORY.md");
           try {
             await fs.promises.writeFile(memoryMdPath, "", { flag: "a" });
             fs.watch(memoryMdPath, (eventType) => {
@@ -260,64 +266,121 @@ export default definePluginEntry({
         // ── 扫描所有 workspace 目录 ──────────────────────────────────────
 
         const scanWorkspaces = async (): Promise<void> => {
+          // 1. 扫描 openclawDir（处理 symlink 和物理目录）
           try {
             const entries = await fs.promises.readdir(openclawDir, {
               withFileTypes: true,
             });
             for (const entry of entries) {
-              if (!entry.isDirectory()) continue;
+              if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
               const name = entry.name;
+              if (name !== "workspace" && !name.startsWith("workspace-")) continue;
 
-              if (name === "workspace" || name.startsWith("workspace-")) {
-                const wsDir = path.join(openclawDir, name);
-                const wsAgentId = resolveAgentId(name);
-                await registerWorkspace(wsDir, wsAgentId);
+              const wsDir = path.join(openclawDir, name);
+
+              if (entry.isSymbolicLink()) {
+                try {
+                  const stat = await fs.promises.stat(wsDir);
+                  if (!stat.isDirectory()) continue;
+                  const realTarget = await fs.promises.realpath(wsDir);
+                  discoveredDataDirs.add(path.dirname(realTarget));
+                } catch {
+                  continue;
+                }
               }
+
+              const wsAgentId = resolveAgentId(name);
+              await registerWorkspace(wsDir, wsAgentId);
             }
           } catch (err) {
             api.logger.warn(
               `memory-gateway-sync: 扫描 workspace 失败: ${String(err)}`
             );
           }
+
+          // 2. 扫描从 symlink 目标发现的数据目录，找到未建立 symlink 的 workspace
+          for (const dataDir of discoveredDataDirs) {
+            if (dataDir === openclawDir) continue;
+            try {
+              const entries = await fs.promises.readdir(dataDir, {
+                withFileTypes: true,
+              });
+              for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                const name = entry.name;
+                if (name !== "workspace" && !name.startsWith("workspace-")) continue;
+
+                const wsDir = path.join(dataDir, name);
+                const wsAgentId = resolveAgentId(name);
+                await registerWorkspace(wsDir, wsAgentId);
+              }
+            } catch (err) {
+              api.logger.warn(
+                `memory-gateway-sync: 扫描数据目录 ${dataDir} 失败: ${String(err)}`
+              );
+            }
+          }
         };
 
-        // ── 监听 .openclaw/ 目录，动态感知新 workspace ──────────────────
+        // ── 监听目录变化，动态感知新 workspace ─────────────────────────
 
-        try {
-          fs.watch(openclawDir, async (eventType, filename) => {
-            if (!filename) return;
-            if (
-              filename !== "workspace" &&
-              !filename.startsWith("workspace-")
-            ) {
-              return;
-            }
+        const watchDirForWorkspaces = (dir: string): void => {
+          try {
+            fs.watch(dir, async (eventType, filename) => {
+              if (!filename) return;
+              if (
+                filename !== "workspace" &&
+                !filename.startsWith("workspace-")
+              ) {
+                return;
+              }
 
-            const wsDir = path.join(openclawDir, filename);
+              const wsDir = path.join(dir, filename);
+
+              try {
+                const stat = await fs.promises.stat(wsDir);
+                if (!stat.isDirectory()) return;
+
+                const realDir = await fs.promises.realpath(wsDir).catch(() => wsDir);
+                if (registeredRealPaths.has(realDir)) return;
 
-            try {
-              const stat = await fs.promises.stat(wsDir);
-              if (stat.isDirectory() && !registeredWorkspaces.has(wsDir)) {
                 const wsAgentId = resolveAgentId(filename);
                 api.logger.info(
-                  `memory-gateway-sync: 发现新 workspace → ${filename} (agentId=${wsAgentId})`
+                  `memory-gateway-sync: 发现新 workspace → ${filename} (agentId=${wsAgentId}) in ${dir}`
                 );
                 await registerWorkspace(wsDir, wsAgentId);
+
+                // 如果是 symlink，也发现其数据目录并监听
+                const parentDir = path.dirname(realDir);
+                if (!discoveredDataDirs.has(parentDir) && parentDir !== openclawDir) {
+                  discoveredDataDirs.add(parentDir);
+                  watchDirForWorkspaces(parentDir);
+                }
+              } catch {
+                // 目录不存在或已删除，忽略
               }
-            } catch {
-              // 目录不存在或已删除，忽略
-            }
-          });
-        } catch (err) {
-          api.logger.warn(
-            `memory-gateway-sync: 无法监听 ${openclawDir}: ${String(err)}`
-          );
-        }
+            });
+          } catch (err) {
+            api.logger.warn(
+              `memory-gateway-sync: 无法监听 ${dir}: ${String(err)}`
+            );
+          }
+        };
+
+        // 监听 openclawDir（在 scan 之前注册，不会遗漏 scan 期间创建的目录）
+        watchDirForWorkspaces(openclawDir);
 
         // ── 启动：扫描所有已有 workspace ─────────────────────────────────
 
         await scanWorkspaces();
 
+        // 监听从 symlink 发现的数据目录（scan 之后才有 discoveredDataDirs）
+        for (const dataDir of discoveredDataDirs) {
+          if (dataDir !== openclawDir) {
+            watchDirForWorkspaces(dataDir);
+          }
+        }
+
         const wsCount = registeredWorkspaces.size;
         const wsIds = Array.from(registeredWorkspaces.values())
           .map((w) => w.agentId)