@cloudrise/openclaw-channel-rocketchat 0.1.10 → 0.1.12

package/README.md

@@ -145,7 +145,7 @@ Then restart the gateway.
 
 ## Features
 
-- **Image attachments**: receives images uploaded to Rocket.Chat and passes them to the vision model.
+- **File attachments**: receives images, PDFs, documents, audio uploaded to Rocket.Chat and passes them to the vision model.
 - **Model prefix**: honors `messages.responsePrefix` (e.g. `({model}) `) so replies can include the model name.
 
 ## Model switching

package/package.json

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

package/src/rocketchat/monitor.ts

@@ -2,6 +2,11 @@
  * Rocket.Chat message monitor - handles incoming messages via Realtime API
  */
 
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+
 import type {
   ChannelAccountSnapshot,
   OpenclawConfig,
@@ -70,63 +75,83 @@ function chatType(kind: "dm" | "group" | "channel"): "direct" | "group" | "chann
   return "channel";
 }
 
-/** Image MIME types we can send to vision models */
-const IMAGE_MIME_TYPES = new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-]);
-
-function isImageMime(mime?: string): boolean {
-  if (!mime) return false;
-  return IMAGE_MIME_TYPES.has(mime.toLowerCase().split(";")[0].trim());
-}
-
 /**
- * Extract image URLs from Rocket.Chat message attachments/files.
+ * Extract file URLs from Rocket.Chat message attachments/files.
  * Returns full URLs that can be fetched with auth headers.
+ * Supports all file types - OpenClaw's media understanding handles type detection.
  */
