@ascegu/teamily 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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/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: {
@@ -305,8 +274,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 +340,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,18 +1,13 @@
-import { generateOperationID } from "./probe.js";
 import type {
   ResolvedTeamilyAccount,
   TeamilyMessage,
+  TeamilyMessageTarget,
   TeamilyPictureContent,
   TeamilyVideoContent,
   TeamilyAudioContent,
 } 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 +15,291 @@ 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. Also exposes send methods
+ * so outbound replies flow through the same WebSocket connection.
  */
 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");
+    const { getSDK, CbEvents } = await loadSDK();
+    const sdk = getSDK();
+    this.sdk = sdk;
+
+    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");
+    });
+
+    sdk.on(CbEvents.OnRecvNewMessages, ({ data }) => {
+      if (this.stopped || !data) return;
+      for (const msg of data) {
+        if (msg.sendID === this.account.userID) continue;
+        const converted = convertSdkMessage(msg, this.account.userID);
+        if (converted) {
+          void this.onMessage(converted);
+        }
+      }
+    });
 
     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);
+      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;
     }
   }
 
-  /**
-   * 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);
+  stop(): void {
+    this.stopped = true;
+    if (this.sdk) {
+      this.sdk.logout().catch(() => {});
+      this.sdk = null;
     }
+    this.setState("disconnected");
   }
 
-  /**
-   * 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();
-        }
-        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);
-    }
+  getState(): TeamilyConnectionState {
+    return this.state;
   }
 
-  /**
-   * 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();
-    }
+  /** 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 || "";
   }
 
-  /**
-   * Handle WebSocket connection closed.
-   */
-  private handleClose(): void {
-    this.stopPing();
-    this.authenticated = false;
-
-    if (this.state === "disconnected" || !this.shouldReconnect) {
-      return;
-    }
-
-    // Schedule reconnection
-    this.reconnectTimer = setTimeout(() => {
-      if (this.shouldReconnect) {
-        this.connect();
-      }
-    }, this.reconnectInterval);
+  /** 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 || "";
   }
 
-  /**
-   * Start heartbeat ping interval.
-   */
-  private startPing(): void {
-    this.stopPing();
+  /** 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 || "";
+  }
 
-    this.pingTimer = setInterval(() => {
-      this.sendPing();
-    }, this.pingInterval);
+  /** 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 || "";
   }
 
-  /**
-   * Stop heartbeat ping.
-   */
-  private stopPing(): void {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
+  /** 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 || "";
   }
 
-  /**
-   * 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);
-      }
+  private requireSdk(): SdkInstance {
+    if (!this.sdk) {
+      throw new Error("Teamily SDK not connected");
     }
+    return this.sdk;
   }
 
-  /**
-   * 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);
+
+  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: {
+      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.
- */
+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 +308,6 @@ export function stopTeamilyMonitoring(accountId: string): void {
   }
 }
 
-/**
- * Get monitor for an account.
- */
 export function getTeamilyMonitor(accountId: string): TeamilyMonitor | undefined {
   return monitors.get(accountId);
 }