mr-memory 2.0.0 → 2.2.0

package/index.ts

@@ -1,88 +1,127 @@
 /**
- * MemoryRouter Plugin for OpenClaw (v2 — Relay Architecture)
+ * MemoryRouter Plugin for OpenClaw
  *
  * Persistent AI memory via MemoryRouter (memoryrouter.ai).
- * Uses OpenClaw's native plugin hooks (before_agent_start + agent_end)
- * to inject relevant memories and capture conversations.
+ * Uses before_agent_start + agent_end hooks to inject/store memories
+ * via the MemoryRouter relay API. No proxy interception needed.
  *
- * No patching required. Works with stock OpenClaw.
+ * BYOK — provider API keys never touch MemoryRouter.
  */
 
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
 import { spawn } from "node:child_process";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 
 const DEFAULT_ENDPOINT = "https://api.memoryrouter.ai";
 
+// Workspace files OpenClaw loads into the system prompt
+const WORKSPACE_FILES = [
+  "IDENTITY.md", "USER.md", "MEMORY.md", "HEARTBEAT.md",
+  "TOOLS.md", "AGENTS.md", "SOUL.md", "BOOTSTRAP.md",
+];
+
 type MemoryRouterConfig = {
   key: string;
   endpoint?: string;
-  density?: 'low' | 'high' | 'xhigh';
+  density?: "low" | "high" | "xhigh";
+  mode?: "relay" | "proxy";
 };
 
+// ──────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────
+
 function resolveOpenClawInvocation(): { command: string; args: string[] } {
   const entry = process.argv[1];
-  if (entry) {
-    return {
-      command: process.execPath,
-      args: [entry],
-    };
-  }
-
-  return {
-    command: "openclaw",
-    args: [],
-  };
+  if (entry) return { command: process.execPath, args: [entry] };
+  return { command: "openclaw", args: [] };
 }
 
 async function runOpenClawConfigSet(path: string, value: string, json = false): Promise<void> {
   const base = resolveOpenClawInvocation();
   const args = [...base.args, "config", "set", path, value];
-  if (json) {
-    args.push("--json");
-  }
+  if (json) args.push("--json");
 
   await new Promise<void>((resolve, reject) => {
     const child = spawn(base.command, args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env,
     });
-
     let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-
-    child.on("error", (err) => reject(err));
+    child.stderr.on("data", (chunk) => { stderr += String(chunk); });
+    child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-        return;
-      }
-      reject(new Error(`openclaw config set failed (exit ${code}): ${stderr.trim()}`));
+      if (code === 0) resolve();
+      else reject(new Error(`openclaw config set failed (exit ${code}): ${stderr.trim()}`));
     });
   });
 }
 
