@ascegu/teamily 1.0.19 → 1.0.22

package/README.md

@@ -26,29 +26,28 @@ openclaw channel configure teamily
 
 ### Server Settings
 
-| Field         | Description              | Default                   |
-|---------------|--------------------------|---------------------------|
-| `platformUrl` | Teamily platform URL     | `https://imserver-test.teamily.ai/im_api`  |
-| `apiURL`      | Teamily REST API URL     | `https://imserver-test.teamily.ai/im_api`  |
-| `wsURL`       | Teamily WebSocket URL    | `wss://imserver-test.teamily.ai/msg_gateway`    |
+| Field    | Description           | Default                                      |
+| -------- | --------------------- | -------------------------------------------- |
+| `apiURL` | Teamily REST API URL  | `https://imserver-test.teamily.ai/im_api`    |
+| `wsURL`  | Teamily WebSocket URL | `wss://imserver-test.teamily.ai/msg_gateway` |
 
 ### Bot Account Settings
 
-| Field      | Required | Description                     |
-|------------|----------|---------------------------------|
-| `userID`   | Yes      | User ID for the bot account     |
-| `token`    | Yes      | User token for authentication   |
-| `nickname` | No       | Display nickname                |
-| `faceURL`  | No       | Avatar URL                      |
+| Field      | Required | Description                   |
+| ---------- | -------- | ----------------------------- |
+| `userID`   | Yes      | User ID for the bot account   |
+| `token`    | Yes      | User token for authentication |
+| `nickname` | No       | Display nickname              |
+| `faceURL`  | No       | Avatar URL                    |
 
 ### DM Security
 
 Per-account or channel-level DM security can be configured:
 
-| Field              | Description                                          |
-|--------------------|------------------------------------------------------|
-| `dm.policy`        | DM security policy (`pairing`, `allowlist`, `open`)  |
-| `dm.allowFrom`     | List of allowed sender IDs                           |
+| Field          | Description                                         |
+| -------------- | --------------------------------------------------- |
+| `dm.policy`    | DM security policy (`pairing`, `allowlist`, `open`) |
+| `dm.allowFrom` | List of allowed sender IDs                          |
 
 ### Example Configuration
 
@@ -57,7 +56,6 @@ channels:
   teamily:
     enabled: true
     server:
-      platformUrl: https://imserver-test.teamily.ai/im_api
       apiURL: https://imserver-test.teamily.ai/im_api
       wsURL: wss://imserver-test.teamily.ai/msg_gateway
     accounts:
@@ -91,12 +89,12 @@ openclaw message send teamily:user:userID --media /path/to/image.jpg
 
 Supported media types are auto-detected by file extension:
 
-| Extension                    | Type  |
-|------------------------------|-------|
-| `.jpg`, `.png`, `.gif`, etc. | Image |
-| `.mp4`, `.mov`, `.webm`     | Video |
-| `.mp3`, `.m4a`, `.wav`      | Audio |
-| `.pdf`, `.doc`, `.docx`, `.zip` | File |
+| Extension                       | Type  |
+| ------------------------------- | ----- |
+| `.jpg`, `.png`, `.gif`, etc.    | Image |
+| `.mp4`, `.mov`, `.webm`         | Video |
+| `.mp3`, `.m4a`, `.wav`          | Audio |
+| `.pdf`, `.doc`, `.docx`, `.zip` | File  |
 
 ## Group Chat Behavior
 
@@ -107,19 +105,19 @@ Supported media types are auto-detected by file extension:
 
 ## Capabilities
 
-| Feature                   | Supported |
-|---------------------------|-----------|
-| Direct messaging          | Yes       |
-| Group messaging           | Yes       |
-| Text messages             | Yes       |
-| Media (image/video/audio/file) | Yes |
-| @-mention gating (groups) | Yes       |
-| WebSocket real-time monitoring | Yes  |
-| Automatic reconnection    | Yes       |
-| Connection health probes  | Yes       |
-| Reactions                 | No        |
-| Threads                   | No        |
-| Polls                     | No        |
+| Feature                        | Supported |
+| ------------------------------ | --------- |
+| Direct messaging               | Yes       |
+| Group messaging                | Yes       |
+| Text messages                  | Yes       |
+| Media (image/video/audio/file) | Yes       |
+| @-mention gating (groups)      | Yes       |
+| WebSocket real-time monitoring | Yes       |
+| Automatic reconnection         | Yes       |
+| Connection health probes       | Yes       |
+| Reactions                      | No        |
+| Threads                        | No        |
+| Polls                          | No        |
 
 ## Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.19",
