@sunnoy/wecom 2.1.0 → 2.2.0

package/wecom/reqid-store.js

@@ -0,0 +1,146 @@
+import path from "node:path";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { logger } from "../logger.js";
+import { REQID_TTL_MS, REQID_MAX_SIZE, REQID_FLUSH_DEBOUNCE_MS } from "./constants.js";
+import { resolveStateDir } from "./openclaw-compat.js";
+
+function getStorePath(accountId) {
+  return path.join(resolveStateDir(), "wecomConfig", `reqids-${accountId}.json`);
+}
+
+async function readJsonFile(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+async function writeJsonFileAtomically(filePath, value) {
+  const dir = path.dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  await rename(tempPath, filePath);
+}
+
+export function createPersistentReqIdStore(accountId, options = {}) {
+  const maxSize = options.maxSize ?? REQID_MAX_SIZE;
+  const ttlMs = options.ttlMs ?? REQID_TTL_MS;
+  const debounceMs = options.debounceMs ?? REQID_FLUSH_DEBOUNCE_MS;
+  const storePath = options.storePath ?? getStorePath(accountId);
+  const writeJson = options.writeJsonFileAtomically ?? writeJsonFileAtomically;
+  const cache = new Map();
+  let dirty = false;
+  let dirtyVersion = 0;
+  let flushTimer = null;
+  let flushPromise = null;
+
+  function evictOldest() {
+    if (cache.size <= maxSize) return;
+    const entries = [...cache.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+    const toRemove = entries.length - maxSize;
+    for (let i = 0; i < toRemove; i++) {
+      cache.delete(entries[i][0]);
+    }
+  }
+
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(async () => {
+      flushTimer = null;
+      try {
+        await store.flush();
+      } catch (error) {
+        logger.warn(`[ReqIdStore:${accountId}] Debounced flush failed: ${error.message}`);
+      }
+    }, debounceMs);
+  }
+
+  const store = {
+    set(chatId, reqId) {
+      cache.set(chatId, { reqId, updatedAt: Date.now() });
+      dirty = true;
+      dirtyVersion += 1;
+      evictOldest();
+      scheduleFlush();
+    },
+
+    getSync(chatId) {
+      const entry = cache.get(chatId);
+      if (!entry) return undefined;
+      if (Date.now() - entry.updatedAt > ttlMs) {
+        cache.delete(chatId);
+        return undefined;
+      }
+      return entry.reqId;
+    },
+
+    async warmup() {
+      try {
+        const data = await readJsonFile(storePath);
+        const now = Date.now();
+        for (const [chatId, entry] of Object.entries(data)) {
+          if (entry?.reqId && entry?.updatedAt && now - entry.updatedAt <= ttlMs) {
+            cache.set(chatId, entry);
+          }
+        }
+        evictOldest();
+        logger.info(`[ReqIdStore:${accountId}] Warmed up ${cache.size} entries from ${storePath}`);
+      } catch (error) {
+        logger.warn(`[ReqIdStore:${accountId}] Warmup failed (non-fatal): ${error.message}`);
+      }
+    },
+
+    async flush() {
+      if (flushPromise) {
+        await flushPromise;
+        if (!dirty) return;
+      }
+      if (!dirty) return;
+      const currentFlush = (async () => {
+        const snapshot = Object.fromEntries(cache);
+        const snapshotVersion = dirtyVersion;
+        try {
+          await writeJson(storePath, snapshot);
+          if (dirtyVersion === snapshotVersion) {
+            dirty = false;
+          } else {
+            scheduleFlush();
+          }
+          logger.debug(`[ReqIdStore:${accountId}] Flushed ${cache.size} entries to disk`);
+        } catch (error) {
+          // Keep dirty = true so a subsequent set() or scheduled flush can retry
+          logger.warn(`[ReqIdStore:${accountId}] Flush failed, will retry on next trigger: ${error.message}`);
+          scheduleFlush();
+        }
+      })();
+      flushPromise = currentFlush;
+      try {
+        await currentFlush;
+      } finally {
+        if (flushPromise === currentFlush) {
+          flushPromise = null;
+        }
+      }
+    },
+
+    destroy() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+    },
+
+    get size() {
+      return cache.size;
+    },
+  };
+
+  return store;
+}
+
+export const reqIdStoreTesting = {
+  getStorePath,
+};

