openclaw-mochat 2026.2.3

package/src/api.ts

@@ -0,0 +1,453 @@
+export type MochatAuthorInfo = {
+  userId?: string;
+  agentId?: string | null;
+  nickname?: string | null;
+  email?: string | null;
+  avatar?: string | null;
+  type?: string;
+};
+
+export type MochatEvent = {
+  seq: number;
+  sessionId: string;
+  type: string;
+  timestamp?: string;
+  payload?: {
+    messageId?: string;
+    author?: string;
+    authorInfo?: MochatAuthorInfo | null;
+    content?: unknown;
+    meta?: Record<string, unknown>;
+    groupId?: string;
+    converseId?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+};
+
+export type MochatParticipantInput = {
+  type: "agent" | "user";
+  id?: string;
+  uniqueName?: string;
+  name?: string;
+  avatar?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type MochatWatchResponse = {
+  sessionId: string;
+  cursor: number;
+  events: MochatEvent[];
+};
+
+export type MochatSendResponse = {
+  sessionId: string;
+  status?: string;
+  [key: string]: unknown;
+};
+
+export type MochatCreateSessionResponse = {
+  sessionId: string;
+  workspaceId: string;
+  converseId: string;
+  participants: string[];
+  visibility: string;
+  status: string;
+  [key: string]: unknown;
+};
+
+export type MochatSessionResponse = {
+  sessionId: string;
+  workspaceId?: string;
+  converseId?: string;
+  participants?: string[];
+  visibility?: string;
+  status?: string;
+  metadata?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+
+export type MochatMessagesResponse = {
+  sessionId: string;
+  messages?: unknown[];
+  [key: string]: unknown;
+};
+
+export type MochatSessionListResponse = {
+  sessions?: MochatSessionResponse[];
+  [key: string]: unknown;
+};
+
+export type MochatGroupResponse = {
+  _id?: string;
+  id?: string;
+  panels?: Array<{
+    id?: string;
+    _id?: string;
+    name?: string;
+    type?: number;
+    provider?: string;
+    pluginPanelName?: string;
+    meta?: Record<string, unknown>;
+  }>;
+  [key: string]: unknown;
+};
+
+export type MochatPanelMessagesResponse = {
+  groupId?: string;
+  panelId: string;
+  messages?: unknown[];
+  [key: string]: unknown;
+};
+
+type MochatRequestOptions = {
+  baseUrl: string;
+  clawToken: string;
+  signal?: AbortSignal;
+};
+
+type ClawWrapped<T> = {
+  code?: number;
+  data?: T;
+  name?: string;
+  message?: string;
+};
+
+const DEFAULT_HEADERS = {
+  "Content-Type": "application/json",
+};
+
+function resolveClawUrl(baseUrl: string, path: string): string {
+  const trimmed = baseUrl.trim();
+  const normalizedBase = trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+  return new URL(path.startsWith("/") ? path : `/${path}`, normalizedBase).toString();
+}
+
+async function postJson<T>(
+  opts: MochatRequestOptions,
+  path: string,
+  payload: Record<string, unknown>,
+): Promise<T> {
+  const url = resolveClawUrl(opts.baseUrl, path);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      ...DEFAULT_HEADERS,
+      "X-Claw-Token": opts.clawToken,
+    },
+    body: JSON.stringify(payload),
+    signal: opts.signal,
+  });
+
+  const rawText = await response.text().catch(() => "");
+  if (!response.ok) {
+    throw new Error(`Claw IM request failed (${response.status}): ${rawText || response.statusText}`);
+  }
+
+  let parsed: unknown = rawText;
+  if (rawText) {
+    try {
+      parsed = JSON.parse(rawText) as unknown;
+    } catch {
+      parsed = rawText;
+    }
+  }
+
+  if (parsed && typeof parsed === "object") {
+    const wrapped = parsed as ClawWrapped<T>;
+    if (typeof wrapped.code === "number") {
+      if (wrapped.code !== 200) {
+        const errMessage = wrapped.message || wrapped.name || "Claw IM request failed";
+        throw new Error(`${errMessage} (code=${wrapped.code})`);
+      }
+      return (wrapped.data ?? ({} as T)) as T;
+    }
+  }
+
+  return parsed as T;
+}
+
+export async function watchSession(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  cursor: number;
+  timeoutMs: number;
+  limit: number;
+  signal?: AbortSignal;
+}): Promise<MochatWatchResponse> {
+  return await postJson<MochatWatchResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/watch",
+    {
+      sessionId: params.sessionId,
+      cursor: params.cursor,
+      timeoutMs: params.timeoutMs,
+      limit: params.limit,
+    },
+  );
+}
+
+export async function sendSessionMessage(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  content: string;
+  replyTo?: string | null;
+  signal?: AbortSignal;
+}): Promise<MochatSendResponse> {
+  return await postJson<MochatSendResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/send",
+    {
+      sessionId: params.sessionId,
+      content: params.content,
+      ...(params.replyTo ? { replyTo: params.replyTo } : {}),
+    },
+  );
+}
+
+export async function sendPanelMessage(params: {
+  baseUrl: string;
+  clawToken: string;
+  panelId: string;
+  content: string;
+  replyTo?: string | null;
+  signal?: AbortSignal;
+  groupId?: string;
+}): Promise<MochatSendResponse> {
+  return await postJson<MochatSendResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/groups/panels/send",
+    {
+      panelId: params.panelId,
+      content: params.content,
+      ...(params.replyTo ? { replyTo: params.replyTo } : {}),
+      ...(params.groupId ? { groupId: params.groupId } : {}),
+    },
+  );
+}
+
+export async function createSession(params: {
+  baseUrl: string;
+  clawToken: string;
+  participants: MochatParticipantInput[];
+  visibility?: string;
+  metadata?: Record<string, unknown>;
+  signal?: AbortSignal;
+}): Promise<MochatCreateSessionResponse> {
+  return await postJson<MochatCreateSessionResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/create",
+    {
+      participants: params.participants,
+      ...(params.visibility ? { visibility: params.visibility } : {}),
+      ...(params.metadata ? { metadata: params.metadata } : {}),
+    },
+  );
+}
+
+export async function addParticipants(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  participants: MochatParticipantInput[];
+  signal?: AbortSignal;
+}): Promise<MochatSessionResponse> {
+  return await postJson<MochatSessionResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/addParticipants",
+    {
+      sessionId: params.sessionId,
+      participants: params.participants,
+    },
+  );
+}
+
+export async function removeParticipants(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  participants: MochatParticipantInput[];
+  signal?: AbortSignal;
+}): Promise<MochatSessionResponse> {
+  return await postJson<MochatSessionResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/removeParticipants",
+    {
+      sessionId: params.sessionId,
+      participants: params.participants,
+    },
+  );
+}
+
+export async function closeSession(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  policy?: string;
+  signal?: AbortSignal;
+}): Promise<MochatSessionResponse> {
+  return await postJson<MochatSessionResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/close",
+    {
+      sessionId: params.sessionId,
+      ...(params.policy ? { policy: params.policy } : {}),
+    },
+  );
+}
+
+export async function getSession(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  signal?: AbortSignal;
+}): Promise<MochatSessionResponse> {
+  return await postJson<MochatSessionResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/get",
+    {
+      sessionId: params.sessionId,
+    },
+  );
+}
+
+export async function getSessionDetail(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  signal?: AbortSignal;
+}): Promise<MochatSessionResponse> {
+  return await postJson<MochatSessionResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/detail",
+    {
+      sessionId: params.sessionId,
+    },
+  );
+}
+
+export async function listSessionMessages(params: {
+  baseUrl: string;
+  clawToken: string;
+  sessionId: string;
+  beforeMessageId?: string;
+  limit?: number;
+  signal?: AbortSignal;
+}): Promise<MochatMessagesResponse> {
+  return await postJson<MochatMessagesResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/messages",
+    {
+      sessionId: params.sessionId,
+      ...(params.beforeMessageId ? { beforeMessageId: params.beforeMessageId } : {}),
+      ...(typeof params.limit === "number" ? { limit: params.limit } : {}),
+    },
+  );
+}
+
+export async function listSessions(params: {
+  baseUrl: string;
+  clawToken: string;
+  updatedAfter?: string;
+  limit?: number;
+  signal?: AbortSignal;
+}): Promise<MochatSessionListResponse> {
+  return await postJson<MochatSessionListResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/sessions/list",
+    {
+      ...(params.updatedAfter ? { updatedAfter: params.updatedAfter } : {}),
+      ...(typeof params.limit === "number" ? { limit: params.limit } : {}),
+    },
+  );
+}
+
+export async function getWorkspaceGroup(params: {
+  baseUrl: string;
+  clawToken: string;
+  groupId?: string;
+  signal?: AbortSignal;
+}): Promise<MochatGroupResponse> {
+  return await postJson<MochatGroupResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/groups/get",
+    {
+      ...(params.groupId ? { groupId: params.groupId } : {}),
+    },
+  );
+}
+
+export async function listPanelMessages(params: {
+  baseUrl: string;
+  clawToken: string;
+  panelId: string;
+  groupId?: string;
+  beforeMessageId?: string;
+  limit?: number;
+  signal?: AbortSignal;
+}): Promise<MochatPanelMessagesResponse> {
+  return await postJson<MochatPanelMessagesResponse>(
+    {
+      baseUrl: params.baseUrl,
+      clawToken: params.clawToken,
+      signal: params.signal,
+    },
+    "/api/claw/groups/panels/messages",
+    {
+      panelId: params.panelId,
+      ...(params.groupId ? { groupId: params.groupId } : {}),
+      ...(params.beforeMessageId ? { beforeMessageId: params.beforeMessageId } : {}),
+      ...(typeof params.limit === "number" ? { limit: params.limit } : {}),
+    },
+  );
+}

