@ascegu/teamily 1.0.19 → 1.0.23

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.23",
   "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

@@ -1,3 +1,4 @@
+import path from "node:path";
 import {
   applyAccountNameToChannelSection,
   buildChannelConfigSchema,
@@ -14,6 +15,9 @@ import {
   type ChannelOutboundContext,
   type ChannelStatusIssue,
   type HistoryEntry,
+  loadOutboundMediaFromUrl,
+  resolveOutboundMediaUrls,
+  sendMediaWithLeadingCaption,
 } from "openclaw/plugin-sdk";
 import {
   buildAccountScopedDmSecurityPolicy,
@@ -26,12 +30,13 @@ import {
 } from "./accounts.js";
 import { TeamilyConfigSchema } from "./config-schema.js";
 import type { CoreConfig } from "./config-schema.js";
-import { getTeamilyMonitor, startTeamilyMonitoring, stopTeamilyMonitoring } from "./monitor.js";
+import { getTeamilyMonitor, startTeamilyMonitoring, stopTeamilyMonitoring, type TeamilyMonitor } from "./monitor.js";
 import { normalizeTeamilyTarget, normalizeTeamilyAllowEntry } from "./normalize.js";
 import { probeTeamily } from "./probe.js";
 import { getTeamilyRuntime } from "./runtime.js";
 import type { ResolvedTeamilyAccount } from "./types.js";
 import { isGroupSession } from "./types.js";
+import { detectMediaCategory, guessContentType, isLocalMediaPath } from "./upload.js";
 
 const meta = {
   id: "teamily",
@@ -178,18 +183,22 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
       const monitor = requireMonitor(accountId);
       const target = normalizeTeamilyTarget(to);
 
-      let messageId: string;
-      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")) {
-        messageId = await monitor.sendAudio(target, mediaUrl);
-      } 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);
+      // Local file path: load buffer and send via SDK's *ByFile methods
+      // (SDK handles the upload internally, like Telegram's InputFile).
+      if (isLocalMediaPath(mediaUrl)) {
+        const media = await loadOutboundMediaFromUrl(mediaUrl, {
+          mediaLocalRoots: ctx.mediaLocalRoots,
+        });
+        const fileName = media.fileName || path.basename(mediaUrl) || "media";
+        const contentType = media.contentType || guessContentType(mediaUrl);
+        const messageId = await sendMediaBuffer(
+          monitor, target, media.buffer, fileName, contentType, mediaUrl,
+        );
+        return { channel: "teamily" as const, messageId };
       }
 
+      // Remote URL: use existing *ByURL methods.
+      const messageId = await sendMediaByUrl(monitor, target, mediaUrl);
       return { channel: "teamily" as const, messageId };
     },
   },
@@ -248,140 +257,167 @@ 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;
-
-        // 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,
-              },
-            });
+          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,
+                },
+              });
+            }
+            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;
-
-        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,
-        };
+          // 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;
 
-        log?.info?.(
-          `[${accountId}] Dispatching reply: sessionKey=${sessionKey}, chatType=${isGroup ? "group" : "direct"}, replyTarget=${replyTarget}`,
-        );
+          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}`,
+          );
 
-        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) {
+          await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: msgCtx,
+            cfg: currentCfg,
+            dispatcherOptions: {
+              deliver: async (payload) => {
                 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})`);
+                if (!monitor)
+                  throw new Error(`Teamily monitor not running for account ${accountId}`);
                 const target = normalizeTeamilyTarget(replyTarget);
-                await monitor.sendText(target, replyText);
-              }
-            },
-            onReplyStart: () => {
-              log?.info?.(`Agent reply started for ${from}`);
-            },
-          },
-        });
+                const replyText = (payload as Record<string, unknown>)?.text as string | undefined
+                  ?? (payload as Record<string, unknown>)?.body as string | undefined
+                  ?? "";
 
