@ascegu/teamily 1.0.3 → 1.0.5

package/src/monitor.ts

@@ -0,0 +1,370 @@
+import type {
+  ResolvedTeamilyAccount,
+  TeamilyMessage,
+  TeamilyPictureContent,
+  TeamilyVideoContent,
+  TeamilyAudioContent,
+} from "./types.js";
+import { CONTENT_TYPES, SESSION_TYPES } from "./types.js";
+import { generateOperationID } from "./probe.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";
+
+export interface TeamilyMonitorOptions {
+  account: ResolvedTeamilyAccount;
+  onMessage: TeamilyMessageHandler;
+  onStateChange?: (state: TeamilyConnectionState, error?: string) => void;
+  reconnectInterval?: number;
+  pingInterval?: number;
+  websocketImpl?: typeof WebSocket;
+}
+
+/**
+ * Monitor for incoming Teamily messages via WebSocket.
+ *
+ * This class manages a WebSocket connection to the Teamily server
+ * and handles incoming messages, reconnections, and heartbeat pings.
+ */
+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 state: TeamilyConnectionState = "disconnected";
+  private shouldReconnect = true;
+  private authenticated = false;
+  private wsImpl: typeof WebSocket;
+
+  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) {
+      this.ws.close(1000, "Monitoring stopped");
+      this.ws = null;
+    }
+
+    this.setState("disconnected");
+  }
+
+  /**
+   * Connect to the Teamily WebSocket server.
+   */
+  private async connect(): Promise<void> {
+    if (!this.shouldReconnect) {
+      return;
+    }
+
+    this.setState("connecting");
+
+    const wsUrl = new URL(this.account.wsURL);
+    wsUrl.searchParams.set("token", this.account.token);
+
+    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();
+        }
+        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.
+   */
+  private handleError(error: unknown): void {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    this.setState("error", errorMessage);
+
+    // Close the connection so it can be re-established
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * 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);
+      }
+    }
+  }
+
+  /**
+   * 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 {};
+  }
+
+  const obj = (
+    typeof raw === "string" ? JSON.parse(raw) : raw
+  ) as Record<string, unknown>;
+
+  switch (contentType) {
+    case CONTENT_TYPES.TEXT:
+      return {
+        text:
+          typeof obj.content === "string"
+            ? obj.content
+            : String(obj.content ?? ""),
+      };
+    case CONTENT_TYPES.PICTURE:
+      return { picture: obj as unknown as TeamilyPictureContent };
+    case CONTENT_TYPES.VIDEO:
+      return { video: obj as unknown as TeamilyVideoContent };
+    case CONTENT_TYPES.VOICE:
+      return { audio: obj as unknown as TeamilyAudioContent };
+    default:
+      return {};
+  }
+}
+
+/**
+ * Global monitor instances per account ID.
+ */
+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,
+  });
+
+  monitors.set(account.accountId, monitor);
+  monitor.start();
+
+  // 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) {
+    monitor.stop();
+    monitors.delete(accountId);
+  }
+}
+
+/**
+ * Get monitor for an account.
+ */
+export function getTeamilyMonitor(accountId: string): TeamilyMonitor | undefined {
+  return monitors.get(accountId);
+}

package/src/normalize.ts