package/src/channel.ts

@@ -0,0 +1,253 @@
+import {
+  buildChannelConfigSchema,
+  DEFAULT_ACCOUNT_ID,
+  type ChannelOutboundContext,
+  type ChannelPlugin,
+} from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { MochatConfigSchema } from "./config-schema.js";
+import {
+  listMochatAccountIds,
+  resolveDefaultMochatAccountId,
+  resolveMochatAccount,
+  type ResolvedMochatAccount,
+} from "./accounts.js";
+import { sendPanelMessage, sendSessionMessage } from "./api.js";
+import { startMochatSocketClient } from "./socket.js";
+
+const meta = {
+  id: "mochat",
+  label: "Mochat",
+  selectionLabel: "Mochat (Claw IM)",
+  docsPath: "/channels/mochat",
+  docsLabel: "mochat",
+  blurb: "Claw IM gateway for Mochat/Tailchat",
+  order: 95,
+};
+
+function resolveMochatTarget(raw: string): { id: string; isPanel: boolean } {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return { id: "", isPanel: false };
+  }
+  const lower = trimmed.toLowerCase();
+  let id = trimmed;
+  let forcePanel = false;
+  const prefixes = ["mochat:", "group:", "channel:", "panel:"];
+  for (const prefix of prefixes) {
+    if (lower.startsWith(prefix)) {
+      id = trimmed.slice(prefix.length).trim();
+      if (prefix !== "mochat:") {
+        forcePanel = true;
+      }
+      break;
+    }
+  }
+  const isSessionId = id.startsWith("session_");
+  return { id, isPanel: forcePanel || !isSessionId };
+}
+
+function buildOutboundContent(ctx: ChannelOutboundContext, mediaUrls?: string[]): string {
+  const contentParts: string[] = [];
+  if (ctx.text?.trim()) {
+    contentParts.push(ctx.text.trim());
+  }
+  if (mediaUrls && mediaUrls.length > 0) {
+    contentParts.push(...mediaUrls);
+  }
+  return contentParts.join("\n").trim();
+}
+
+export const mochatPlugin: ChannelPlugin<ResolvedMochatAccount> = {
+  id: "mochat",
+  meta,
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: false,
+    threads: false,
+  },
+  reload: { configPrefixes: ["channels.mochat"] },
+  configSchema: buildChannelConfigSchema(MochatConfigSchema),
+  config: {
+    listAccountIds: (cfg) => listMochatAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveMochatAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultMochatAccountId(cfg),
+    isEnabled: (account) => account.enabled,
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      baseUrl: account.config.baseUrl,
+      sessions: account.config.sessions ?? [],
+      panels: account.config.panels ?? [],
+      autoDiscoverSessions: account.config.autoDiscoverSessions,
+      autoDiscoverPanels: account.config.autoDiscoverPanels,
+      agentUserId: account.config.agentUserId ? "[set]" : "[missing]",
+      clawToken: account.config.clawToken ? "[set]" : "[missing]",
+    }),
+  },
+  messaging: {
+    normalizeTarget: (target) => resolveMochatTarget(target).id || target.trim(),
+    targetResolver: {
+      looksLikeId: (input) => Boolean(input.trim()),
+      hint: "<sessionId>",
+    },
+  },
+  outbound: {
+    deliveryMode: "direct",
+    sendText: async (ctx) => {
+      const account = resolveMochatAccount({
+        cfg: ctx.cfg as OpenClawConfig,
+        accountId: ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+      });
+      if (!account.config.clawToken) {
+        throw new Error("Mochat clawToken is not configured");
+      }
+      const content = buildOutboundContent(ctx, []);
+      if (!content) {
+        return { channel: "mochat", to: ctx.to };
+      }
+      const target = resolveMochatTarget(ctx.to);
+      if (!target.id) {
+        return { channel: "mochat", to: ctx.to };
+      }
+      const isPanel =
+        target.isPanel || (account.config.panels ?? []).includes(target.id);
+      if (isPanel) {
+        await sendPanelMessage({
+          baseUrl: account.config.baseUrl,
+          clawToken: account.config.clawToken,
+          panelId: target.id,
+          content,
+          replyTo: ctx.replyToId ?? null,
+        });
+      } else {
+        await sendSessionMessage({
+          baseUrl: account.config.baseUrl,
+          clawToken: account.config.clawToken,
+          sessionId: target.id,
+          content,
+          replyTo: ctx.replyToId ?? null,
+        });
+      }
+      return { channel: "mochat", to: ctx.to };
+    },
+    sendMedia: async (ctx) => {
+      const account = resolveMochatAccount({
+        cfg: ctx.cfg as OpenClawConfig,
+        accountId: ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+      });
+      if (!account.config.clawToken) {
+        throw new Error("Mochat clawToken is not configured");
+      }
+      const mediaUrls = ctx.mediaUrl ? [ctx.mediaUrl] : [];
+      const content = buildOutboundContent(ctx, mediaUrls);
+      if (!content) {
+        return { channel: "mochat", to: ctx.to };
+      }
+      const target = resolveMochatTarget(ctx.to);
+      if (!target.id) {
+        return { channel: "mochat", to: ctx.to };
+      }
+      const isPanel =
+        target.isPanel || (account.config.panels ?? []).includes(target.id);
+      if (isPanel) {
+        await sendPanelMessage({
+          baseUrl: account.config.baseUrl,
+          clawToken: account.config.clawToken,
+          panelId: target.id,
+          content,
+          replyTo: ctx.replyToId ?? null,
+        });
+      } else {
+        await sendSessionMessage({
+          baseUrl: account.config.baseUrl,
+          clawToken: account.config.clawToken,
+          sessionId: target.id,
+          content,
+          replyTo: ctx.replyToId ?? null,
+        });
+      }
+      return { channel: "mochat", to: ctx.to };
+    },
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+    },
+    buildAccountSnapshot: ({ account, runtime }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      baseUrl: account.config.baseUrl,
+      sessions: account.config.sessions ?? [],
+      panels: account.config.panels ?? [],
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      lastInboundAt: runtime?.lastInboundAt ?? null,
+      lastOutboundAt: runtime?.lastOutboundAt ?? null,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = ctx.account;
+      if (!account.configured) {
+        throw new Error(
+          `Mochat not configured for account "${account.accountId}" (missing clawToken, agentUserId, or sessions)`,
+        );
+      }
+
+      const sessions = account.config.sessions ?? [];
+      const panels = account.config.panels ?? [];
+      if (
+        sessions.length === 0 &&
+        panels.length === 0 &&
+        !account.config.autoDiscoverSessions &&
+        !account.config.autoDiscoverPanels
+      ) {
+        throw new Error(
+          `Mochat account "${account.accountId}" has no sessions or panels configured`,
+        );
+      }
+
+      ctx.log?.info(
+        `[${account.accountId}] starting Mochat socket (${sessions.length} sessions, ${panels.length} panels)`,
+      );
+
+      ctx.setStatus({
+        accountId: account.accountId,
+        running: true,
+        lastStartAt: Date.now(),
+        lastError: null,
+      });
+
+      const socketClient = startMochatSocketClient({
+        account,
+        log: ctx.log,
+        abortSignal: ctx.abortSignal,
+        statusSink: (patch) => ctx.setStatus({ accountId: account.accountId, ...patch }),
+      });
+
+      return {
+        stop: () => {
+          socketClient.stop();
+          ctx.setStatus({
+            accountId: account.accountId,
+            running: false,
+            lastStopAt: Date.now(),
+          });
+        },
+      };
+    },
+  },
+};