@cloudrise/openclaw-channel-rocketchat 0.1.0 → 0.1.10

package/.env.example

@@ -0,0 +1,4 @@
+# Rocket.Chat test credentials (DO NOT COMMIT REAL VALUES)
+ROCKETCHAT_BASE_URL=http://localhost:3000
+ROCKETCHAT_AUTH_TOKEN=replace_me
+ROCKETCHAT_USER_ID=replace_me

package/README.md

@@ -1,20 +1,338 @@
-# @cloudrise/openclaw-channel-rocketchat
+# OpenClaw Rocket.Chat Channel Plugin
 
-Rocket.Chat channel plugin for **OpenClaw** (Cloudrise-maintained).
+[![npm](https://img.shields.io/npm/v/@cloudrise/openclaw-channel-rocketchat)](https://www.npmjs.com/package/@cloudrise/openclaw-channel-rocketchat)
+[![license](https://img.shields.io/npm/l/@cloudrise/openclaw-channel-rocketchat)](LICENSE)
+
+Neutral, self-host friendly Rocket.Chat channel plugin for **OpenClaw** (Cloudrise-maintained).
 
 - **Inbound:** Rocket.Chat Realtime (DDP/WebSocket) subscribe to `stream-room-messages`
 - **Outbound:** Rocket.Chat REST `chat.postMessage`
 
+## Upgrade / rename notice
+
+If you were using the old Clawdbot-era package:
+
+- Old: `@cloudrise/clawdbot-channel-rocketchat`
+- New: `@cloudrise/openclaw-channel-rocketchat`
+
+## Authors
+
+- Chad (AI assistant running in OpenClaw) — primary implementer
+- Marshal Morse — project owner, requirements, infrastructure, and testing
+
+## Quickstart (5–10 minutes)
+
+1) **Create a Rocket.Chat bot user** (or a dedicated user account) and obtain:
+   - `userId`
+   - `authToken` (treat like a password)
+
+2) **Add the bot user to the rooms** you want it to monitor (channels/private groups). For DMs, ensure users can message the bot.
+
+3) **Install + enable the plugin in OpenClaw**
+
+```yaml
+plugins:
+  installs:
+    rocketchat:
+      source: npm
+      spec: "@cloudrise/openclaw-channel-rocketchat"
+  entries:
+    rocketchat:
+      enabled: true
+
+channels:
+  rocketchat:
+    baseUrl: "https://chat.example.com"
+    userId: "<ROCKETCHAT_USER_ID>"
+    authToken: "<ROCKETCHAT_AUTH_TOKEN>"
+
+    # Optional: keep noise down
+    replyMode: auto
+    rooms:
+      GENERAL:
+        requireMention: true
+```
+
+4) **Restart the gateway**.
+
+5) **Test** by @mentioning the bot in a room it’s a member of.
+
+### Example chat commands (reply to a room + model switching)
+
+In Rocket.Chat you can send a normal message, or you can switch the session’s model first.
+
+**Switch model, then ask a question**:
+
+Rocket.Chat treats messages starting with `/` as Rocket.Chat slash-commands.
+So for model switching, either:
+
+- put the directive *after* an @mention (works on most servers/clients), or
+- use the plugin’s alternate `--model` / `--<alias>` syntax.
+
+```text
+# Option A: use /model after an @mention
+@Chad /model qwen3
+@Chad write a 5-line summary of our incident in plain English
+
+# Option B: alternate syntax (avoids Rocket.Chat /commands)
+@Chad --model qwen3
+@Chad write a 5-line summary of our incident in plain English
+
+# Option C: shorthand alias form
+@Chad --qwen3
+@Chad write a 5-line summary of our incident in plain English
+```
+
+**Example output** (with `messages.responsePrefix: "({model}) "` enabled):
+
+```text
+(mlx-qwen/mlx-community/Qwen3-14B-4bit) Here’s a 5-line summary...
+...
+```
+
+**Send a one-off message to a specific Rocket.Chat room** (from the gateway host):
+
+```bash
+openclaw message send --channel rocketchat --to room:GENERAL --message "Hello from OpenClaw"
+```
+
+**Send using a specific model for that one message**:
+
+```bash
+openclaw message send --channel rocketchat --to room:GENERAL --message "/model qwen3 Hello from Qwen3"
+```
+
+---
+
 ## Install
 