-function extractImageUrls(
+function extractFileUrls(
   msg: IncomingMessage,
   baseUrl: string
-): Array<{ url: string; mimeType?: string }> {
-  const images: Array<{ url: string; mimeType?: string }> = [];
+): Array<{ url: string; mimeType?: string; fileName?: string }> {
+  const files: Array<{ url: string; mimeType?: string; fileName?: string }> = [];
+
+  // From file/files (used for direct uploads) - check these first as they're more reliable
+  const fileList = msg.files ?? (msg.file ? [msg.file] : []);
+  for (const f of fileList) {
+    if (f._id && f.name) {
+      // Rocket.Chat file-upload URL pattern
+      const url = `${baseUrl}/file-upload/${f._id}/${encodeURIComponent(f.name)}`;
+      files.push({ url, mimeType: f.type, fileName: decodeURIComponent(f.name) });
+    }
+  }
 
-  // From attachments array (used for image_url references)
-  if (msg.attachments?.length) {
+  // From attachments array (fallback for image_url references if no files found)
+  if (files.length === 0 && msg.attachments?.length) {
     for (const att of msg.attachments) {
       if (att.image_url) {
         const url = att.image_url.startsWith("http")
           ? att.image_url
           : `${baseUrl}${att.image_url.startsWith("/") ? "" : "/"}${att.image_url}`;
-        images.push({ url, mimeType: att.image_type });
+        files.push({ url, mimeType: att.image_type, fileName: att.title });
       }
     }
   }
 
-  // From file/files (used for direct uploads)
-  const files = msg.files ?? (msg.file ? [msg.file] : []);
-  for (const f of files) {
-    if (f._id && f.name && isImageMime(f.type)) {
-      // Rocket.Chat file-upload URL pattern
-      const url = `${baseUrl}/file-upload/${f._id}/${encodeURIComponent(f.name)}`;
-      images.push({ url, mimeType: f.type });
-    }
-  }
+  return files;
+}
+
+type FetchedFile = {
+  path: string;
+  mimeType: string;
+  cleanup: () => Promise<void>;
+};
 
-  return images;
+/** Map common MIME types to file extensions */
+function getExtensionFromMime(mimeType: string): string {
+  const mime = mimeType.toLowerCase().split(";")[0].trim();
+  const map: Record<string, string> = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+    "text/csv": ".csv",
+    "application/json": ".json",
+    "application/xml": ".xml",
+    "text/xml": ".xml",
+    "audio/mpeg": ".mp3",
+    "audio/wav": ".wav",
+    "audio/ogg": ".ogg",
+    "video/mp4": ".mp4",
+    "video/webm": ".webm",
+  };
+  return map[mime] ?? ".bin";
 }
 
 /**
- * Fetch an image from Rocket.Chat and return as base64 data URL.
+ * Fetch a file from Rocket.Chat and save to a temp file.
+ * Returns the file path (OpenClaw expects file paths, not data URLs).
  */
-async function fetchImageAsDataUrl(
+async function fetchFileToTemp(
   url: string,
   authToken: string,
   userId: string,
-  mimeType?: string
-): Promise<string | null> {
+  mimeType?: string,
+  fileName?: string
+): Promise<FetchedFile | null> {
   try {
     const res = await fetch(url, {
       headers: {
@@ -136,12 +161,26 @@ async function fetchImageAsDataUrl(
     });
     if (!res.ok) return null;
 
-    const contentType = mimeType ?? res.headers.get("content-type") ?? "image/png";
-    if (!isImageMime(contentType)) return null;
-
-    const buffer = await res.arrayBuffer();
-    const base64 = Buffer.from(buffer).toString("base64");
-    return `data:${contentType};base64,${base64}`;
+    const contentType = mimeType ?? res.headers.get("content-type") ?? "application/octet-stream";
+    const buffer = Buffer.from(await res.arrayBuffer());
+    
+    // Determine extension from filename or mime type
+    let ext = getExtensionFromMime(contentType);
+    if (fileName) {
+      const fnExt = path.extname(fileName);
+      if (fnExt) ext = fnExt;
+    }
+    
+    const tempPath = path.join(os.tmpdir(), `openclaw-rc-${crypto.randomUUID()}${ext}`);
+    await fs.writeFile(tempPath, buffer, { mode: 0o600 });
+    
+    return {
+      path: tempPath,
+      mimeType: contentType,
+      cleanup: async () => {
+        await fs.unlink(tempPath).catch(() => {});
+      },
+    };
   } catch {
     return null;
   }
@@ -370,16 +409,21 @@ async function handleIncomingMessage(
     ? msg.ts.$date 
     : Date.parse(String(msg.ts));
 
-  // Extract image attachments (if any)
+  // Extract file attachments (images, PDFs, documents, etc.)
   const baseUrl = account.baseUrl;
   const authToken = account.authToken;
   const userId = account.userId;
-  const imageRefs = extractImageUrls(msg, baseUrl);
+  
+  // DEBUG: Log raw message to see what DDP sends
+  logger.debug?.(`[RC DEBUG] Raw message: file=${JSON.stringify(msg.file)} files=${JSON.stringify(msg.files)} attachments=${JSON.stringify(msg.attachments?.slice(0, 2))}`);
+  
+  const fileRefs = extractFileUrls(msg, baseUrl);
+  logger.debug?.(`[RC DEBUG] Extracted ${fileRefs.length} file refs`);
   
   let rawBody = msg.msg.trim();
   
-  // Allow messages with only images (no text)
-  if (!rawBody && imageRefs.length === 0) return;
+  // Allow messages with only file attachments (no text)
+  if (!rawBody && fileRefs.length === 0) return;
 
   // Optional per-message overrides
   // - !thread  -> force reply in thread
@@ -392,8 +436,8 @@ async function handleIncomingMessage(
     forcedReplyMode = "channel";
     rawBody = rawBody.replace(/^!channel\b\s*/i, "").trim();
   }
-  // Skip if no text and no images
-  if (!rawBody && imageRefs.length === 0) return;
+  // Skip if no text and no file attachments
+  if (!rawBody && fileRefs.length === 0) return;
 
   // Determine reply mode
   const baseReplyMode: "thread" | "channel" | "auto" =
@@ -474,8 +518,8 @@ async function handleIncomingMessage(
     : undefined;
 
   // Format the envelope body
-  // For image-only messages, use a placeholder so the agent knows there's content
-  const effectiveRawBody = rawBody || (imageRefs.length > 0 ? "[image]" : "");
+  // For attachment-only messages, use a placeholder so the agent knows there's content
+  const effectiveRawBody = rawBody || (fileRefs.length > 0 ? "[attachment]" : "");
   const body = core.channel?.reply?.formatAgentEnvelope?.({
     channel: "Rocket.Chat",
     from: fromLabel,
@@ -485,34 +529,73 @@ async function handleIncomingMessage(
     body: effectiveRawBody,
   }) ?? effectiveRawBody;
 
-  // Rocket.Chat NOTE: Messages starting with "/" are treated as Rocket.Chat slash-commands.
-  // To make model switching usable from chat, we support an alternate syntax:
-  //   --model qwen3
-  //   --qwen3
-  // which we normalize into OpenClaw inline directives.
-  const commandBody = rawBody
+
+  // Inline directives (e.g. /model <ref>) should be parsed from the raw inbound text.
+  // Rocket.Chat users often type one-line directives like: "/model qwen3 hello".
+  // We split a leading directive into:
+  // - BodyForCommands: directive-only (so OpenClaw applies it)
+  // - BodyForAgent: the full envelope (so the agent retains context)
+  const normalizedRawBody = rawBody
+    // Shorthands (Rocket.Chat doesn't reliably allow leading `/...`)
+    .replace(/^\s*--opus\b/i, "/model opus")
+    .replace(/^\s*-opus\b/i, "/model opus")
+    .replace(/^\s*--oss\b/i, "/model oss")
+    .replace(/^\s*-oss\b/i, "/model oss")
     .replace(/^\s*--model\b/i, "/model")
+    .replace(/^\s*-model\b/i, "/model")
+    // Generic: `--foo` => `/foo` (we intentionally do NOT do this for single-dash to avoid
+    // accidental triggers on markdown bullets / negative numbers).
     .replace(/^\s*--/, "/");
 
-  // Fetch images as data URLs (authenticated fetch required for Rocket.Chat uploads)
-  let mediaUrls: string[] | undefined;
-  if (imageRefs.length > 0) {
+  const bodyForCommands = (() => {
+    const t = normalizedRawBody.trim();
+    if (!t.startsWith("/")) return normalizedRawBody;
+
+    // IMPORTANT: Rocket.Chat users can't reliably send leading `/...` (Rocket.Chat treats it as an internal slash command).
+    // We allow `--...` as a stand-in for `/...`.
+    //
+    // For directives like `/think high`, `/verbose full`, `/elevated ask`, etc, we must preserve arguments.
+    // So: when the message starts with a directive/command, pass the *full first line* to the command parser.
+    // (OpenClaw will apply it as a directive-only message if the remaining body is empty.)
+    return t.split("\n", 1)[0].trim();
+  })();
+
+  const commandAuthorized = true;
+  const bodyForAgent = body;
+
+  // Fetch files to temp (OpenClaw expects file paths, not data URLs)
+  let mediaPaths: string[] | undefined;
+  let mediaTypes: string[] | undefined;
+  const fileCleanups: Array<() => Promise<void>> = [];
+  
+  if (fileRefs.length > 0) {
     const fetched = await Promise.all(
-      imageRefs.map((ref) =>
-        fetchImageAsDataUrl(ref.url, authToken, userId, ref.mimeType)
+      fileRefs.map((ref) =>
+        fetchFileToTemp(ref.url, authToken, userId, ref.mimeType, ref.fileName)
       )
     );
-    mediaUrls = fetched.filter((u): u is string => u !== null);
-    if (mediaUrls.length > 0) {
-      logger.debug?.(`Fetched ${mediaUrls.length} image(s) from Rocket.Chat attachments`);
+    const validFiles = fetched.filter((f): f is FetchedFile => f !== null);
+    if (validFiles.length > 0) {
+      mediaPaths = validFiles.map((f) => f.path);
+      mediaTypes = validFiles.map((f) => f.mimeType);
+      fileCleanups.push(...validFiles.map((f) => f.cleanup));
+      logger.debug?.(`Fetched ${validFiles.length} file(s) from Rocket.Chat attachments`);
     }
   }
 
-  // Finalize inbound context
   const ctxPayload = core.channel?.reply?.finalizeInboundContext?.({
     Body: body,
+    BodyForAgent: bodyForAgent,
     RawBody: rawBody,
-    CommandBody: commandBody,
+    CommandBody: bodyForCommands,
+    // Be explicit: directives (/model, /qwen, etc.) should be parsed from the raw inbound text.
+    BodyForCommands: bodyForCommands,
+    // Hint to OpenClaw that this is plain text (not a platform-native slash command).
+    CommandSource: "text",
+
+    // Allow inline directives like /model ...
+    CommandAuthorized: commandAuthorized,
+
     From: isGroup ? `rocketchat:room:${roomId}` : `rocketchat:${senderId}`,
     To: `rocketchat:${roomId}`,
     SessionKey: route.sessionKey,
@@ -529,15 +612,15 @@ async function handleIncomingMessage(
     OriginatingChannel: "rocketchat",
     OriginatingTo: `rocketchat:${roomId}`,
 
-    // Image attachments (fetched as base64 data URLs)
-    MediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+    // Image attachments (fetched to temp files)
+    MediaPaths: mediaPaths?.length ? mediaPaths : undefined,
+    MediaTypes: mediaTypes?.length ? mediaTypes : undefined,
   });
 
   if (!ctxPayload) {
     logger.error?.(`Failed to finalize inbound context for message ${msg._id}`);
     return;
   }
-
   // Record inbound session
   if (storePath) {
     await core.channel?.session?.recordInboundSession?.({
@@ -628,5 +711,9 @@ async function handleIncomingMessage(
     });
   } finally {
     await stopTyping();
+    // Clean up temp files
+    for (const cleanup of fileCleanups) {
+      await cleanup();
+    }
   }
 }