package/wecom/workspace-template.js

@@ -1,4 +1,13 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { logger } from "../logger.js";
@@ -19,8 +28,10 @@ function expandTilde(p) {
 
 // --- mtime caches for force-reseed ---
 const _templateMtimeCache = new Map();   // templateDir → { maxMtimeMs, checkedAt }
-const _agentSeedMtimeCache = new Map();  // `${templateDir}::${agentId}` → maxMtimeMs
 const TEMPLATE_MTIME_CACHE_TTL_MS = 60_000;
+const TEMPLATE_STATE_DIRNAME = ".openclaw";
+const TEMPLATE_STATE_FILENAME = "wecom-template-state.json";
+const TEMPLATE_STATE_VERSION = 1;
 
 function getTemplateMaxMtimeMs(templateDir) {
   const now = Date.now();
@@ -43,7 +54,7 @@ function getTemplateMaxMtimeMs(templateDir) {
 
 export function clearTemplateMtimeCache({ agentSeedCache = true } = {}) {
   _templateMtimeCache.clear();
-  if (agentSeedCache) _agentSeedMtimeCache.clear();
+  void agentSeedCache;
 }
 
 /**
@@ -67,9 +78,76 @@ export function getWorkspaceTemplateDir(config) {
   return config?.channels?.wecom?.workspaceTemplate?.trim() || null;
 }
 
+function hasWorkspaceMemoryMarkers(workspaceDir) {
+  return existsSync(join(workspaceDir, "memory")) || existsSync(join(workspaceDir, "MEMORY.md"));
+}
+
+function resolveTemplateStatePath(workspaceDir) {
+  return join(workspaceDir, TEMPLATE_STATE_DIRNAME, TEMPLATE_STATE_FILENAME);
+}
+
+function readTemplateState(workspaceDir) {
+  const statePath = resolveTemplateStatePath(workspaceDir);
+  if (!existsSync(statePath)) {
+    return null;
+  }
+
+  try {
+    const raw = readFileSync(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+
+    return {
+      version: parsed.version,
+      seededAt: typeof parsed.seededAt === "string" ? parsed.seededAt : null,
+      templateDir: typeof parsed.templateDir === "string" ? parsed.templateDir : null,
+      seededFiles: Array.isArray(parsed.seededFiles)
+        ? parsed.seededFiles.filter((file) => typeof file === "string")
+        : [],
+      templateMtimeMs:
+        typeof parsed.templateMtimeMs === "number" && Number.isFinite(parsed.templateMtimeMs)
+          ? parsed.templateMtimeMs
+          : null,
+      migratedFromLegacy: parsed.migratedFromLegacy === true,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function writeTemplateState(workspaceDir, state) {
+  const statePath = resolveTemplateStatePath(workspaceDir);
+  const stateDir = join(workspaceDir, TEMPLATE_STATE_DIRNAME);
+  mkdirSync(stateDir, { recursive: true });
+
+  const payload = `${JSON.stringify(
+    {
+      version: TEMPLATE_STATE_VERSION,
+      seededAt: state.seededAt,
+      templateDir: state.templateDir,
+      seededFiles: [...new Set(state.seededFiles)].sort(),
+      templateMtimeMs: state.templateMtimeMs,
+      migratedFromLegacy: state.migratedFromLegacy === true,
+    },
+    null,
+    2,
+  )}\n`;
+  const tmpPath = `${statePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  writeFileSync(tmpPath, payload, "utf8");
+  renameSync(tmpPath, statePath);
+}
+
+function collectExistingSeededFiles(workspaceDir, templateFiles) {
+  return templateFiles.filter((file) => existsSync(join(workspaceDir, file)));
+}
+
 /**
- * Copy template files into a newly created agent's workspace directory.
- * Only copies files that don't already exist (writeFileIfMissing semantics).
+ * Copy selected template files into a dynamic agent workspace.
+ * BOOTSTRAP.md may be synced only before user memory markers appear; once the
+ * workspace has memory/ or MEMORY.md, bootstrap is treated as completed and is
+ * never re-seeded by the plugin.
  * Silently skips if workspaceTemplate is not configured or directory is missing.
  *
  * @param {string} agentId
@@ -89,33 +167,38 @@ export function seedAgentWorkspace(agentId, config, overrideTemplateDir) {
   }
 
   const workspaceDir = resolveAgentWorkspaceDirLocal(agentId);
+  const workspaceExistedBefore = existsSync(workspaceDir);
 
   try {
     const templateMaxMtimeMs = getTemplateMaxMtimeMs(templateDir);
-    const cacheKey = `${templateDir}::${agentId}`;
-    const lastSyncedMtimeMs = _agentSeedMtimeCache.get(cacheKey) ?? 0;
-    const isFirstSeed = lastSyncedMtimeMs === 0;
+    mkdirSync(workspaceDir, { recursive: true });
 
-    if (templateMaxMtimeMs <= lastSyncedMtimeMs && existsSync(workspaceDir)) {
-      return;
-    }
+    const templateFiles = readdirSync(templateDir).filter((file) => BOOTSTRAP_FILENAMES.has(file));
+    let state = readTemplateState(workspaceDir);
+    const isLegacyWorkspace = !state && workspaceExistedBefore;
+    const isFirstSeed = !state && !workspaceExistedBefore;
 
-    mkdirSync(workspaceDir, { recursive: true });
+    if (!state) {
+      state = {
+        version: TEMPLATE_STATE_VERSION,
+        seededAt: new Date().toISOString(),
+        templateDir,
+        seededFiles: isLegacyWorkspace ? collectExistingSeededFiles(workspaceDir, templateFiles) : [],
+        templateMtimeMs: templateMaxMtimeMs,
+        migratedFromLegacy: isLegacyWorkspace,
+      };
+    }
 
-    const files = readdirSync(templateDir);
-    for (const file of files) {
-      if (!BOOTSTRAP_FILENAMES.has(file)) {
+    const bootstrapAllowed = !hasWorkspaceMemoryMarkers(workspaceDir);
+    for (const file of templateFiles) {
+      if (file === "BOOTSTRAP.md" && !bootstrapAllowed) {
         continue;
       }
       const src = join(templateDir, file);
       const dest = join(workspaceDir, file);
       if (existsSync(dest)) {
         if (!isFirstSeed) {
-          const srcMtimeMs = statSync(src).mtimeMs;
-          const destMtimeMs = statSync(dest).mtimeMs;
-          if (srcMtimeMs <= destMtimeMs) {
-            continue;
-          }
+          continue;
         }
         copyFileSync(src, dest);
         logger.info("WeCom: re-seeded workspace file", { agentId, file, isFirstSeed });
@@ -123,9 +206,12 @@ export function seedAgentWorkspace(agentId, config, overrideTemplateDir) {
         copyFileSync(src, dest);
         logger.info("WeCom: seeded workspace file", { agentId, file });
       }
+      state.seededFiles.push(file);
     }
 
-    _agentSeedMtimeCache.set(cacheKey, templateMaxMtimeMs);
+    state.templateDir = templateDir;
+    state.templateMtimeMs = templateMaxMtimeMs;
+    writeTemplateState(workspaceDir, state);
   } catch (err) {
     logger.warn("WeCom: failed to seed agent workspace", {
       agentId,