@fontdo/5g-message 1.0.4

package/README.md

@@ -0,0 +1,88 @@
+# Fontdo 5G Message Channel Plugin
+
+OpenClaw 通道插件，用于连接 Fontdo 5G 消息平台。
+
+## 协议支持
+
+- **传输协议**: WebSocket over TLS (wss://)
+- **消息协议**: JSON-RPC 2.0
+- **认证方式**: Headers 签名认证
+
+## 安装
+
+### 方法 1: 本地安装
+
+```bash
+# 将插件复制到 OpenClaw 扩展目录
+cp -r . ~/.openclaw/extensions/fontdo-5g-message
+
+# 或者使用链接方式（开发模式）
+openclaw plugins install -l /path/to/fontdo-5g-message
+```
+
+### 方法 2: NPM 安装
+
+```bash
+openclaw plugins install @openclaw/fontdo-5g-message
+```
+
+## 配置
+
+在 `~/.openclaw/openclaw.json` 中添加配置：
+
+```json
+{
+  "channels": {
+    "fontdo-5g-message": {
+      "enabled": true,
+      "accounts": {
+        "default": {
+          "host": "5g.fontdo.com",
+          "appId": "your-app-id",
+          "appKey": "your-app-secret",
+          "botName": "OpenClaw Bot",
+          "enabled": true
+        }
+      },
+      "dmPolicy": "pairing",
+      "allowFrom": []
+    }
+  }
+}
+```
+
+### 配置项说明
+
+| 字段 | 说明 | 必填 |
+|------|------|------|
+| `host` | IM 服务器地址（不含协议前缀） | ✅ |
+| `appId` | 应用 ID | ✅ |
+| `appKey` | 应用密钥 | ✅ |
+| `botName` | 机器人显示名称 | ❌ |
+| `enabled` | 是否启用该账号 | ❌ (默认 true) |
+
+### 多账号配置
+
+```json
+{
+  "channels": {
+    "fontdo-5g-message": {
+      "defaultAccount": "prod",
+      "accounts": {
+        "prod": {
+          "host": "5g.fontdo.com",
+          "appId": "your-app-id",
+          "appKey": "your-app-secret",
+          "botName": "Production Bot"
+        },
+        "dev": {
+          "host": "test.fontdo.com",
+          "appId": "your-app-id",
+          "appKey": "your-app-secret",
+          "botName": "Dev Bot"
+        }
+      }
+    }
+  }
+}
+```

package/index.ts

@@ -0,0 +1,872 @@
+/**
+ * OpenClaw Channel Plugin for Custom IM Platform
+ * 
+ * This plugin connects OpenClaw to your custom IM platform via WebSocket
+ * using JSON-RPC 2.0 protocol.
+ */
+
+import type { OpenClawPluginApi, ChannelPlugin, RuntimeEnv, ClawdbotConfig, PluginRuntime } from "openclaw/plugin-sdk";
+import {
+  emptyPluginConfigSchema,
+  buildBaseChannelStatusSummary,
+  createDefaultChannelRuntimeState,
+  DEFAULT_ACCOUNT_ID,
+  createReplyPrefixContext,
+} from "openclaw/plugin-sdk";
+import WebSocket from "ws";
+import crypto from "crypto";
+
+// ============================================================================
+// Runtime (set during plugin registration)
+// ============================================================================
+
+let pluginRuntime: PluginRuntime | null = null;
+
+function getRuntime(): PluginRuntime {
+  if (!pluginRuntime) {
+    throw new Error("Custom IM plugin runtime not initialized");
+  }
+  return pluginRuntime;
+}
+
+// ============================================================================
+// Global Connection Registry (one WebSocket connection per account)
+// ============================================================================
+
+const activeConnections: Map<string, CustomIMClient> = new Map();
+
+function registerConnection(accountId: string, client: CustomIMClient): void {
+  activeConnections.set(accountId, client);
+  console.log(`[CustomIM] Registered connection for account ${accountId}`);
+}
+
+function unregisterConnection(accountId: string): void {
+  activeConnections.delete(accountId);
+  console.log(`[CustomIM] Unregistered connection for account ${accountId}`);
+}
+
+function getActiveConnection(accountId: string): CustomIMClient | undefined {
+  return activeConnections.get(accountId);
+}
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface CustomIMAccount {
+  accountId: string;
+  host: string;
+  appId: string;
+  appKey: string;
+  botName: string;
+  enabled: boolean;
+  configured: boolean;
+}
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  method: string;
+  params: Record<string, unknown>;
+  id: string;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+  id: string;
+}
+
+interface MessagePayload {
+  messageId: string;
+  sender: string;
+  content: string;
+  contentType: "text" | "card" | "file";
+  timestamp: number;
+  chatId?: string;
+  isGroup?: boolean;
+}
+
+// ============================================================================
+// Account Resolution
+// ============================================================================
+
+function resolveCustomIMAccount(
+  cfg: Record<string, unknown>,
+  accountId?: string
+): CustomIMAccount {
+  const actualAccountId = accountId ?? DEFAULT_ACCOUNT_ID;
+  const channels = cfg.channels as Record<string, Record<string, unknown>> | undefined;
+  const customImChannel = channels?.["custom-im"] as Record<string, unknown> | undefined;
+  const accounts = customImChannel?.accounts as Record<string, Record<string, unknown>> | undefined;
+  const account = accounts?.[actualAccountId] as Record<string, unknown> | undefined;
+
+  if (!account) {
+    return {
+      accountId: actualAccountId,
+      host: "",
+      appId: "",
+      appKey: "",
+      botName: "OpenClaw Bot",
+      enabled: false,
+      configured: false,
+    };
+  }
+
+  return {
+    accountId: actualAccountId,
+    host: (account.host as string) ?? "",
+    appId: (account.appId as string) ?? "",
+    appKey: (account.appKey as string) ?? "",
+    botName: (account.botName as string) ?? "OpenClaw Bot",
+    enabled: (account.enabled as boolean) ?? true,
+    configured: !!(account.host && account.appId && account.appKey),
+  };
+}
+
+function listCustomIMAccountIds(cfg: Record<string, unknown>): string[] {
+  const channels = cfg.channels as Record<string, Record<string, unknown>> | undefined;
+  const customImChannel = channels?.["custom-im"] as Record<string, unknown> | undefined;
+  const accounts = customImChannel?.accounts as Record<string, Record<string, unknown>> | undefined;
+  return accounts ? Object.keys(accounts) : [];
+}
+
+// ============================================================================
+// WebSocket Client for Custom IM
+// ============================================================================
+
+class CustomIMClient {
+  private ws: WebSocket | null = null;
+  private account: CustomIMAccount;
+  private onMessage: (msg: MessagePayload) => void;
+  private onClose: () => void;
+  private onHeartbeat?: () => void;
+  private logger: Console;
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+  private readonly heartbeatInterval: number = 30000; // 30 seconds
+
+  constructor(
+    account: CustomIMAccount,
+    onMessage: (msg: MessagePayload) => void,
+    onClose: () => void,
+    logger: Console,
+    onHeartbeat?: () => void
+  ) {
+    this.account = account;
+    this.onMessage = onMessage;
+    this.onClose = onClose;
+    this.onHeartbeat = onHeartbeat;
+    this.logger = logger;
+  }
+
+  private generateSignature(timestamp: number): string {
+    const data = this.account.appId + this.account.appKey + timestamp;
+    return crypto.createHash("sha256").update(data).digest("hex");
+  }
+
+  async connect(): Promise<void> {
+    const url = `wss://${this.account.host}/clawgw/ws/v1/chat`;
+    const timestamp = Date.now();
+    const signature = this.generateSignature(timestamp);
+
+    this.logger.log(`[CustomIM] Connecting to ${url}...`);
+
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(url, {
+        headers: {
+          "X-App-Id": this.account.appId,
+          "X-Timestamp": String(timestamp),
+          "X-Signature": signature,
+        },
+      });
+
+      this.ws.on("open", () => {
+        this.logger.log(`[CustomIM] Connected to ${url}`);
+        this.startHeartbeat();
+        resolve();
+      });
+
+      this.ws.on("message", (data: Buffer) => {
+        this.logger.log(`[CustomIM] Raw message received: ${data.toString()}`);
+        try {
+          this.handleMessage(data);
+        } catch (error) {
+          this.logger.error("[CustomIM] Error handling message:", error);
+        }
+      });
+
+      this.ws.on("error", (error) => {
+        this.logger.error("[CustomIM] WebSocket error:", error);
+        reject(error);
+      });
+
+      this.ws.on("close", (code, reason) => {
+        this.logger.log(`[CustomIM] Connection closed (code=${code}, reason=${reason.toString() || 'none'})`);
+        this.stopHeartbeat();
+        this.onClose();
+      });
+    });
+  }
+
+  private handleMessage(data: Buffer): void {
+    try {
+      const msg = JSON.parse(data.toString());
+      this.logger.log(`[CustomIM] Parsed message:`, JSON.stringify(msg));
+
+      // Handle heartbeat request from server - must respond to keep connection alive
+      if (msg.method === "heartbeat" && msg.id) {
+        this.logger.log(`[CustomIM] Received heartbeat request, sending response`);
+        this.sendHeartbeatResponse(msg.id, msg.params?.timestamp);
+        return;
+      }
+
+      // Handle direct notification: {"jsonrpc":"2.0","method":"onMessage","params":{...}}
+      if (msg.method === "onMessage" && msg.params) {
+        const params = msg.params as {
+          messageId: string;
+          sender: string;
+          payload: object;
+          msgType?: string;
+          timestamp: number;
+          chatId?: string;
+          isGroup?: boolean;
+        };
+
+        this.logger.log(`[CustomIM] Processing onMessage from ${params.sender}: ${params.payload.content}`);
+
+        this.onMessage({
+          messageId: params.messageId,
+          sender: params.sender,
+          content: params.payload.content,
+          contentType: (params.msgType as "text" | "card" | "file") ?? "text",
+          timestamp: params.timestamp,
+          chatId: params.chatId,
+          isGroup: params.isGroup,
+        });
+        return;
+      }
+
+      // Handle response with result containing method (old format)
+      const response = msg as JsonRpcResponse;
+      if (response.error) {
+        this.logger.error("[CustomIM] RPC error:", response.error);
+        return;
+      }
+
+      if (
+        response.result &&
+        typeof response.result === "object" &&
+        "method" in response.result
+      ) {
+        const notification = response.result as { method: string; params: Record<string, unknown> };
+        
+        if (notification.method === "onMessage") {
+          const params = notification.params as {
+            messageId: string;
+            sender: string;
+            content: string;
+            contentType: string;
+            timestamp: number;
+            chatId?: string;
+            isGroup?: boolean;
+          };
+
+          this.onMessage({
+            messageId: params.messageId,
+            sender: params.sender,
+            content: params.content,
+            contentType: params.contentType as "text" | "card" | "file",
+            timestamp: params.timestamp,
+            chatId: params.chatId,
+            isGroup: params.isGroup,
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.error("[CustomIM] Failed to parse message:", error);
+    }
+  }
+
+  async sendText(
+    receiver: string,
+    text: string,
+    options?: { replyTo?: string }
+  ): Promise<{ messageId: string }> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected");
+    }
+
+    const id = crypto.randomUUID();
+    const request: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      method: "sendMessage",
+      params: {
+        msgType: "text",
+        receiver,
+        payload: {
+          content: text,  // Changed from 'text' to 'content' to match server API
+        },
+        replyTo: options?.replyTo,
+      },
+      id,
+    };
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.ws?.off("message", handler);
+        reject(new Error("Request timeout"));
+      }, 30000);
+
+      const handler = (data: Buffer) => {
+        try {
+          const response: JsonRpcResponse = JSON.parse(data.toString());
+          if (response.id === id) {
+            clearTimeout(timeout);
+            this.ws?.off("message", handler);
+
+            if (response.error) {
+              reject(new Error(response.error.message));
+            } else {
+              resolve(response.result as { messageId: string });
+            }
+          }
+        } catch {
+          // Ignore
+        }
+      };
+
+      this.ws.on("message", handler);
+      this.ws.send(JSON.stringify(request));
+    });
+  }
+
+  private sendHeartbeatResponse(requestId: string, timestamp?: number): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.logger.log(`[CustomIM] Cannot send heartbeat response: WebSocket not connected`);
+      return;
+    }
+
+    const response = {
+      jsonrpc: "2.0",
+      method: "heartbeat",
+      result: {
+        timestamp: timestamp ?? Date.now(),
+      },
+      id: requestId,
+    };
+
+    this.ws.send(JSON.stringify(response));
+    this.logger.log(`[CustomIM] Heartbeat response sent for request ${requestId}`);
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.sendHeartbeat();
+    }, this.heartbeatInterval);
+    this.logger.log(`[CustomIM] Heartbeat started, interval=${this.heartbeatInterval}ms`);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+      this.logger.log(`[CustomIM] Heartbeat stopped`);
+    }
+  }
+
+  private sendHeartbeat(): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.logger.log(`[CustomIM] Cannot send heartbeat: WebSocket not connected`);
+      return;
+    }
+
+    const request = {
+      jsonrpc: "2.0",
+      method: "heartbeat",
+      params: {
+        clientTime: Date.now(),
+      },
+      id: crypto.randomUUID(),
+    };
+
+    this.ws.send(JSON.stringify(request));
+    this.logger.log(`[CustomIM] Heartbeat sent`);
+    
+    // Report connection is active to prevent stale-socket detection
+    if (this.onHeartbeat) {
+      this.onHeartbeat();
+    }
+  }
+
+  disconnect(): void {
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+}
+
+// ============================================================================
+// Message Dispatcher (using OpenClaw core API)
+// ============================================================================
+
+async function dispatchCustomIMMessage(params: {
+  cfg: ClawdbotConfig;
+  runtime: RuntimeEnv;
+  account: CustomIMAccount;
+  msg: MessagePayload;
+  client: CustomIMClient;
+}): Promise<void> {
+  const { cfg, runtime, account, msg, client } = params;
+  
+  console.log(`[CustomIM] dispatchCustomIMMessage called`);
+  
+  // Get runtime
+  let core: PluginRuntime;
+  try {
+    core = getRuntime();
+    console.log(`[CustomIM] getRuntime() returned: ${core ? 'valid' : 'null'}`);
+  } catch (error) {
+    console.error(`[CustomIM] getRuntime() error: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+  
+  const isGroup = msg.isGroup ?? false;
+  const chatId = msg.chatId ?? msg.sender;
+
+  // Resolve agent route
+  let route;
+  try {
+    route = core.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "custom-im",
+      accountId: account.accountId,
+      peer: {
+        kind: isGroup ? "group" : "direct",
+        id: chatId,
+      },
+    });
+    console.log(`[CustomIM] Routing message to session: ${route.sessionKey}`);
+  } catch (error) {
+    console.error(`[CustomIM] resolveAgentRoute error: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+
+  // Build the message context
+  const customImFrom = `custom-im:${msg.sender}`;
+  const customImTo = isGroup ? `chat:${chatId}` : `user:${msg.sender}`;
+
+  // Format message envelope
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+  const body = core.channel.reply.formatAgentEnvelope({
+    channel: "Custom IM",
+    from: msg.sender,
+    timestamp: new Date(),
+    envelope: envelopeOptions,
+    body: msg.content,
+  });
+
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: msg.content,
+    RawBody: msg.content,
+    CommandBody: msg.content,
+    From: customImFrom,
+    To: customImTo,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: isGroup ? "group" : "direct",
+    GroupSubject: isGroup ? chatId : undefined,
+    SenderName: msg.sender,
+    SenderId: msg.sender,
+    Provider: "custom-im" as const,
+    Surface: "custom-im" as const,
+    MessageSid: msg.messageId,
+    Timestamp: msg.timestamp,
+    WasMentioned: false,
+    CommandAuthorized: true,
+    OriginatingChannel: "custom-im" as const,
+    OriginatingTo: customImTo,
+  });
+
+  console.log(`[CustomIM] ctxPayload created: SessionKey=${ctxPayload.SessionKey}, ChatType=${ctxPayload.ChatType}`);
+
+  // Create reply dispatcher using OpenClaw's helper
+  const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+  
+  console.log(`[CustomIM] Creating reply dispatcher...`);
+  console.log(`[CustomIM] prefixContext.responsePrefix: ${prefixContext.responsePrefix}`);
+  
+  const dispatcherResult = core.channel.reply.createReplyDispatcherWithTyping({
+    responsePrefix: prefixContext.responsePrefix,
+    responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+    humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
+    onReplyStart: () => {
+      console.log(`[CustomIM] Starting reply...`);
+    },
+    deliver: async (payload, info) => {
+      console.log(`[CustomIM] deliver called, payload:`, JSON.stringify(payload ?? 'null'));
+      const text = payload?.text ?? "";
+      console.log(`[CustomIM] deliver text length: ${text.length}`);
+      if (!text.trim()) {
+        console.log(`[CustomIM] deliver: text is empty, skipping`);
+        return;
+      }
+
+      console.log(`[CustomIM] Sending reply to ${msg.sender}: ${text.slice(0, 100)}...`);
+      
+      try {
+        const result = await client.sendText(msg.sender, text);
+        console.log(`[CustomIM] Reply sent: ${result.messageId}`);
+      } catch (error) {
+        console.log(`[CustomIM] Failed to send reply: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+      }
+    },
+    onError: async (error, info) => {
+      console.log(`[CustomIM] ${info.kind} reply failed: ${error instanceof Error ? error.message : String(error)}`);
+    },
+    onIdle: async () => {
+      console.log(`[CustomIM] Reply session idle`);
+    },
+    onCleanup: () => {
+      console.log(`[CustomIM] Reply session cleanup`);
+    },
+  });
+
+  console.log(`[CustomIM] dispatcherResult keys: ${Object.keys(dispatcherResult).join(', ')}`);
+  console.log(`[CustomIM] dispatcher type: ${typeof dispatcherResult.dispatcher}`);
+  console.log(`[CustomIM] dispatcher keys: ${dispatcherResult.dispatcher ? Object.keys(dispatcherResult.dispatcher).join(', ') : 'null'}`);
+
+  const { dispatcher, replyOptions, markDispatchIdle } = dispatcherResult;
+
+  const finalReplyOptions = {
+    ...replyOptions,
+    onModelSelected: prefixContext.onModelSelected,
+  };
+
+  console.log(`[CustomIM] Dispatching to agent (session=${route.sessionKey})`);
+
+  try {
+    const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg,
+      dispatcher,
+      replyOptions: finalReplyOptions,
+    });
+
+    console.log(`[CustomIM] Dispatch complete (queuedFinal=${queuedFinal})`);
+    console.log(`[CustomIM] counts: ${JSON.stringify(counts)}`);
+    console.log(`[CustomIM] dispatcher.getQueuedCounts(): ${JSON.stringify(dispatcher.getQueuedCounts())}`);
+    
+    // Wait for the dispatcher to become idle (agent to finish processing)
+    await dispatcher.waitForIdle();
+    console.log(`[CustomIM] Dispatcher idle, final counts: ${JSON.stringify(dispatcher.getQueuedCounts())}`);
+    
+    markDispatchIdle();
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const errorStack = error instanceof Error ? error.stack : 'N/A';
+    console.error(`[CustomIM] Dispatch error: ${errorMsg}`);
+    console.error(`[CustomIM] Dispatch stack: ${errorStack}`);
+    throw error;
+  }
+}
+
+// ============================================================================
+// Channel Plugin Definition
+// ============================================================================
+
+export const customIMPlugin: ChannelPlugin<CustomIMAccount> = {
+  id: "custom-im",
+
+  meta: {
+    id: "custom-im",
+    label: "Custom IM",
+    selectionLabel: "Custom IM (WebSocket)",
+    docsPath: "/channels/custom-im",
+    blurb: "Custom IM platform integration via WebSocket JSON-RPC 2.0",
+    aliases: ["cim", "custom"],
+  },
+
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    polls: false,
+    threads: false,
+    media: false,
+    reactions: false,
+    edit: false,
+    reply: true,
+  },
+
+  reload: { configPrefixes: ["channels.custom-im"] },
+
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        host: { type: "string" },
+        appId: { type: "string" },
+        appKey: { type: "string" },
+        botName: { type: "string" },
+        dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+        groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
+        autoRestart: { type: "boolean" },
+        restartDelayMs: { type: "number" },
+        maxRestartDelayMs: { type: "number" },
+        maxRestartAttempts: { type: "number" },
+        accounts: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              enabled: { type: "boolean" },
+              host: { type: "string" },
+              appId: { type: "string" },
+              appKey: { type: "string" },
+              botName: { type: "string" },
+              autoRestart: { type: "boolean" },
+              restartDelayMs: { type: "number" },
+              maxRestartDelayMs: { type: "number" },
+              maxRestartAttempts: { type: "number" },
+            },
+          },
+        },
+      },
+    },
+  },
+
+  config: {
+    listAccountIds: listCustomIMAccountIds,
+    resolveAccount: resolveCustomIMAccount,
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      host: account.host,
+      botName: account.botName,
+    }),
+  },
+
+  setup: {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    applyAccountConfig: ({ cfg, accountId }) => {
+      const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+
+      if (isDefault) {
+        return {
+          ...cfg,
+          channels: {
+            ...cfg.channels,
+            "custom-im": {
+              ...cfg.channels?.["custom-im"],
+              enabled: true,
+            },
+          },
+        };
+      }
+
+      const customImCfg = cfg.channels?.["custom-im"] as Record<string, unknown> | undefined;
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          "custom-im": {
+            ...customImCfg,
+            accounts: {
+              ...(customImCfg?.accounts as Record<string, unknown>),
+              [accountId]: {
+                ...(customImCfg?.accounts as Record<string, unknown>)?.[accountId],
+                enabled: true,
+              },
+            },
+          },
+        },
+      };
+    },
+  },
+
+  status: {
+    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+    buildChannelSummary: ({ snapshot }) => ({
+      ...buildBaseChannelStatusSummary(snapshot),
+    }),
+    buildAccountSnapshot: ({ account, runtime }) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      host: account.host,
+      botName: account.botName,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+    }),
+  },
+
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = resolveCustomIMAccount(ctx.cfg, ctx.accountId);
+      
+      if (!account.configured) {
+        throw new Error(`Custom IM account ${ctx.accountId} not configured`);
+      }
+
+      ctx.log?.info(`starting custom-im[${ctx.accountId}]`);
+
+      // Set initial status
+      ctx.setStatus({ accountId: ctx.accountId, connected: false });
+
+      // Create a promise that will be resolved when we need to stop
+      let stopResolver: (() => void) | null = null;
+      const stopPromise = new Promise<void>((resolve) => {
+        stopResolver = resolve;
+      });
+
+      const client = new CustomIMClient(
+        account,
+        async (msg) => {
+          ctx.log?.info(`[CustomIM] Received message from ${msg.sender}: ${msg.content}`);
+          
+          try {
+            await dispatchCustomIMMessage({
+              cfg: ctx.cfg,
+              runtime: ctx.runtime,
+              account,
+              msg,
+              client,
+            });
+            ctx.log?.info(`[CustomIM] Message processed successfully`);
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : 'N/A';
+            ctx.log?.error(`[CustomIM] Error processing message: ${errorMsg}`);
+            ctx.log?.error(`[CustomIM] Error stack: ${errorStack}`);
+          }
+        },
+        () => {
+          // Called when WebSocket connection is closed
+          ctx.log?.info(`[CustomIM] Connection lost, triggering reconnect...`);
+          unregisterConnection(ctx.accountId);
+          ctx.setStatus({ accountId: ctx.accountId, connected: false });
+          // Trigger reconnect by resolving the stop promise
+          if (stopResolver) {
+            stopResolver();
+          }
+        },
+        console,
+        () => {
+          // Called on each heartbeat - report connection is active to prevent stale-socket detection
+          ctx.setStatus({ accountId: ctx.accountId, connected: true });
+        }
+      );
+
+      await client.connect();
+      
+      // Register the connection for this account
+      registerConnection(ctx.accountId, client);
+      
+      // Update status to connected
+      ctx.setStatus({ accountId: ctx.accountId, connected: true });
+      ctx.log?.info(`[CustomIM] Connection established, channel is now running`);
+
+      // Wait for either abort signal or connection close
+      return new Promise<{ stop: () => void }>((resolve) => {
+        const stopHandler = () => {
+          ctx.log?.info(`stopping custom-im[${ctx.accountId}]`);
+          ctx.setStatus({ accountId: ctx.accountId, connected: false });
+          unregisterConnection(ctx.accountId);
+          client.disconnect();
+          resolve({ stop: stopHandler });
+        };
+
+        // Listen for abort signal
+        if (ctx.abortSignal) {
+          ctx.abortSignal.addEventListener('abort', stopHandler);
+        }
+
+        // Also resolve when connection is closed (stopPromise)
+        // This triggers immediate reconnect instead of waiting for OpenClaw's backoff
+        stopPromise.then(() => {
+          if (ctx.abortSignal) {
+            ctx.abortSignal.removeEventListener('abort', stopHandler);
+          }
+          // Don't resolve immediately - let OpenClaw handle the restart
+          // But signal that we want to restart by throwing an error
+          resolve({ stop: stopHandler });
+        });
+      });
+    },
+  },
+
+  outbound: {
+    deliveryMode: "direct",
+
+    sendText: async ({ cfg, accountId, peerId, text }) => {
+      const account = resolveCustomIMAccount(cfg, accountId);
+
+      if (!account.configured) {
+        throw new Error(`Custom IM account ${accountId} not configured`);
+      }
+
+      const client = getActiveConnection(accountId);
+      if (!client) {
+        throw new Error(`Custom IM account ${accountId} is not connected`);
+      }
+
+      const result = await client.sendText(peerId, text);
+      return { ok: true, messageId: result.messageId };
+    },
+  },
+
+  pairing: {
+    idLabel: "customImUserId",
+    normalizeAllowEntry: (entry) => entry.replace(/^(custom|cim):/i, ""),
+    notifyApproval: async ({ cfg, id, accountId }) => {
+      const account = resolveCustomIMAccount(cfg, accountId);
+
+      if (!account.configured) return;
+
+      const client = getActiveConnection(accountId);
+      if (!client) {
+        console.error(`[CustomIM] Account ${accountId} is not connected, cannot send approval message`);
+        return;
+      }
+
+      try {
+        await client.sendText(id, "✅ You have been approved to chat with me!");
+      } catch (error) {
+        console.error("[CustomIM] Failed to send approval message:", error);
+      }
+    },
+  },
+
+  security: {
+    dmPolicy: "open",
+  },
+};
+
+// ============================================================================
+// Plugin Registration
+// ============================================================================
+
+const plugin = {
+  id: "custom-im",
+  name: "Custom IM",
+  description: "Custom IM platform integration via WebSocket JSON-RPC 2.0",
+  configSchema: emptyPluginConfigSchema(),
+
+  register(api: OpenClawPluginApi) {
+    // Store the runtime for use in message dispatching
+    pluginRuntime = api.runtime;
+    api.registerChannel({ plugin: customIMPlugin });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,37 @@
+{
+  "id": "fontdo-5g-message",
+  "channels": ["fontdo-5g-message"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "host": {
+        "type": "string",
+        "title": "服务器地址",
+        "description": "Fontdo 5G 消息平台地址（不含协议前缀，如 5g.fontdo.com）"
+      },
+      "appId": {
+        "type": "string",
+        "title": "应用 ID",
+        "description": "从平台获取的应用 ID"
+      },
+      "appKey": {
+        "type": "string",
+        "title": "应用密钥",
+        "description": "从平台获取的应用密钥"
+      },
+      "botName": {
+        "type": "string",
+        "title": "机器人名称",
+        "description": "机器人在对话中的显示名称",
+        "default": "Fontdo Bot"
+      },
+      "enabled": {
+        "type": "boolean",
+        "title": "启用账号",
+        "description": "是否启用该账号",
+        "default": true
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@fontdo/5g-message",
+  "version": "1.0.4",
+  "description": "OpenClaw 通道插件，用于连接 Fontdo 5G 消息平台",
+  "main": "index.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "fontdo-5g-message",
+      "label": "Fontdo 5G Message",
+      "selectionLabel": "Fontdo 5G Message (WebSocket)",
+      "docsPath": "/channels/fontdo-5g-message",
+      "docsLabel": "fontdo-5g-message",
+      "blurb": "Fontdo 5G 消息平台集成，通过 WebSocket JSON-RPC 2.0 协议",
+      "order": 100,
+      "aliases": [
+        "fontdo",
+        "5g",
+        "5g-message"
+      ]
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}