+type CompatApi = OpenClawPluginApi & {
+  updatePluginConfig?: (config: Record<string, unknown>) => Promise<void>;
+  updatePluginEnabled?: (enabled: boolean) => Promise<void>;
+};
+
 async function setPluginConfig(api: OpenClawPluginApi, config: Record<string, unknown>): Promise<void> {
-  const anyApi = api as any;
-  if (typeof anyApi.updatePluginConfig === "function") {
-    await anyApi.updatePluginConfig(config);
+  const compat = api as CompatApi;
+  if (typeof compat.updatePluginConfig === "function") {
+    await compat.updatePluginConfig(config);
     return;
   }
-
   await runOpenClawConfigSet(`plugins.entries.${api.id}.config`, JSON.stringify(config), true);
 }
 
 async function setPluginEnabled(api: OpenClawPluginApi, enabled: boolean): Promise<void> {
-  const anyApi = api as any;
-  if (typeof anyApi.updatePluginEnabled === "function") {
-    await anyApi.updatePluginEnabled(enabled);
+  const compat = api as CompatApi;
+  if (typeof compat.updatePluginEnabled === "function") {
+    await compat.updatePluginEnabled(enabled);
     return;
   }
-
   await runOpenClawConfigSet(`plugins.entries.${api.id}.enabled`, enabled ? "true" : "false", true);
 }
 
+/**
+ * Read all workspace files and return as a single text blob for token counting.
+ */
+async function readWorkspaceFiles(workspaceDir: string): Promise<string> {
+  const parts: string[] = [];
+  for (const file of WORKSPACE_FILES) {
+    try {
+      const content = await readFile(join(workspaceDir, file), "utf8");
+      if (content.trim()) parts.push(`## ${file}\n${content}`);
+    } catch { /* file doesn't exist — skip */ }
+  }
+  return parts.join("\n\n");
+}
+
+/**
+ * Build a text representation of tools config for token counting.
+ */
+function serializeToolsConfig(config: Record<string, unknown>): string {
+  const tools = config.tools;
+  if (!tools) return "";
+  try {
+    return `## Tools Config\n${JSON.stringify(tools, null, 2)}`;
+  } catch { return ""; }
+}
+
+/**
+ * Build a text representation of skills for token counting.
+ */
+function serializeSkillsConfig(config: Record<string, unknown>): string {
+  const skills = (config as any).skills?.entries;
+  if (!skills || typeof skills !== "object") return "";
+  try {
+    const names = Object.keys(skills);
+    return `## Skills (${names.length})\n${names.join(", ")}`;
+  } catch { return ""; }
+}
+
+// ──────────────────────────────────────────────────────
+// Plugin Definition
+// ──────────────────────────────────────────────────────
+
 const memoryRouterPlugin = {
   id: "mr-memory",
   name: "MemoryRouter",
@@ -92,34 +131,96 @@ const memoryRouterPlugin = {
     const cfg = api.pluginConfig as MemoryRouterConfig | undefined;
     const endpoint = cfg?.endpoint?.replace(/\/v1\/?$/, "") || DEFAULT_ENDPOINT;
     const memoryKey = cfg?.key;
-    const density = cfg?.density || 'high';
-
-    // ==================================================================
-    // Core: Relay architecture — memory via API hooks (no patching needed)
-    // ==================================================================
+    const density = cfg?.density || "high";
+    const mode = cfg?.mode || "relay";
 
     if (memoryKey) {
-      api.logger.info?.(`memoryrouter: registered (endpoint: ${endpoint})`);
+      api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}..., mode: ${mode})`);
     } else {
       api.logger.info?.("memoryrouter: no key configured — run: openclaw mr <key>");
     }
 
+    // ==================================================================
+    // Core: before_agent_start — search memories, inject context
+    // ==================================================================
+
     if (memoryKey) {
-      // RETRIEVAL — inject relevant memories before every agent turn
-      api.on("before_agent_start", async (event: Record<string, unknown>) => {
-        const prompt = event.prompt as string | undefined;
-        if (!prompt || prompt.length < 5) return;
+      // Track whether we've already fired for this prompt (dedup double-fire)
+      let lastPreparedPrompt = "";
 
+      api.on("before_prompt_build", async (event, ctx) => {
         try {
+          const prompt = event.prompt;
+
+          // Deduplicate — if we already prepared this exact prompt, skip
+          if (prompt === lastPreparedPrompt && lastPreparedPrompt !== "") {
+            return;
+          }
+          lastPreparedPrompt = prompt;
+
+          // 1. Read workspace files for full token count
+          const workspaceDir = ctx.workspaceDir || "";
+          let workspaceText = "";
+          if (workspaceDir) {
+            workspaceText = await readWorkspaceFiles(workspaceDir);
+          }
+
+          // 2. Serialize tools + skills from config
+          const toolsText = serializeToolsConfig(api.config as unknown as Record<string, unknown>);
+          const skillsText = serializeSkillsConfig(api.config as unknown as Record<string, unknown>);
+
+          // 3. Build full context payload (messages + workspace + tools + skills)
+          const contextPayload: Array<{ role: string; content: string }> = [];
+
+          // Add workspace context as a system-level entry
+          const fullContext = [workspaceText, toolsText, skillsText].filter(Boolean).join("\n\n");
+          if (fullContext) {
+            contextPayload.push({ role: "system", content: fullContext });
+          }
+
+          // Add conversation history
+          if (event.messages && Array.isArray(event.messages)) {
+            let skipped = 0;
+            for (const msg of event.messages) {
+              const m = msg as { role?: string; content?: unknown };
+              if (!m.role) continue;
+              
+              let text = "";
+              if (typeof m.content === "string") {
+                text = m.content;
+              } else if (Array.isArray(m.content)) {
+                // Handle Anthropic-style content blocks [{type:"text", text:"..."}, ...]
+                text = (m.content as Array<{ type?: string; text?: string }>)
+                  .filter(b => b.type === "text" && b.text)
+                  .map(b => b.text!)
+                  .join("\n");
+              }
+              
+              if (text) {
+                contextPayload.push({ role: m.role, content: text });
+              } else {
+                skipped++;
+              }
+            }
+          }
+
+          // Add current user prompt
+          contextPayload.push({ role: "user", content: prompt });
+
+          // 4. Call /v1/memory/prepare
+          const densityMap: Record<string, number> = { low: 40, high: 80, xhigh: 160 };
+          const contextLimit = densityMap[density] || 80;
+
           const res = await fetch(`${endpoint}/v1/memory/prepare`, {
             method: "POST",
             headers: {
-              "Authorization": `Bearer ${memoryKey}`,
               "Content-Type": "application/json",
+              Authorization: `Bearer ${memoryKey}`,
             },
             body: JSON.stringify({
-              messages: [{ role: "user", content: prompt }],
+              messages: contextPayload,
               density,
+              context_limit: contextLimit,
             }),
           });
 
@@ -128,94 +229,112 @@ const memoryRouterPlugin = {
             return;
           }
 
-          const data = await res.json() as { context: string | null; tokens_billed: number; memories_found: number };
+          const data = (await res.json()) as {
+            context?: string;
+            memories_found?: number;
+            tokens_billed?: number;
+          };
 
           if (data.context) {
-            api.logger.info?.(`memoryrouter: injected ${data.memories_found} memories (${data.tokens_billed} tokens)`);
+            api.logger.info?.(
+              `memoryrouter: injected ${data.memories_found || 0} memories (${data.tokens_billed || 0} tokens billed)`,
+            );
             return { prependContext: data.context };
           }
         } catch (err) {
-          api.logger.warn?.(`memoryrouter: prepare error: ${String(err)}`);
+          api.logger.warn?.(
+            `memoryrouter: prepare error — ${err instanceof Error ? err.message : String(err)}`,
+          );
         }
       });
 
-      // STORAGE — capture conversation after every agent turn
-      // Only stores the LAST user message + assistant response per turn (no duplication)
-      api.on("agent_end", async (event: Record<string, unknown>) => {
-        if (!event.success || !event.messages) return;
-
-        const msgs = event.messages as Array<Record<string, unknown>>;
-        if (!msgs.length) return;
+      // ==================================================================
+      // Core: agent_end — store this turn's conversation
+      // ==================================================================
 
+      api.on("agent_end", async (event, ctx) => {
         try {
-          // Walk backwards: find the last assistant, then the last user before it
-          let assistantMsg: { role: string; content: string } | null = null;
-          let userMsg: { role: string; content: string } | null = null;
-
-          for (let i = msgs.length - 1; i >= 0; i--) {
-            const role = msgs[i].role as string;
-            if (!role) continue;
-
-            // Extract text content
-            let text = "";
-            const content = msgs[i].content;
-            if (typeof content === "string") {
-              text = content;
-            } else if (Array.isArray(content)) {
-              for (const block of content as Array<Record<string, unknown>>) {
-                if (typeof block.text === "string") {
-                  text += (text ? "\n" : "") + block.text;
-                }
-              }
+          const msgs = event.messages;
+          if (!msgs || !Array.isArray(msgs) || msgs.length === 0) return;
+
+          // Extract text from a message (handles string + content block arrays)
+          function extractText(content: unknown): string {
+            if (typeof content === "string") return content;
+            if (Array.isArray(content)) {
+              return (content as Array<{ type?: string; text?: string }>)
+                .filter(b => b.type === "text" && b.text)
+                .map(b => b.text!)
+                .join("\n");
             }
+            return "";
+          }
 
-            if (!text || text.length < 10) continue;
-
-            if (!assistantMsg && role === "assistant") {
-              assistantMsg = { role, content: text };
-            }
-            if (assistantMsg && !userMsg && role === "user") {
-              // Strip any injected memory context from user messages
-              let cleanText = text;
-              if (cleanText.includes("[Memory Context]")) {
-                cleanText = cleanText.replace(/\[Memory Context\][\s\S]*?\n\n/g, "").trim();
-              }
-              if (cleanText.length >= 10) {
-                userMsg = { role, content: cleanText };
-              }
+          // Find the last user message, then collect ALL assistant messages after it
+          // This captures the full response even if she sent multiple messages
+          let lastUserIdx = -1;
+          for (let i = msgs.length - 1; i >= 0; i--) {
+            const msg = msgs[i] as { role?: string; content?: unknown };
+            const text = extractText(msg.content);
+            if (msg.role === "user" && text) {
+              lastUserIdx = i;
               break;
             }
           }
 
-          // Only store this turn's pair — no duplication
           const toStore: Array<{ role: string; content: string }> = [];
-          if (userMsg) toStore.push(userMsg);
-          if (assistantMsg) toStore.push(assistantMsg);
+
+          // Add the user message
+          if (lastUserIdx >= 0) {
+            const userMsg = msgs[lastUserIdx] as { content?: unknown };
+            const userText = extractText(userMsg.content);
+            if (userText) toStore.push({ role: "user", content: userText });
+          }
+
+          // Collect ALL assistant messages after the last user message
+          const assistantParts: string[] = [];
+          for (let i = (lastUserIdx >= 0 ? lastUserIdx + 1 : 0); i < msgs.length; i++) {
+            const msg = msgs[i] as { role?: string; content?: unknown };
+            if (msg.role === "assistant") {
+              const text = extractText(msg.content);
+              if (text) assistantParts.push(text);
+            }
+          }
+          if (assistantParts.length > 0) {
+            toStore.push({ role: "assistant", content: assistantParts.join("\n\n") });
+          }
 
           if (toStore.length === 0) return;
 
-          const res = await fetch(`${endpoint}/v1/memory/ingest`, {
+          // Fire and forget — don't block the response
+          fetch(`${endpoint}/v1/memory/ingest`, {
             method: "POST",
             headers: {
-              "Authorization": `Bearer ${memoryKey}`,
               "Content-Type": "application/json",
+              Authorization: `Bearer ${memoryKey}`,
             },
             body: JSON.stringify({
               messages: toStore,
+              session_id: ctx.sessionKey,
             }),
+          }).then(async (res) => {
+            if (!res.ok) {
+              api.logger.warn?.(`memoryrouter: ingest failed (${res.status})`);
+            }
+          }).catch((err) => {
+            api.logger.warn?.(
+              `memoryrouter: ingest error — ${err instanceof Error ? err.message : String(err)}`,
+            );
           });
-
-          if (!res.ok) {
-            api.logger.warn?.(`memoryrouter: ingest failed (${res.status})`);
-          }
         } catch (err) {
-          api.logger.warn?.(`memoryrouter: ingest error: ${String(err)}`);
+          api.logger.warn?.(
+            `memoryrouter: agent_end error — ${err instanceof Error ? err.message : String(err)}`,
+          );
         }
       });
-    } // end if (memoryKey) for relay hooks
+    } // end if (memoryKey)
 
     // ==================================================================
-    // CLI Commands (always registered — even without key, for enable/off)
+    // CLI Commands
     // ==================================================================
 
     api.registerCli(
@@ -225,7 +344,6 @@ const memoryRouterPlugin = {
             console.error("Invalid key format. Keys start with 'mk' (e.g. mk_xxx)");
             return;
           }
-
           try {
             await setPluginConfig(api, { key });
             await setPluginEnabled(api, true);
@@ -234,30 +352,22 @@ const memoryRouterPlugin = {
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`Failed to enable MemoryRouter: ${message}`);
-            console.error("Fallback: openclaw config set plugins.entries.mr-memory.config.key <key>");
-            console.error("Then: openclaw config set plugins.entries.mr-memory.enabled true --json");
           }
         };
 
-        const mr = program.command("mr")
+        const mr = program
+          .command("mr")
           .description("MemoryRouter memory commands")
           .argument("[key]", "Your MemoryRouter memory key (mk_xxx)")
           .action(async (key: string | undefined) => {
-            if (!key) {
-              // No key provided — show help
-              mr.help();
-              return;
-            }
+            if (!key) { mr.help(); return; }
             await applyKey(key);
           });
 
-        // Backward compat: `openclaw mr enable <key>` still works
         mr.command("enable")
           .description("Enable MemoryRouter with a memory key (alias)")
           .argument("<key>", "Your MemoryRouter memory key (mk_xxx)")
-          .action(async (key: string) => {
-            await applyKey(key);
-          });
+          .action(async (key: string) => { await applyKey(key); });
 
         mr.command("off")
           .description("Disable MemoryRouter (removes key)")
@@ -265,143 +375,110 @@ const memoryRouterPlugin = {
             try {
               await setPluginConfig(api, {});
               await setPluginEnabled(api, false);
-              console.log("✓ MemoryRouter disabled. LLM calls go direct to provider.");
-              console.log("  Key removed. Re-enable with: openclaw mr <key>");
+              console.log("✓ MemoryRouter disabled.");
             } catch (err) {
-              console.error(`Failed to disable MemoryRouter: ${err instanceof Error ? err.message : String(err)}`);
+              console.error(`Failed to disable: ${err instanceof Error ? err.message : String(err)}`);
             }
           });
 
         // Density commands
-        mr.command("xhigh")
-          .description("Set memory density to xhigh (160 results, ~50k tokens)")
-          .action(async () => {
-            if (!memoryKey) {
-              console.error("MemoryRouter not configured. Run: openclaw mr <key>");
-              return;
-            }
-            try {
-              await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: 'xhigh' });
-              console.log("✓ Memory density set to xhigh (160 results, ~50k tokens)");
-              console.log("  Maximum context injection for deepest memory.");
-            } catch (err) {
-              console.error(`Failed to set density: ${err instanceof Error ? err.message : String(err)}`);
-            }
-          });
-
-        mr.command("high")
-          .description("Set memory density to high (80 results, ~24k tokens) [default]")
-          .action(async () => {
-            if (!memoryKey) {
-              console.error("MemoryRouter not configured. Run: openclaw mr <key>");
-              return;
-            }
-            try {
-              await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: 'high' });
-              console.log("✓ Memory density set to high (80 results, ~24k tokens)");
-            } catch (err) {
-              console.error(`Failed to set density: ${err instanceof Error ? err.message : String(err)}`);
-            }
-          });
+        for (const [name, desc] of [
+          ["xhigh", "Set density to xhigh (160 results, ~50k tokens)"],
+          ["high", "Set density to high (80 results, ~24k tokens) [default]"],
+          ["low", "Set density to low (40 results, ~12k tokens)"],
+        ] as const) {
+          mr.command(name)
+            .description(desc)
+            .action(async () => {
+              if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+              try {
+                await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: name });
+                console.log(`✓ Memory density set to ${name}`);
+              } catch (err) {
+                console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+            });
+        }
 
-        mr.command("low")
-          .description("Set memory density to low (40 results, ~12k tokens)")
-          .action(async () => {
-            if (!memoryKey) {
-              console.error("MemoryRouter not configured. Run: openclaw mr <key>");
-              return;
-            }
-            try {
-              await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density: 'low' });
-              console.log("✓ Memory density set to low (40 results, ~12k tokens)");
-              console.log("  Lighter context for faster responses or smaller models.");
-            } catch (err) {
-              console.error(`Failed to set density: ${err instanceof Error ? err.message : String(err)}`);
-            }
-          });
+        // Mode commands
+        for (const [modeName, modeDesc] of [
+          ["relay", "Relay mode — hooks only, works on stock OpenClaw [default]"],
+          ["proxy", "Proxy mode — memory on every LLM call (requires registerStreamFnWrapper)"],
+        ] as const) {
+          mr.command(modeName)
+            .description(modeDesc)
+            .action(async () => {
+              if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
+              try {
+                await setPluginConfig(api, { key: memoryKey, endpoint: cfg?.endpoint, density, mode: modeName });
+                console.log(`✓ Mode set to ${modeName}`);
+              } catch (err) {
+                console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+            });
+        }
 
         mr.command("status")
           .description("Show MemoryRouter vault stats")
           .option("--json", "JSON output")
           .action(async (opts) => {
-            if (!memoryKey) {
-              console.error("MemoryRouter not configured. Run: openclaw mr <key>");
-              return;
-            }
+            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
             try {
               const res = await fetch(`${endpoint}/v1/memory/stats`, {
                 headers: { Authorization: `Bearer ${memoryKey}` },
               });
-              const data = await res.json() as Record<string, unknown>;
-
+              const data = (await res.json()) as { totalVectors?: number; totalTokens?: number };
               if (opts.json) {
-                console.log(JSON.stringify({ enabled: true, key: memoryKey, density, stats: data }, null, 2));
+                console.log(JSON.stringify({ enabled: true, key: memoryKey, density, mode, stats: data }, null, 2));
               } else {
                 console.log("MemoryRouter Status");
                 console.log("───────────────────────────");
                 console.log(`Enabled:     ✓ Yes`);
                 console.log(`Key:         ${memoryKey.slice(0, 6)}...${memoryKey.slice(-3)}`);
-                console.log(`Density:     ${density} (openclaw mr xhigh|high|low)`);
+                console.log(`Mode:        ${mode}`);
+                console.log(`Density:     ${density}`);
                 console.log(`Endpoint:    ${endpoint}`);
-                console.log("");
-                console.log("Vault Stats:");
-                const stats = data as { totalVectors?: number; totalTokens?: number };
-                console.log(`  Memories:  ${stats.totalVectors ?? 0}`);
-                console.log(`  Tokens:    ${stats.totalTokens ?? 0}`);
+                console.log(`Memories:    ${data.totalVectors ?? 0}`);
+                console.log(`Tokens:      ${data.totalTokens ?? 0}`);
               }
             } catch (err) {
-              console.error(`Failed to fetch stats: ${err instanceof Error ? err.message : String(err)}`);
+              console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
             }
           });
 
         mr.command("upload")
           .description("Upload workspace + session history to vault")
           .argument("[path]", "Specific file or directory to upload")
-          .option("--workspace <dir>", "Workspace directory (default: cwd)")
-          .option("--brain <dir>", "State directory with sessions (default: ~/.openclaw)")
+          .option("--workspace <dir>", "Workspace directory")
+          .option("--brain <dir>", "State directory with sessions")
           .action(async (targetPath: string | undefined, opts: { workspace?: string; brain?: string }) => {
-            if (!memoryKey) {
-              console.error("MemoryRouter not configured. Run: openclaw mr <key>");
-              return;
-            }
+            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
             const os = await import("node:os");
             const path = await import("node:path");
             const stateDir = opts.brain ? path.resolve(opts.brain) : path.join(os.homedir(), ".openclaw");
-            // Use OpenClaw's configured workspace, not cwd
-            const configWorkspace = api.config.workspace || api.config.agents?.defaults?.workspace;
+            const configWorkspace = (api.config as any).workspace || (api.config as any).agents?.defaults?.workspace;
             const workspacePath = opts.workspace
               ? path.resolve(opts.workspace)
               : configWorkspace
                 ? path.resolve(configWorkspace.replace(/^~/, os.homedir()))
                 : path.join(os.homedir(), ".openclaw", "workspace");
             const { runUpload } = await import("./upload.js");
-            await runUpload({
-              memoryKey,
-              endpoint,
-              targetPath,
-              stateDir,
-              workspacePath,
-              hasWorkspaceFlag: !!opts.workspace,
-              hasBrainFlag: !!opts.brain,
-            });
+            await runUpload({ memoryKey, endpoint, targetPath, stateDir, workspacePath, hasWorkspaceFlag: !!opts.workspace, hasBrainFlag: !!opts.brain });
           });
 
         mr.command("delete")
           .description("Clear all memories from vault")
           .action(async () => {
-            if (!memoryKey) {
-              console.error("MemoryRouter not configured. Run: openclaw mr <key>");
-              return;
-            }
+            if (!memoryKey) { console.error("Not configured. Run: openclaw mr <key>"); return; }
             try {
               const res = await fetch(`${endpoint}/v1/memory`, {
                 method: "DELETE",
                 headers: { Authorization: `Bearer ${memoryKey}` },
               });
-              const data = await res.json() as { message?: string };
+              const data = (await res.json()) as { message?: string };
               console.log(`✓ ${data.message || "Vault cleared"}`);
             } catch (err) {
-              console.error(`Failed to clear vault: ${err instanceof Error ? err.message : String(err)}`);
+              console.error(`Failed: ${err instanceof Error ? err.message : String(err)}`);
             }
           });
       },
@@ -415,9 +492,7 @@ const memoryRouterPlugin = {
     api.registerService({
       id: "mr-memory",
       start: () => {
-        if (memoryKey) {
-          api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
-        }
+        if (memoryKey) api.logger.info?.(`memoryrouter: active (key: ${memoryKey.slice(0, 6)}...)`);
       },
       stop: () => {
         api.logger.info?.("memoryrouter: stopped");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mr-memory",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "MemoryRouter persistent memory plugin for OpenClaw — your AI remembers every conversation",
   "type": "module",
   "files": [