openclaw-elys 1.8.0 → 1.8.2

package/dist/src/monitor.js

@@ -1,3 +1,8 @@
+import { createWriteStream } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
 import { loadCredentials } from "./config.js";
 import { registerDevice } from "./register.js";
 import { ElysDeviceMQTTClient } from "./mqtt-client.js";
@@ -39,15 +44,25 @@ export async function monitorElysProvider(opts) {
             try {
                 let seq = 0;
                 let fullText = "";
-                // Build media context for inbound (user-sent media)
-                const mediaUrls = cmd.mediaUrls?.length
+                // Download inbound media (user-sent) to local temp files
+                // OpenClaw expects local file paths in MediaPath/MediaUrl, not remote URLs
+                const rawMediaUrls = cmd.mediaUrls?.length
                     ? cmd.mediaUrls
                     : cmd.mediaUrl
                         ? [cmd.mediaUrl]
-                        : undefined;
-                const mediaTypes = mediaUrls
-                    ? mediaUrls.map(() => cmd.mediaType ?? "application/octet-stream")
-                    : undefined;
+                        : [];
+                const downloadedPaths = [];
+                const downloadedTypes = [];
+                for (const url of rawMediaUrls) {
+                    try {
+                        const localPath = await downloadToTemp(url, log);
+                        downloadedPaths.push(localPath);
+                        downloadedTypes.push(cmd.mediaType ?? guessMediaType(url));
+                    }
+                    catch (err) {
+                        log(`[elys] failed to download media ${url}:`, err);
+                    }
+                }
                 const inboundCtx = finalizeCtx({
                     Body: formatCommandAsText(cmd),
                     BodyForAgent: formatCommandAsText(cmd),
@@ -63,12 +78,14 @@ export async function monitorElysProvider(opts) {
                     CommandAuthorized: true,
                     OriginatingChannel: "elys",
                     OriginatingTo: credentials.deviceId,
-                    // Inbound media from user
-                    ...(mediaUrls && {
-                        MediaUrl: mediaUrls[0],
-                        MediaUrls: mediaUrls,
-                        MediaType: mediaTypes[0],
-                        MediaTypes: mediaTypes,
+                    // Inbound media as local file paths
+                    ...(downloadedPaths.length > 0 && {
+                        MediaPath: downloadedPaths[0],
+                        MediaUrl: downloadedPaths[0],
+                        MediaPaths: downloadedPaths,
+                        MediaUrls: downloadedPaths,
+                        MediaType: downloadedTypes[0],
+                        MediaTypes: downloadedTypes,
                     }),
                 });
                 // Deliver callback: stream chunks back via MQTT
@@ -174,3 +191,52 @@ function formatCommandAsText(cmd) {
     }
     return parts.join(" ");
 }
+const MIME_BY_EXT = {
+    ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
+    ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp",
+    ".mp4": "video/mp4", ".mov": "video/quicktime", ".avi": "video/x-msvideo",
+    ".mp3": "audio/mpeg", ".ogg": "audio/ogg", ".wav": "audio/wav",
+    ".pdf": "application/pdf",
+};
+function guessMediaType(url) {
+    const pathname = new URL(url).pathname.toLowerCase();
+    for (const [ext, mime] of Object.entries(MIME_BY_EXT)) {
+        if (pathname.includes(ext))
+            return mime;
+    }
+    return "application/octet-stream";
+}
+function extFromMimeOrUrl(url, mime) {
+    for (const [ext, m] of Object.entries(MIME_BY_EXT)) {
+        if (m === mime)
+            return ext;
+    }
+    const pathname = new URL(url).pathname;
+    const dot = pathname.lastIndexOf(".");
+    if (dot >= 0) {
+        const ext = pathname.slice(dot).split(/[?#!/]/)[0];
+        if (ext.length <= 6)
+            return ext;
+    }
+    return ".bin";
+}
+let tempDir = null;
+async function downloadToTemp(url, log) {
+    if (!tempDir) {
+        tempDir = await mkdtemp(join(tmpdir(), "elys-media-"));
+    }
+    const mime = guessMediaType(url);
+    const ext = extFromMimeOrUrl(url, mime);
+    const filename = `media_${Date.now()}${ext}`;
+    const filePath = join(tempDir, filename);
+    log(`[elys] downloading media: ${url} → ${filePath}`);
+    const resp = await fetch(url);
+    if (!resp.ok || !resp.body) {
+        throw new Error(`HTTP ${resp.status} downloading ${url}`);
+    }
+    const { Readable } = await import("node:stream");
+    const nodeStream = Readable.fromWeb(resp.body);
+    await pipeline(nodeStream, createWriteStream(filePath));
+    log(`[elys] downloaded media: ${filePath}`);
+    return filePath;
+}

package/dist/src/mqtt-client.d.ts

@@ -45,7 +45,7 @@ export declare class ElysDeviceMQTTClient {
     private flushDebounce;
     private startCommand;
     private processPendingCommands;
-    /** Merge multiple buffered commands into one. Joins text args with newline. */
+    /** Merge multiple buffered commands into one. Joins text args with newline, collects all media. */
     private mergeCommands;
     private executeCommand;
     private cleanupDedup;

package/dist/src/mqtt-client.js

@@ -208,7 +208,7 @@ export class ElysDeviceMQTTClient {
         this.log(`[elys] processing queued command ${merged.id}`);
         this.startCommand(merged);
     }
-    /** Merge multiple buffered commands into one. Joins text args with newline. */
+    /** Merge multiple buffered commands into one. Joins text args with newline, collects all media. */
     mergeCommands(cmds) {
         if (cmds.length === 1)
             return cmds[0];
@@ -216,11 +216,25 @@ export class ElysDeviceMQTTClient {
         const texts = cmds
             .map((c) => c.args?.text ?? "")
             .filter(Boolean);
-        if (texts.length > 1) {
-            this.log(`[elys] debounce: merged ${cmds.length} commands`);
+        // Collect all media URLs from all commands
+        const allMediaUrls = [];
+        for (const c of cmds) {
+            if (c.mediaUrls?.length) {
+                allMediaUrls.push(...c.mediaUrls);
+            }
+            else if (c.mediaUrl) {
+                allMediaUrls.push(c.mediaUrl);
+            }
+        }
+        const mergedText = texts.length > 1 ? texts.join("\n") : texts[0] ?? "";
+        if (texts.length > 1 || allMediaUrls.length > 0) {
+            this.log(`[elys] debounce: merged ${cmds.length} commands (${texts.length} texts, ${allMediaUrls.length} media)`);
             return {
                 ...last,
-                args: { ...last.args, text: texts.join("\n") },
+                args: { ...last.args, ...(mergedText && { text: mergedText }) },
+                mediaUrl: allMediaUrls[0] ?? last.mediaUrl,
+                mediaUrls: allMediaUrls.length > 0 ? allMediaUrls : undefined,
+                mediaType: last.mediaType,
             };
         }
         // Can't merge non-text commands, use the latest one

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-elys",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "OpenClaw Elys channel plugin — connects to Elys App",
   "type": "module",
   "main": "dist/index.js",