+  "version": "1.0.22",
   "description": "OpenClaw Teamily channel plugin - Team instant messaging server integration",
   "keywords": [
     "channel",

package/src/accounts.ts

@@ -38,7 +38,6 @@ export function resolveTeamilyAccount(
   return {
     accountId: targetAccountId,
     enabled: true,
-    platformUrl: config.server.platformUrl,
     apiURL: config.server.apiURL,
     wsURL: config.server.wsURL,
     userID: account.userID,

package/src/channel.ts

@@ -182,9 +182,18 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
       const urlLower = mediaUrl.toLowerCase();
       if (urlLower.endsWith(".mp4") || urlLower.endsWith(".mov") || urlLower.endsWith(".webm")) {
         messageId = await monitor.sendVideo(target, mediaUrl);
-      } else if (urlLower.endsWith(".mp3") || urlLower.endsWith(".m4a") || urlLower.endsWith(".wav")) {
+      } else if (
+        urlLower.endsWith(".mp3") ||
+        urlLower.endsWith(".m4a") ||
+        urlLower.endsWith(".wav")
+      ) {
         messageId = await monitor.sendAudio(target, mediaUrl);
-      } else if (urlLower.endsWith(".pdf") || urlLower.endsWith(".doc") || urlLower.endsWith(".docx") || urlLower.endsWith(".zip")) {
+      } else if (
+        urlLower.endsWith(".pdf") ||
+        urlLower.endsWith(".doc") ||
+        urlLower.endsWith(".docx") ||
+        urlLower.endsWith(".zip")
+      ) {
         messageId = await monitor.sendFile(target, mediaUrl);
       } else {
         messageId = await monitor.sendImage(target, mediaUrl);
@@ -248,140 +257,146 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
 
       const stopFn = startTeamilyMonitoring(account, async (message) => {
         try {
-        const rt = getTeamilyRuntime();
-        const currentCfg = rt.config.loadConfig();
+          const rt = getTeamilyRuntime();
+          const currentCfg = rt.config.loadConfig();
 
-        const isGroup = isGroupSession(message.sessionType);
-        const from = message.sendID;
-        const rawText = message.content?.text || "";
+          const isGroup = isGroupSession(message.sessionType);
+          const from = message.sendID;
+          const rawText = message.content?.text || "";
 
-        log?.info?.(
-          `[${accountId}] Incoming message: sessionType=${message.sessionType}, isGroup=${isGroup}, ` +
-          `from=${from}, recvID=${message.recvID}, isAtSelf=${message.isAtSelf ?? false}`,
-        );
+          log?.info?.(
+            `[${accountId}] Incoming message: sessionType=${message.sessionType}, isGroup=${isGroup}, ` +
+              `from=${from}, recvID=${message.recvID}, isAtSelf=${message.isAtSelf ?? false}`,
+          );
 
-        const historyKey = isGroup ? `teamily:group:${message.recvID}` : undefined;
+          const historyKey = isGroup ? `teamily:group:${message.recvID}` : undefined;
 
-        // In group chats, buffer non-@-mention text-only messages for context.
-        // Media messages (picture/video/audio) are always dispatched — OpenIM sends
-        // @-mention text and media as separate messages, so a PICTURE following an
-        // AT_TEXT won't have isAtSelf=true. Dispatching media keeps group image
-        // handling consistent with DM behavior.
-        const hasMedia = !!(
-          message.content?.picture ||
-          message.content?.video ||
-          message.content?.audio
-        );
-        if (isGroup && !message.isAtSelf && !hasMedia) {
-          if (historyKey && rawText) {
-            recordPendingHistoryEntryIfEnabled({
-              historyMap: groupHistories,
-              historyKey,
-              limit: historyLimit,
-              entry: {
-                sender: from,
-                body: rawText,
-                timestamp: message.sendTime,
-              },
-            });
+          // In group chats, buffer non-@-mention text-only messages for context.
+          // Media messages (picture/video/audio) are always dispatched — OpenIM sends
+          // @-mention text and media as separate messages, so a PICTURE following an
+          // AT_TEXT won't have isAtSelf=true. Dispatching media keeps group image
+          // handling consistent with DM behavior.
+          const hasMedia = !!(
+            message.content?.picture ||
+            message.content?.video ||
+            message.content?.audio
+          );
+          if (isGroup && !message.isAtSelf && !hasMedia) {
+            if (historyKey && rawText) {
+              recordPendingHistoryEntryIfEnabled({
+                historyMap: groupHistories,
+                historyKey,
+                limit: historyLimit,
+                entry: {
+                  sender: from,
+                  body: rawText,
+                  timestamp: message.sendTime,
+                },
+              });
+            }
+            return;
           }
-          return;
-        }
 
-        const sessionKey = isGroup ? `teamily:group:${message.recvID}` : `teamily:${from}`;
+          const sessionKey = isGroup ? `teamily:group:${message.recvID}` : `teamily:${from}`;
 
-        let mediaUrl: string | undefined;
-        if (message.content?.picture?.sourcePicture?.url) {
-          mediaUrl = message.content.picture.sourcePicture.url;
-        } else if (message.content?.video?.videoUrl) {
-          mediaUrl = message.content.video.videoUrl;
-        } else if (message.content?.audio?.sourceUrl) {
-          mediaUrl = message.content.audio.sourceUrl;
-        }
+          let mediaUrl: string | undefined;
+          if (message.content?.picture?.sourcePicture?.url) {
+            mediaUrl = message.content.picture.sourcePicture.url;
+          } else if (message.content?.video?.videoUrl) {
+            mediaUrl = message.content.video.videoUrl;
+          } else if (message.content?.audio?.sourceUrl) {
+            mediaUrl = message.content.audio.sourceUrl;
+          }
 
-        // Download remote media to a local temp file so the agent recognises
-        // image-only messages (hasMediaAttachment checks MediaPath, not MediaUrl).
-        let mediaPath: string | undefined;
-        let mediaType: string | undefined;
-        if (mediaUrl) {
-          try {
-            const fetched = await rt.channel.media.fetchRemoteMedia({ url: mediaUrl, maxBytes: MEDIA_MAX_BYTES });
-            const saved = await rt.channel.media.saveMediaBuffer(
-              fetched.buffer,
-              fetched.contentType,
-              "inbound",
-              MEDIA_MAX_BYTES,
-            );
-            mediaPath = saved.path;
-            mediaType = saved.contentType;
-          } catch (err) {
-            log?.warn?.(`[${accountId}] Failed to download Teamily media: ${String(err)}`);
+          // Download remote media to a local temp file so the agent recognises
+          // image-only messages (hasMediaAttachment checks MediaPath, not MediaUrl).
+          let mediaPath: string | undefined;
+          let mediaType: string | undefined;
+          if (mediaUrl) {
+            try {
+              const fetched = await rt.channel.media.fetchRemoteMedia({
+                url: mediaUrl,
+                maxBytes: MEDIA_MAX_BYTES,
+              });
+              const saved = await rt.channel.media.saveMediaBuffer(
+                fetched.buffer,
+                fetched.contentType,
+                "inbound",
+                MEDIA_MAX_BYTES,
+              );
+              mediaPath = saved.path;
+              mediaType = saved.contentType;
+            } catch (err) {
+              log?.warn?.(`[${accountId}] Failed to download Teamily media: ${String(err)}`);
+            }
           }
-        }
 
-        // For group @-mention messages, prepend buffered history as context.
-        const body =
-          isGroup && historyKey
-            ? buildPendingHistoryContextFromMap({
-                historyMap: groupHistories,
-                historyKey,
-                limit: historyLimit,
-                currentMessage: rawText,
-                formatEntry: (entry) => `${entry.sender}: ${entry.body}`,
-              })
-            : rawText;
+          // For group @-mention messages, prepend buffered history as context.
+          const body =
+            isGroup && historyKey
+              ? buildPendingHistoryContextFromMap({
+                  historyMap: groupHistories,
+                  historyKey,
+                  limit: historyLimit,
+                  currentMessage: rawText,
+                  formatEntry: (entry) => `${entry.sender}: ${entry.body}`,
+                })
+              : rawText;
 
-        const replyTarget = isGroup ? `group:${message.recvID}` : from;
-        const msgCtx = {
-          Body: body,
-          From: from,
-          To: account.userID,
-          SessionKey: sessionKey,
-          AccountId: accountId,
-          Provider: "teamily" as const,
-          Surface: "teamily" as const,
-          OriginatingChannel: "teamily" as const,
-          OriginatingTo: replyTarget,
-          ChatType: isGroup ? "group" : "direct",
-          MediaUrl: mediaUrl,
-          MediaPath: mediaPath,
-          MediaType: mediaType,
-        };
+          const replyTarget = isGroup ? `group:${message.recvID}` : from;
+          const msgCtx = {
+            Body: body,
+            From: from,
+            To: account.userID,
+            SessionKey: sessionKey,
+            AccountId: accountId,
+            Provider: "teamily" as const,
+            Surface: "teamily" as const,
+            OriginatingChannel: "teamily" as const,
+            OriginatingTo: replyTarget,
+            ChatType: isGroup ? "group" : "direct",
+            MediaUrl: mediaUrl,
+            MediaPath: mediaPath,
+            MediaType: mediaType,
+          };
 
-        log?.info?.(
-          `[${accountId}] Dispatching reply: sessionKey=${sessionKey}, chatType=${isGroup ? "group" : "direct"}, replyTarget=${replyTarget}`,
-        );
+          log?.info?.(
+            `[${accountId}] Dispatching reply: sessionKey=${sessionKey}, chatType=${isGroup ? "group" : "direct"}, replyTarget=${replyTarget}`,
+          );
 
-        await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-          ctx: msgCtx,
-          cfg: currentCfg,
-          dispatcherOptions: {
-            deliver: async (payload: { text?: string; body?: string }) => {
-              const replyText = payload?.text ?? payload?.body;
-              if (replyText) {
-                const monitor = getTeamilyMonitor(accountId);
-                if (!monitor) throw new Error(`Teamily monitor not running for account ${accountId}`);
-                log?.info?.(`[${accountId}] Sending reply to: ${replyTarget} (isGroup=${isGroup})`);
-                const target = normalizeTeamilyTarget(replyTarget);
-                await monitor.sendText(target, replyText);
-              }
-            },
-            onReplyStart: () => {
-              log?.info?.(`Agent reply started for ${from}`);
+          await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: msgCtx,
+            cfg: currentCfg,
+            dispatcherOptions: {
+              deliver: async (payload: { text?: string; body?: string }) => {
+                const replyText = payload?.text ?? payload?.body;
+                if (replyText) {
+                  const monitor = getTeamilyMonitor(accountId);
+                  if (!monitor)
+                    throw new Error(`Teamily monitor not running for account ${accountId}`);
+                  log?.info?.(
+                    `[${accountId}] Sending reply to: ${replyTarget} (isGroup=${isGroup})`,
+                  );
+                  const target = normalizeTeamilyTarget(replyTarget);
+                  await monitor.sendText(target, replyText);
+                }
+              },
+              onReplyStart: () => {
+                log?.info?.(`Agent reply started for ${from}`);
+              },
             },
-          },
-        });
+          });
 
-        log?.info?.(`[${accountId}] Dispatch completed for ${sessionKey}`);
+          log?.info?.(`[${accountId}] Dispatch completed for ${sessionKey}`);
 
-        // Clear history buffer after dispatch so context doesn't repeat.
-        if (isGroup && historyKey) {
-          clearHistoryEntriesIfEnabled({
-            historyMap: groupHistories,
-            historyKey,
-            limit: historyLimit,
-          });
-        }
+          // Clear history buffer after dispatch so context doesn't repeat.
+          if (isGroup && historyKey) {
+            clearHistoryEntriesIfEnabled({
+              historyMap: groupHistories,
+              historyKey,
+              limit: historyLimit,
+            });
+          }
         } catch (err) {
           log?.error?.(
             `[${accountId}] Error handling message from ${message.sendID}: ${err instanceof Error ? err.stack || err.message : String(err)}`,
@@ -410,7 +425,7 @@ function applyTeamilyAccountConfig(params: {
 }): CoreConfig {
   const { cfg, accountId, input } = params;
   const existing = cfg.channels?.teamily;
-  const server = existing?.server ?? { platformUrl: "", apiURL: "", wsURL: "" };
+  const server = existing?.server ?? { apiURL: "", wsURL: "" };
   const accounts = existing?.accounts ?? {};
 
   const accountUpdate: Record<string, unknown> = {};
@@ -420,7 +435,6 @@ function applyTeamilyAccountConfig(params: {
   if (input.faceURL) accountUpdate.faceURL = String(input.faceURL);
 
   const serverUpdate: Record<string, string> = {};
-  if (input.platformUrl) serverUpdate.platformUrl = String(input.platformUrl);
   if (input.apiURL) serverUpdate.apiURL = String(input.apiURL);
   if (input.wsURL) serverUpdate.wsURL = String(input.wsURL);
 
@@ -447,7 +461,9 @@ function requireMonitor(accountId?: string | null) {
   const id = accountId || "default";
   const monitor = getTeamilyMonitor(id);
   if (!monitor) {
-    throw new Error(`Teamily gateway not running for account "${id}" — outbound requires an active gateway`);
+    throw new Error(
+      `Teamily gateway not running for account "${id}" — outbound requires an active gateway`,
+    );
   }
   return monitor;
 }

package/src/config-schema.ts

@@ -5,7 +5,6 @@ import type { TeamilyConfig } from "./types.js";
 
 // Server configuration schema
 export const TeamilyServerConfigSchema = z.object({
-  platformUrl: z.string().url().default("http://localhost:10002").describe("Teamily platform URL"),
   apiURL: z.string().url().default("http://localhost:10002").describe("Teamily REST API URL"),
   wsURL: z.string().url().default("ws://localhost:10001").describe("Teamily WebSocket URL"),
 });

package/src/monitor.ts

@@ -36,6 +36,11 @@ async function loadSDK() {
  * reconnection to the official OpenIM SDK. Also exposes send methods
  * so outbound replies flow through the same WebSocket connection.
  */
+/** Returns true when the string looks like an HTTP(S) URL rather than a local file path. */
+function isHttpUrl(s: string): boolean {
+  return s.startsWith("http://") || s.startsWith("https://");
+}
+
 export class TeamilyMonitor {
   private account: ResolvedTeamilyAccount;
   private onMessage: TeamilyMessageHandler;
@@ -126,9 +131,29 @@ export class TeamilyMonitor {
     return result.data?.serverMsgID || result.data?.clientMsgID || "";
   }
 
+  /**
+   * Upload a local file to the OpenIM server and return its download URL.
+   * Uses the SDK's built-in uploadFile which handles multipart upload to
+   * the server's object storage. Requires Node.js 20+ for global File.
+   */
+  async uploadLocalFile(localPath: string, contentType?: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const { readFileSync } = await import("node:fs");
+    const { basename, extname } = await import("node:path");
+    const buffer = readFileSync(localPath);
+    const fileName = basename(localPath);
+    const mime = contentType || guessMimeType(extname(localPath));
+    const file = new File([buffer], fileName, { type: mime });
+    const result = await sdk.uploadFile({ file, name: fileName, contentType: mime });
+    const url = result.data?.url;
+    if (!url) throw new Error(`Upload failed for ${localPath}: no URL returned`);
+    return url;
+  }
+
   /** Send an image message through the SDK WebSocket connection. */
-  async sendImage(target: TeamilyMessageTarget, url: string): Promise<string> {
+  async sendImage(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
     const sdk = this.requireSdk();
+    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const picInfo = { uuid: "", type: "", width: 0, height: 0, size: 0, url };
     const created = await sdk.createImageMessageByURL({
       sourcePicture: picInfo,
@@ -145,8 +170,9 @@ export class TeamilyMonitor {
   }
 
   /** Send a video message through the SDK WebSocket connection. */
-  async sendVideo(target: TeamilyMessageTarget, url: string): Promise<string> {
+  async sendVideo(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
     const sdk = this.requireSdk();
+    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createVideoMessageByURL({
       videoPath: "",
       duration: 0,
@@ -170,8 +196,9 @@ export class TeamilyMonitor {
   }
 
   /** Send a sound/audio message through the SDK WebSocket connection. */
-  async sendAudio(target: TeamilyMessageTarget, url: string): Promise<string> {
+  async sendAudio(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
     const sdk = this.requireSdk();
+    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createSoundMessageByURL({
       uuid: "",
       soundPath: "",
@@ -188,11 +215,12 @@ export class TeamilyMonitor {
   }
 
   /** Send a file message through the SDK WebSocket connection. */
-  async sendFile(target: TeamilyMessageTarget, url: string, fileName?: string): Promise<string> {
+  async sendFile(target: TeamilyMessageTarget, urlOrPath: string, fileName?: string): Promise<string> {
     const sdk = this.requireSdk();
+    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createFileMessageByURL({
       filePath: "",
-      fileName: fileName || url.split("/").pop() || "file",
+      fileName: fileName || urlOrPath.split("/").pop() || "file",
       uuid: "",
       sourceUrl: url,
       fileSize: 0,
@@ -218,6 +246,32 @@ export class TeamilyMonitor {
   }
 }
 
+// ---- MIME type helper ----
+
+const MIME_MAP: Record<string, string> = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".zip": "application/zip",
+};
+
+function guessMimeType(ext: string): string {
+  return MIME_MAP[ext.toLowerCase()] || "application/octet-stream";
+}
+
 // ---- SDK message conversion helpers ----
 
 import type { MessageItem } from "@openim/client-sdk";

package/src/types.ts

@@ -1,7 +1,6 @@
 // Core configuration types for Teamily channel
 
 export interface TeamilyServerConfig {
-  platformUrl: string;
   apiURL: string;
   wsURL: string;
 }
@@ -29,7 +28,6 @@ export interface TeamilyConfig {
 export interface ResolvedTeamilyAccount {
   accountId: string;
   enabled: boolean;
-  platformUrl: string;
   apiURL: string;
   wsURL: string;
   userID: string;