@ascegu/teamily 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "OpenClaw Teamily channel plugin - Team instant messaging server integration",
   "keywords": [
     "channel",
@@ -29,6 +29,7 @@
   "type": "module",
   "main": "index.ts",
   "dependencies": {
+    "@openim/client-sdk": "^3.8.3",
     "zod": "^4.3.6"
   },
   "openclaw": {

package/src/monitor.ts

@@ -1,4 +1,3 @@
-import { generateOperationID } from "./probe.js";
 import type {
   ResolvedTeamilyAccount,
   TeamilyMessage,
@@ -8,11 +7,6 @@ import type {
 } from "./types.js";
 import { CONTENT_TYPES, SESSION_TYPES } from "./types.js";
 
-const WS_REQ = {
-  LOGIN: 1001,
-  HEARTBEAT: 1002,
-} as const;
-
 export type TeamilyMessageHandler = (message: TeamilyMessage) => Promise<void> | void;
 export type TeamilyConnectionState = "connecting" | "connected" | "disconnected" | "error";
 
@@ -20,361 +14,198 @@ export interface TeamilyMonitorOptions {
   account: ResolvedTeamilyAccount;
   onMessage: TeamilyMessageHandler;
   onStateChange?: (state: TeamilyConnectionState, error?: string) => void;
-  reconnectInterval?: number;
-  pingInterval?: number;
-  websocketImpl?: typeof WebSocket;
+}
+
+type SdkModule = typeof import("@openim/client-sdk");
+type SdkInstance = ReturnType<SdkModule["getSDK"]>;
+
+// Lazy-loaded SDK to avoid top-level dynamic import issues
+let sdkModule: SdkModule | null = null;
+async function loadSDK() {
+  if (!sdkModule) {
+    sdkModule = await import("@openim/client-sdk");
+  }
+  return sdkModule;
 }
 
 /**
- * Monitor for incoming Teamily messages via WebSocket.
+ * Monitor for incoming Teamily messages using @openim/client-sdk.
  *
- * This class manages a WebSocket connection to the Teamily server
- * and handles incoming messages, reconnections, and heartbeat pings.
+ * Delegates WebSocket connection, authentication, heartbeat, and
+ * reconnection to the official OpenIM SDK.
  */
 export class TeamilyMonitor {
   private account: ResolvedTeamilyAccount;
   private onMessage: TeamilyMessageHandler;
   private onStateChange?: (state: TeamilyConnectionState, error?: string) => void;
-  private reconnectInterval: number;
-  private pingInterval: number;
-  private ws: WebSocket | null = null;
-  private pingTimer: NodeJS.Timeout | null = null;
-  private reconnectTimer: NodeJS.Timeout | null = null;
+  private sdk: SdkInstance | null = null;
   private state: TeamilyConnectionState = "disconnected";
-  private shouldReconnect = true;
-  private authenticated = false;
-  private wsImpl: typeof WebSocket;
+  private stopped = false;
 
   constructor(options: TeamilyMonitorOptions) {
     this.account = options.account;
     this.onMessage = options.onMessage;
     this.onStateChange = options.onStateChange;
-    this.reconnectInterval = options.reconnectInterval ?? 5000;
-    this.pingInterval = options.pingInterval ?? 30000;
-    this.wsImpl = options.websocketImpl ?? WebSocket;
   }
 
-  /**
-   * Start monitoring for messages.
-   */
   async start(): Promise<void> {
-    this.shouldReconnect = true;
-    await this.connect();
-  }
-
-  /**
-   * Stop monitoring and close the connection.
-   */
-  stop(): void {
-    this.shouldReconnect = false;
-    this.authenticated = false;
-
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-
-    if (this.ws) {
-      const ws = this.ws;
-      ws.onopen = null;
-      ws.onmessage = null;
-      ws.onerror = null;
-      ws.onclose = null;
-      this.ws = null;
-      try {
-        ws.close(1000, "Monitoring stopped");
-      } catch {
-        // Ignore – socket may already be closed.
-      }
-    }
-
-    this.setState("disconnected");
-  }
-
-  /**
-   * Connect to the Teamily WebSocket server.
-   */
-  private async connect(): Promise<void> {
-    if (!this.shouldReconnect) {
-      return;
-    }
-
+    this.stopped = false;
     this.setState("connecting");
 
-    const wsUrl = new URL(this.account.wsURL);
-    wsUrl.searchParams.set("sendID", this.account.userID);
-    wsUrl.searchParams.set("token", this.account.token);
-    wsUrl.searchParams.set("platformID", "5");
-    wsUrl.searchParams.set("sdkType", "js");
-
-    try {
-      const ws = new this.wsImpl(wsUrl.toString()) as WebSocket & { isMock?: boolean };
-      this.ws = ws;
-
-      ws.onopen = () => this.handleOpen();
-      ws.onmessage = (event) => this.handleMessage(event);
-      ws.onerror = (error) => this.handleError(error);
-      ws.onclose = () => this.handleClose();
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-
-  /**
-   * Handle WebSocket connection opened.
-   */
-  private handleOpen(): void {
-    this.sendAuth();
-  }
-
-  /**
-   * Send authentication message after WebSocket connection opens.
-   */
-  private sendAuth(): void {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      return;
-    }
-    try {
-      this.ws.send(
-        JSON.stringify({
-          reqIdentifier: WS_REQ.LOGIN,
-          operationID: generateOperationID(),
-          sendID: this.account.userID,
-          token: this.account.token,
-          platformID: 5,
-        }),
-      );
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-
-  /**
-   * Handle incoming WebSocket message.
-   */
-  private async handleMessage(event: MessageEvent): Promise<void> {
-    try {
-      const data = JSON.parse(event.data) as {
-        reqIdentifier?: number;
-        errCode?: number;
-        errMsg?: string;
-        msgID?: string;
-        sendID?: string;
-        msgFrom?: string;
-        recvID?: string;
-        contentType?: number;
-        content?: unknown;
-        sessionType?: number;
-        sendTime?: number;
-      };
-
-      // Handle login response
-      if (data.reqIdentifier === WS_REQ.LOGIN) {
-        if (data.errCode === 0) {
-          this.authenticated = true;
-          this.setState("connected");
-          this.startPing();
-        } else {
-          this.setState("error", data.errMsg || "Authentication failed");
-          this.ws?.close();
+    const { getSDK, CbEvents } = await loadSDK();
+    const sdk = getSDK();
+    this.sdk = sdk;
+
+    // Connection events
+    sdk.on(CbEvents.OnConnecting, () => {
+      if (!this.stopped) this.setState("connecting");
+    });
+    sdk.on(CbEvents.OnConnectSuccess, () => {
+      if (!this.stopped) this.setState("connected");
+    });
+    sdk.on(CbEvents.OnConnectFailed, ({ errCode, errMsg }) => {
+      if (!this.stopped) this.setState("error", `[${errCode}] ${errMsg}`);
+    });
+    sdk.on(CbEvents.OnKickedOffline, () => {
+      if (!this.stopped) this.setState("error", "Kicked offline");
+    });
+    sdk.on(CbEvents.OnUserTokenExpired, () => {
+      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);
         }
-        return;
-      }
-
-      // Ignore heartbeat responses
-      if (data.reqIdentifier === WS_REQ.HEARTBEAT) {
-        return;
-      }
-
-      if (!this.authenticated) {
-        return;
       }
+    });
 
-      const contentType = data.contentType || CONTENT_TYPES.TEXT;
-
-      const message: TeamilyMessage = {
-        serverMsgID: data.msgID || `${Date.now()}_${Math.random()}`,
-        sendID: data.sendID || data.msgFrom || "unknown",
-        recvID: data.recvID || this.account.userID,
-        content: parseMessageContent(data.content, contentType),
-        contentType,
-        sessionType: data.sessionType || SESSION_TYPES.SINGLE,
-        sendTime: data.sendTime || Date.now(),
-      };
-
-      await this.onMessage(message);
-    } catch (error) {
-      console.error("Failed to parse Teamily message:", error);
-    }
-  }
-
-  /**
-   * Handle WebSocket error.
-   * Detaches event handlers before closing to prevent recursive calls
-   * (ws.close() on an errored socket can re-fire onerror → stack overflow).
-   */
-  private handleError(error: unknown): void {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    this.setState("error", errorMessage);
-
-    // Detach handlers and grab ref before nulling, so close() cannot recurse.
-    const ws = this.ws;
-    if (ws) {
-      ws.onopen = null;
-      ws.onmessage = null;
-      ws.onerror = null;
-      ws.onclose = null;
-      this.ws = null;
-      try {
-        ws.close();
-      } catch {
-        // Ignore – socket may already be closed/invalid.
-      }
-      // onclose was detached, so manually trigger reconnect logic.
-      this.handleClose();
-    }
-  }
-
-  /**
-   * Handle WebSocket connection closed.
-   */
-  private handleClose(): void {
-    this.stopPing();
-    this.authenticated = false;
-
-    if (this.state === "disconnected" || !this.shouldReconnect) {
-      return;
+    try {
+      await sdk.login({
+        userID: this.account.userID,
+        token: this.account.token,
+        platformID: 5,
+        wsAddr: this.account.wsURL,
+        apiAddr: this.account.apiURL,
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.setState("error", msg);
+      throw err;
     }
-
-    // Schedule reconnection
-    this.reconnectTimer = setTimeout(() => {
-      if (this.shouldReconnect) {
-        this.connect();
-      }
-    }, this.reconnectInterval);
-  }
-
-  /**
-   * Start heartbeat ping interval.
-   */
-  private startPing(): void {
-    this.stopPing();
-
-    this.pingTimer = setInterval(() => {
-      this.sendPing();
-    }, this.pingInterval);
   }
 
-  /**
-   * Stop heartbeat ping.
-   */
-  private stopPing(): void {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
+  stop(): void {
+    this.stopped = true;
+    if (this.sdk) {
+      this.sdk.logout().catch(() => {});
+      this.sdk = null;
     }
+    this.setState("disconnected");
   }
 
-  /**
-   * Send ping to keep connection alive.
-   */
-  private sendPing(): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      try {
-        this.ws.send(
-          JSON.stringify({
-            reqIdentifier: WS_REQ.HEARTBEAT,
-            operationID: generateOperationID(),
-            sendID: this.account.userID,
-            sendTime: Date.now(),
-          }),
-        );
-      } catch (error) {
-        console.error("Teamily ping failed:", error);
-      }
-    }
+  getState(): TeamilyConnectionState {
+    return this.state;
   }
 
-  /**
-   * Update and notify connection state.
-   */
   private setState(state: TeamilyConnectionState, error?: string): void {
     this.state = state;
     this.onStateChange?.(state, error);
   }
-
-  /**
-   * Get current connection state.
-   */
-  getState(): TeamilyConnectionState {
-    return this.state;
-  }
 }
 
-/**
- * Parse raw OpenIM message content into normalized internal format.
- * OpenIM text messages use `{ content: "text" }`, not `{ text: "..." }`.
- */
-function parseMessageContent(raw: unknown, contentType: number): TeamilyMessage["content"] {
-  if (!raw) {
-    return {};
+// ---- SDK message conversion helpers ----
+
+import type { MessageItem } from "@openim/client-sdk";
+
+function convertSdkMessage(msg: MessageItem, selfUserID: string): TeamilyMessage | null {
+  const contentType = msg.contentType ?? CONTENT_TYPES.TEXT;
+  const sessionType = msg.sessionType ?? SESSION_TYPES.SINGLE;
+
+  const content = parseSdkContent(msg, contentType);
+
+  // Skip messages with no usable content
+  if (!content.text && !content.picture && !content.video && !content.audio) {
+    return null;
   }
 
-  const obj = (typeof raw === "string" ? JSON.parse(raw) : raw) as Record<string, unknown>;
+  return {
+    serverMsgID: msg.serverMsgID || msg.clientMsgID || `${Date.now()}_${Math.random()}`,
+    sendID: msg.sendID || "unknown",
+    recvID: sessionType === SESSION_TYPES.GROUP ? (msg.groupID || "") : (msg.recvID || selfUserID),
+    content,
+    contentType,
+    sessionType,
+    sendTime: msg.sendTime || Date.now(),
+  };
+}
 
+function parseSdkContent(msg: MessageItem, contentType: number): TeamilyMessage["content"] {
   switch (contentType) {
-    case CONTENT_TYPES.TEXT:
-      return {
-        text: typeof obj.content === "string" ? obj.content : String(obj.content ?? ""),
-      };
+    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 } : {};
+    }
     case CONTENT_TYPES.PICTURE:
-      return { picture: obj as unknown as TeamilyPictureContent };
+      if (msg.pictureElem?.sourcePicture) {
+        return { picture: msg.pictureElem as unknown as TeamilyPictureContent };
+      }
+      return {};
     case CONTENT_TYPES.VIDEO:
-      return { video: obj as unknown as TeamilyVideoContent };
+      if (msg.videoElem?.videoUrl) {
+        return { video: msg.videoElem as unknown as TeamilyVideoContent };
+      }
+      return {};
     case CONTENT_TYPES.VOICE:
-      return { audio: obj as unknown as TeamilyAudioContent };
+      if (msg.soundElem?.sourceUrl) {
+        return { audio: msg.soundElem as unknown as TeamilyAudioContent };
+      }
+      return {};
     default:
       return {};
   }
 }
 
-/**
- * Global monitor instances per account ID.
- */
+/** 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 {
+    const obj = JSON.parse(raw) as { content?: string };
+    return typeof obj.content === "string" ? obj.content : undefined;
+  } catch {
+    return raw;
+  }
+}
+
+// ---- Global monitor registry ----
+
 const monitors = new Map<string, TeamilyMonitor>();
 
-/**
- * Start monitoring for a Teamily account.
- */
 export function startTeamilyMonitoring(
   account: ResolvedTeamilyAccount,
   onMessage: TeamilyMessageHandler,
   onStateChange?: (state: TeamilyConnectionState, error?: string) => void,
 ): () => void {
-  const monitor = new TeamilyMonitor({
-    account,
-    onMessage,
-    onStateChange,
-  });
-
+  const monitor = new TeamilyMonitor({ account, onMessage, onStateChange });
   monitors.set(account.accountId, monitor);
-  monitor.start();
+  monitor.start().catch((err) => {
+    console.error(`Teamily monitor start failed for ${account.accountId}:`, err);
+  });
 
-  // Return cleanup function
   return () => {
     monitor.stop();
     monitors.delete(account.accountId);
   };
 }
 
-/**
- * Stop monitoring for a Teamily account.
- */
 export function stopTeamilyMonitoring(accountId: string): void {
   const monitor = monitors.get(accountId);
   if (monitor) {
@@ -383,9 +214,6 @@ export function stopTeamilyMonitoring(accountId: string): void {
   }
 }
 
-/**
- * Get monitor for an account.
- */
 export function getTeamilyMonitor(accountId: string): TeamilyMonitor | undefined {
   return monitors.get(accountId);
 }