@sunnoy/wecom 1.0.0

package/logger.js

@@ -0,0 +1,64 @@
+/**
+ * Structured logging for WeCom plugin
+ */
+const LEVELS = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: 100,
+};
+
+function getEnvLogLevel() {
+    const raw = (process.env.WECOM_LOG_LEVEL || process.env.LOG_LEVEL || "info").toLowerCase();
+    return Object.prototype.hasOwnProperty.call(LEVELS, raw) ? raw : "info";
+}
+
+export class Logger {
+    prefix;
+    level;
+    constructor(prefix = "[wecom]", level = getEnvLogLevel()) {
+        this.prefix = prefix;
+        this.level = level;
+    }
+    log(level, message, context) {
+        if (LEVELS[level] < LEVELS[this.level]) {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const contextStr = context ? ` ${JSON.stringify(context)}` : "";
+        const logMessage = `${timestamp} ${level.toUpperCase()} ${this.prefix} ${message}${contextStr}`;
+        switch (level) {
+            case "debug":
+                console.debug(logMessage);
+                break;
+            case "info":
+                console.info(logMessage);
+                break;
+            case "warn":
+                console.warn(logMessage);
+                break;
+            case "error":
+                console.error(logMessage);
+                break;
+        }
+    }
+    debug(message, context) {
+        this.log("debug", message, context);
+    }
+    info(message, context) {
+        this.log("info", message, context);
+    }
+    warn(message, context) {
+        this.log("warn", message, context);
+    }
+    error(message, context) {
+        this.log("error", message, context);
+    }
+    child(subPrefix) {
+        return new Logger(`${this.prefix}:${subPrefix}`, this.level);
+    }
+}
+// Default logger instance
+export const logger = new Logger();
+//# sourceMappingURL=logger.js.map

package/openclaw.plugin.json

@@ -0,0 +1,13 @@
+{
+  "id": "wecom",
+  "name": "OpenClaw WeCom",
+  "description": "Enterprise WeChat (WeCom) messaging channel plugin for OpenClaw",
+  "channels": [
+    "wecom"
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@sunnoy/wecom",
+    "version": "1.0.0",
+    "description": "Enterprise WeChat AI Bot channel plugin for OpenClaw",
+    "type": "module",
+    "main": "index.js",
+    "files": [
+        "index.js",
+        "client.js",
+        "crypto.js",
+        "dynamic-agent.js",
+        "image-processor.js",
+        "logger.js",
+        "README.md",
+        "README_ZH.md",
+        "LICENSE",
+        "CONTRIBUTING.md",
+        "stream-manager.js",
+        "utils.js",
+        "webhook.js",
+        "openclaw.plugin.json"
+    ],
+    "dependencies": {
+        "fast-xml-parser": "^4.2.0"
+    },
+    "peerDependencies": {
+        "openclaw": "*"
+    },
+    "openclaw": {
+        "extensions": [
+            "./index.js"
+        ],
+        "channel": {
+            "id": "wecom",
+            "label": "Enterprise WeChat",
+            "selectionLabel": "Enterprise WeChat (AI Bot)",
+            "docsPath": "/channels/wecom",
+            "docsLabel": "wecom",
+            "blurb": "Support for Enterprise WeChat (WeCom) AI Bot integration",
+            "order": 90,
+            "aliases": [
+                "wecom",
+                "wework"
+            ]
+        },
+        "install": {
+            "defaultChoice": "npm",
+            "npmSpec": "@sunnoy/wecom"
+        }
+    },
+    "keywords": [
+        "openclaw",
+        "wecom",
+        "enterprise-wechat",
+        "chat",
+        "plugin"
+    ],
+    "author": "",
+    "license": "ISC"
+}

package/stream-manager.js

@@ -0,0 +1,307 @@
+import { logger } from "./logger.js";
+import { prepareImageForMsgItem } from "./image-processor.js";
+
+/**
+ * 流式消息状态管理器
+ * 管理所有活跃的流式消息会话,支持企业微信的流式刷新机制
+ */
+class StreamManager {
+    constructor() {
+        // streamId -> { content: string, finished: boolean, updatedAt: number, feedbackId: string|null, msgItem: Array, pendingImages: Array }
+        this.streams = new Map();
+        this._cleanupInterval = null;
+    }
+
+    /**
+     * 启动定时清理（避免在 import 时产生常驻 side-effect）
+     */
+    startCleanup() {
+        if (this._cleanupInterval) return;
+        this._cleanupInterval = setInterval(() => this.cleanup(), 60 * 1000);
+        // 不阻止进程退出（例如 npm pack / import smoke test）
+        this._cleanupInterval.unref?.();
+    }
+
+    stopCleanup() {
+        if (!this._cleanupInterval) return;
+        clearInterval(this._cleanupInterval);
+        this._cleanupInterval = null;
+    }
+
+    /**
+     * 创建新的流式会话
+     * @param {string} streamId - 流ID
+     * @param {object} options - 可选配置
+     * @param {string} options.feedbackId - 反馈追踪ID (最长256字节)
+     */
+    createStream(streamId, options = {}) {
+        this.startCleanup();
+        logger.debug("Creating stream", { streamId, feedbackId: options.feedbackId });
+        this.streams.set(streamId, {
+            content: "",
+            finished: false,
+            updatedAt: Date.now(),
+            feedbackId: options.feedbackId || null,  // 用户反馈追踪
+            msgItem: [],  // 图文混排消息列表
+            pendingImages: [],  // 待处理的图片路径列表
+        });
+        return streamId;
+    }
+
+    /**
+     * 更新流的内容 (增量或全量)
+     * @param {string} streamId - 流ID
+     * @param {string} content - 消息内容 (最长20480字节)
+     * @param {boolean} finished - 是否完成
+     * @param {object} options - 可选配置
+     * @param {Array} options.msgItem - 图文混排列表 (仅finish=true时有效)
+     */
+    updateStream(streamId, content, finished = false, options = {}) {
+        this.startCleanup();
+        const stream = this.streams.get(streamId);
+        if (!stream) {
+            logger.warn("Stream not found for update", { streamId });
+            return false;
+        }
+
+        // 检查内容长度 (企业微信限制20480字节)
+        const contentBytes = Buffer.byteLength(content, 'utf8');
+        if (contentBytes > 20480) {
+            logger.warn("Stream content exceeds 20480 bytes, truncating", {
+                streamId,
+                bytes: contentBytes
+            });
+            // 截断到20480字节
+            content = Buffer.from(content, 'utf8').slice(0, 20480).toString('utf8');
+        }
+
+        stream.content = content;
+        stream.finished = finished;
+        stream.updatedAt = Date.now();
+
+        // 图文混排仅在完成时支持
+        if (finished && options.msgItem && options.msgItem.length > 0) {
+            stream.msgItem = options.msgItem.slice(0, 10);  // 最多10个
+        }
+
+        logger.debug("Stream updated", {
+            streamId,
+            contentLength: content.length,
+            contentBytes,
+            finished,
+            hasMsgItem: stream.msgItem.length > 0
+        });
+
+        return true;
+    }
+
+    /**
+     * 追加内容到流 (用于流式生成)
+     */
+    appendStream(streamId, chunk) {
+        this.startCleanup();
+        const stream = this.streams.get(streamId);
+        if (!stream) {
+            logger.warn("Stream not found for append", { streamId });
+            return false;
+        }
+
+        stream.content += chunk;
+        stream.updatedAt = Date.now();
+
+        logger.debug("Stream appended", {
+            streamId,
+            chunkLength: chunk.length,
+            totalLength: stream.content.length
+        });
+
+        return true;
+    }
+
+    /**
+     * Queue image for inclusion when stream finishes
+     * @param {string} streamId - 流ID
+     * @param {string} imagePath - 图片绝对路径
+     * @returns {boolean} 是否成功队列
+     */
+    queueImage(streamId, imagePath) {
+        this.startCleanup();
+        const stream = this.streams.get(streamId);
+        if (!stream) {
+            logger.warn("Stream not found for queueImage", { streamId });
+            return false;
+        }
+
+        stream.pendingImages.push({
+            path: imagePath,
+            queuedAt: Date.now()
+        });
+
+        logger.debug("Image queued for stream", {
+            streamId,
+            imagePath,
+            totalQueued: stream.pendingImages.length
+        });
+
+        return true;
+    }
+
+    /**
+     * Process all pending images and build msgItem array
+     * @param {string} streamId - 流ID
+     * @returns {Promise<Array>} msg_item 数组
+     */
+    async processPendingImages(streamId) {
+        const stream = this.streams.get(streamId);
+        if (!stream || stream.pendingImages.length === 0) {
+            return [];
+        }
+
+        logger.debug("Processing pending images", {
+            streamId,
+            count: stream.pendingImages.length
+        });
+
+        const msgItems = [];
+
+        for (const img of stream.pendingImages) {
+            try {
+                // Limit to 10 images per WeCom API spec
+                if (msgItems.length >= 10) {
+                    logger.warn("Stream exceeded 10 image limit, truncating", {
+                        streamId,
+                        total: stream.pendingImages.length,
+                        processed: msgItems.length
+                    });
+                    break;
+                }
+
+                const processed = await prepareImageForMsgItem(img.path);
+                msgItems.push({
+                    msgtype: "image",
+                    image: {
+                        base64: processed.base64,
+                        md5: processed.md5
+                    }
+                });
+
+                logger.debug("Image processed successfully", {
+                    streamId,
+                    imagePath: img.path,
+                    format: processed.format,
+                    size: processed.size
+                });
+            } catch (error) {
+                logger.error("Failed to process image for stream", {
+                    streamId,
+                    imagePath: img.path,
+                    error: error.message
+                });
+                // Continue processing other images even if one fails
+            }
+        }
+
+        logger.info("Completed processing images for stream", {
+            streamId,
+            processed: msgItems.length,
+            pending: stream.pendingImages.length
+        });
+
+        return msgItems;
+    }
+
+    /**
+     * 标记流为完成状态（异步，处理待发送的图片）
+     */
+    async finishStream(streamId) {
+        this.startCleanup();
+        const stream = this.streams.get(streamId);
+        if (!stream) {
+            logger.warn("Stream not found for finish", { streamId });
+            return false;
+        }
+
+        // Process pending images before finishing
+        if (stream.pendingImages.length > 0) {
+            stream.msgItem = await this.processPendingImages(streamId);
+        }
+
+        stream.finished = true;
+        stream.updatedAt = Date.now();
+
+        logger.info("Stream finished", {
+            streamId,
+            contentLength: stream.content.length,
+            imageCount: stream.msgItem.length
+        });
+
+        return true;
+    }
+
+    /**
+     * 获取流的当前状态
+     */
+    getStream(streamId) {
+        return this.streams.get(streamId);
+    }
+
+    /**
+     * 检查流是否存在
+     */
+    hasStream(streamId) {
+        return this.streams.has(streamId);
+    }
+
+    /**
+     * 删除流
+     */
+    deleteStream(streamId) {
+        const deleted = this.streams.delete(streamId);
+        if (deleted) {
+            logger.debug("Stream deleted", { streamId });
+        }
+        return deleted;
+    }
+
+    /**
+     * 清理超过10分钟未更新的流
+     */
+    cleanup() {
+        const now = Date.now();
+        const timeout = 10 * 60 * 1000; // 10 minutes
+        let cleaned = 0;
+
+        for (const [streamId, stream] of this.streams.entries()) {
+            if (now - stream.updatedAt > timeout) {
+                this.streams.delete(streamId);
+                cleaned++;
+            }
+        }
+
+        if (cleaned > 0) {
+            logger.info("Cleaned up expired streams", { count: cleaned });
+        }
+    }
+
+    /**
+     * 获取统计信息
+     */
+    getStats() {
+        const total = this.streams.size;
+        let finished = 0;
+        let active = 0;
+
+        for (const stream of this.streams.values()) {
+            if (stream.finished) {
+                finished++;
+            } else {
+                active++;
+            }
+        }
+
+        return { total, finished, active };
+    }
+}
+
+// 单例实例
+export const streamManager = new StreamManager();

package/utils.js

@@ -0,0 +1,251 @@
+/**
+ * Utility functions and helpers for WeCom plugin
+ */
+export class TTLCache {
+    options;
+    cache = new Map();
+    checkPeriod;
+    cleanupTimer;
+    constructor(options) {
+        this.options = options;
+        this.checkPeriod = options.checkPeriod || options.ttl;
+        this.startCleanup();
+    }
+    set(key, value, ttl) {
+        const expiresAt = Date.now() + (ttl || this.options.ttl);
+        this.cache.set(key, { value, expiresAt });
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    size() {
+        this.cleanup();
+        return this.cache.size;
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    startCleanup() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.checkPeriod);
+        // Don't prevent process from exiting
+        if (this.cleanupTimer.unref) {
+            this.cleanupTimer.unref();
+        }
+    }
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        this.cache.clear();
+    }
+}
+// ============================================================================
+// Promise Lock (for preventing race conditions)
+// ============================================================================
+export class PromiseLock {
+    pending = new Map();
+    async acquire(key, fn) {
+        // If there's already a pending operation, wait for it
+        const existing = this.pending.get(key);
+        if (existing) {
+            return existing;
+        }
+        // Start new operation
+        const promise = fn();
+        this.pending.set(key, promise);
+        try {
+            const result = await promise;
+            return result;
+        }
+        finally {
+            this.pending.delete(key);
+        }
+    }
+    clear(key) {
+        if (key) {
+            this.pending.delete(key);
+        }
+        else {
+            this.pending.clear();
+        }
+    }
+}
+export async function withRetry(fn, options = {}) {
+    const { retries = 3, minTimeout = 1000, maxTimeout = 10000, factor = 2, randomize = true, onRetry, } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === retries) {
+                throw lastError;
+            }
+            // Calculate backoff delay
+            let delay = Math.min(minTimeout * Math.pow(factor, attempt), maxTimeout);
+            if (randomize) {
+                delay = delay * (0.5 + Math.random() * 0.5);
+            }
+            if (onRetry) {
+                onRetry(lastError, attempt + 1);
+            }
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ============================================================================
+// Message Deduplication
+// ============================================================================
+export class MessageDeduplicator {
+    seen = new TTLCache({ ttl: 300000 }); // 5 minutes
+    isDuplicate(msgId) {
+        if (this.seen.has(msgId)) {
+            return true;
+        }
+        this.seen.set(msgId, true);
+        return false;
+    }
+    markAsSeen(msgId) {
+        this.seen.set(msgId, true);
+    }
+}
+export function parseWecomError(errcode, errmsg) {
+    // Reference: https://developer.work.weixin.qq.com/document/path/96213
+    switch (errcode) {
+        case -1:
+            return {
+                code: errcode,
+                message: "System busy, retry later",
+                retryable: true,
+                category: "system",
+            };
+        case 0:
+            return {
+                code: errcode,
+                message: "Success",
+                retryable: false,
+                category: "system",
+            };
+        case 40001:
+        case 40014:
+        case 42001:
+        case 42007:
+        case 42009:
+            return {
+                code: errcode,
+                message: `Invalid or expired access_token: ${errmsg}`,
+                retryable: true,
+                category: "auth",
+            };
+        case 45009:
+            return {
+                code: errcode,
+                message: "API rate limit exceeded",
+                retryable: true,
+                category: "rate_limit",
+            };
+        case 48002:
+            return {
+                code: errcode,
+                message: "API concurrent call limit exceeded",
+                retryable: true,
+                category: "rate_limit",
+            };
+        case 40003:
+        case 40013:
+        case 40035:
+            return {
+                code: errcode,
+                message: `Invalid parameter: ${errmsg}`,
+                retryable: false,
+                category: "invalid_input",
+            };
+        default:
+            return {
+                code: errcode,
+                message: errmsg || "Unknown error",
+                retryable: errcode >= 50000 && errcode < 60000, // System errors are retryable
+                category: "unknown",
+            };
+    }
+}
+export function shouldRetryError(errcode) {
+    const info = parseWecomError(errcode, "");
+    return info.retryable;
+}
+// ============================================================================
+// URL Helpers
+// ============================================================================
+export function buildApiUrl(path, params) {
+    const base = `https://qyapi.weixin.qq.com${path}`;
+    if (!params || Object.keys(params).length === 0) {
+        return base;
+    }
+    const query = new URLSearchParams(params).toString();
+    return `${base}?${query}`;
+}
+// ============================================================================
+// Random String Generation
+// ============================================================================
+export function randomString(length) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+// ============================================================================
+// Constants
+// ============================================================================
+export const CONSTANTS = {
+    // Token settings
+    TOKEN_REFRESH_MARGIN_MS: 300000, // 5 minutes before expiry
+    TOKEN_CACHE_KEY: "access_token",
+    // Response URL settings
+    RESPONSE_URL_TTL_MS: 3600000, // 1 hour
+    RESPONSE_URL_MAX_USES: 1,
+    // Media settings
+    MEDIA_ID_TTL_MS: 259200000, // 3 days
+    // Rate limiting
+    MESSAGE_RATE_LIMIT_PER_MINUTE: 20,
+    // Timeouts
+    API_TIMEOUT_MS: 10000, // 10 seconds
+    WEBHOOK_RESPONSE_TIMEOUT_MS: 5000, // 5 seconds
+    // Retry settings
+    DEFAULT_RETRY_COUNT: 3,
+    DEFAULT_RETRY_MIN_DELAY_MS: 1000,
+    DEFAULT_RETRY_MAX_DELAY_MS: 10000,
+    // AES/Crypto
+    AES_BLOCK_SIZE: 32,
+    AES_KEY_LENGTH: 43,
+};
+//# sourceMappingURL=utils.js.map