@ascegu/teamily 1.0.9 → 1.0.11

package/package.json

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

package/src/channel.ts

@@ -21,11 +21,10 @@ import {
 } from "./accounts.js";
 import { TeamilyConfigSchema } from "./config-schema.js";
 import type { CoreConfig } from "./config-schema.js";
-import { startTeamilyMonitoring, stopTeamilyMonitoring } from "./monitor.js";
+import { getTeamilyMonitor, startTeamilyMonitoring, stopTeamilyMonitoring } from "./monitor.js";
 import { normalizeTeamilyTarget, normalizeTeamilyAllowEntry } from "./normalize.js";
 import { probeTeamily } from "./probe.js";
 import { getTeamilyRuntime } from "./runtime.js";
-import { sendMessageTeamily, sendMediaTeamily } from "./send.js";
 import type { ResolvedTeamilyAccount } from "./types.js";
 import { SESSION_TYPES } from "./types.js";
 
@@ -89,13 +88,12 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
     notifyApproval: async ({ id, cfg }) => {
       try {
         const accountId = resolveDefaultTeamilyAccountId(cfg as CoreConfig);
-        const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
         const target = normalizeTeamilyTarget(id);
-        await sendMessageTeamily({
-          account,
-          target,
-          text: PAIRING_APPROVED_MESSAGE,
-        });
+        const monitor = getTeamilyMonitor(accountId);
+        if (monitor) {
+          await monitor.sendText(target, PAIRING_APPROVED_MESSAGE);
+        }
+        // If monitor isn't running, skip silently — pairing was still approved
       } catch {
         // Silently fail on notification
       }
@@ -152,71 +150,42 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
       }
       try {
         const target = normalizeTeamilyTarget(to);
-        return { ok: true, to: target.id };
+        // Preserve the full target format so sendText/sendMedia can distinguish user vs group
+        const resolved = target.type === "group" ? `group:${target.id}` : target.id;
+        return { ok: true, to: resolved };
       } catch (err) {
         return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
       }
     },
     sendText: async (ctx: ChannelOutboundContext) => {
       const { to, text, accountId } = ctx;
-      const account = resolveTeamilyAccount(ctx.cfg as CoreConfig, accountId);
+      const monitor = requireMonitor(accountId);
       const target = normalizeTeamilyTarget(to);
-
-      const result = await sendMessageTeamily({
-        account,
-        target,
-        text,
-        replyToId: ctx.replyToId || undefined,
-      });
-
-      if (!result.success) {
-        throw new Error(result.error || "Failed to send message");
-      }
-
-      return { channel: "teamily" as const, messageId: result.messageId ?? "" };
+      const messageId = await monitor.sendText(target, text);
+      return { channel: "teamily" as const, messageId };
     },
     sendMedia: async (ctx: ChannelOutboundContext) => {
-      const { to, text, accountId } = ctx;
+      const { to, accountId } = ctx;
       const mediaUrl = ctx.mediaUrl;
       if (!mediaUrl) {
         throw new Error("Media URL is required");
       }
-      const account = resolveTeamilyAccount(ctx.cfg as CoreConfig, accountId);
+      const monitor = requireMonitor(accountId);
       const target = normalizeTeamilyTarget(to);
 
-      // Determine media type from URL or assume image
-      let mediaType: "image" | "video" | "audio" | "file" = "image";
+      let messageId: string;
       const urlLower = mediaUrl.toLowerCase();
       if (urlLower.endsWith(".mp4") || urlLower.endsWith(".mov") || urlLower.endsWith(".webm")) {
-        mediaType = "video";
-      } else if (
-        urlLower.endsWith(".mp3") ||
-        urlLower.endsWith(".m4a") ||
-        urlLower.endsWith(".wav")
-      ) {
-        mediaType = "audio";
-      } else if (
-        urlLower.endsWith(".pdf") ||
-        urlLower.endsWith(".doc") ||
-        urlLower.endsWith(".docx") ||
-        urlLower.endsWith(".zip")
-      ) {
-        mediaType = "file";
+        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);
       }
 
-      const result = await sendMediaTeamily({
-        account,
-        target,
-        mediaUrl,
-        mediaType,
-        caption: text,
-      });
-
-      if (!result.success) {
-        throw new Error(result.error || "Failed to send media");
-      }
-
-      return { channel: "teamily" as const, messageId: result.messageId ?? "" };
+      return { channel: "teamily" as const, messageId };
     },
   },
   status: {
@@ -268,6 +237,8 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
 
       log?.info?.(`Starting Teamily channel (account: ${accountId})`);
 
+      const MEDIA_MAX_BYTES = 5 * 1024 * 1024; // 5 MB
+
       const stopFn = startTeamilyMonitoring(account, async (message) => {
         const rt = getTeamilyRuntime();
         const currentCfg = rt.config.loadConfig();
@@ -286,6 +257,26 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
           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)}`);
+          }
+        }
+
         const msgCtx = {
           Body: text,
           From: from,
@@ -296,6 +287,8 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
           OriginatingTo: from,
           ChatType: isGroup ? "group" : "direct",
           MediaUrl: mediaUrl,
+          MediaPath: mediaPath,
+          MediaType: mediaType,
         };
 
         await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
@@ -305,8 +298,10 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
             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}`);
                 const target = normalizeTeamilyTarget(from);
