@ascegu/teamily 1.0.22 → 1.0.23

package/package.json

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

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,27 +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 };
     },
   },
@@ -368,16 +368,37 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
             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}`);
+              deliver: async (payload) => {
+                const monitor = getTeamilyMonitor(accountId);
+                if (!monitor)
+                  throw new Error(`Teamily monitor not running for account ${accountId}`);
+                const target = normalizeTeamilyTarget(replyTarget);
+                const replyText = (payload as Record<string, unknown>)?.text as string | undefined
+                  ?? (payload as Record<string, unknown>)?.body as string | undefined
+                  ?? "";
+
+                // 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)}`);
+                  },
+                });
+
+                // If no media was sent, send text only.
+                if (!sentMedia && replyText) {
                   log?.info?.(
                     `[${accountId}] Sending reply to: ${replyTarget} (isGroup=${isGroup})`,
                   );
-                  const target = normalizeTeamilyTarget(replyTarget);
                   await monitor.sendText(target, replyText);
                 }
               },
@@ -457,6 +478,66 @@ 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);

package/src/monitor.ts

@@ -36,11 +36,6 @@ 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;
@@ -131,29 +126,9 @@ 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, urlOrPath: string): Promise<string> {
+  async sendImage(target: TeamilyMessageTarget, url: 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,
@@ -170,9 +145,8 @@ export class TeamilyMonitor {
   }
 
   /** Send a video message through the SDK WebSocket connection. */
-  async sendVideo(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
+  async sendVideo(target: TeamilyMessageTarget, url: string): Promise<string> {
     const sdk = this.requireSdk();
-    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createVideoMessageByURL({
       videoPath: "",
       duration: 0,
@@ -196,9 +170,8 @@ export class TeamilyMonitor {
   }
 
   /** Send a sound/audio message through the SDK WebSocket connection. */
-  async sendAudio(target: TeamilyMessageTarget, urlOrPath: string): Promise<string> {
+  async sendAudio(target: TeamilyMessageTarget, url: string): Promise<string> {
     const sdk = this.requireSdk();
-    const url = isHttpUrl(urlOrPath) ? urlOrPath : await this.uploadLocalFile(urlOrPath);
     const created = await sdk.createSoundMessageByURL({
       uuid: "",
       soundPath: "",
@@ -215,12 +188,11 @@ export class TeamilyMonitor {
   }
 
   /** Send a file message through the SDK WebSocket connection. */
-  async sendFile(target: TeamilyMessageTarget, urlOrPath: string, fileName?: string): Promise<string> {
+  async sendFile(target: TeamilyMessageTarget, url: 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 || urlOrPath.split("/").pop() || "file",
+      fileName: fileName || url.split("/").pop() || "file",
       uuid: "",
       sourceUrl: url,
       fileSize: 0,
@@ -233,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");
@@ -246,32 +311,6 @@ 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/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";
+}