@memtensor/memos-cloud-openclaw-plugin 0.1.11 → 0.1.12-beta.0

package/lib/arms-reporter.js

@@ -0,0 +1,116 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const ARMS_ENDPOINT = "https://proj-xtrace-e218d9316b328f196a3c640cc7ca84-cn-hangzhou.cn-hangzhou.log.aliyuncs.com/rum/web/v2?workspace=default-cms-1026429231103299-cn-hangzhou&service_id=a3u72ukxmr@bed68dd882dd823439015"
+const ARMS_PID = "a3u72ukxmr@c42a249fb14f4d9";
+const ARMS_ENV = "prod";
+const ARMS_UID_FILE = new URL("../.memos_arms_uid", import.meta.url);
+
+let armsUidCache = "";
+
+function readUidFromFile() {
+  try {
+    return readFileSync(ARMS_UID_FILE, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+
+function writeUidToFile(value) {
+  try {
+    writeFileSync(ARMS_UID_FILE, `${value}\n`, { mode: 0o600 });
+  } catch {}
+}
+
+function createEventId() {
+  const traceId = randomBytes(16).toString("hex");
+  const spanId = randomBytes(8).toString("hex");
+  return `00-${traceId}-${spanId}`;
+}
+
+function readOpenClawDeviceId(log) {
+  try {
+    const deviceFile = join(homedir(), ".openclaw", "identity", "device.json");
+    const content = readFileSync(deviceFile, "utf-8");
+    const data = JSON.parse(content);
+    if (data && typeof data.deviceId === "string" && data.deviceId.trim()) {
+      return `uid_${data.deviceId.trim()}`;
+    }
+  } catch (err) {
+    log?.warn?.(`[memos-cloud] Failed to read OpenClaw deviceId: ${String(err)}`);
+  }
+  return "";
+}
+
+function loadArmsUid(log) {
+  if (armsUidCache) return armsUidCache;
+
+  const openclawDevice = readOpenClawDeviceId(log);
+  if (openclawDevice) {
+    armsUidCache = openclawDevice;
+    writeUidToFile(armsUidCache);
+    return armsUidCache;
+  }
+
+  const fromUidFile = readUidFromFile();
+  if (fromUidFile) {
+    armsUidCache = fromUidFile;
+    return armsUidCache;
+  }
+
+  armsUidCache = `uid_${randomUUID()}`;
+  writeUidToFile(armsUidCache);
+  return armsUidCache;
+}
+
+function buildPayload(ctx, eventName, payload, log) {
+  return {
+    app: {
+      id: ARMS_PID,
+      env: ARMS_ENV,
+      type: "node",
+    },
+    user: { id: loadArmsUid(log) },
+    session: { id: ctx.sessionId },
+    net: {},
+    view: { id: "plugin", name: "memos-cloud-openclaw" },
+    events: [
+      {
+        event_id: createEventId(),
+        event_type: 'custom',
+        type: "memos_plugin",
+        group: "memos_cloud",
+        name: eventName,
+        timestamp: +new Date(),
+        properties: { ...payload }
+      }
+    ]
+  };
+}
+
+export async function reportRumEvent(eventName, payload, cfg, ctx, log) {
+  if (!cfg.rumEnabled) return;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(),
+    Number.isFinite(cfg.rumTimeoutMs) ? Math.max(1000, cfg.rumTimeoutMs) : 3000,
+  );
+  try {
+    const body = buildPayload(ctx, eventName, payload, log);
+    const res = await fetch(ARMS_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "text/plain" },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}`);
+    }
+  } catch (err) {
+    log.warn?.(`[memos-cloud] RUM report failed: ${String(err)}`);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

package/lib/check-update.js

@@ -1,270 +1,187 @@
-import https from "https";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { spawn, exec } from "child_process";
-import os from "os";
-
-/**
- * Kill a spawned child process and its entire process tree.
- */
-function killProcessTree(child) {
-  try {
-    if (process.platform === "win32") {
-      exec(`taskkill /pid ${child.pid} /T /F`, () => {});
-    } else {
-      // On Unix, kill the process group
-      process.kill(-child.pid, "SIGKILL");
-    }
-  } catch (e) {
-    // Fallback: try the basic kill
-    try { child.kill("SIGKILL"); } catch (_) {}
-  }
-}
-
-let isUpdating = false;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const CHECK_INTERVAL = 12 * 60 * 60 * 1000; // 12 hours check interval
-const UPDATE_TIMEOUT = 3 * 60 * 1000; // 3 minutes timeout for the CLI update command to finish
-const PLUGIN_NAME = "@memtensor/memos-cloud-openclaw-plugin";
-const CHECK_FILE = path.join(os.tmpdir(), "memos_openclaw_update_check.json");
-
-const ANSI = {
-  RESET: "\x1b[0m",
-  GREEN: "\x1b[32m",
-  YELLOW: "\x1b[33m",
-  CYAN: "\x1b[36m",
-  RED: "\x1b[31m"
-};
-
-
-function getPackageVersion() {
-  try {
-    const pkgPath = path.join(__dirname, "..", "package.json");
-    const pkgData = fs.readFileSync(pkgPath, "utf-8");
-    const pkg = JSON.parse(pkgData);
-    return pkg.version;
-  } catch (err) {
-    return null;
-  }
-}
-
-function getLatestVersion(log) {
-  return new Promise((resolve, reject) => {
-    const req = https.get(
-      `https://registry.npmjs.org/${PLUGIN_NAME}/latest`,
-      { timeout: 5000 },
-      (res) => {
-        if (res.statusCode !== 200) {
-          req.destroy();
-          return reject(new Error(`Failed to fetch version, status: ${res.statusCode}`));
-        }
-
-        let body = "";
-        res.on("data", (chunk) => {
-          body += chunk;
-        });
-
-        res.on("end", () => {
-          try {
-            const data = JSON.parse(body);
-            resolve(data.version);
-          } catch (err) {
-            reject(err);
-          }
-        });
-      }
-    );
-
-    req.on("error", (err) => {
-      reject(err);
-    });
-
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Timeout getting latest version"));
-    });
-  });
-}
-
-function compareVersions(v1, v2) {
-  // Split pre-release tags (e.g. 0.1.8-beta.1 -> "0.1.8" and "beta.1")
-  const split1 = v1.split("-");
-  const split2 = v2.split("-");
-  const parts1 = split1[0].split(".").map(Number);
-  const parts2 = split2[0].split(".").map(Number);
-  
-  // Compare major.minor.patch
-  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-    const p1 = parts1[i] || 0;
-    const p2 = parts2[i] || 0;
-    if (p1 > p2) return 1;
-    if (p1 < p2) return -1;
-  }
-  
-  // If base versions are equal, compare pre-release tags.
-  // A version WITH a pre-release tag is LOWER than a version WITHOUT one.
-  // e.g. 0.1.8-beta is less than 0.1.8. 0.1.8 is the final release.
-  const hasPre1 = split1.length > 1;
-  const hasPre2 = split2.length > 1;
-  
-  if (hasPre1 && !hasPre2) return -1; // v1 is a beta, v2 is a full release
-  if (!hasPre1 && hasPre2) return 1;  // v1 is a full release, v2 is a beta
-  if (!hasPre1 && !hasPre2) return 0; // both are full releases and equal
-  
-  // If both are pre-releases, do a basic string compare on the tag
-  // "alpha" < "beta" < "rc"
-  if (split1[1] > split2[1]) return 1;
-  if (split1[1] < split2[1]) return -1;
-  
-  return 0;
-}
-
-export function startUpdateChecker(log) {
-  // Only start the interval if we are in the gateway
-  const isGateway = process.argv.includes("gateway");
-  if (!isGateway) {
-    return;
-  }
-
-  const runCheck = async () => {
-    if (isUpdating) {
-      log.info?.(`${ANSI.YELLOW}[memos-cloud] An update sequence is currently in progress, skipping this check.${ANSI.RESET}`);
-      return;
-    }
-
-    // TRULY PREVENT LOOPS: The instant we start a check, record the time BEFORE any network or processing happens.
-    // This absolutely guarantees that even if the network hangs, NPM crashes, or openclaw update causes an immediate hot reload,
-    // the system has already advanced the 12-hour/1-min clock and will NOT re-enter this function on boot.
-    try {
-      fs.writeFileSync(CHECK_FILE, JSON.stringify({ time: Date.now() }));
-    } catch (e) {
-      log.warn?.(`${ANSI.RED}[memos-cloud] Failed to write timestamp file: ${e.message}${ANSI.RESET}`);
-    }
-
-    const currentVersion = getPackageVersion();
-    if (!currentVersion) {
-      log.warn?.(`${ANSI.RED}[memos-cloud] Could not read current version from package.json${ANSI.RESET}`);
-      return;
-    }
-
-    try {
-      const latestVersion = await getLatestVersion(log);
-
-      // Normal version check
-      if (compareVersions(latestVersion, currentVersion) <= 0) {
-        return;
-      }
-
-      log.info?.(`${ANSI.YELLOW}[memos-cloud] Update available: ${currentVersion} -> ${latestVersion}. Updating in background...${ANSI.RESET}`);
-
-      let dotCount = 0;
-      const progressInterval = setInterval(() => {
-        dotCount++;
-        const dots = ".".repeat(dotCount % 4);
-        log.info?.(`${ANSI.YELLOW}[memos-cloud] Update in progress for memos-cloud-openclaw-plugin${dots}${ANSI.RESET}`);
-      }, 30000); // Log every 30 seconds to show it's still alive without spamming
-
-      const cliName = (() => {
-        // Check the full path of the entry script (e.g., .../moltbot/bin/index.js) or the executable
-        const scriptPath = process.argv[1] ? process.argv[1].toLowerCase() : "";
-        const execPath = process.execPath ? process.execPath.toLowerCase() : "";
-
-        if (scriptPath.includes("moltbot") || execPath.includes("moltbot")) return "moltbot";
-        if (scriptPath.includes("clawdbot") || execPath.includes("clawdbot")) return "clawdbot";
-        return "openclaw";
-      })();
-
-      isUpdating = true;
-      const spawnOpts = { shell: true };
-      // On Unix, detach the process so we can kill the entire process group on timeout
-      if (process.platform !== "win32") {
-        spawnOpts.detached = true;
-      }
-      const child = spawn(cliName, ["plugins", "update", "memos-cloud-openclaw-plugin"], spawnOpts);
-
-      // Timeout mechanism: forcefully kill the update process if it hangs for more than the configured timeout
-      const updateTimeout = setTimeout(() => {
-        log.warn?.(`${ANSI.RED}[memos-cloud] Update process timed out. Please try manually running: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`);
-        killProcessTree(child);
-
-        // Fallback: if kill failed and the close event never fires, forcefully release the lock after 5 seconds
-        setTimeout(() => {
-          if (isUpdating) {
-            clearInterval(progressInterval);
-            isUpdating = false;
-          }
-        }, 5000);
-      }, UPDATE_TIMEOUT);
-
-      child.stdout.on("data", (data) => {
-        const outText = data.toString();
-        log.info?.(`${ANSI.CYAN}[${cliName}-cli]${ANSI.RESET}\n${outText.trim()}`);
-        
-        // Auto-reply to any [y/N] prompts from the CLI
-        if (outText.toLowerCase().includes("[y/n]")) {
-          child.stdin.write("y\n");
-        }
-      });
-
-      child.stderr.on("data", (data) => {
-        const errText = data.toString();
-        log.warn?.(`${ANSI.RED}[${cliName}-cli]${ANSI.RESET}\n${errText.trim()}`);
-        
-        // Some CLIs output interactive prompts to stderr instead of stdout
-        if (errText.toLowerCase().includes("[y/n]")) {
-          child.stdin.write("y\n");
-        }
-      });
-
-      child.on("close", (code) => {
-        clearTimeout(updateTimeout);
-        clearInterval(progressInterval);
-        isUpdating = false;
-
-        // Wait for a brief moment to let file system sync if needed
-        setTimeout(() => {
-          const postUpdateVersion = getPackageVersion();
-          const actuallyUpdated = (postUpdateVersion === latestVersion) && (postUpdateVersion !== currentVersion);
-
-          if (code !== 0 || !actuallyUpdated) {
-            log.warn?.(`${ANSI.RED}[memos-cloud] Auto-update failed or version did not change. Please refer to the CLI logs above, or run manually: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`);
-          } else {
-            log.info?.(`${ANSI.GREEN}[memos-cloud] Successfully updated to version ${latestVersion}. Please restart the gateway to apply changes.${ANSI.RESET}`);
-          }
-        }, 1000); // Small 1-second buffer for file systems
-      });
-
-    } catch (error) {
-      log.warn?.(`${ANSI.RED}[memos-cloud] Update check failed entirely: ${error.message}${ANSI.RESET}`);
-    }
-  };
-
-  // Check when we last ran
-  let lastCheckTime = 0;
-  try {
-    if (fs.existsSync(CHECK_FILE)) {
-      const data = JSON.parse(fs.readFileSync(CHECK_FILE, "utf-8"));
-      lastCheckTime = data.time || 0;
-    }
-  } catch (e) {}
-
-  const now = Date.now();
-  const timeSinceLastCheck = now - lastCheckTime;
-
-  // If the interval has passed, run it IMMEDIATELY without delay.
-  // The immediate file-write at the top of runCheck() will prevent loop scenarios.
-  if (timeSinceLastCheck >= CHECK_INTERVAL) {
-    runCheck();
-    setInterval(runCheck, CHECK_INTERVAL);
-  } else {
-    // If it hasn't been the full interval yet, wait the remaining time, then trigger interval
-    const timeUntilNextCheck = CHECK_INTERVAL - timeSinceLastCheck;
-    setTimeout(() => {
-      runCheck();
-      setInterval(runCheck, CHECK_INTERVAL);
-    }, timeUntilNextCheck);
-  }
-}
+import https from "https";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import os from "os";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const CHECK_INTERVAL = 12 * 60 * 60 * 1000; // 12 hours check interval
+const PLUGIN_NAME = "@memtensor/memos-cloud-openclaw-plugin";
+const CHECK_FILE = path.join(os.tmpdir(), "memos_openclaw_update_check.json");
+
+const ANSI = {
+  RESET: "\x1b[0m",
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  CYAN: "\x1b[36m",
+  RED: "\x1b[31m"
+};
+
+
+function getPackageVersion() {
+  try {
+    const pkgPath = path.join(__dirname, "..", "package.json");
+    const pkgData = fs.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgData);
+    return pkg.version;
+  } catch (err) {
+    return null;
+  }
+}
+
+function getLatestVersion(log) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(
+      `https://registry.npmjs.org/${PLUGIN_NAME}/latest`,
+      { timeout: 5000 },
+      (res) => {
+        if (res.statusCode !== 200) {
+          req.destroy();
+          return reject(new Error(`Failed to fetch version, status: ${res.statusCode}`));
+        }
+
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+
+        res.on("end", () => {
+          try {
+            const data = JSON.parse(body);
+            resolve(data.version);
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+    );
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Timeout getting latest version"));
+    });
+  });
+}
+
+function compareVersions(v1, v2) {
+  // Split pre-release tags (e.g. 0.1.8-beta.1 -> "0.1.8" and "beta.1")
+  const split1 = v1.split("-");
+  const split2 = v2.split("-");
+  const parts1 = split1[0].split(".").map(Number);
+  const parts2 = split2[0].split(".").map(Number);
+  
+  // Compare major.minor.patch
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 > p2) return 1;
+    if (p1 < p2) return -1;
+  }
+  
+  // If base versions are equal, compare pre-release tags.
+  // A version WITH a pre-release tag is LOWER than a version WITHOUT one.
+  // e.g. 0.1.8-beta is less than 0.1.8. 0.1.8 is the final release.
+  const hasPre1 = split1.length > 1;
+  const hasPre2 = split2.length > 1;
+  
+  if (hasPre1 && !hasPre2) return -1; // v1 is a beta, v2 is a full release
+  if (!hasPre1 && hasPre2) return 1;  // v1 is a full release, v2 is a beta
+  if (!hasPre1 && !hasPre2) return 0; // both are full releases and equal
+  
+  // If both are pre-releases, do a basic string compare on the tag
+  // "alpha" < "beta" < "rc"
+  if (split1[1] > split2[1]) return 1;
+  if (split1[1] < split2[1]) return -1;
+  
+  return 0;
+}
+
+export function startUpdateChecker(log) {
+  // Only start the interval if we are in the gateway
+  const isGateway = process.argv.includes("gateway");
+  if (!isGateway) {
+    return;
+  }
+
+  const runCheck = async () => {
+    // TRULY PREVENT LOOPS: The instant we start a check, record the time BEFORE any network or processing happens.
+    // This absolutely guarantees that even if the network hangs, NPM crashes, or openclaw update causes an immediate hot reload,
+    // the system has already advanced the 12-hour/1-min clock and will NOT re-enter this function on boot.
+    try {
+      fs.writeFileSync(CHECK_FILE, JSON.stringify({ time: Date.now() }));
+    } catch (e) {
+      log.warn?.(`${ANSI.RED}[memos-cloud] Failed to write timestamp file: ${e.message}${ANSI.RESET}`);
+    }
+
+    const currentVersion = getPackageVersion();
+    if (!currentVersion) {
+      log.warn?.(`${ANSI.RED}[memos-cloud] Could not read current version from package.json${ANSI.RESET}`);
+      return;
+    }
+
+    try {
+      const latestVersion = await getLatestVersion(log);
+
+      // Normal version check
+      if (compareVersions(latestVersion, currentVersion) <= 0) {
+        return;
+      }
+
+      const cliName = (() => {
+        // Check the full path of the entry script (e.g., .../moltbot/bin/index.js) or the executable
+        const scriptPath = process.argv[1] ? process.argv[1].toLowerCase() : "";
+        const execPath = process.execPath ? process.execPath.toLowerCase() : "";
+
+        if (scriptPath.includes("moltbot") || execPath.includes("moltbot")) return "moltbot";
+        if (scriptPath.includes("clawdbot") || execPath.includes("clawdbot")) return "clawdbot";
+        return "openclaw";
+      })();
+
+      const border = "=".repeat(64);
+      log.info?.("");
+      log.info?.(`${ANSI.GREEN}${border}${ANSI.RESET}`);
+      log.info?.(`${ANSI.YELLOW}🚀 [memos-cloud] NEW VERSION AVAILABLE!${ANSI.RESET}`);
+      log.info?.(`${ANSI.CYAN}📦 Current version : ${currentVersion}${ANSI.RESET}`);
+      log.info?.(`${ANSI.GREEN}✨ Latest version  : ${latestVersion}${ANSI.RESET}`);
+      log.info?.(`${ANSI.CYAN}────────────────────────────────────────────────────────────────${ANSI.RESET}`);
+      log.info?.(`${ANSI.GREEN}Please run the following command to update manually:${ANSI.RESET}`);
+      log.info?.(`${ANSI.YELLOW}${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`);
+      log.info?.(`${ANSI.GREEN}${border}${ANSI.RESET}`);
+      log.info?.("");
+
+    } catch (error) {
+      log.warn?.(`${ANSI.RED}[memos-cloud] Update check failed entirely: ${error.message}${ANSI.RESET}`);
+    }
+  };
+
+  // Check when we last ran
+  let lastCheckTime = 0;
+  try {
+    if (fs.existsSync(CHECK_FILE)) {
+      const data = JSON.parse(fs.readFileSync(CHECK_FILE, "utf-8"));
+      lastCheckTime = data.time || 0;
+    }
+  } catch (e) {}
+
+  const now = Date.now();
+  const timeSinceLastCheck = now - lastCheckTime;
+
+  // If the interval has passed, run it IMMEDIATELY without delay.
+  // The immediate file-write at the top of runCheck() will prevent loop scenarios.
+  if (timeSinceLastCheck >= CHECK_INTERVAL) {
+    runCheck();
+    setInterval(runCheck, CHECK_INTERVAL);
+  } else {
+    // If it hasn't been the full interval yet, wait the remaining time, then trigger interval
+    const timeUntilNextCheck = CHECK_INTERVAL - timeSinceLastCheck;
+    setTimeout(() => {
+      runCheck();
+      setInterval(runCheck, CHECK_INTERVAL);
+    }, timeUntilNextCheck);
+  }
+}

