memorylake-openclaw 0.0.10 → 0.0.11

package/README.md

@@ -14,7 +14,9 @@ Your agent forgets everything between sessions. This plugin fixes that. It watch
 
 **Auto-Capture** — After the agent responds, the plugin sends the exchange to MemoryLake. MemoryLake decides what's worth keeping — new facts get stored, stale ones updated, duplicates merged.
 
-Both run silently. No prompting, no configuration, no manual calls.
+**Auto-Upload** — When a user sends a file (image, document, etc.), the plugin uploads it to MemoryLake as a project document.
+
+Auto-Recall, Auto-Capture, and Auto-Upload run silently by default.
 
 ## Setup
 
@@ -68,6 +70,7 @@ openclaw memorylake stats
 | `host` | `string` | `https://app.memorylake.ai` | MemoryLake server endpoint URL |
 | `autoRecall` | `boolean` | `true` | Inject memories before each turn |
 | `autoCapture` | `boolean` | `true` | Store facts after each turn |
+| `autoUpload` | `boolean` | `true` | Auto-upload inbound files to MemoryLake |
 | `topK` | `number` | `5` | Max memories per recall |
 | `searchThreshold` | `number` | `0.3` | Min similarity (0–1) |
 | `rerank` | `boolean` | `true` | Rerank search results |

package/docs/openclaw.mdx

@@ -13,9 +13,10 @@ Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents
 The plugin provides:
 1. **Auto-Recall** — Before the agent responds, memories and relevant document excerpts matching the current message are injected into context
 2. **Auto-Capture** — After the agent responds, the exchange is sent to MemoryLake which decides what's worth keeping
-3. **Agent Tools** — Seven tools for memory, document, and optional web search operations during conversations
+3. **Auto-Upload** — When a user sends a file, the plugin uploads it to MemoryLake as a project document asynchronously
+4. **Agent Tools** — Seven tools for memory, document, and optional web search operations during conversations
 
-Both auto-recall and auto-capture run silently with no manual configuration required.
+Auto-Recall, Auto-Capture, and Auto-Upload run silently by default.
 
 ## Installation
 
@@ -73,6 +74,7 @@ openclaw memorylake stats
 | `host` | `string` | `https://app.memorylake.ai` | MemoryLake server endpoint URL |
 | `autoRecall` | `boolean` | `true` | Inject memories before each turn |
 | `autoCapture` | `boolean` | `true` | Store facts after each turn |
+| `autoUpload` | `boolean` | `true` | Auto-upload inbound files to MemoryLake |
 | `topK` | `number` | `5` | Max memories per recall |
 | `searchThreshold` | `number` | `0.3` | Min similarity (0–1) |
 | `rerank` | `boolean` | `true` | Rerank search results for better relevance |
@@ -86,7 +88,7 @@ openclaw memorylake stats
 ## Key Features
 
 1. **Zero Configuration** — Auto-recall and auto-capture work out of the box with no prompting required
-2. **Async Processing** — Memory extraction runs asynchronously via MemoryLake's API
+2. **Async Processing** — Memory extraction and file uploads run asynchronously without blocking the agent
 3. **Session Tracking** — Conversations are tagged with `chat_session_id` for traceability
 4. **Rich Tool Suite** — Seven agent tools for memory, document, and optional web search operations when needed
 

package/index.ts