@@ -0,0 +1,90 @@
+import type { TeamilyMessageTarget } from "./types.js";
+
+/**
+ * Normalize Teamily messaging target from raw string input.
+ *
+ * Supports formats:
+ * - "user:12345" or "u:12345" -> user 12345
+ * - "group:67890" or "g:67890" -> group 67890
+ * - "12345" -> user 12345 (default)
+ *
+ * @param raw - Raw target string
+ * @returns Normalized target with type and ID
+ */
+export function normalizeTeamilyTarget(raw: string): TeamilyMessageTarget {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("Target cannot be empty");
+  }
+
+  const lowered = trimmed.toLowerCase();
+
+  // Remove "teamily:" prefix if present
+  const withoutPrefix = lowered.startsWith("teamily:")
+    ? trimmed.slice("teamily:".length).trim()
+    : trimmed;
+
+  // Group target
+  if (
+    withoutPrefix.startsWith("group:") ||
+    withoutPrefix.startsWith("g:")
+  ) {
+    const groupId = withoutPrefix
+      .replace(/^(group:|g:)/i, "")
+      .trim();
+    if (!groupId) {
+      throw new Error("Group ID cannot be empty");
+    }
+    return { type: "group", id: groupId };
+  }
+
+  // User target
+  const userId = withoutPrefix
+    .replace(/^(user:|u:)/i, "")
+    .trim();
+  if (!userId) {
+    throw new Error("User ID cannot be empty");
+  }
+  return { type: "user", id: userId };
+}
+
+/**
+ * Normalize Teamily allow list entry from raw string input.
+ *
+ * @param entry - Raw allow list entry
+ * @returns Normalized user ID or group ID
+ */
+export function normalizeTeamilyAllowEntry(entry: string): string {
+  const trimmed = entry.trim();
+  if (!trimmed) {
+    throw new Error("Allow entry cannot be empty");
+  }
+
+  const target = normalizeTeamilyTarget(trimmed);
+  return target.type === "group" ? `group:${target.id}` : target.id;
+}
+
+/**
+ * Check if a string looks like a Teamily target ID.
+ *
+ * @param raw - String to check
+ * @returns True if it looks like a Teamily target
+ */
+export function looksLikeTeamilyTargetId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return false;
+  }
+
+  const lowered = trimmed.toLowerCase();
+
+  // Check for explicit prefixes
+  if (lowered.startsWith("teamily:") || lowered.startsWith("user:") || lowered.startsWith("u:") ||
+      lowered.startsWith("group:") || lowered.startsWith("g:")) {
+    return true;
+  }
+
+  // Assume it's a user ID if it doesn't start with a known channel prefix
+  const knownPrefixes = ["telegram:", "discord:", "slack:", "matrix:", "signal:", "whatsapp:"];
+  return !knownPrefixes.some((prefix) => lowered.startsWith(prefix));
+}

package/src/probe.ts

@@ -0,0 +1,86 @@
+import { randomUUID } from "node:crypto";
+import type { ResolvedTeamilyAccount } from "./types.js";
+import type { TeamilyProbeResult } from "./types.js";
+
+/**
+ * Generate a unique operation ID for Teamily API requests.
+ */
+export function generateOperationID(): string {
+  return `${Date.now()}_${randomUUID().replace(/-/g, "").substring(0, 16)}`;
+}
+
+/**
+ * Probe Teamily server to verify connection and authentication.
+ *
+ * @param account - Resolved Teamily account
+ * @param fetchImpl - Fetch implementation (for testing)
+ * @returns Probe result with connection status
+ */
+export async function probeTeamily(
+  account: ResolvedTeamilyAccount,
+  fetchImpl: typeof fetch = fetch
+): Promise<TeamilyProbeResult> {
+  try {
+    const url = `${account.apiURL}/user/get_users_info`;
+
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "operationID": generateOperationID(),
+        "token": account.token,
+      },
+      body: JSON.stringify({
+        userIDs: [account.userID],
+      }),
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        connected: false,
+        error: `HTTP ${response.status}: ${errorText}`,
+      };
+    }
+
+    const data = await response.json() as {
+      errCode: number;
+      errMsg: string;
+      data?: Array<{ userID: string }>;
+    };
+
+    if (data.errCode !== 0) {
+      return {
+        connected: false,
+        error: data.errMsg || "Unknown error",
+      };
+    }
+
+    // Check if the user exists in the response
+    const userExists =
+      Array.isArray(data.data) && data.data.some((u) => u.userID === account.userID);
+
+    return {
+      connected: true,
+      userExists,
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return {
+          connected: false,
+          error: "Connection timeout",
+        };
+      }
+      return {
+        connected: false,
+        error: error.message,
+      };
+    }
+    return {
+      connected: false,
+      error: String(error),
+    };
+  }
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let teamilyRuntime: PluginRuntime | null = null;
+
+export function setTeamilyRuntime(runtime: PluginRuntime): void {
+  teamilyRuntime = runtime;
+}
+
+export function getTeamilyRuntime(): PluginRuntime {
+  if (!teamilyRuntime) {
+    throw new Error("Teamily runtime not initialized");
+  }
+  return teamilyRuntime;
+}