+### Install from npm
+
 ```bash
-npm i @cloudrise/openclaw-channel-rocketchat
+npm install @cloudrise/openclaw-channel-rocketchat
 ```
 
-## Upgrade / rename notice
+### Configure OpenClaw to load the plugin
 
-If you were using the old Clawdbot-era package:
+You need to tell OpenClaw to load the installed plugin.
 
-- Old: `@cloudrise/clawdbot-channel-rocketchat`
-- New: `@cloudrise/openclaw-channel-rocketchat`
+**Option A (recommended): install via `plugins.installs` (npm source)**
+
+```yaml
+plugins:
+  installs:
+    rocketchat:
+      source: npm
+      spec: "@cloudrise/openclaw-channel-rocketchat"
+  entries:
+    rocketchat:
+      enabled: true
+```
+
+**Option B: load from a local path**
+
+```yaml
+plugins:
+  load:
+    paths:
+      - /absolute/path/to/node_modules/@cloudrise/openclaw-channel-rocketchat
+  entries:
+    rocketchat:
+      enabled: true
+```
+
+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
+
+There are two parts:
+
+1) **Switching models in chat** (temporary, per-session) via `/model ...`
+2) **Defining short aliases** like `qwen3` so you don’t have to type the full `provider/model`
+
+### Switching models in chat (`/model`)
+
+In any chat where OpenClaw slash-commands are enabled, you can switch the current session’s model:
+
+```text
+/model
+/model list
+/model status
+/model openai/gpt-5.2
+/model qwen3
+```
+
+Tip: on Rocket.Chat you’ll often be writing something like:
+
+```text
+@Chad /model qwen3
+@Chad what do you think about ...
+```
+
+### Model aliases (shortcuts like `qwen3`)
+
+OpenClaw supports **model aliases** so you can type a short name (like `qwen3`) instead of a full `provider/model` ref.
+
+**Option A: define aliases in config**
+
+Aliases come from `agents.defaults.models.<modelId>.alias`.
+
+```yaml
+agents:
+  defaults:
+    models:
+      "mlx-qwen/mlx-community/qwen3-14b-4bit":
+        alias: qwen3
+```
+
+**Option B: use the CLI**
+
+```bash
+openclaw models aliases add qwen3 mlx-qwen/mlx-community/Qwen3-14B-4bit
+openclaw models aliases list
+```
+
+Notes:
+- Model refs are normalized to lowercase.
+- If you define the same alias in config and via CLI, your config value wins.
+
+## Configuration
+
+> Use the room **rid** (e.g. `GENERAL`) for per-room settings.
+
+### Minimal (single account)
+
+```yaml
+channels:
+  rocketchat:
+    baseUrl: "https://chat.example.com"
+    userId: "<ROCKETCHAT_USER_ID>"
+    authToken: "<ROCKETCHAT_AUTH_TOKEN>"
+```
+
+### Multiple accounts / multiple Rocket.Chat servers
+
+You can configure multiple Rocket.Chat “accounts” under `channels.rocketchat.accounts` and choose which one to use via `accountId` when sending.
+
+```yaml
+channels:
+  rocketchat:
+    accounts:
+      prod:
+        name: "Prod RC"
+        baseUrl: "https://chat.example.com"
+        userId: "<PROD_USER_ID>"
+        authToken: "<PROD_AUTH_TOKEN>"
+
+      staging:
+        name: "Staging RC"
+        baseUrl: "https://chat-staging.example.com"
+        userId: "<STAGING_USER_ID>"
+        authToken: "<STAGING_AUTH_TOKEN>"
+```
+
+Notes:
+- The legacy single-account format (top-level `baseUrl/userId/authToken`) still works and is treated as `accountId: default`.
+- Per-room settings live under each account (e.g. `channels.rocketchat.accounts.prod.rooms`).
+
+### Reply routing (thread vs channel)
+
+```yaml
+channels:
+  rocketchat:
+    # thread | channel | auto
+    replyMode: auto
+
+    rooms:
+      GENERAL:
+        requireMention: false
+        # Optional per-room override
+        # replyMode: channel
+```
+
+**Auto rules** (deterministic):
+- If the inbound message is already in a thread (`tmid` exists) → reply in that thread
+- Else if the inbound message is “long” (≥280 chars or contains a newline) → reply in a thread
+- Else → reply in channel
+
+### Per-message overrides
+
+Prefix your message:
+- `!thread ...` → force the reply to be posted as a thread reply
+- `!channel ...` → force the reply to be posted in the channel
+
+(The prefix is stripped before the message is sent to the agent.)
+
+### Typing indicator
+
+```yaml
+channels:
+  rocketchat:
+    # Delay (ms) before emitting typing indicator
+    typingDelayMs: 500
+```
+
+(When using multiple accounts, this can also be set per account at `channels.rocketchat.accounts.<accountId>.typingDelayMs`.)
+
+Typing indicators are emitted via DDP `stream-notify-room` using `<RID>/user-activity`.
+- Channel replies emit typing without `tmid` → shows under channel composer
+- Thread replies include `{ tmid: ... }` → shows under thread composer
+
+## Development
+
+```bash
+git clone git@github.com:cloudrise-network/openclaw-channel-rocketchat.git
+cd openclaw-channel-rocketchat
+npm install
+```
+
+Local smoke tests (uses env vars; see `.env.example`):
+
+```bash
+# REST send
+node test-chad.mjs
+
+# Realtime receive
+node test-realtime.mjs
+```
+
+## Packaging + publishing (no secrets)
+
+Before publishing:
+
+1) Run a quick secret scan (at minimum):
+
+```bash
+grep -RIn --exclude-dir=node_modules --exclude=package-lock.json -E "npm_[A-Za-z0-9]+|ghp_[A-Za-z0-9]+|xox[baprs]-|authToken\s*[:=]\s*\"" .
+```
+
+2) Bump version in `package.json`.
+
+3) Verify the tarball:
+
+```bash
+npm pack
+```
+
+4) Publish:
+
+```bash
+npm publish
+```
+
+(There is also a GitHub Actions workflow in `.github/workflows/publish.yml`.)
+
+## Security
+
+Treat Rocket.Chat `authToken` like a password.
+
+This repository is intended to be publishable (no secrets committed).
+
+## License
 