@@ -28,6 +28,7 @@ type MemoryLakeConfig = {
   userId: string;
   autoCapture: boolean;
   autoRecall: boolean;
+  autoUpload: boolean;
   searchThreshold: number;
   topK: number;
   rerank: boolean;
@@ -204,7 +205,7 @@ class PlatformProvider implements MemoryLakeProvider {
   constructor(host: string, apiKey: string, projectId: string) {
     this.basePath = `openapi/memorylake/api/v2/projects/${projectId}/memories`;
     this.docSearchPath = `openapi/memorylake/api/v1/projects/${projectId}/documents/search`;
-    this.webSearchPath = "openapi/memorylake/api/v1/search"; 
+    this.webSearchPath = "openapi/memorylake/api/v1/search";
     this.http = got.extend({
       prefixUrl: host,
       headers: {
@@ -310,6 +311,7 @@ class PlatformProvider implements MemoryLakeProvider {
       .json<WebSearchResponse>();
     return normalizeWebSearchResponse(resp);
   }
+
 }
 
 // ============================================================================
@@ -427,6 +429,7 @@ const ALLOWED_KEYS = [
   "userId",
   "autoCapture",
   "autoRecall",
+  "autoUpload",
   "searchThreshold",
   "topK",
   "rerank",
@@ -493,6 +496,7 @@ const memoryLakeConfigSchema = {
       userId: DEFAULT_USER_ID,
       autoCapture: cfg.autoCapture !== false,
       autoRecall: cfg.autoRecall !== false,
+      autoUpload: cfg.autoUpload !== false,
       searchThreshold:
         typeof cfg.searchThreshold === "number" ? cfg.searchThreshold : 0.3,
       topK: typeof cfg.topK === "number" ? cfg.topK : 5,
@@ -582,7 +586,7 @@ const memoryPlugin = {
     let currentSessionId: string | undefined;
 
     api.logger.info(
-      `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`,
+      `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`,
     );
 
     // Helper: build add options
@@ -1191,6 +1195,114 @@ const memoryPlugin = {
     // Lifecycle Hooks
     // ========================================================================
 
+    // --- Auto-upload helpers ---
+    const UPLOADED_RECORD_FILE = "uploaded.json";
+
+    type UploadedRecord = Record<string, { mtimeMs: number }>;
+
+    function getUploadedRecord(workspaceDir: string): UploadedRecord {
+      const filePath = path.join(workspaceDir, ".memorylake", UPLOADED_RECORD_FILE);
+      try {
+        if (fs.existsSync(filePath)) {
+          const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+          return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+        }
+      } catch (err) {
+        api.logger.warn(`memorylake-openclaw: failed to read uploaded record: ${String(err)}`);
+      }
+      return {};
+    }
+
+    function saveUploadedRecord(workspaceDir: string, record: UploadedRecord): void {
+      const dirPath = path.join(workspaceDir, ".memorylake");
+      if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+      fs.writeFileSync(
+        path.join(dirPath, UPLOADED_RECORD_FILE),
+        JSON.stringify(record, null, 2),
+      );
+    }
+
+    function needsUpload(record: UploadedRecord, filePath: string): fs.Stats | null {
+      if (!fs.existsSync(filePath)) return null;
+      const stat = fs.statSync(filePath);
+      const prev = record[filePath];
+      return (!prev || prev.mtimeMs !== stat.mtimeMs) ? stat : null;
+    }
+
+    function extractInboundPaths(prompt: string): string[] {
+      // Path must contain /media/inbound/ (or \media\inbound\)
+      // Filename must end with .<ext>, ext = alphanumeric, 1-6 chars
+      const sep = '[/\\\\]';
+      const regex = new RegExp(
+        `(?:[A-Za-z]:${sep}|/)\\S*?media${sep}inbound${sep}.+?\\.[a-zA-Z0-9]{1,6}(?=[^a-zA-Z0-9]|$)`,
+        "g",
+      );
+      const matches = prompt.match(regex) || [];
+      return [...new Set(matches)];
+    }
+
+    // Auto-upload: upload inbound files to MemoryLake before prompt build
+    if (cfg.autoUpload) {
+      // Lazy-load upload function from upload.mjs
+      let uploadFn: ((opts: { host: string; apiKey: string; projectId: string; filePath: string; fileName: string }) => Promise<unknown>) | undefined;
+
+      api.on("before_prompt_build", (event, ctx) => {
+        const workspaceDir = (ctx as any)?.workspaceDir;
+        if (!workspaceDir || !event.prompt) return;
+
+        const effectiveCfg = resolveConfig(ctx);
+        const paths = extractInboundPaths(event.prompt);
+        if (paths.length === 0) return;
+
+        const record = getUploadedRecord(workspaceDir);
+        const filesToUpload: { filePath: string; stat: fs.Stats }[] = [];
+        for (const p of paths) {
+          const stat = needsUpload(record, p);
+          if (stat) filesToUpload.push({ filePath: p, stat });
+        }
+        if (filesToUpload.length === 0) return;
+
+        // Fire-and-forget: upload asynchronously without blocking
+        (async () => {
+          // Lazy import upload.mjs
+          if (!uploadFn) {
+            const uploadModule = await import(
+              /* webpackIgnore: true */
+              new URL("./skills/memorylake-upload/scripts/upload.mjs", import.meta.url).href
+            );
+            uploadFn = uploadModule.upload;
+          }
+
+          for (const { filePath, stat } of filesToUpload) {
+            try {
+              await uploadFn!({
+                host: effectiveCfg.host,
+                apiKey: effectiveCfg.apiKey,
+                projectId: effectiveCfg.projectId,
+                filePath,
+                fileName: path.basename(filePath),
+              });
+              // Save record only after successful upload to avoid race on crash
+              const current = getUploadedRecord(workspaceDir);
+              current[filePath] = { mtimeMs: stat.mtimeMs };
+              saveUploadedRecord(workspaceDir, current);
+              api.logger.info(
+                `memorylake-openclaw: auto-uploaded ${path.basename(filePath)}`,
+              );
+            } catch (err) {
+              api.logger.warn(
+                `memorylake-openclaw: auto-upload failed for ${filePath}: ${String(err)}`,
+              );
+            }
+          }
+        })().catch((err) => {
+          api.logger.warn(
+            `memorylake-openclaw: auto-upload unexpected error: ${String(err)}`,
+          );
+        });
+      });
+    }
+
     // Auto-recall: inject relevant memories and documents before agent starts
     if (cfg.autoRecall) {
       api.on("before_agent_start", async (event, ctx) => {
@@ -1337,7 +1449,7 @@ const memoryPlugin = {
       id: "memorylake-openclaw",
       start: () => {
         api.logger.info(
-          `memorylake-openclaw: initialized (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`,
+          `memorylake-openclaw: initialized (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`,
         );
       },
       stop: () => {

package/openclaw.plugin.json

@@ -22,6 +22,10 @@
       "label": "Auto-Recall",
       "help": "Automatically inject relevant memories before each agent turn"
     },
+    "autoUpload": {
+      "label": "Auto-Upload",
+      "help": "Automatically upload files from media/inbound to MemoryLake"
+    },
     "searchThreshold": {
       "label": "Search Threshold",
       "placeholder": "0.3",
@@ -76,6 +80,9 @@
       "autoRecall": {
         "type": "boolean"
       },
+      "autoUpload": {
+        "type": "boolean"
+      },
       "searchThreshold": {
         "type": "number"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",

package/skills/memorylake-upload/scripts/upload.mjs

@@ -270,4 +270,8 @@ Examples:
   }
 }
 
-main();
+// Only run CLI when executed directly, not when imported
+const isDirectRun = process.argv[1] && import.meta.url === new URL(process.argv[1], 'file://').href;
+if (isDirectRun) {
+  main();
+}

package/test/path_reg.test.mjs

@@ -0,0 +1,197 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+// Extract the regex logic inline (same as index.ts extractInboundPaths)
+function extractInboundPaths(prompt) {
+  // Path must contain /media/inbound/ (or \media\inbound\)
+  // Filename must end with .<ext>, ext = alphanumeric, 1-6 chars
+  const sep = '[/\\\\]';
+  const regex = new RegExp(
+    `(?:[A-Za-z]:${sep}|/)\\S*?media${sep}inbound${sep}.+?\\.[a-zA-Z0-9]{1,6}(?=[^a-zA-Z0-9]|$)`,
+    "g",
+  );
+  const matches = prompt.match(regex) || [];
+  return [...new Set(matches)];
+}
+
+describe("extractInboundPaths", () => {
+  // ==================== Should match ====================
+
+  it("Unix: basic inbound path", () => {
+    const prompt = "请看这个文件 /Users/henry/.openclaw/media/inbound/abc.png";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/Users/henry/.openclaw/media/inbound/abc.png",
+    ]);
+  });
+
+  it("Unix: UUID filename", () => {
+    const prompt =
+      "[media attached: /Users/henry/.openclaw/media/inbound/69b064ed-7afa-4184-b81d-aacbc34c7d95.png (image/png)]";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/Users/henry/.openclaw/media/inbound/69b064ed-7afa-4184-b81d-aacbc34c7d95.png",
+    ]);
+  });
+
+  it("Unix: timestamp-prefixed filename", () => {
+    const prompt =
+      "文件已保存: /Users/henry/.openclaw/workspace/media/inbound/1774440188532-b204bb126d0b41bf8b97275d0871728c_1.doc，请基于文件名和上下文回答";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/Users/henry/.openclaw/workspace/media/inbound/1774440188532-b204bb126d0b41bf8b97275d0871728c_1.doc",
+    ]);
+  });
+
+  it("Unix: Chinese filename", () => {
+    const prompt =
+      "上传 /Users/henry/.openclaw/workspace/media/inbound/1773887151830-男士护肤品推广.xlsx 到项目";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/Users/henry/.openclaw/workspace/media/inbound/1773887151830-男士护肤品推广.xlsx",
+    ]);
+  });
+
+  it("Unix: subdirectory under inbound", () => {
+    const prompt = "file at /data/media/inbound/subdir/nested/report.pdf end";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/data/media/inbound/subdir/nested/report.pdf",
+    ]);
+  });
+
+  it("Unix: multiple paths in one prompt", () => {
+    const prompt =
+      "files: /a/media/inbound/one.txt and /b/media/inbound/two.pdf here";
+    const result = extractInboundPaths(prompt);
+    assert.equal(result.length, 2);
+    assert.ok(result.includes("/a/media/inbound/one.txt"));
+    assert.ok(result.includes("/b/media/inbound/two.pdf"));
+  });
+
+  it("Unix: dedup same path appearing twice", () => {
+    const prompt =
+      "/x/media/inbound/f.txt and again /x/media/inbound/f.txt here";
+    assert.deepEqual(extractInboundPaths(prompt), ["/x/media/inbound/f.txt"]);
+  });
+
+  it("Windows: backslash path with drive letter", () => {
+    const prompt =
+      'file at C:\\Users\\hello\\.openclaw\\media\\inbound\\report.docx end';
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "C:\\Users\\hello\\.openclaw\\media\\inbound\\report.docx",
+    ]);
+  });
+
+  it("Windows: Chinese username and filename", () => {
+    const prompt =
+      'C:\\Users\\你好\\.openclaw\\media\\inbound\\sds\\中文的.odf 这个文件';
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "C:\\Users\\你好\\.openclaw\\media\\inbound\\sds\\中文的.odf",
+    ]);
+  });
+
+  it("Windows: mixed separators (forward slash after drive)", () => {
+    const prompt = "C:/Users/test/media/inbound/file.txt done";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "C:/Users/test/media/inbound/file.txt",
+    ]);
+  });
+
+  it("Unix: path with dot-prefixed directory", () => {
+    const prompt = "/home/user/.config/media/inbound/data.csv end";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/home/user/.config/media/inbound/data.csv",
+    ]);
+  });
+
+  // ==================== Should NOT match ====================
+
+  it("no match: no media/inbound in path", () => {
+    const prompt = "/Users/henry/Documents/report.pdf";
+    assert.deepEqual(extractInboundPaths(prompt), []);
+  });
+
+  it("no match: media/outbound (not inbound)", () => {
+    const prompt = "/Users/henry/media/outbound/file.txt";
+    assert.deepEqual(extractInboundPaths(prompt), []);
+  });
+
+  it("no match: bare text media/inbound without leading path", () => {
+    const prompt = "check media/inbound/file.txt please";
+    assert.deepEqual(extractInboundPaths(prompt), []);
+  });
+
+  it("no match: empty prompt", () => {
+    assert.deepEqual(extractInboundPaths(""), []);
+  });
+
+  it("no match: path-like text without separator before media", () => {
+    const prompt = "wordmedia/inbound/file.txt";
+    assert.deepEqual(extractInboundPaths(prompt), []);
+  });
+
+  // ==================== Edge cases ====================
+
+  it("stops at Chinese comma after path", () => {
+    const prompt =
+      "文件已保存: /a/media/inbound/file.doc，请回答";
+    const result = extractInboundPaths(prompt);
+    assert.equal(result.length, 1);
+    // Should NOT include the Chinese comma or text after it
+    assert.ok(!result[0].includes("，"));
+  });
+
+  it("stops at Chinese enumeration comma (、) after path", () => {
+    const prompt =
+      "上传 /a/media/inbound/one.txt、/a/media/inbound/two.txt 到项目";
+    const result = extractInboundPaths(prompt);
+    assert.equal(result.length, 2);
+    assert.ok(!result[0].includes("、"));
+    assert.ok(!result[1].includes("、"));
+    assert.ok(result.includes("/a/media/inbound/one.txt"));
+    assert.ok(result.includes("/a/media/inbound/two.txt"));
+  });
+
+  it("stops at parenthesis after path", () => {
+    const prompt =
+      "[media attached: /a/media/inbound/img.png (image/png) | /a/media/inbound/img.png]";
+    const result = extractInboundPaths(prompt);
+    // Should capture the path but not "(image/png)"
+    assert.ok(result.length >= 1);
+    assert.ok(result.some((p) => p === "/a/media/inbound/img.png"));
+  });
+
+  it("stops at double quote", () => {
+    const prompt = 'path is "/a/media/inbound/file.txt" here';
+    const result = extractInboundPaths(prompt);
+    assert.equal(result.length, 1);
+    assert.ok(!result[0].includes('"'));
+  });
+
+  it("path inside brackets", () => {
+    const prompt = "[/a/media/inbound/file.txt]";
+    const result = extractInboundPaths(prompt);
+    assert.equal(result.length, 1);
+    assert.equal(result[0], "/a/media/inbound/file.txt");
+  });
+
+  it("filename with parentheses (browser duplicate)", () => {
+    const prompt =
+      "C:\\Users\\test\\.openclaw\\workspace\\media\\inbound\\米家吸尘器2(1)-1774512141374.pdf 这个文件";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "C:\\Users\\test\\.openclaw\\workspace\\media\\inbound\\米家吸尘器2(1)-1774512141374.pdf",
+    ]);
+  });
+
+  it("filename with spaces", () => {
+    const prompt =
+      "C:\\Users\\test\\.openclaw\\workspace\\media\\inbound\\Contemporary Report-1774522842609.pdf 请分析";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "C:\\Users\\test\\.openclaw\\workspace\\media\\inbound\\Contemporary Report-1774522842609.pdf",
+    ]);
+  });
+
+  it("Unix: filename with spaces and parens", () => {
+    const prompt =
+      "看看 /Users/henry/.openclaw/media/inbound/My Document (2).pdf 这个";
+    assert.deepEqual(extractInboundPaths(prompt), [
+      "/Users/henry/.openclaw/media/inbound/My Document (2).pdf",
+    ]);
+  });
+});