@cloudrise/openclaw-channel-rocketchat 0.1.9 → 0.1.11

package/README.md

@@ -145,6 +145,7 @@ Then restart the gateway.
 
 ## Features
 
+- **Image attachments**: receives images 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.9",
+  "version": "0.1.11",
   "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,
@@ -22,7 +27,7 @@ import {
   type RocketChatRoom,
   type RocketChatClient,
 } from "./client.js";
-import { RocketChatRealtime, type IncomingMessage } from "./realtime.js";
+import { RocketChatRealtime, type IncomingMessage, type RocketChatAttachment, type RocketChatFile } from "./realtime.js";
 import { sendMessageRocketChat } from "./send.js";
 
 export type MonitorRocketChatOpts = {
@@ -70,6 +75,105 @@ 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.
+ * Returns full URLs that can be fetched with auth headers.
+ */
+function extractImageUrls(
+  msg: IncomingMessage,
+  baseUrl: string
+): Array<{ url: string; mimeType?: string }> {
+  const images: Array<{ url: string; mimeType?: string }> = [];
+
+  // From attachments array (used for image_url references)
+  if (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 });
+      }
+    }
+  }
+
+  // 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 images;
+}
+
+type FetchedImage = {
+  path: string;
+  mimeType: string;
+  cleanup: () => Promise<void>;
+};
+
+/**
+ * Fetch an image from Rocket.Chat and save to a temp file.
+ * Returns the file path (OpenClaw expects file paths, not data URLs).
+ */
+async function fetchImageToTempFile(
+  url: string,
+  authToken: string,
+  userId: string,
+  mimeType?: string
+): Promise<FetchedImage | null> {
+  try {
+    const res = await fetch(url, {
+      headers: {
+        "X-Auth-Token": authToken,
+        "X-User-Id": userId,
+      },
+    });
+    if (!res.ok) return null;
+
+    const contentType = mimeType ?? res.headers.get("content-type") ?? "image/png";
+    if (!isImageMime(contentType)) return null;
+
+    const buffer = Buffer.from(await res.arrayBuffer());
+    
+    // Determine extension from mime type
+    const ext = contentType.includes("png") ? ".png" 
+      : contentType.includes("gif") ? ".gif"
+      : contentType.includes("webp") ? ".webp"
+      : ".jpg";
+    
+    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;
+  }
+}
+
 export async function monitorRocketChatProvider(
   opts: MonitorRocketChatOpts
 ): Promise<() => void> {
@@ -293,8 +397,21 @@ async function handleIncomingMessage(
     ? msg.ts.$date 
     : Date.parse(String(msg.ts));
 
+  // Extract image attachments (if any)
+  const baseUrl = account.baseUrl;
+  const authToken = account.authToken;
+  const userId = account.userId;
+  
+  // 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 imageRefs = extractImageUrls(msg, baseUrl);
+  logger.debug?.(`[RC DEBUG] Extracted ${imageRefs.length} image refs`);
+  
   let rawBody = msg.msg.trim();
-  if (!rawBody) return;
+  
+  // Allow messages with only images (no text)
+  if (!rawBody && imageRefs.length === 0) return;
 
   // Optional per-message overrides
   // - !thread  -> force reply in thread
@@ -307,7 +424,8 @@ async function handleIncomingMessage(
     forcedReplyMode = "channel";
     rawBody = rawBody.replace(/^!channel\b\s*/i, "").trim();
   }
-  if (!rawBody) return;
+  // Skip if no text and no images
+  if (!rawBody && imageRefs.length === 0) return;
 
   // Determine reply mode
   const baseReplyMode: "thread" | "channel" | "auto" =
@@ -388,29 +506,84 @@ 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]" : "");
   const body = core.channel?.reply?.formatAgentEnvelope?.({
     channel: "Rocket.Chat",
     from: fromLabel,
     timestamp: ts,
     previousTimestamp,
     envelope: envelopeOptions,
-    body: rawBody,
-  }) ?? rawBody;
-
-  // 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
+    body: effectiveRawBody,
+  }) ?? effectiveRawBody;
+
+
+  // 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*--/, "/");
 
-  // Finalize inbound context
+  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 images to temp files (OpenClaw expects file paths, not data URLs)
+  let mediaPaths: string[] | undefined;
+  let mediaTypes: string[] | undefined;
+  const imageCleanups: Array<() => Promise<void>> = [];
+  
+  if (imageRefs.length > 0) {
+    const fetched = await Promise.all(
+      imageRefs.map((ref) =>
+        fetchImageToTempFile(ref.url, authToken, userId, ref.mimeType)
+      )
+    );
+    const validImages = fetched.filter((img): img is FetchedImage => img !== null);
+    if (validImages.length > 0) {
+      mediaPaths = validImages.map((img) => img.path);
+      mediaTypes = validImages.map((img) => img.mimeType);
+      imageCleanups.push(...validImages.map((img) => img.cleanup));
+      logger.debug?.(`Fetched ${validImages.length} image(s) from Rocket.Chat attachments`);
+    }
+  }
+
   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,
@@ -426,13 +599,16 @@ async function handleIncomingMessage(
     Timestamp: ts,
     OriginatingChannel: "rocketchat",
     OriginatingTo: `rocketchat:${roomId}`,
+
+    // 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?.({
@@ -523,5 +699,9 @@ async function handleIncomingMessage(
     });
   } finally {
     await stopTyping();
+    // Clean up temp image files
+    for (const cleanup of imageCleanups) {
+      await cleanup();
+    }
   }
 }

package/src/rocketchat/realtime.ts

@@ -33,6 +33,24 @@ export type RealtimeOpts = {
   logger?: { debug?: (msg: string) => void; info?: (msg: string) => void };
 };
 
+export type RocketChatAttachment = {
+  title?: string;
+  title_link?: string;
+  image_url?: string;
+  audio_url?: string;
+  video_url?: string;
+  type?: string;
+  image_type?: string;
+  image_size?: number;
+};
+
+export type RocketChatFile = {
+  _id: string;
+  name: string;
+  type?: string;
+  size?: number;
+};
+
 export type IncomingMessage = {
   _id: string;
   rid: string;
@@ -41,12 +59,9 @@ export type IncomingMessage = {
   u: { _id: string; username: string; name?: string };
   tmid?: string;
   t?: string;
-  attachments?: Array<{
-    title?: string;
-    image_url?: string;
-    audio_url?: string;
-    video_url?: string;
-  }>;
+  attachments?: RocketChatAttachment[];
+  file?: RocketChatFile;
+  files?: RocketChatFile[];
 };
 
 export class RocketChatRealtime {