@fontdo/5g-message 1.0.8 → 1.0.10

package/dist/index.js

@@ -0,0 +1,699 @@
+/**
+ * OpenClaw Channel Plugin for Fontdo 5G Message Platform
+ *
+ * This plugin connects OpenClaw to your Fontdo 5G message platform via WebSocket
+ * using JSON-RPC 2.0 protocol.
+ */
+// 模拟函数
+const emptyPluginConfigSchema = () => ({});
+const buildBaseChannelStatusSummary = (snapshot) => ({});
+const createDefaultChannelRuntimeState = (accountId) => ({});
+const DEFAULT_ACCOUNT_ID = "default";
+const createReplyPrefixContext = (options) => ({
+    responsePrefix: "",
+    responsePrefixContextProvider: () => { },
+    onModelSelected: () => { }
+});
+import WebSocket from "ws";
+import crypto from "crypto";
+// ============================================================================
+// Runtime (set during plugin registration)
+// ============================================================================
+let pluginRuntime = null;
+function getRuntime() {
+    if (!pluginRuntime) {
+        throw new Error("Custom IM plugin runtime not initialized");
+    }
+    return pluginRuntime;
+}
+// ============================================================================
+// Global Connection Registry (one WebSocket connection per account)
+// ============================================================================
+const activeConnections = new Map();
+function registerConnection(accountId, client) {
+    activeConnections.set(accountId, client);
+    console.log(`[CustomIM] Registered connection for account ${accountId}`);
+}
+function unregisterConnection(accountId) {
+    activeConnections.delete(accountId);
+    console.log(`[CustomIM] Unregistered connection for account ${accountId}`);
+}
+function getActiveConnection(accountId) {
+    return activeConnections.get(accountId);
+}
+// ============================================================================
+// Account Resolution
+// ============================================================================
+function resolveCustomIMAccount(cfg, accountId) {
+    const actualAccountId = accountId ?? DEFAULT_ACCOUNT_ID;
+    const channels = cfg.channels;
+    const customImChannel = channels?.["5g-message"];
+    const accounts = customImChannel?.accounts;
+    const account = accounts?.[actualAccountId];
+    if (!account) {
+        return {
+            accountId: actualAccountId,
+            host: "",
+            appId: "",
+            appKey: "",
+            botName: "OpenClaw Bot",
+            enabled: false,
+            configured: false,
+        };
+    }
+    return {
+        accountId: actualAccountId,
+        host: account.host ?? "",
+        appId: account.appId ?? "",
+        appKey: account.appKey ?? "",
+        botName: account.botName ?? "OpenClaw Bot",
+        enabled: account.enabled ?? true,
+        configured: !!(account.host && account.appId && account.appKey),
+    };
+}
+function listCustomIMAccountIds(cfg) {
+    const channels = cfg.channels;
+    const customImChannel = channels?.["5g-message"];
+    const accounts = customImChannel?.accounts;
+    return accounts ? Object.keys(accounts) : [];
+}
+// ============================================================================
+// WebSocket Client for Custom IM
+// ============================================================================
+class CustomIMClient {
+    ws = null;
+    account;
+    onMessage;
+    onClose;
+    onHeartbeat;
+    logger;
+    heartbeatTimer = null;
+    heartbeatInterval = 30000; // 30 seconds
+    constructor(account, onMessage, onClose, logger, onHeartbeat) {
+        this.account = account;
+        this.onMessage = onMessage;
+        this.onClose = onClose;
+        this.onHeartbeat = onHeartbeat;
+        this.logger = logger;
+    }
+    generateSignature(timestamp) {
+        const data = this.account.appId + this.account.appKey + timestamp;
+        return crypto.createHash("sha256").update(data).digest("hex");
+    }
+    async connect() {
+        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) => {
+                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();
+            });
+        });
+    }
+    handleMessage(data) {
+        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;
+                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 ?? "text",
+                    timestamp: params.timestamp,
+                    chatId: params.chatId,
+                    isGroup: params.isGroup,
+                });
+                return;
+            }
+            // Handle response with result containing method (old format)
+            const response = msg;
+            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;
+                if (notification.method === "onMessage") {
+                    const params = notification.params;
+                    this.onMessage({
+                        messageId: params.messageId,
+                        sender: params.sender,
+                        content: params.content,
+                        contentType: params.contentType,
+                        timestamp: params.timestamp,
+                        chatId: params.chatId,
+                        isGroup: params.isGroup,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error("[CustomIM] Failed to parse message:", error);
+        }
+    }
+    async sendText(receiver, text, options) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("WebSocket not connected");
+        }
+        const id = crypto.randomUUID();
+        const request = {
+            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) => {
+                try {
+                    const response = 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);
+                        }
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            };
+            if (this.ws) {
+                this.ws.on("message", handler);
+                this.ws.send(JSON.stringify(request));
+            }
+            else {
+                reject(new Error("WebSocket not connected"));
+            }
+        });
+    }
+    sendHeartbeatResponse(requestId, timestamp) {
+        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}`);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.heartbeatInterval);
+        this.logger.log(`[CustomIM] Heartbeat started, interval=${this.heartbeatInterval}ms`);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+            this.logger.log(`[CustomIM] Heartbeat stopped`);
+        }
+    }
+    sendHeartbeat() {
+        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() {
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+// ============================================================================
+// Message Dispatcher (using OpenClaw core API)
+// ============================================================================
+async function dispatchCustomIMMessage(params) {
+    const { cfg, runtime, account, msg, client } = params;
+    console.log(`[CustomIM] dispatchCustomIMMessage called`);
+    // Get runtime
+    let core;
+    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: "5g-message",
+            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 = `5g-message:${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: "5g-message",
+        Surface: "5g-message",
+        MessageSid: msg.messageId,
+        Timestamp: msg.timestamp,
+        WasMentioned: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "5g-message",
+        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 fontdo5GMessagePlugin = {
+    id: "5g-message",
+    meta: {
+        id: "5g-message",
+        label: "Fontdo 5G Message",
+        selectionLabel: "Fontdo 5G Message (WebSocket)",
+        docsPath: "/channels/5g-message",
+        blurb: "Fontdo 5G 消息平台集成，通过 WebSocket JSON-RPC 2.0 协议",
+        aliases: ["fontdo", "5g", "5g-message"],
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        polls: false,
+        threads: false,
+        media: false,
+        reactions: false,
+        edit: false,
+        reply: true,
+    },
+    reload: { configPrefixes: ["channels.5g-message"] },
+    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,
+                        "5g-message": {
+                            ...cfg.channels?.["5g-message"],
+                            enabled: true,
+                        },
+                    },
+                };
+            }
+            const customImCfg = cfg.channels?.["5g-message"];
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    "5g-message": {
+                        ...customImCfg,
+                        accounts: {
+                            ...customImCfg?.accounts,
+                            [accountId]: {
+                                ...(customImCfg?.accounts?.[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 5g-message[${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 = null;
+            const stopPromise = new Promise((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((resolve) => {
+                const stopHandler = () => {
+                    ctx.log?.info(`stopping 5g-message[${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: "5g-message",
+    name: "Fontdo 5G Message",
+    description: "Fontdo 5G 消息平台集成，通过 WebSocket JSON-RPC 2.0 协议",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        // Store the runtime for use in message dispatching
+        pluginRuntime = api.runtime;
+        api.registerChannel({ plugin: fontdo5GMessagePlugin });
+    },
+};
+export default plugin;
+//# sourceMappingURL=index.js.map