openclaw-mochat 2026.2.3

package/src/poller.ts

@@ -0,0 +1,116 @@
+import type { ChannelLogSink } from "openclaw/plugin-sdk";
+import { watchSession } from "./api.js";
+import type { ResolvedMochatAccount } from "./accounts.js";
+import { handleInboundMessage, type MochatStatusSink } from "./inbound.js";
+
+async function sleep(ms: number, signal?: AbortSignal) {
+  if (ms <= 0) {
+    return;
+  }
+  await new Promise<void>((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        { once: true },
+      );
+    }
+  });
+}
+
+function computeBackoffMs(params: {
+  baseDelayMs: number;
+  consecutiveErrors: number;
+  maxDelayMs: number;
+}) {
+  const baseDelayMs = Math.max(1, params.baseDelayMs);
+  const maxDelayMs = Math.max(baseDelayMs, params.maxDelayMs);
+  const exponent = Math.max(0, params.consecutiveErrors - 1);
+  const delayMs = baseDelayMs * Math.pow(2, exponent);
+  return Math.min(delayMs, maxDelayMs);
+}
+
+export function startMochatSessionPoller(params: {
+  account: ResolvedMochatAccount;
+  sessionId: string;
+  log?: ChannelLogSink;
+  abortSignal: AbortSignal;
+  statusSink?: MochatStatusSink;
+}) {
+  const { account, sessionId, log, abortSignal, statusSink } = params;
+  const controller = new AbortController();
+  let stopped = false;
+  let cursor = 0;
+  let consecutiveErrors = 0;
+  const maxBackoffMs = 30000;
+
+  const onAbort = () => {
+    stopped = true;
+    controller.abort();
+  };
+  if (abortSignal.aborted) {
+    onAbort();
+  } else {
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
+
+  const run = async () => {
+    while (!stopped) {
+      try {
+        const response = await watchSession({
+          baseUrl: account.config.baseUrl,
+          clawToken: account.config.clawToken ?? "",
+          sessionId,
+          cursor,
+          timeoutMs: account.config.watchTimeoutMs,
+          limit: account.config.watchLimit,
+          signal: controller.signal,
+        });
+
+        cursor = typeof response.cursor === "number" ? response.cursor : cursor;
+        consecutiveErrors = 0;
+
+        for (const event of response.events ?? []) {
+          if (event.type !== "message.add") {
+            continue;
+          }
+          await handleInboundMessage({
+            account,
+            sessionId,
+            event,
+            log,
+            statusSink,
+          });
+        }
+      } catch (err) {
+        if (controller.signal.aborted) {
+          break;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        log?.error?.(`mochat: watch failed for ${sessionId}: ${message}`);
+        statusSink?.({ lastError: message });
+        consecutiveErrors += 1;
+        const delayMs = computeBackoffMs({
+          baseDelayMs: account.config.retryDelayMs,
+          consecutiveErrors,
+          maxDelayMs: maxBackoffMs,
+        });
+        await sleep(delayMs, controller.signal);
+      }
+    }
+  };
+
+  void run();
+
+  return {
+    stop: () => {
+      stopped = true;
+      controller.abort();
+      abortSignal.removeEventListener("abort", onAbort);
+    },
+  };
+}

package/src/runtime.ts

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

package/src/socket.ts

@@ -0,0 +1,439 @@
+import type { ChannelLogSink } from "openclaw/plugin-sdk";
+import { io, type Socket } from "socket.io-client";
+import msgpackParser from "socket.io-msgpack-parser";
+import {
+  getWorkspaceGroup,
+  listSessions,
+  type MochatEvent,
+  type MochatWatchResponse,
+} from "./api.js";
+import type { ResolvedMochatAccount } from "./accounts.js";
+import { handleInboundMessage, type MochatStatusSink } from "./inbound.js";
+import { recordPanelEvent } from "./event-store.js";
+
+type SubscribeAck = {
+  sessions?: MochatWatchResponse[];
+};
+
+type SocketAck<T> = {
+  result: boolean;
+  data?: T;
+  message?: string;
+};
+
+type SessionCursorMap = Record<string, number | undefined>;
+type SessionSet = Set<string>;
+type PanelSet = Set<string>;
+type PanelInfo = {
+  id: string;
+  type?: number;
+};
+
+const PANEL_TYPE_TEXT = 0;
+
+function resolveSocketUrl(account: ResolvedMochatAccount): string {
+  const raw = account.config.socketUrl?.trim() || account.config.baseUrl;
+  return raw.trim().replace(/\/+$/, "");
+}
+
+function collectCursors(cursorBySession: Map<string, number>): SessionCursorMap {
+  const snapshot: SessionCursorMap = {};
+  for (const [sessionId, cursor] of cursorBySession.entries()) {
+    snapshot[sessionId] = cursor;
+  }
+  return snapshot;
+}
+
+function normalizeSessions(data: unknown): MochatWatchResponse[] {
+  if (!data) {
+    return [];
+  }
+  if (Array.isArray(data)) {
+    return data as MochatWatchResponse[];
+  }
+  const obj = data as SubscribeAck;
+  if (Array.isArray(obj.sessions)) {
+    return obj.sessions;
+  }
+  return [data as MochatWatchResponse];
+}
+
+function buildCursorFromPayload(
+  payload: MochatWatchResponse,
+  lastCursor: number,
+): number {
+  let nextCursor = lastCursor;
+  if (typeof payload.cursor === "number") {
+    nextCursor = Math.max(nextCursor, payload.cursor);
+  }
+  for (const event of payload.events ?? []) {
+    if (typeof event.seq === "number") {
+      nextCursor = Math.max(nextCursor, event.seq);
+    }
+  }
+  return nextCursor;
+}
+
+export function startMochatSocketClient(params: {
+  account: ResolvedMochatAccount;
+  log?: ChannelLogSink;
+  abortSignal: AbortSignal;
+  statusSink?: MochatStatusSink;
+}) {
+  const { account, log, abortSignal, statusSink } = params;
+  const socketUrl = resolveSocketUrl(account);
+  const cursorBySession = new Map<string, number>();
+  const queueBySession = new Map<string, Promise<void>>();
+  const explicitSessions = account.config.sessions ?? [];
+  const explicitPanels = account.config.panels ?? [];
+  const autoDiscoverSessions = account.config.autoDiscoverSessions;
+  const autoDiscoverPanels = account.config.autoDiscoverPanels;
+  const refreshIntervalMs = account.config.refreshIntervalMs;
+  const sessionSet: SessionSet = new Set(explicitSessions.map((id) => String(id)));
+  const panelSet: PanelSet = new Set(explicitPanels.map((id) => String(id)));
+  let refreshTimer: NodeJS.Timeout | null = null;
+  let stopped = false;
+
+  const enqueue = (sessionId: string, task: () => Promise<void>) => {
+    const previous = queueBySession.get(sessionId) ?? Promise.resolve();
+    const next = previous.then(task, task);
+    queueBySession.set(sessionId, next.catch(() => {}));
+  };
+
+  const applyEvents = (
+    payload: MochatWatchResponse,
+    targetKind: "session" | "panel" = "session",
+  ) => {
+    const sessionId = payload.sessionId;
+    if (!sessionId) {
+      return;
+    }
+    const lastCursor = cursorBySession.get(sessionId) ?? 0;
+    const events = (payload.events ?? []).filter(
+      (event) => typeof event.seq === "number" && event.seq > lastCursor,
+    );
+    const nextCursor = buildCursorFromPayload(payload, lastCursor);
+    cursorBySession.set(sessionId, nextCursor);
+    if (events.length === 0) {
+      return;
+    }
+
+    enqueue(sessionId, async () => {
+      for (const event of events) {
+        if (event.type !== "message.add") {
+          continue;
+        }
+        try {
+          await handleInboundMessage({
+            account,
+            sessionId,
+            event: event as MochatEvent,
+            targetKind,
+            log,
+            statusSink,
+          });
+        } catch (err) {
+          log?.error?.(`mochat: socket event failed for ${sessionId}: ${String(err)}`);
+        }
+      }
+    });
+  };
+
+  const subscribeSessions = (socket: Socket, sessionIds: string[]) => {
+    if (sessionIds.length === 0) {
+      return;
+    }
+    const cursors = collectCursors(cursorBySession);
+    socket.emit(
+      "com.claw.im.subscribeSessions",
+      {
+        sessionIds,
+        cursors,
+        limit: account.config.watchLimit,
+      },
+      (ack: SocketAck<SubscribeAck>) => {
+        if (!ack?.result) {
+          const message = ack?.message ?? "subscribe failed";
+          log?.error?.(`mochat: subscribe failed: ${message}`);
+          statusSink?.({ lastError: message });
+          return;
+        }
+        for (const session of normalizeSessions(ack.data)) {
+          applyEvents(session);
+        }
+      },
+    );
+  };
+
+  const subscribePanels = (socket: Socket, panelIds: string[]) => {
+    if (!autoDiscoverPanels && panelIds.length === 0) {
+      return;
+    }
+    socket.emit(
+      "com.claw.im.subscribePanels",
+      {
+        panelIds,
+      },
+      (ack: SocketAck<{ panelIds?: string[]; groupId?: string }>) => {
+        if (!ack?.result) {
+          const message = ack?.message ?? "subscribe panels failed";
+          log?.error?.(`mochat: panel subscribe failed: ${message}`);
+          statusSink?.({ lastError: message });
+        }
+      },
+    );
+  };
+
+  const refreshSessions = async (socket: Socket) => {
+    if (!autoDiscoverSessions) {
+      return;
+    }
+    try {
+      const response = await listSessions({
+        baseUrl: account.config.baseUrl,
+        clawToken: account.config.clawToken ?? "",
+      });
+      const discovered = (response.sessions ?? [])
+        .map((session) => session.sessionId)
+        .filter(Boolean)
+        .map((id) => String(id));
+      const newSessions: string[] = [];
+      for (const sessionId of discovered) {
+        if (!sessionSet.has(sessionId)) {
+          sessionSet.add(sessionId);
+          newSessions.push(sessionId);
+        }
+      }
+      subscribeSessions(socket, newSessions);
+    } catch (err) {
+      log?.error?.(`mochat: session refresh failed: ${String(err)}`);
+    }
+  };
+
+  const resolveTextPanels = (panels?: PanelInfo[]) => {
+    if (!Array.isArray(panels)) {
+      return [];
+    }
+    return panels
+      .filter((panel) => {
+        if (!panel) {
+          return false;
+        }
+        if (typeof panel.type === "number" && panel.type !== PANEL_TYPE_TEXT) {
+          return false;
+        }
+        return Boolean(panel.id);
+      })
+      .map((panel) => String(panel.id));
+  };
+
+  const refreshPanels = async (socket: Socket) => {
+    if (!autoDiscoverPanels) {
+      return;
+    }
+    try {
+      const groupInfo = await getWorkspaceGroup({
+        baseUrl: account.config.baseUrl,
+        clawToken: account.config.clawToken ?? "",
+      });
+      const rawPanels = Array.isArray(groupInfo.panels) ? groupInfo.panels : [];
+      const panels = resolveTextPanels(
+        rawPanels.map((panel) => ({
+          id: String((panel as any)?.id ?? (panel as any)?._id ?? ""),
+          type: (panel as any)?.type,
+        })),
+      );
+      const newPanels: string[] = [];
+      for (const panelId of panels) {
+        if (!panelSet.has(panelId)) {
+          panelSet.add(panelId);
+          newPanels.push(panelId);
+        }
+      }
+      subscribePanels(socket, newPanels);
+    } catch (err) {
+      log?.error?.(`mochat: panel refresh failed: ${String(err)}`);
+    }
+  };
+
+  const refreshTargets = async (socket: Socket) => {
+    await Promise.all([refreshSessions(socket), refreshPanels(socket)]);
+  };
+
+  const subscribe = (socket: Socket) => {
+    subscribeSessions(socket, Array.from(sessionSet));
+    subscribePanels(socket, Array.from(panelSet));
+    if (autoDiscoverSessions || autoDiscoverPanels) {
+      void refreshTargets(socket);
+      if (refreshTimer) {
+        clearInterval(refreshTimer);
+      }
+      refreshTimer = setInterval(() => {
+        if (stopped) {
+          return;
+        }
+        void refreshTargets(socket);
+      }, refreshIntervalMs);
+    }
+  };
+
+  const socket = io(socketUrl, {
+    path: account.config.socketPath,
+    transports: ["websocket"],
+    parser: account.config.socketDisableMsgpack ? undefined : msgpackParser,
+    auth: {
+      token: account.config.clawToken ?? "",
+    },
+    reconnection: true,
+    reconnectionAttempts:
+      account.config.maxRetryAttempts > 0 ? account.config.maxRetryAttempts : undefined,
+    reconnectionDelay: account.config.socketReconnectDelayMs,
+    reconnectionDelayMax: account.config.socketMaxReconnectDelayMs,
+    timeout: account.config.socketConnectTimeoutMs,
+  });
+
+  socket.on("connect", () => {
+    if (stopped) {
+      return;
+    }
+    statusSink?.({ lastError: null });
+    subscribe(socket);
+  });
+
+  socket.on("connect_error", (err) => {
+    if (stopped) {
+      return;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    log?.error?.(`mochat: socket connect failed: ${message}`);
+    statusSink?.({ lastError: message });
+  });
+
+  socket.on("disconnect", (reason) => {
+    if (stopped) {
+      return;
+    }
+    log?.info?.(`mochat: socket disconnected (${reason})`);
+    if (reason !== "io client disconnect") {
+      statusSink?.({ lastError: reason });
+    }
+  });
+
+  socket.on("claw.session.events", (payload: MochatWatchResponse) => {
+    if (stopped) {
+      return;
+    }
+    log?.info?.(
+      `mochat: recv claw.session.events session=${payload?.sessionId ?? "unknown"}`,
+    );
+    applyEvents(payload);
+  });
+
+  socket.on("claw.panel.events", (payload: MochatWatchResponse) => {
+    if (stopped) {
+      return;
+    }
+    log?.info?.(
+      `mochat: recv claw.panel.events panel=${payload?.sessionId ?? "unknown"}`,
+    );
+    applyEvents(payload, "panel");
+  });
+
+  socket.onAny((eventName, payload) => {
+    if (stopped) {
+      return;
+    }
+    if (typeof eventName !== "string" || !eventName.startsWith("notify:")) {
+      return;
+    }
+
+    if (eventName.startsWith("notify:chat.message.")) {
+      if (!payload || typeof payload !== "object") {
+        return;
+      }
+      const groupId = (payload as any).groupId ? String((payload as any).groupId) : "";
+      if (!groupId) {
+        return;
+      }
+      const panelId = (payload as any).converseId
+        ? String((payload as any).converseId)
+        : "";
+      if (!panelId) {
+        return;
+      }
+      if (panelSet.size > 0 && !panelSet.has(panelId)) {
+        return;
+      }
+
+      const event: MochatEvent = {
+        seq: 0,
+        sessionId: panelId,
+        type: "message.add",
+        timestamp:
+          typeof (payload as any).createdAt === "string"
+            ? (payload as any).createdAt
+            : new Date().toISOString(),
+        payload: {
+          messageId: String((payload as any)._id ?? (payload as any).messageId ?? ""),
+          author: (payload as any).author ? String((payload as any).author) : "",
+          authorInfo: (payload as any).authorInfo ?? undefined,
+          content: (payload as any).content,
+          meta: (payload as any).meta ?? {},
+          groupId,
+          converseId: panelId,
+        },
+      };
+
+      enqueue(panelId, async () => {
+        try {
+          await handleInboundMessage({
+            account,
+            sessionId: panelId,
+            event,
+            targetKind: "panel",
+            log,
+            statusSink,
+          });
+        } catch (err) {
+          log?.error?.(`mochat: panel message failed for ${panelId}: ${String(err)}`);
+        }
+      });
+      return;
+    }
+
+    void recordPanelEvent({
+      accountId: account.accountId,
+      eventName,
+      payload,
+    }).catch((err) => {
+      log?.error?.(`mochat: failed to persist panel event: ${String(err)}`);
+    });
+  });
+
+  const onAbort = () => {
+    stopped = true;
+    if (refreshTimer) {
+      clearInterval(refreshTimer);
+      refreshTimer = null;
+    }
+    socket.disconnect();
+  };
+
+  if (abortSignal.aborted) {
+    onAbort();
+  } else {
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
+
+  return {
+    stop: () => {
+      stopped = true;
+      if (refreshTimer) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+      }
+      socket.disconnect();
+      abortSignal.removeEventListener("abort", onAbort);
+    },
+  };
+}