package/lib/config-resolution-schema.js

@@ -0,0 +1,50 @@
+export const CONFIG_RESOLUTION_FIELDS = [
+  { key: "baseUrl", configMode: "truthy", envVar: "MEMOS_BASE_URL", envMode: "truthy", fallbackSource: "default", uiDefaultValue: "https://memos.memtensor.cn/api/openmem/v1" },
+  { key: "apiKey", configMode: "truthy", envVar: "MEMOS_API_KEY", envMode: "truthy", fallbackSource: "empty", inheritedFrom: "env", inheritedFallback: "" },
+  { key: "userId", configMode: "truthy", envVar: "MEMOS_USER_ID", envMode: "truthy", fallbackSource: "default", uiDefaultValue: "openclaw-user", inheritedFrom: "env", inheritedFallback: "openclaw-user" },
+  { key: "useDirectSessionUserId", configMode: "nullish", envVar: "MEMOS_USE_DIRECT_SESSION_USER_ID", envMode: "defined", fallbackSource: "default", uiDefaultValue: false },
+  { key: "conversationId", configMode: "truthy", envVar: "MEMOS_CONVERSATION_ID", envMode: "truthy", fallbackSource: "empty", inheritedFrom: "env", inheritedFallback: "" },
+  { key: "conversationIdPrefix", configMode: "nullish", envVar: "MEMOS_CONVERSATION_PREFIX", envMode: "defined", fallbackSource: "empty", inheritedFrom: "env", inheritedFallback: "" },
+  { key: "conversationIdSuffix", configMode: "nullish", envVar: "MEMOS_CONVERSATION_SUFFIX", envMode: "defined", fallbackSource: "empty", inheritedFrom: "env", inheritedFallback: "" },
+  { key: "conversationSuffixMode", configMode: "nullish", envVar: "MEMOS_CONVERSATION_SUFFIX_MODE", envMode: "truthy", fallbackSource: "default", uiDefaultValue: "none" },
+  { key: "resetOnNew", configMode: "nullish", envVar: "MEMOS_CONVERSATION_RESET_ON_NEW", envMode: "defined", fallbackSource: "default", uiDefaultValue: true },
+  { key: "queryPrefix", configMode: "nullish", envMode: "none", fallbackSource: "empty", inheritedValue: "" },
+  { key: "maxQueryChars", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 0 },
+  { key: "recallEnabled", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: true },
+  { key: "recallGlobal", configMode: "nullish", envVar: "MEMOS_RECALL_GLOBAL", envMode: "defined", fallbackSource: "default", uiDefaultValue: true },
+  { key: "maxItemChars", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 8000 },
+  { key: "memoryLimitNumber", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 9 },
+  { key: "preferenceLimitNumber", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 6 },
+  { key: "includePreference", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: true },
+  { key: "includeToolMemory", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: false },
+  { key: "toolMemoryLimitNumber", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 6 },
+  { key: "relativity", configMode: "nullish", envVar: "MEMOS_RELATIVITY", envMode: "defined", fallbackSource: "default", uiDefaultValue: 0.45 },
+  { key: "filter", configMode: "nullish", envMode: "none", fallbackSource: "empty", inheritedValue: undefined },
+  { key: "knowledgebaseIds", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: [] },
+  { key: "addEnabled", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: true },
+  { key: "captureStrategy", configMode: "nullish", envVar: "MEMOS_CAPTURE_STRATEGY", envMode: "truthy", fallbackSource: "default", uiDefaultValue: "last_turn" },
+  { key: "maxMessageChars", configMode: "nullish", envVar: "MEMOS_MAX_MESSAGE_CHARS", envMode: "defined", fallbackSource: "default", uiDefaultValue: 20000, inheritedFrom: "env", inheritedFallback: 20000 },
+  { key: "includeAssistant", configMode: "nullish", envVar: "MEMOS_INCLUDE_ASSISTANT", envMode: "defined", fallbackSource: "default", uiDefaultValue: true },
+  { key: "tags", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: ["openclaw"] },
+  { key: "info", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: {} },
+  { key: "asyncMode", configMode: "nullish", envVar: "MEMOS_ASYNC_MODE", envMode: "defined", fallbackSource: "default", uiDefaultValue: true },
+  { key: "agentId", configMode: "nullish", envMode: "none", fallbackSource: "empty", inheritedValue: undefined },
+  { key: "multiAgentMode", configMode: "nullish", envVar: "MEMOS_MULTI_AGENT_MODE", envMode: "defined", fallbackSource: "default", uiDefaultValue: false },
+  { key: "allowedAgents", configMode: "nullish", envVar: "MEMOS_ALLOWED_AGENTS", envMode: "defined", fallbackSource: "default", uiDefaultValue: [] },
+  { key: "agentOverrides", configKey: "agentOverrides", resolvedKey: "_agentOverrides", configMode: "nullish", envVar: "MEMOS_AGENT_OVERRIDES", envMode: "defined", fallbackSource: "default", uiDefaultValue: {} },
+  { key: "appId", configMode: "nullish", envMode: "none", fallbackSource: "empty", inheritedValue: undefined },
+  { key: "allowPublic", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: false },
+  { key: "allowKnowledgebaseIds", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: [] },
+  { key: "recallFilterEnabled", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_ENABLED", envMode: "defined", fallbackSource: "default", uiDefaultValue: false },
+  { key: "recallFilterBaseUrl", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_BASE_URL", envMode: "defined", fallbackSource: "empty" },
+  { key: "recallFilterApiKey", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_API_KEY", envMode: "defined", fallbackSource: "empty" },
+  { key: "recallFilterModel", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_MODEL", envMode: "defined", fallbackSource: "empty" },
+  { key: "recallFilterTimeoutMs", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_TIMEOUT_MS", envMode: "defined", fallbackSource: "default", uiDefaultValue: 6000 },
+  { key: "recallFilterRetries", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_RETRIES", envMode: "defined", fallbackSource: "default", uiDefaultValue: 0 },
+  { key: "recallFilterCandidateLimit", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_CANDIDATE_LIMIT", envMode: "defined", fallbackSource: "default", uiDefaultValue: 30 },
+  { key: "recallFilterMaxItemChars", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_MAX_ITEM_CHARS", envMode: "defined", fallbackSource: "default", uiDefaultValue: 500 },
+  { key: "recallFilterFailOpen", configMode: "nullish", envVar: "MEMOS_RECALL_FILTER_FAIL_OPEN", envMode: "defined", fallbackSource: "default", uiDefaultValue: true },
+  { key: "timeoutMs", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 5000 },
+  { key: "retries", configMode: "nullish", envMode: "none", fallbackSource: "default", uiDefaultValue: 1 },
+  { key: "throttleMs", configMode: "nullish", envVar: "MEMOS_THROTTLE_MS", envMode: "defined", fallbackSource: "default", uiDefaultValue: 0 },
+];