memorylake-openclaw 1.0.2-beta.5 → 1.0.2-beta.6

package/index.ts

@@ -15,6 +15,7 @@ import fsPromises from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import got from "got";
+import { pipeline } from "node:stream/promises";
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { loadCoreAgentDeps } from "./core-bridge";
@@ -1329,35 +1330,76 @@ const memoryPlugin = {
       { name: "document_search" },
     );
 
+    /**
+     * Try to extract a usable filename from a pre-signed download URL.
+     * Returns null if the URL doesn't contain a recognizable filename.
+     */
+    function fileNameFromUrl(urlStr: string): string | null {
+      try {
+        const p = new URL(urlStr).pathname;
+        const base = path.posix.basename(p);
+        if (base && /\.\w{1,10}$/.test(base)) return decodeURIComponent(base);
+      } catch { /* ignore */ }
+      return null;
+    }
+
     api.registerTool(
       (ctx) => ({
         name: "document_download",
         label: "Document Download",
         description:
-          "Download a document (image, PDF, etc.) from MemoryLake and get a temporary download URL. After calling this tool, you MUST call the `message` tool with action='send' and media=<the returned URL> to deliver the file to the user.",
+          "Download a document (image, PDF, etc.) from MemoryLake to local disk. After calling this tool, you MUST call the `message` tool with action='send' and media=<the returned local file path> to deliver the file to the user.",
         parameters: Type.Object({
           documentId: Type.String({
             description:
               "The document ID to download (from document_search results or document listing)",
           }),
+          fileName: Type.Optional(
+            Type.String({
+              description:
+                "Original file name for saving locally (e.g. 'report.pdf'). Falls back to the name in the download URL or the document ID.",
+            }),
+          ),
         }),
         async execute(_toolCallId, params) {
           const effectiveCfg = resolveConfig(ctx);
           const effectiveProvider = getProvider(effectiveCfg);
-          const { documentId } = params as { documentId: string };
+          const { documentId, fileName } = params as {
+            documentId: string;
+            fileName?: string;
+          };
 
           try {
+            // 1. Get pre-signed download URL
             const downloadUrl =
               await effectiveProvider.getDocumentDownloadUrl(documentId);
 
+            // 2. Determine local save directory (cross-platform)
+            const workspaceDir = (ctx as any)?.workspaceDir;
+            const downloadDir = workspaceDir
+              ? path.join(workspaceDir, ".memorylake", "downloads")
+              : path.join(os.tmpdir(), "memorylake-downloads");
+            fs.mkdirSync(downloadDir, { recursive: true });
+
+            // 3. Determine filename: explicit param > URL-derived > documentId
+            const finalName =
+              fileName || fileNameFromUrl(downloadUrl) || documentId;
+            const localPath = path.join(downloadDir, finalName);
+
+            // 4. Stream download to local file
+            await pipeline(
+              got.stream(downloadUrl),
+              fs.createWriteStream(localPath),
+            );
+
             return {
               content: [
                 {
                   type: "text",
-                  text: `Document ${documentId} ready. Download URL (expires in ~20 minutes):\n${downloadUrl}\n\nYou MUST now call the message tool with action="send" and media set to this URL to deliver the file to the user.`,
+                  text: `Document ${documentId} downloaded to:\n${localPath}\n\nYou MUST now call the message tool with action="send" and media set to this local path to deliver the file to the user.`,
                 },
               ],
-              details: { documentId },
+              details: { documentId, localPath },
             };
           } catch (err) {
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "1.0.2-beta.5",
+  "version": "1.0.2-beta.6",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",

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

@@ -369,8 +369,13 @@ function collectFiles(dir, _counter = { value: 0 }) {
   return files;
 }
 
+/** Max number of concurrent uploads */
+const UPLOAD_CONCURRENCY = 10;
+
 /**
- * Upload multiple files with progress summary.
+ * Upload multiple files with a sliding-window concurrency pool.
+ * Up to UPLOAD_CONCURRENCY uploads run simultaneously; as soon as one
+ * finishes the next file starts immediately — no waiting for a full batch.
  * @param {Array<string>} files - absolute paths of files to upload
  * @param {string} label - label for the summary line (e.g. "Archive" / "Directory")
  */
@@ -378,21 +383,31 @@ async function uploadMany({ host, apiKey, projectId, files, label }) {
   const results = [];
   let success = 0;
   let failed = 0;
-
-  for (const f of files) {
-    try {
-      const doc = await upload({
-        host, apiKey, projectId,
-        filePath: f,
-        fileName: path.basename(f),
-      });
+  let nextIndex = 0;
+
+  function runNext() {
+    if (nextIndex >= files.length) return null;
+    const i = nextIndex++;
+    const f = files[i];
+    return upload({
+      host, apiKey, projectId,
+      filePath: f,
+      fileName: path.basename(f),
+    }).then(doc => {
       results.push(doc);
       success++;
-    } catch (err) {
+    }).catch(err => {
       console.error(`Failed to upload ${path.basename(f)}: ${err.message}`);
       failed++;
-    }
+    }).then(() => runNext());   // slot freed → pick up next file immediately
+  }
+
+  // Kick off the initial pool of workers
+  const workers = [];
+  for (let w = 0; w < Math.min(UPLOAD_CONCURRENCY, files.length); w++) {
+    workers.push(runNext());
   }
+  await Promise.all(workers);
 
   console.log(`\n${label} upload complete: ${success} succeeded, ${failed} failed.`);
   return results;