-        log?.info?.(`[${accountId}] Dispatch completed for ${sessionKey}`);
+                // Send media attachments (first with caption, rest without).
+                const mediaUrls = resolveOutboundMediaUrls(payload as Record<string, unknown>);
+                const sentMedia = await sendMediaWithLeadingCaption({
+                  mediaUrls,
+                  caption: replyText,
+                  send: async ({ mediaUrl: url, caption }) => {
+                    await loadAndSendMedia(monitor, target, url);
+                    // OpenIM doesn't support inline captions on media; send separately.
+                    if (caption) {
+                      await monitor.sendText(target, caption);
+                    }
+                  },
+                  onError: (error) => {
+                    log?.warn?.(`[${accountId}] Media send failed: ${String(error)}`);
+                  },
+                });
 
-        // Clear history buffer after dispatch so context doesn't repeat.
-        if (isGroup && historyKey) {
-          clearHistoryEntriesIfEnabled({
-            historyMap: groupHistories,
-            historyKey,
-            limit: historyLimit,
+                // If no media was sent, send text only.
+                if (!sentMedia && replyText) {
+                  log?.info?.(
+                    `[${accountId}] Sending reply to: ${replyTarget} (isGroup=${isGroup})`,
+                  );
+                  await monitor.sendText(target, replyText);
+                }
+              },
+              onReplyStart: () => {
+                log?.info?.(`Agent reply started for ${from}`);
+              },
+            },
           });