-                await sendMessageTeamily({ account, target, text: replyText });
+                await monitor.sendText(target, replyText);
               }
             },
             onReplyStart: () => {
@@ -369,3 +364,12 @@ function applyTeamilyAccountConfig(params: {
     },
   } as CoreConfig;
 }
+
+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`);
+  }
+  return monitor;
+}

package/src/monitor.ts

@@ -1,6 +1,7 @@
 import type {
   ResolvedTeamilyAccount,
   TeamilyMessage,
+  TeamilyMessageTarget,
   TeamilyPictureContent,
   TeamilyVideoContent,
   TeamilyAudioContent,
@@ -32,7 +33,8 @@ async function loadSDK() {
  * Monitor for incoming Teamily messages using @openim/client-sdk.
  *
  * Delegates WebSocket connection, authentication, heartbeat, and
- * reconnection to the official OpenIM SDK.
+ * reconnection to the official OpenIM SDK. Also exposes send methods
+ * so outbound replies flow through the same WebSocket connection.
  */
 export class TeamilyMonitor {
   private account: ResolvedTeamilyAccount;
@@ -56,7 +58,6 @@ export class TeamilyMonitor {
     const sdk = getSDK();
     this.sdk = sdk;
 
-    // Connection events
     sdk.on(CbEvents.OnConnecting, () => {
       if (!this.stopped) this.setState("connecting");
     });
@@ -73,15 +74,12 @@ export class TeamilyMonitor {
       if (!this.stopped) this.setState("error", "Token expired");
     });
 
-    // Incoming messages
     sdk.on(CbEvents.OnRecvNewMessages, ({ data }) => {
       if (this.stopped || !data) return;
       for (const msg of data) {
-        // Skip self-sent messages
         if (msg.sendID === this.account.userID) continue;
         const converted = convertSdkMessage(msg, this.account.userID);
         if (converted) {
-          // Fire-and-forget; errors are logged by the gateway dispatcher
           void this.onMessage(converted);
         }
       }
@@ -115,6 +113,105 @@ export class TeamilyMonitor {
     return this.state;
   }
 
+  /** Send a text message through the SDK WebSocket connection. */
+  async sendText(target: TeamilyMessageTarget, text: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const created = await sdk.createTextMessage(text);
+    const message = created.data;
+    const result = await sdk.sendMessage({
+      recvID: target.type === "user" ? target.id : "",
+      groupID: target.type === "group" ? target.id : "",
+      message,
+    });
+    return result.data?.serverMsgID || result.data?.clientMsgID || "";
+  }
+
+  /** Send an image message through the SDK WebSocket connection. */
+  async sendImage(target: TeamilyMessageTarget, url: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const picInfo = { uuid: "", type: "", width: 0, height: 0, size: 0, url };
+    const created = await sdk.createImageMessageByURL({
+      sourcePicture: picInfo,
+      bigPicture: picInfo,
+      snapshotPicture: { ...picInfo, url: "" },
+      sourcePath: "",
+    });
+    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 message through the SDK WebSocket connection. */
+  async sendVideo(target: TeamilyMessageTarget, url: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const created = await sdk.createVideoMessageByURL({
+      videoPath: "",
+      duration: 0,
+      videoType: "mp4",
+      snapshotPath: "",
+      videoUUID: "",
+      videoUrl: url,
+      videoSize: 0,
+      snapshotUUID: "",
+      snapshotSize: 0,
+      snapshotUrl: "",
+      snapshotWidth: 0,
+      snapshotHeight: 0,
+    });
+    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 sound/audio message through the SDK WebSocket connection. */
+  async sendAudio(target: TeamilyMessageTarget, url: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const created = await sdk.createSoundMessageByURL({
+      uuid: "",
+      soundPath: "",
+      sourceUrl: url,
+      dataSize: 0,
+      duration: 0,
+    });
+    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 file message through the SDK WebSocket connection. */
+  async sendFile(target: TeamilyMessageTarget, url: string, fileName?: string): Promise<string> {
+    const sdk = this.requireSdk();
+    const created = await sdk.createFileMessageByURL({
+      filePath: "",
+      fileName: fileName || url.split("/").pop() || "file",
+      uuid: "",
+      sourceUrl: url,
+      fileSize: 0,
+    });
+    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");
+    }
+    return this.sdk;
+  }
+
   private setState(state: TeamilyConnectionState, error?: string): void {
     this.state = state;
     this.onStateChange?.(state, error);
@@ -131,7 +228,6 @@ function convertSdkMessage(msg: MessageItem, selfUserID: string): TeamilyMessage
 
   const content = parseSdkContent(msg, contentType);
 
-  // Skip messages with no usable content
   if (!content.text && !content.picture && !content.video && !content.audio) {
     return null;
   }
@@ -150,7 +246,6 @@ function convertSdkMessage(msg: MessageItem, selfUserID: string): TeamilyMessage
 function parseSdkContent(msg: MessageItem, contentType: number): TeamilyMessage["content"] {
   switch (contentType) {
     case CONTENT_TYPES.TEXT: {
-      // SDK puts text in textElem.content; fallback to raw content string
       const text = msg.textElem?.content ?? tryParseTextContent(msg.content);
       return text ? { text } : {};
     }
@@ -174,7 +269,6 @@ function parseSdkContent(msg: MessageItem, contentType: number): TeamilyMessage[
   }
 }
 
-/** Try to extract text from the raw JSON content string (OpenIM text format: `{"content":"..."}`) */
 function tryParseTextContent(raw: string | undefined): string | undefined {
   if (!raw) return undefined;
   try {