+MIT

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@cloudrise/openclaw-channel-rocketchat",
-  "version": "0.1.0",
+  "version": "0.1.10",
   "description": "Rocket.Chat channel plugin for OpenClaw (Cloudrise)",
+  "license": "MIT",
   "type": "module",
   "main": "index.ts",
   "openclaw": {

package/src/rocketchat/monitor.ts

@@ -8,6 +8,8 @@ import type {
   RuntimeEnv,
 } from "openclaw/plugin-sdk";
 
+import { createReplyPrefixContext } from "openclaw/plugin-sdk";
+
 import { getRocketChatRuntime } from "../runtime.js";
 import { resolveRocketChatAccount, type ResolvedRocketChatAccount } from "./accounts.js";
 import {
@@ -20,7 +22,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 = {
@@ -68,17 +70,92 @@ 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;
+}
+
+/**
+ * Fetch an image from Rocket.Chat and return as base64 data URL.
+ */
+async function fetchImageAsDataUrl(
+  url: string,
+  authToken: string,
+  userId: string,
+  mimeType?: string
+): Promise<string | 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 = await res.arrayBuffer();
+    const base64 = Buffer.from(buffer).toString("base64");
+    return `data:${contentType};base64,${base64}`;
+  } catch {
+    return null;
+  }
+}
+
 export async function monitorRocketChatProvider(
   opts: MonitorRocketChatOpts
 ): Promise<() => void> {
-  console.log("[ROCKETCHAT DEBUG] monitorRocketChatProvider called!");
   const core = getRocketChatRuntime();
   const logger = core?.logging?.getChildLogger?.({ module: "rocketchat" }) ?? {
     info: console.log,
     debug: console.log,
     error: console.error,
   };
-  console.log("[ROCKETCHAT DEBUG] Got logger, getting config...");
   const cfg = opts.config ?? core?.config?.loadConfig?.() ?? {};
 
   const account = resolveRocketChatAccount({
@@ -229,9 +306,7 @@ export async function monitorRocketChatProvider(
   });
 
   // Connect and subscribe to all rooms
-  console.log("[ROCKETCHAT DEBUG] About to connect realtime...");
   await realtime.connect();
-  console.log("[ROCKETCHAT DEBUG] Realtime connected!");
   
   // Subscribe to current rooms
   await refreshSubscriptions();
@@ -295,8 +370,16 @@ 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;
+  const imageRefs = extractImageUrls(msg, baseUrl);
+  
   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
@@ -309,7 +392,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" =
@@ -390,20 +474,45 @@ 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;
+    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
+    .replace(/^\s*--model\b/i, "/model")
+    .replace(/^\s*--/, "/");
+
+  // Fetch images as data URLs (authenticated fetch required for Rocket.Chat uploads)
+  let mediaUrls: string[] | undefined;
+  if (imageRefs.length > 0) {
+    const fetched = await Promise.all(
+      imageRefs.map((ref) =>
+        fetchImageAsDataUrl(ref.url, authToken, userId, ref.mimeType)
+      )
+    );
+    mediaUrls = fetched.filter((u): u is string => u !== null);
+    if (mediaUrls.length > 0) {
+      logger.debug?.(`Fetched ${mediaUrls.length} image(s) from Rocket.Chat attachments`);
+    }
+  }
 
   // Finalize inbound context
   const ctxPayload = core.channel?.reply?.finalizeInboundContext?.({
     Body: body,
     RawBody: rawBody,
-    CommandBody: rawBody,
+    CommandBody: commandBody,
     From: isGroup ? `rocketchat:room:${roomId}` : `rocketchat:${senderId}`,
     To: `rocketchat:${roomId}`,
     SessionKey: route.sessionKey,
@@ -419,6 +528,9 @@ async function handleIncomingMessage(
     Timestamp: ts,
     OriginatingChannel: "rocketchat",
     OriginatingTo: `rocketchat:${roomId}`,
+
+    // Image attachments (fetched as base64 data URLs)
+    MediaUrls: mediaUrls?.length ? mediaUrls : undefined,
   });
 
   if (!ctxPayload) {
@@ -484,10 +596,16 @@ async function handleIncomingMessage(
   startTypingAfterDelay();
 
   try {
+    // Wire up responsePrefix support (e.g. messages.responsePrefix: "({model}) ")
+    // so Rocket.Chat replies can include the selected model name.
+    const prefix = createReplyPrefixContext({ cfg, agentId: route.agentId });
+
     await core.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher?.({
       ctx: ctxPayload,
       cfg,
       dispatcherOptions: {
+        responsePrefix: prefix.responsePrefix,
+        responsePrefixContextProvider: prefix.responsePrefixContextProvider,
         deliver: async (payload) => {
           const text = (payload as { text?: string }).text ?? "";
           if (!text.trim()) return;
@@ -504,6 +622,9 @@ async function handleIncomingMessage(
           logger.error?.(`Rocket.Chat ${info.kind} reply failed: ${String(err)}`);
         },
       },
+      replyOptions: {
+        onModelSelected: prefix.onModelSelected,
+      },
     });
   } finally {
     await stopTyping();

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 {

package/test-chad.mjs

@@ -1,79 +1,23 @@
-import WebSocket from "ws";
-
-const baseUrl = "http://10.99.0.4:3000";
-const authToken = "m2E8phh3dmtOag3UTh84d60YZOQVfa6wjhIWBV01jRr";
-const userId = "M3NTzRzjwZfE9FRxi";
-
-const wsUrl = baseUrl.replace(/^http/, "ws") + "/websocket";
-console.log("Connecting as Chad to:", wsUrl);
-
-const ws = new WebSocket(wsUrl);
-let msgId = 0;
-
-function send(msg) {
-  console.log(">>> SEND:", JSON.stringify(msg));
-  ws.send(JSON.stringify(msg));
+// Local manual test helper.
+// DO NOT hardcode credentials in this repo.
+//
+// Usage:
+//   export ROCKETCHAT_BASE_URL='https://your-rocketchat'
+//   export ROCKETCHAT_AUTH_TOKEN='...'
+//   export ROCKETCHAT_USER_ID='...'
+//   node ./test-realtime.mjs
+
+const baseUrl = process.env.ROCKETCHAT_BASE_URL;
+const authToken = process.env.ROCKETCHAT_AUTH_TOKEN;
+const userId = process.env.ROCKETCHAT_USER_ID;
+
+if (!baseUrl || !authToken || !userId) {
+  throw new Error('Missing env: ROCKETCHAT_BASE_URL, ROCKETCHAT_AUTH_TOKEN, ROCKETCHAT_USER_ID');
 }
 
-ws.on("open", () => {
-  console.log("Connected, sending DDP connect...");
-  send({ msg: "connect", version: "1", support: ["1"] });
-});
-
-ws.on("message", (data) => {
-  const msg = JSON.parse(data.toString());
-  console.log("<<< RECV:", JSON.stringify(msg).slice(0, 200));
-  
-  if (msg.msg === "connected") {
-    console.log("DDP connected, logging in as Chad...");
-    send({
-      msg: "method",
-      method: "login",
-      id: String(++msgId),
-      params: [{ resume: authToken }]
-    });
-  }
-  
-  if (msg.msg === "result" && msg.id === "1") {
-    if (msg.error) {
-      console.error("LOGIN FAILED:", msg.error);
-      ws.close();
-      return;
-    }
-    console.log("Logged in as Chad! Subscribing to GENERAL...");
-    send({
-      msg: "sub",
-      id: String(++msgId),
-      name: "stream-room-messages",
-      params: ["GENERAL", false]
-    });
-  }
-  
-  if (msg.msg === "ping") {
-    send({ msg: "pong" });
-  }
-  
-  if (msg.msg === "changed") {
-    console.log("\n*** MESSAGE RECEIVED ***");
-    console.log(JSON.stringify(msg, null, 2));
-    console.log("************************\n");
-  }
-  
-  if (msg.msg === "nosub") {
-    console.error("SUBSCRIPTION FAILED:", msg);
-  }
-});
-
-ws.on("error", (err) => {
-  console.error("WebSocket Error:", err.message);
-});
-
-ws.on("close", (code, reason) => {
-  console.log("Connection closed:", code, reason?.toString());
-});
+console.log('Base URL:', baseUrl);
+console.log('User ID:', userId);
+console.log('Auth token set:', authToken ? 'yes' : 'no');
 
-console.log("Listening for 60 seconds... Send a message in #general!");
-setTimeout(() => {
-  console.log("Test complete, closing...");
-  ws.close();
-}, 60000);
+// TODO: call into the library / run your test logic here.
+console.log('TODO: implement test logic');

package/test-chad2.mjs

@@ -1,111 +1,23 @@
-import WebSocket from "ws";
-
-const baseUrl = "http://10.99.0.4:3000";
-const authToken = "m2E8phh3dmtOag3UTh84d60YZOQVfa6wjhIWBV01jRr";
-const userId = "M3NTzRzjwZfE9FRxi";
-
-const wsUrl = baseUrl.replace(/^http/, "ws") + "/websocket";
-console.log("Connecting as Chad to:", wsUrl);
-
-const ws = new WebSocket(wsUrl);
-let msgId = 0;
-
-function send(msg) {
-  console.log(">>> SEND:", JSON.stringify(msg));
-  ws.send(JSON.stringify(msg));
+// Local manual test helper.
+// DO NOT hardcode credentials in this repo.
+//
+// Usage:
+//   export ROCKETCHAT_BASE_URL='https://your-rocketchat'
+//   export ROCKETCHAT_AUTH_TOKEN='...'
+//   export ROCKETCHAT_USER_ID='...'
+//   node ./test-realtime.mjs
+
+const baseUrl = process.env.ROCKETCHAT_BASE_URL;
+const authToken = process.env.ROCKETCHAT_AUTH_TOKEN;
+const userId = process.env.ROCKETCHAT_USER_ID;
+
+if (!baseUrl || !authToken || !userId) {
+  throw new Error('Missing env: ROCKETCHAT_BASE_URL, ROCKETCHAT_AUTH_TOKEN, ROCKETCHAT_USER_ID');
 }
 
-ws.on("open", () => {
-  console.log("Connected, sending DDP connect...");
-  send({ msg: "connect", version: "1", support: ["1"] });
-});
-
-ws.on("message", (data) => {
-  const msg = JSON.parse(data.toString());
-  const preview = JSON.stringify(msg).slice(0, 300);
-  console.log("<<< RECV:", preview);
-  
-  if (msg.msg === "connected") {
-    console.log("\n=== DDP connected, logging in as Chad... ===\n");
-    send({
-      msg: "method",
-      method: "login",
-      id: String(++msgId),
-      params: [{ resume: authToken }]
-    });
-  }
-  
-  if (msg.msg === "result" && msg.id === "1") {
-    if (msg.error) {
-      console.error("LOGIN FAILED:", msg.error);
-      ws.close();
-      return;
-    }
-    console.log("\n=== Logged in! Trying multiple subscription formats... ===\n");
-    
-    // Try format 1: just roomId and boolean
-    send({
-      msg: "sub",
-      id: String(++msgId),
-      name: "stream-room-messages",
-      params: ["GENERAL", false]
-    });
-    
-    // Try format 2: with event name
-    send({
-      msg: "sub", 
-      id: String(++msgId),
-      name: "stream-room-messages",
-      params: ["GENERAL", { useCollection: false, args: [{ visitorToken: null }] }]
-    });
-    
-    // Try format 3: stream-notify-user for notifications
-    send({
-      msg: "sub",
-      id: String(++msgId),
-      name: "stream-notify-user",
-      params: [`${userId}/notification`, false]
-    });
-    
-    // Try format 4: stream-notify-room
-    send({
-      msg: "sub",
-      id: String(++msgId),
-      name: "stream-notify-room",
-      params: ["GENERAL/deleteMessage", false]
-    });
-  }
-  
-  if (msg.msg === "ping") {
-    send({ msg: "pong" });
-  }
-  
-  if (msg.msg === "changed") {
-    console.log("\n**************************************************");
-    console.log("*** MESSAGE/EVENT RECEIVED ***");
-    console.log(JSON.stringify(msg, null, 2));
-    console.log("**************************************************\n");
-  }
-  
-  if (msg.msg === "nosub") {
-    console.error("SUBSCRIPTION FAILED:", JSON.stringify(msg));
-  }
-  
-  if (msg.msg === "ready") {
-    console.log("=== Subscription ready:", msg.subs, "===");
-  }
-});
-
-ws.on("error", (err) => {
-  console.error("WebSocket Error:", err.message);
-});
-
-ws.on("close", (code, reason) => {
-  console.log("Connection closed:", code, reason?.toString());
-});
+console.log('Base URL:', baseUrl);
+console.log('User ID:', userId);
+console.log('Auth token set:', authToken ? 'yes' : 'no');
 
-console.log("Listening for 45 seconds... Send a message in #general!");
-setTimeout(() => {
-  console.log("Test complete, closing...");
-  ws.close();
-}, 45000);
+// TODO: call into the library / run your test logic here.
+console.log('TODO: implement test logic');

package/test-realtime.mjs

@@ -1,68 +1,23 @@
-import WebSocket from "ws";
-
-const baseUrl = "http://10.99.0.4:3000";
-const authToken = "tZATKtqCY9b4q7X9RbY0_d6v5uZg7rDTvW7mqDKPHjF";
-const userId = "j4CZSpAFxRoSk6ieH";
-
-const wsUrl = baseUrl.replace(/^http/, "ws") + "/websocket";
-console.log("Connecting to:", wsUrl);
-
-const ws = new WebSocket(wsUrl);
-let msgId = 0;
-
-function send(msg) {
-  console.log(">>> SEND:", JSON.stringify(msg));
-  ws.send(JSON.stringify(msg));
+// Local manual test helper.
+// DO NOT hardcode credentials in this repo.
+//
+// Usage:
+//   export ROCKETCHAT_BASE_URL='https://your-rocketchat'
+//   export ROCKETCHAT_AUTH_TOKEN='...'
+//   export ROCKETCHAT_USER_ID='...'
+//   node ./test-realtime.mjs
+
+const baseUrl = process.env.ROCKETCHAT_BASE_URL;
+const authToken = process.env.ROCKETCHAT_AUTH_TOKEN;
+const userId = process.env.ROCKETCHAT_USER_ID;
+
+if (!baseUrl || !authToken || !userId) {
+  throw new Error('Missing env: ROCKETCHAT_BASE_URL, ROCKETCHAT_AUTH_TOKEN, ROCKETCHAT_USER_ID');
 }
 
-ws.on("open", () => {
-  console.log("Connected, sending DDP connect...");
-  send({ msg: "connect", version: "1", support: ["1"] });
-});
-
-ws.on("message", (data) => {
-  const msg = JSON.parse(data.toString());
-  console.log("<<< RECV:", JSON.stringify(msg));
-  
-  if (msg.msg === "connected") {
-    console.log("DDP connected, logging in...");
-    send({
-      msg: "method",
-      method: "login",
-      id: String(++msgId),
-      params: [{ resume: authToken }]
-    });
-  }
-  
-  if (msg.msg === "result" && msg.id === "1") {
-    console.log("Logged in! Subscribing to GENERAL...");
-    send({
-      msg: "sub",
-      id: String(++msgId),
-      name: "stream-room-messages",
-      params: ["GENERAL", false]
-    });
-  }
-  
-  if (msg.msg === "ping") {
-    send({ msg: "pong" });
-  }
-  
-  if (msg.msg === "changed") {
-    console.log("*** MESSAGE RECEIVED ***", msg);
-  }
-});
-
-ws.on("error", (err) => {
-  console.error("Error:", err);
-});
-
-ws.on("close", (code, reason) => {
-  console.log("Closed:", code, reason?.toString());
-});
+console.log('Base URL:', baseUrl);
+console.log('User ID:', userId);
+console.log('Auth token set:', authToken ? 'yes' : 'no');
 
-// Keep alive
-setTimeout(() => {
-  console.log("Test complete, closing...");
-  ws.close();
-}, 60000);
+// TODO: call into the library / run your test logic here.
+console.log('TODO: implement test logic');