moltbot-wecom 1.0.2 → 2.0.0

package/dist/src/receive.js

@@ -0,0 +1,282 @@
+/**
+ * WeCom WebSocket message receive handler.
+ *
+ * Connects to WeCom via a WebSocket proxy, dispatches incoming
+ * messages to Clawdbot's channel reply infrastructure.
+ */
+import { isDuplicate } from "./dedup.js";
+import { shouldRespondInGroup } from "./group-filter.js";
+import { sendReplyMessage, sendPing, registerConnection, unregisterConnection } from "./send.js";
+import { getWeComRuntime } from "./runtime.js";
+/** Start the WeCom WebSocket provider. Returns a stop function. */
+export function startWeComProvider(options) {
+    const { account, config, log, statusSink, abortSignal } = options;
+    const { proxyUrl, proxyToken, accountId } = account;
+    const thinkingThresholdMs = account.config.thinkingThresholdMs ?? 0;
+    const botNames = account.config.botNames;
+    const pingIntervalMs = account.config.pingIntervalMs ?? 30000;
+    const reconnectDelayMs = account.config.reconnectDelayMs ?? 5000;
+    log.info(`[wecom:${accountId}] Starting WebSocket provider (proxy=${proxyUrl})`);
+    const state = {
+        ws: null,
+        pingTimer: null,
+        reconnectTimer: null,
+        isAlive: false,
+        stopped: false,
+    };
+    // Handle abort signal
+    if (abortSignal) {
+        abortSignal.addEventListener("abort", () => {
+            state.stopped = true;
+            cleanup();
+        });
+    }
+    function cleanup() {
+        if (state.pingTimer) {
+            clearInterval(state.pingTimer);
+            state.pingTimer = null;
+        }
+        if (state.reconnectTimer) {
+            clearTimeout(state.reconnectTimer);
+            state.reconnectTimer = null;
+        }
+        if (state.ws) {
+            unregisterConnection(accountId);
+            try {
+                state.ws.terminate();
+            }
+            catch {
+                // Ignore
+            }
+            state.ws = null;
+        }
+    }
+    function startHeartbeat() {
+        if (state.pingTimer) {
+            clearInterval(state.pingTimer);
+        }
+        state.pingTimer = setInterval(() => {
+            if (!state.ws || state.ws.readyState !== 1 /* OPEN */) {
+                return;
+            }
+            if (!state.isAlive) {
+                log.warn?.(`[wecom:${accountId}] Heartbeat timeout, reconnecting...`);
+                state.ws.terminate();
+                return;
+            }
+            state.isAlive = false;
+            sendPing(state.ws);
+        }, pingIntervalMs);
+    }
+    function scheduleReconnect() {
+        if (state.stopped || state.reconnectTimer)
+            return;
+        state.reconnectTimer = setTimeout(() => {
+            state.reconnectTimer = null;
+            if (!state.stopped) {
+                connect();
+            }
+        }, reconnectDelayMs);
+    }
+    async function connect() {
+        if (state.stopped)
+            return;
+        try {
+            const { default: WebSocket } = await import("ws");
+            const url = proxyToken
+                ? `${proxyUrl}?token=${encodeURIComponent(proxyToken)}`
+                : proxyUrl;
+            log.info(`[wecom:${accountId}] Connecting to proxy: ${proxyUrl}`);
+            const ws = new WebSocket(url);
+            state.ws = ws;
+            ws.on("open", () => {
+                log.info(`[wecom:${accountId}] WebSocket connected`);
+                state.isAlive = true;
+                registerConnection(accountId, ws);
+                statusSink?.({ running: true, lastStartAt: Date.now() });
+                if (state.reconnectTimer) {
+                    clearTimeout(state.reconnectTimer);
+                    state.reconnectTimer = null;
+                }
+                startHeartbeat();
+            });
+            ws.on("message", async (data) => {
+                try {
+                    const event = JSON.parse(data.toString());
+                    await handleIncomingEvent(event, {
+                        ws,
+                        account,
+                        config,
+                        log,
+                        thinkingThresholdMs,
+                        botNames,
+                        statusSink,
+                    });
+                }
+                catch (err) {
+                    log.error(`[wecom:${accountId}] Message handler error: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            });
+            ws.on("close", () => {
+                log.warn?.(`[wecom:${accountId}] WebSocket disconnected`);
+                state.isAlive = false;
+                unregisterConnection(accountId);
+                statusSink?.({ running: false, lastStopAt: Date.now() });
+                if (state.pingTimer) {
+                    clearInterval(state.pingTimer);
+                    state.pingTimer = null;
+                }
+                scheduleReconnect();
+            });
+            ws.on("error", (err) => {
+                log.error(`[wecom:${accountId}] WebSocket error: ${err.message}`);
+                statusSink?.({ lastError: err.message });
+                ws.terminate();
+            });
+        }
+        catch (err) {
+            log.error(`[wecom:${accountId}] Connection failed: ${err instanceof Error ? err.message : String(err)}`);
+            scheduleReconnect();
+        }
+    }
+    // Start initial connection
+    connect();
+    const stop = () => {
+        log.info(`[wecom:${accountId}] Stopping WebSocket provider`);
+        state.stopped = true;
+        cleanup();
+        statusSink?.({ running: false, lastStopAt: Date.now() });
+    };
+    return { stop };
+}
+/** Handle a single incoming WeCom event. */
+async function handleIncomingEvent(event, ctx) {
+    // Handle pong response
+    if (event.kind === "pong") {
+        return;
+    }
+    // Handle connection confirmation
+    if (event.kind === "connected") {
+        ctx.log.info(`[wecom:${ctx.account.accountId}] Connection confirmed by proxy`);
+        return;
+    }
+    // Only process message events
+    if (event.kind !== "message") {
+        return;
+    }
+    const payload = event.payload;
+    if (!payload)
+        return;
+    const msgId = event.msgId;
+    const senderId = payload.FromUserName;
+    const text = payload.Content?.trim();
+    // Basic validation
+    if (!senderId || !text) {
+        // Send empty reply for non-text messages
+        await sendReplyMessage(ctx.ws, msgId ?? "", "");
+        return;
+    }
+    // Dedup check
+    if (isDuplicate(msgId)) {
+        ctx.log.debug?.(`[wecom:${ctx.account.accountId}] Duplicate message ignored: ${msgId}`);
+        await sendReplyMessage(ctx.ws, msgId ?? "", "");
+        return;
+    }
+    ctx.statusSink?.({ lastInboundAt: Date.now() });
+    // WeCom Smart Bot messages are typically direct; group logic kept for future use
+    const isGroup = false;
+    if (isGroup && !shouldRespondInGroup(text, [], ctx.botNames)) {
+        ctx.log.debug?.(`[wecom:${ctx.account.accountId}] Ignoring group message (no trigger)`);
+        await sendReplyMessage(ctx.ws, msgId ?? "", "");
+        return;
+    }
+    const sessionKey = `wecom:${senderId}`;
+    ctx.log.info(`[wecom:${ctx.account.accountId}] Rx [${senderId}]: ${text.slice(0, 80)}`);
+    // Dispatch via Clawdbot runtime
+    const runtime = getWeComRuntime();
+    const channel = runtime.channel;
+    if (!channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+        ctx.log.error(`[wecom:${ctx.account.accountId}] dispatchReplyWithBufferedBlockDispatcher not available`);
+        await sendReplyMessage(ctx.ws, msgId ?? "", "");
+        return;
+    }
+    // Build inbound context
+    const inboundCtx = {
+        Body: text,
+        RawBody: text,
+        CommandBody: text,
+        From: senderId,
+        To: payload.ToUserName ?? "",
+        SessionKey: sessionKey,
+        AccountId: ctx.account.accountId,
+        MessageSid: msgId,
+        ChatType: "direct",
+        ConversationLabel: senderId,
+        SenderId: senderId,
+        CommandAuthorized: true,
+        Provider: "wecom",
+        Surface: "wecom",
+        OriginatingChannel: "wecom",
+        OriginatingTo: senderId,
+        DeliveryContext: {
+            channel: "wecom",
+            to: senderId,
+            accountId: ctx.account.accountId,
+        },
+    };
+    // Timeout for passive reply (WeCom has strict 5s limit)
+    const REPLY_TIMEOUT_MS = 4500;
+    let replied = false;
+    // Promise to handle the reply
+    const replyPromise = new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            if (!replied) {
+                replied = true;
+                ctx.log.warn?.(`[wecom:${ctx.account.accountId}] Reply timeout, sending empty`);
+                sendReplyMessage(ctx.ws, msgId ?? "", "").finally(resolve);
+            }
+        }, REPLY_TIMEOUT_MS);
+        // Create reply handler
+        const replyHandler = async (replyText) => {
+            if (replied)
+                return;
+            replied = true;
+            clearTimeout(timeout);
+            if (!replyText || replyText === "NO_REPLY") {
+                await sendReplyMessage(ctx.ws, msgId ?? "", "");
+            }
+            else {
+                ctx.log.info(`[wecom:${ctx.account.accountId}] Tx [${senderId}]: ${replyText.slice(0, 50)}...`);
+                ctx.statusSink?.({ lastOutboundAt: Date.now() });
+                await sendReplyMessage(ctx.ws, msgId ?? "", replyText);
+            }
+            resolve();
+        };
+        // Dispatch to Clawdbot pipeline
+        channel.reply?.dispatchReplyWithBufferedBlockDispatcher?.({
+            ctx: inboundCtx,
+            replyFn: replyHandler,
+            blockHandler: {
+                onBlock: async (block) => {
+                    // For buffered responses, we collect and send at end
+                    if (block.text && !replied) {
+                        await replyHandler(block.text);
+                    }
+                },
+                onComplete: async () => {
+                    if (!replied) {
+                        await replyHandler("");
+                    }
+                },
+            },
+        }).catch((err) => {
+            ctx.log.error(`[wecom:${ctx.account.accountId}] Pipeline error: ${err.message}`);
+            if (!replied) {
+                replied = true;
+                clearTimeout(timeout);
+                sendReplyMessage(ctx.ws, msgId ?? "", "").finally(resolve);
+            }
+        });
+    });
+    await replyPromise;
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Global runtime reference for the WeCom plugin.
+ */
+import type { PluginRuntime } from "clawdbot/plugin-sdk";
+export declare function setWeComRuntime(next: PluginRuntime): void;
+export declare function getWeComRuntime(): PluginRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/src/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAEzD;AAED,wBAAgB,eAAe,IAAI,aAAa,CAK/C"}

package/dist/src/runtime.js

@@ -0,0 +1,13 @@
+/**
+ * Global runtime reference for the WeCom plugin.
+ */
+let runtime = null;
+export function setWeComRuntime(next) {
+    runtime = next;
+}
+export function getWeComRuntime() {
+    if (!runtime) {
+        throw new Error("WeCom runtime not initialized");
+    }
+    return runtime;
+}

package/dist/src/send.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Send messages to WeCom via WebSocket proxy.
+ */
+import type { WeComSendResult } from "./types.js";
+import type WebSocket from "ws";
+/** Register an active WebSocket connection for an account. */
+export declare function registerConnection(accountId: string, ws: WebSocket): void;
+/** Unregister a WebSocket connection for an account. */
+export declare function unregisterConnection(accountId: string): void;
+/** Get active WebSocket connection for an account. */
+export declare function getConnection(accountId: string): WebSocket | undefined;
+/**
+ * Send a reply to a specific message via the WeCom proxy.
+ */
+export declare function sendReplyMessage(ws: WebSocket | undefined, msgId: string, text: string): Promise<WeComSendResult>;
+/**
+ * Send a text message to a WeCom chat.
+ * Note: For passive reply mode, messages go through sendReplyMessage.
+ * This is a placeholder for potential active messaging support.
+ */
+export declare function sendTextMessage(accountId: string, chatId: string, text: string): Promise<WeComSendResult>;
+/**
+ * Send a ping to keep the connection alive.
+ */
+export declare function sendPing(ws: WebSocket | undefined): boolean;
+//# sourceMappingURL=send.d.ts.map

package/dist/src/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/send.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,SAAS,MAAM,IAAI,CAAC;AAKhC,8DAA8D;AAC9D,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,IAAI,CAEzE;AAED,wDAAwD;AACxD,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAEtE;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,SAAS,GAAG,SAAS,EACzB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,CAAC,CAwB1B;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,CAAC,CAc1B;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAW3D"}

package/dist/src/send.js

@@ -0,0 +1,75 @@
+/**
+ * Send messages to WeCom via WebSocket proxy.
+ */
+/** Active WebSocket connections by account. */
+const activeConnections = new Map();
+/** Register an active WebSocket connection for an account. */
+export function registerConnection(accountId, ws) {
+    activeConnections.set(accountId, ws);
+}
+/** Unregister a WebSocket connection for an account. */
+export function unregisterConnection(accountId) {
+    activeConnections.delete(accountId);
+}
+/** Get active WebSocket connection for an account. */
+export function getConnection(accountId) {
+    return activeConnections.get(accountId);
+}
+/**
+ * Send a reply to a specific message via the WeCom proxy.
+ */
+export async function sendReplyMessage(ws, msgId, text) {
+    if (!ws || ws.readyState !== 1 /* OPEN */) {
+        return { ok: false, error: "WebSocket not connected" };
+    }
+    if (!msgId) {
+        return { ok: false, error: "No message ID provided" };
+    }
+    try {
+        ws.send(JSON.stringify({
+            kind: "reply",
+            msgId,
+            text: text ?? "",
+        }));
+        return { ok: true, messageId: msgId };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Send a text message to a WeCom chat.
+ * Note: For passive reply mode, messages go through sendReplyMessage.
+ * This is a placeholder for potential active messaging support.
+ */
+export async function sendTextMessage(accountId, chatId, text) {
+    const ws = activeConnections.get(accountId);
+    if (!ws || ws.readyState !== 1 /* OPEN */) {
+        return { ok: false, error: "WebSocket not connected" };
+    }
+    // WeCom Smart Bot uses passive reply mode; active messaging
+    // would require calling WeCom APIs directly (future enhancement).
+    // For now, return an error indicating this limitation.
+    return {
+        ok: false,
+        error: "Active messaging not supported in proxy mode. Use reply flow.",
+    };
+}
+/**
+ * Send a ping to keep the connection alive.
+ */
+export function sendPing(ws) {
+    if (!ws || ws.readyState !== 1 /* OPEN */) {
+        return false;
+    }
+    try {
+        ws.send(JSON.stringify({ kind: "ping", ts: Date.now() }));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/status-issues.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Diagnostic issues collector for WeCom channel.
+ */
+import type { ChannelAccountSnapshot, ChannelStatusIssue } from "clawdbot/plugin-sdk";
+/** Collect configuration issues for all WeCom accounts. */
+export declare function collectWeComStatusIssues(accounts: ChannelAccountSnapshot[]): ChannelStatusIssue[];
+//# sourceMappingURL=status-issues.d.ts.map

package/dist/src/status-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-issues.d.ts","sourceRoot":"","sources":["../../src/status-issues.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AA2BtF,2DAA2D;AAC3D,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,sBAAsB,EAAE,GACjC,kBAAkB,EAAE,CAiCtB"}

package/dist/src/status-issues.js

@@ -0,0 +1,47 @@
+/**
+ * Diagnostic issues collector for WeCom channel.
+ */
+const isRecord = (value) => Boolean(value && typeof value === "object");
+const asString = (value) => typeof value === "string" ? value : typeof value === "number" ? String(value) : undefined;
+function readWeComAccountStatus(value) {
+    if (!isRecord(value))
+        return null;
+    return {
+        accountId: value.accountId,
+        enabled: value.enabled,
+        configured: value.configured,
+        dmPolicy: value.dmPolicy,
+        proxyUrl: value.proxyUrl,
+    };
+}
+/** Collect configuration issues for all WeCom accounts. */
+export function collectWeComStatusIssues(accounts) {
+    const issues = [];
+    for (const entry of accounts) {
+        const account = readWeComAccountStatus(entry);
+        if (!account)
+            continue;
+        const accountId = asString(account.accountId) ?? "default";
+        const enabled = account.enabled !== false;
+        const configured = account.configured === true;
+        if (enabled && !configured) {
+            issues.push({
+                channel: "wecom",
+                accountId,
+                kind: "config",
+                message: "WeCom account is enabled but not configured (missing proxyUrl).",
+                fix: "Set channels.wecom.proxyUrl in clawdbot.json or set WECOM_PROXY_URL environment variable.",
+            });
+        }
+        if (enabled && configured && account.dmPolicy === "open") {
+            issues.push({
+                channel: "wecom",
+                accountId,
+                kind: "config",
+                message: 'WeCom dmPolicy is "open", allowing any user to message the bot without pairing.',
+                fix: 'Set channels.wecom.dmPolicy to "pairing" or "allowlist" to restrict access.',
+            });
+        }
+    }
+    return issues;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * WeCom channel plugin — type definitions.
+ */
+/** Per-account configuration stored in clawdbot.json channels.wecom */
+export type WeComAccountConfig = {
+    /** Optional display name for this account. */
+    name?: string;
+    /** If false, do not start this WeCom account. Default: true. */
+    enabled?: boolean;
+    /** WebSocket proxy URL for WeCom Smart Bot. */
+    proxyUrl?: string;
+    /** Token for authenticating with the WebSocket proxy. */
+    proxyToken?: string;
+    /** Direct message access policy (default: pairing). */
+    dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
+    /** Allowlist for DM senders (WeCom user IDs). */
+    allowFrom?: Array<string | number>;
+    /** "Thinking…" placeholder threshold in milliseconds. 0 to disable. */
+    thinkingThresholdMs?: number;
+    /** Bot name aliases used for group-chat address detection. */
+    botNames?: string[];
+    /** Heartbeat ping interval in milliseconds. Default: 30000. */
+    pingIntervalMs?: number;
+    /** Reconnect delay in milliseconds. Default: 5000. */
+    reconnectDelayMs?: number;
+};
+/** Top-level WeCom config section (channels.wecom). */
+export type WeComConfig = {
+    /** Multi-account map. */
+    accounts?: Record<string, WeComAccountConfig>;
+    /** Default account ID when multiple accounts exist. */
+    defaultAccount?: string;
+} & WeComAccountConfig;
+/** How the credentials were resolved. */
+export type WeComTokenSource = "config" | "plugin" | "env" | "none";
+/** Resolved account ready for use. */
+export type ResolvedWeComAccount = {
+    accountId: string;
+    name?: string;
+    enabled: boolean;
+    proxyUrl: string;
+    proxyToken: string;
+    tokenSource: WeComTokenSource;
+    config: WeComAccountConfig;
+};
+/** Result of sending a message via WeCom proxy. */
+export type WeComSendResult = {
+    ok: boolean;
+    messageId?: string;
+    error?: string;
+};
+/** WeCom probe result. */
+export type WeComProbeResult = {
+    ok: boolean;
+    error?: string;
+    elapsedMs: number;
+};
+/** Incoming message from WeCom proxy. */
+export type WeComIncomingMessage = {
+    kind: "message" | "pong" | "connected" | "error";
+    msgId?: string;
+    payload?: {
+        FromUserName?: string;
+        ToUserName?: string;
+        Content?: string;
+        MsgType?: string;
+        CreateTime?: number;
+    };
+    ts?: number;
+    error?: string;
+};
+/** Outgoing reply to WeCom proxy. */
+export type WeComOutgoingReply = {
+    kind: "reply" | "ping";
+    msgId?: string;
+    text?: string;
+    ts?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAC;IACzD,iDAAiD;IACjD,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACnC,uEAAuE;IACvE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,WAAW,GAAG;IACxB,yBAAyB;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC9C,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,kBAAkB,CAAC;AAEvB,yCAAyC;AACzC,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpE,sCAAsC;AACtC,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,gBAAgB,CAAC;IAC9B,MAAM,EAAE,kBAAkB,CAAC;CAC5B,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,0BAA0B;AAC1B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE;QACR,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,qCAAqC;AACrC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dist/src/types.js

@@ -0,0 +1,4 @@
+/**
+ * WeCom channel plugin — type definitions.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moltbot-wecom",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "type": "module",
   "description": "企业微信机器人插件 - 让 AI 助手接入企业微信智能机器人 | WeCom Smart Bot channel plugin for Moltbot",
   "author": "xiajingan",
@@ -20,21 +20,30 @@
     "websocket",
     "smart-bot"
   ],
-  "main": "plugin.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./plugin.js"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     }
   },
   "files": [
-    "plugin.js",
-    "moltbot.plugin.json",
+    "dist",
+    "clawdbot.plugin.json",
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsc --watch"
+  },
   "moltbot": {
     "extensions": [
-      "./plugin.js"
+      "./dist/index.js"
     ],
     "channel": {
       "id": "wecom",
@@ -45,9 +54,11 @@
       "blurb": "WeCom (Enterprise WeChat) Smart Bot with WebSocket proxy.",
       "aliases": [
         "企微",
-        "qw"
+        "qw",
+        "wechat-work",
+        "qywx"
       ],
-      "order": 80,
+      "order": 86,
       "quickstartAllowFrom": true
     },
     "install": {
@@ -56,13 +67,19 @@
     }
   },
   "dependencies": {
-    "ws": "^8.16.0"
+    "ws": "^8.16.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.0"
   },
   "peerDependencies": {
-    "moltbot": ">=1.0.0"
+    "clawdbot": ">=1.0.0"
   },
   "peerDependenciesMeta": {
-    "moltbot": {
+    "clawdbot": {
       "optional": false
     }
   },

package/moltbot.plugin.json

@@ -1,27 +0,0 @@
-{
-  "id": "wecom",
-  "name": "WeCom",
-  "description": "WeCom (企业微信) channel plugin — WebSocket proxy connection for Smart Bot",
-  "version": "1.0.1",
-  "channels": ["wecom"],
-  "configSchema": {
-    "type": "object",
-    "properties": {
-      "proxyUrl": {
-        "type": "string",
-        "description": "WeCom Proxy WebSocket URL (wss://your-domain.com)"
-      },
-      "proxyToken": {
-        "type": "string",
-        "description": "Authentication token for wecom-proxy connection"
-      },
-      "pingInterval": {
-        "type": "number",
-        "default": 30000,
-        "description": "WebSocket heartbeat interval in milliseconds"
-      }
-    },
-    "required": ["proxyUrl", "proxyToken"],
-    "additionalProperties": true
-  }
-}