-        }
+
+          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,
+            });
+          }
         } catch (err) {
           log?.error?.(
             `[${accountId}] Error handling message from ${message.sendID}: ${err instanceof Error ? err.stack || err.message : String(err)}`,
@@ -410,7 +446,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 +456,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);
 
@@ -443,11 +478,73 @@ function applyTeamilyAccountConfig(params: {
   } as CoreConfig;
 }
 
+/** Send a local media buffer using SDK's *ByFile methods (SDK handles upload). */
+async function sendMediaBuffer(
+  monitor: TeamilyMonitor,
+  target: ReturnType<typeof normalizeTeamilyTarget>,
+  buffer: Buffer,
+  fileName: string,
+  contentType: string,
+  originalPath: string,
+): Promise<string> {
+  const category = detectMediaCategory(originalPath);
+  switch (category) {
+    case "video":
+      return monitor.sendVideoBuffer(target, buffer, fileName, contentType);
+    case "audio":
+      return monitor.sendAudioBuffer(target, buffer, fileName, contentType);
+    case "file":
+      return monitor.sendFileBuffer(target, buffer, fileName, contentType);
+    default:
+      return monitor.sendImageBuffer(target, buffer, fileName, contentType);
+  }
+}
+
+/** Send media by remote URL using existing *ByURL methods. */
+async function sendMediaByUrl(
+  monitor: TeamilyMonitor,
+  target: ReturnType<typeof normalizeTeamilyTarget>,
+  url: string,
+): Promise<string> {
+  const category = detectMediaCategory(url);
+  switch (category) {
+    case "video":
+      return monitor.sendVideo(target, url);
+    case "audio":
+      return monitor.sendAudio(target, url);
+    case "file":
+      return monitor.sendFile(target, url);
+    default:
+      return monitor.sendImage(target, url);
+  }
+}
+
+/**
+ * Load a local media file and send it via SDK buffer upload.
+ * For remote URLs, send directly via *ByURL methods.
+ */
+async function loadAndSendMedia(
+  monitor: TeamilyMonitor,
+  target: ReturnType<typeof normalizeTeamilyTarget>,
+  mediaUrl: string,
+): Promise<void> {
+  if (isLocalMediaPath(mediaUrl)) {
+    const media = await loadOutboundMediaFromUrl(mediaUrl);
+    const fileName = media.fileName || path.basename(mediaUrl) || "media";
+    const contentType = media.contentType || guessContentType(mediaUrl);
+    await sendMediaBuffer(monitor, target, media.buffer, fileName, contentType, mediaUrl);
+  } else {
+    await sendMediaByUrl(monitor, target, mediaUrl);
+  }
+}
+
 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

@@ -205,6 +205,99 @@ export class TeamilyMonitor {
     return result.data?.serverMsgID || result.data?.clientMsgID || "";
   }
 
+  // ---- Buffer-based send methods (local file → SDK upload) ----
+  // Like Telegram's InputFile(buffer), pass a buffer and let the SDK upload.
+
+  /** Send an image from a local buffer. SDK handles the upload to object storage. */
+  async sendImageBuffer(target: TeamilyMessageTarget, buffer: Buffer, fileName: string, contentType: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const file = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    const picInfo = { uuid: "", type: contentType, width: 0, height: 0, size: buffer.length, url: "" };
+    const created = await sdk.createImageMessageByFile({
+      sourcePicture: picInfo,
+      bigPicture: picInfo,
+      snapshotPicture: picInfo,
+      sourcePath: "",
+      file,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send a video from a local buffer. SDK handles the upload to object storage. */
+  async sendVideoBuffer(target: TeamilyMessageTarget, buffer: Buffer, fileName: string, contentType: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const videoFile = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    // snapshotFile is required by the SDK type but we have no thumbnail; use an empty file.
+    const snapshotFile = new File([], "snapshot.jpg", { type: "image/jpeg" });
+    const created = await sdk.createVideoMessageByFile({
+      videoPath: "",
+      duration: 0,
+      videoType: contentType,
+      snapshotPath: "",
+      videoUUID: "",
+      videoUrl: "",
+      videoSize: buffer.length,
+      snapshotUUID: "",
+      snapshotSize: 0,
+      snapshotUrl: "",
+      snapshotWidth: 0,
+      snapshotHeight: 0,
+      videoFile,
+      snapshotFile,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send an audio/sound from a local buffer. SDK handles the upload to object storage. */
+  async sendAudioBuffer(target: TeamilyMessageTarget, buffer: Buffer, fileName: string, contentType: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const file = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    const created = await sdk.createSoundMessageByFile({
+      uuid: "",
+      soundPath: "",
+      sourceUrl: "",
+      dataSize: buffer.length,
+      duration: 0,
+      file,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send a document/file from a local buffer. SDK handles the upload to object storage. */
+  async sendFileBuffer(target: TeamilyMessageTarget, buffer: Buffer, fileName: string, contentType: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const file = new File([new Uint8Array(buffer)], fileName, { type: contentType });
+    const created = await sdk.createFileMessageByFile({
+      filePath: "",
+      fileName,
+      uuid: "",
+      sourceUrl: "",
+      fileSize: buffer.length,
+      file,
+    });
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message: created.data,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
   private requireSdk(): SdkInstance {
     if (!this.sdk) {
       throw new Error("Teamily SDK not connected");

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;

package/src/upload.ts

@@ -0,0 +1,46 @@
+import path from "node:path";
+
+/** Returns true if the media URL is a local file path rather than a remote URL. */
+export function isLocalMediaPath(mediaUrl: string): boolean {
+  return !(/^https?:\/\//i.test(mediaUrl));
+}
+
+/** Detect the media category from a file extension. */
+export type MediaCategory = "image" | "video" | "audio" | "file";
+
+export function detectMediaCategory(filePath: string): MediaCategory {
+  const ext = path.extname(filePath).toLowerCase();
+  if ([".mp4", ".mov", ".webm"].includes(ext)) return "video";
+  if ([".mp3", ".m4a", ".wav", ".ogg"].includes(ext)) return "audio";
+  if ([".pdf", ".doc", ".docx", ".zip"].includes(ext)) return "file";
+  return "image";
+}
+
+/**
+ * Guess a reasonable MIME content type from a file extension.
+ * Falls back to application/octet-stream for unknown types.
+ */
+export function guessContentType(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",
+    ".bmp": "image/bmp",
+    ".svg": "image/svg+xml",
+    ".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",
+  };
+  return map[ext] ?? "application/octet-stream";
+}