@cloudrise/openclaw-channel-rocketchat 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudrise/openclaw-channel-rocketchat",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Rocket.Chat channel plugin for OpenClaw (Cloudrise)",
   "license": "MIT",
   "type": "module",

package/src/rocketchat/client.ts

@@ -225,3 +225,114 @@ export async function sendRocketChatTyping(
     body: JSON.stringify({ roomId, typing: Boolean(isTyping) }),
   });
 }
+
+export type RocketChatUploadOpts = {
+  roomId: string;
+  file: Buffer;
+  fileName: string;
+  mimeType?: string;
+  description?: string;
+  tmid?: string;
+};
+
+export type RocketChatUploadResult = {
+  _id: string;
+  rid: string;
+  ts: string;
+};
+
+/**
+ * Upload a file to a Rocket.Chat room.
+ * RC 8.x uses a two-step process:
+ *   1. POST /api/v1/rooms.media/{roomId} → returns file._id
+ *   2. POST /api/v1/chat.sendMessage with file reference
+ */
+export async function uploadRocketChatFile(
+  client: RocketChatClient,
+  opts: RocketChatUploadOpts
+): Promise<RocketChatUploadResult> {
+  // Step 1: Upload file to rooms.media
+  const uploadUrl = `${client.baseUrl}/api/v1/rooms.media/${opts.roomId}`;
+  
+  // Build FormData manually for Node.js
+  const boundary = `----OpenClawBoundary${Date.now()}`;
+  const parts: Buffer[] = [];
+  
+  // Add file part
+  const fileHeader = [
+    `--${boundary}`,
+    `Content-Disposition: form-data; name="file"; filename="${opts.fileName}"`,
+    `Content-Type: ${opts.mimeType ?? "application/octet-stream"}`,
+    "",
+    "",
+  ].join("\r\n");
+  parts.push(Buffer.from(fileHeader));
+  parts.push(opts.file);
+  parts.push(Buffer.from("\r\n"));
+  
+  // End boundary
+  parts.push(Buffer.from(`--${boundary}--\r\n`));
+  
+  const uploadBody = Buffer.concat(parts);
+  
+  const uploadRes = await client.fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      "X-Auth-Token": client.authToken,
+      "X-User-Id": client.userId,
+      "Content-Type": `multipart/form-data; boundary=${boundary}`,
+      "Content-Length": String(uploadBody.length),
+    },
+    body: uploadBody,
+  });
+  
+  if (!uploadRes.ok) {
+    const text = await uploadRes.text().catch(() => "");
+    throw new Error(`Rocket.Chat media upload error ${uploadRes.status}: ${text}`);
+  }
+  
+  const uploadData = await uploadRes.json() as { 
+    file: { _id: string; url: string }; 
+    success: boolean 
+  };
+  
+  if (!uploadData.success || !uploadData.file?._id) {
+    throw new Error("Rocket.Chat media upload failed: no file ID returned");
+  }
+  
+  // Step 2: Send message with file reference
+  const messagePayload = {
+    message: {
+      rid: opts.roomId,
+      msg: opts.description ?? "",
+      file: { _id: uploadData.file._id },
+      ...(opts.tmid && { tmid: opts.tmid }),
+    },
+  };
+  
+  const sendRes = await client.fetch(`${client.baseUrl}/api/v1/chat.sendMessage`, {
+    method: "POST",
+    headers: {
+      "X-Auth-Token": client.authToken,
+      "X-User-Id": client.userId,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(messagePayload),
+  });
+  
+  if (!sendRes.ok) {
+    const text = await sendRes.text().catch(() => "");
+    throw new Error(`Rocket.Chat send message error ${sendRes.status}: ${text}`);
+  }
+  
+  const sendData = await sendRes.json() as { 
+    message: { _id: string; rid: string; ts: string }; 
+    success: boolean 
+  };
+  
+  return {
+    _id: sendData.message._id,
+    rid: sendData.message.rid,
+    ts: sendData.message.ts,
+  };
+}

package/src/rocketchat/send.ts

@@ -2,6 +2,9 @@
  * Rocket.Chat message sending
  */
 
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
 import { resolveRocketChatAccount } from "./accounts.js";
 import {
   createRocketChatClient,
@@ -10,6 +13,7 @@ import {
   fetchRocketChatUserByUsername,
   normalizeRocketChatBaseUrl,
   postRocketChatMessage,
+  uploadRocketChatFile,
   type RocketChatUser,
 } from "./client.js";
 import { getRocketChatRuntime } from "../runtime.js";
@@ -47,6 +51,32 @@ function isHttpUrl(value: string): boolean {
   return /^https?:\/\//i.test(value);
 }
 
+function isLocalPath(value: string): boolean {
+  // Check if it's an absolute path or relative path (not a URL)
+  return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || /^[A-Za-z]:\\/.test(value);
+}
+
+/** Map file extensions to MIME types */
+function getMimeFromExt(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const map: Record<string, string> = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
 function parseRocketChatTarget(raw: string): RocketChatTarget {
   const trimmed = raw.trim();
   if (!trimmed) throw new Error("Recipient is required for Rocket.Chat sends");
@@ -165,7 +195,46 @@ export async function sendMessageRocketChat(
   let message = text?.trim() ?? "";
   const mediaUrl = opts.mediaUrl?.trim();
 
-  // For media, we just append the URL since Rocket.Chat will unfurl it
+  // Resolve room ID for uploads (channels need special handling)
+  const isChannel = target.kind === "channel";
+  const uploadRoomId = isChannel ? roomId : roomId;
+
+  // Handle local file uploads
+  if (mediaUrl && isLocalPath(mediaUrl)) {
+    try {
+      const fileBuffer = await fs.readFile(mediaUrl);
+      const fileName = path.basename(mediaUrl);
+      const mimeType = getMimeFromExt(mediaUrl);
+      
+      logger?.debug?.(`Uploading file to Rocket.Chat: ${fileName} (${mimeType}, ${fileBuffer.length} bytes)`);
+      
+      const upload = await uploadRocketChatFile(client, {
+        roomId: uploadRoomId,
+        file: fileBuffer,
+        fileName,
+        mimeType,
+        description: message || undefined,
+        tmid: opts.replyToId,
+      });
+      
+      core?.channel?.activity?.record?.({
+        channel: "rocketchat",
+        accountId: account.accountId,
+        direction: "outbound",
+      });
+      
+      return {
+        messageId: upload._id ?? "unknown",
+        roomId: upload.rid ?? uploadRoomId,
+      };
+    } catch (err) {
+      logger?.error?.(`Failed to upload file to Rocket.Chat: ${String(err)}`);
+      // Fall through to send as text message with path (degraded experience)
+      message = normalizeMessage(message, `[File: ${mediaUrl}]`);
+    }
+  }
+
+  // For HTTP URLs, append to message (Rocket.Chat will unfurl)
   if (mediaUrl && isHttpUrl(mediaUrl)) {
     message = normalizeMessage(message, mediaUrl);
   }
@@ -174,7 +243,6 @@ export async function sendMessageRocketChat(
     throw new Error("Rocket.Chat message is empty");
   }
 
-  const isChannel = target.kind === "channel";
   const post = await postRocketChatMessage(client, {
     roomId: isChannel ? undefined : roomId,
     channel: isChannel ? `#${target.name}` : undefined,