@sunnoy/wecom 1.9.0 → 2.0.0

package/wecom/ws-state.js

@@ -0,0 +1,160 @@
+import {
+  MESSAGE_STATE_CLEANUP_INTERVAL_MS,
+  MESSAGE_STATE_MAX_SIZE,
+  MESSAGE_STATE_TTL_MS,
+  PENDING_REPLY_MAX_SIZE,
+  PENDING_REPLY_TTL_MS,
+} from "./constants.js";
+
+const wsClientInstances = new Map();
+const messageStates = new Map();
+
+/**
+ * Pending final replies that failed to send due to WS disconnection.
+ * Keyed by accountId → array of { text, senderId, chatId, isGroupChat, createdAt }.
+ * @type {Map<string, Array<{text: string, senderId: string, chatId: string, isGroupChat: boolean, createdAt: number}>>}
+ */
+const pendingReplies = new Map();
+
+let cleanupTimer = null;
+let cleanupUsers = 0;
+
+function pruneMessageStates() {
+  const currentTime = Date.now();
+  for (const [messageId, entry] of messageStates.entries()) {
+    if (currentTime - entry.createdAt >= MESSAGE_STATE_TTL_MS) {
+      messageStates.delete(messageId);
+    }
+  }
+
+  if (messageStates.size <= MESSAGE_STATE_MAX_SIZE) {
+    return;
+  }
+
+  const oldestFirst = [...messageStates.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt);
+  for (const [messageId] of oldestFirst.slice(0, messageStates.size - MESSAGE_STATE_MAX_SIZE)) {
+    messageStates.delete(messageId);
+  }
+}
+
+export function getWsClient(accountId) {
+  return wsClientInstances.get(accountId) ?? null;
+}
+
+export function setWsClient(accountId, client) {
+  wsClientInstances.set(accountId, client);
+}
+
+export function removeWsClient(accountId) {
+  const client = wsClientInstances.get(accountId);
+  if (client) {
+    try {
+      client.disconnect();
+    } catch {
+      // Ignore disconnect errors.
+    }
+  }
+  wsClientInstances.delete(accountId);
+}
+
+export function startMessageStateCleanup() {
+  cleanupUsers += 1;
+  if (cleanupTimer) {
+    return;
+  }
+
+  cleanupTimer = setInterval(pruneMessageStates, MESSAGE_STATE_CLEANUP_INTERVAL_MS);
+  if (typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+    cleanupTimer.unref();
+  }
+}
+
+export function stopMessageStateCleanup() {
+  cleanupUsers = Math.max(0, cleanupUsers - 1);
+  if (cleanupUsers > 0 || !cleanupTimer) {
+    return;
+  }
+
+  clearInterval(cleanupTimer);
+  cleanupTimer = null;
+}
+
+export function setMessageState(messageId, state) {
+  messageStates.set(messageId, {
+    state,
+    createdAt: Date.now(),
+  });
+}
+
+export function getMessageState(messageId) {
+  const entry = messageStates.get(messageId);
+  if (!entry) {
+    return undefined;
+  }
+  if (Date.now() - entry.createdAt >= MESSAGE_STATE_TTL_MS) {
+    messageStates.delete(messageId);
+    return undefined;
+  }
+  return entry.state;
+}
+
+export function deleteMessageState(messageId) {
+  messageStates.delete(messageId);
+}
+
+/**
+ * Enqueue a final reply that failed to send due to WS disconnection.
+ */
+export function enqueuePendingReply(accountId, entry) {
+  let queue = pendingReplies.get(accountId);
+  if (!queue) {
+    queue = [];
+    pendingReplies.set(accountId, queue);
+  }
+  queue.push({ ...entry, createdAt: Date.now() });
+  // Evict oldest if over capacity.
+  while (queue.length > PENDING_REPLY_MAX_SIZE) {
+    queue.shift();
+  }
+}
+
+/**
+ * Drain all pending replies for an account, removing expired entries.
+ * @returns {Array<{text: string, senderId: string, chatId: string, isGroupChat: boolean, createdAt: number}>}
+ */
+export function drainPendingReplies(accountId) {
+  const queue = pendingReplies.get(accountId);
+  if (!queue || queue.length === 0) {
+    return [];
+  }
+  pendingReplies.delete(accountId);
+  const now = Date.now();
+  return queue.filter((entry) => now - entry.createdAt < PENDING_REPLY_TTL_MS);
+}
+
+/**
+ * Check if there are pending replies for an account.
+ */
+export function hasPendingReplies(accountId) {
+  const queue = pendingReplies.get(accountId);
+  return Boolean(queue && queue.length > 0);
+}
+
+export async function cleanupWsAccount(accountId) {
+  removeWsClient(accountId);
+}
+
+export async function resetWsStateForTesting() {
+  for (const accountId of [...wsClientInstances.keys()]) {
+    removeWsClient(accountId);
+  }
+
+  messageStates.clear();
+  pendingReplies.clear();
+
+  cleanupUsers = 0;
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}

package/crypto.js

@@ -1,135 +0,0 @@
-import { createCipheriv, createDecipheriv, randomBytes, createHash } from "node:crypto";
-import { logger } from "./logger.js";
-import { CONSTANTS } from "./utils.js";
-
-/**
- * Enterprise WeChat Intelligent Robot Crypto Implementation
- * Simplified for AI Bot mode (no corpId validation)
- */
-export class WecomCrypto {
-  token;
-  encodingAesKey;
-  aesKey;
-  iv;
-
-  constructor(token, encodingAesKey) {
-    if (!encodingAesKey || encodingAesKey.length !== CONSTANTS.AES_KEY_LENGTH) {
-      throw new Error(`EncodingAESKey invalid: length must be ${CONSTANTS.AES_KEY_LENGTH}`);
-    }
-    if (!token) {
-      throw new Error("Token is required");
-    }
-    this.token = token;
-    this.encodingAesKey = encodingAesKey;
-    this.aesKey = Buffer.from(encodingAesKey + "=", "base64");
-    this.iv = this.aesKey.subarray(0, 16);
-    logger.debug("WecomCrypto initialized (AI Bot mode)");
-  }
-
-  getSignature(timestamp, nonce, encrypt) {
-    const shasum = createHash("sha1");
-    // WeCom requires plain lexicographic sorting before SHA1; localeCompare is locale-sensitive.
-    const sorted = [this.token, timestamp, nonce, encrypt]
-      .map((value) => String(value))
-      .toSorted();
-    shasum.update(sorted.join(""));
-    return shasum.digest("hex");
-  }
-
-  decrypt(text) {
-    let decipher;
-    try {
-      decipher = createDecipheriv("aes-256-cbc", this.aesKey, this.iv);
-      decipher.setAutoPadding(false);
-    } catch (e) {
-      throw new Error(`Decrypt init failed: ${String(e)}`, { cause: e });
-    }
-
-    let deciphered = Buffer.concat([decipher.update(text, "base64"), decipher.final()]);
-
-    deciphered = this.decodePkcs7(deciphered);
-
-    // Format: 16 random bytes | 4 bytes msg_len | msg_content | appid
-    const content = deciphered.subarray(16);
-    const lenList = content.subarray(0, 4);
-    const xmlLen = lenList.readUInt32BE(0);
-    const xmlContent = content.subarray(4, 4 + xmlLen).toString("utf-8");
-    // For AI Bot mode, corpId/appid is empty, skip validation
-
-    return { message: xmlContent };
-  }
-
-  encrypt(text) {
-    // For AI Bot mode, corpId is empty
-    const random16 = randomBytes(16);
-    const msgBuffer = Buffer.from(text);
-    const lenBuffer = Buffer.alloc(4);
-    lenBuffer.writeUInt32BE(msgBuffer.length, 0);
-
-    const rawMsg = Buffer.concat([random16, lenBuffer, msgBuffer]);
-    const encoded = this.encodePkcs7(rawMsg);
-
-    const cipher = createCipheriv("aes-256-cbc", this.aesKey, this.iv);
-    cipher.setAutoPadding(false);
-    const ciphered = Buffer.concat([cipher.update(encoded), cipher.final()]);
-    return ciphered.toString("base64");
-  }
-
-  encodePkcs7(buff) {
-    const blockSize = CONSTANTS.AES_BLOCK_SIZE;
-    const amountToPad = blockSize - (buff.length % blockSize);
-    const pad = Buffer.alloc(amountToPad, amountToPad);
-    return Buffer.concat([buff, pad]);
-  }
-
-  decodePkcs7(buff) {
-    const pad = buff[buff.length - 1];
-    if (pad < 1 || pad > CONSTANTS.AES_BLOCK_SIZE) {
-      throw new Error(`Invalid PKCS7 padding: ${pad}`);
-    }
-    for (let i = buff.length - pad; i < buff.length; i++) {
-      if (buff[i] !== pad) {
-        throw new Error("Invalid PKCS7 padding: inconsistent padding bytes");
-      }
-    }
-    return buff.subarray(0, buff.length - pad);
-  }
-
-  /**
-   * Decrypt image/media file from Enterprise WeChat.
-   * Images are encrypted with AES-256-CBC using the same key as messages.
-   * Note: WeCom uses PKCS7 padding to 32-byte blocks (not standard 16-byte).
-   * @param {Buffer} encryptedData - The encrypted image data (raw bytes, not base64)
-   * @returns {Buffer} - Decrypted image data
-   */
-  decryptMedia(encryptedData) {
-    const decipher = createDecipheriv("aes-256-cbc", this.aesKey, this.iv);
-    decipher.setAutoPadding(false);
-    const decrypted = Buffer.concat([
-      decipher.update(encryptedData),
-      decipher.final(),
-    ]);
-
-    // Remove PKCS7 padding manually (padded to 32-byte blocks).
-    const padLen = decrypted[decrypted.length - 1];
-    let unpadded = decrypted;
-    if (padLen >= 1 && padLen <= 32) {
-      let validPadding = true;
-      for (let i = decrypted.length - padLen; i < decrypted.length; i++) {
-        if (decrypted[i] !== padLen) {
-          validPadding = false;
-          break;
-        }
-      }
-      if (validPadding) {
-        unpadded = decrypted.subarray(0, decrypted.length - padLen);
-      }
-    }
-
-    logger.debug("Media decrypted successfully", {
-      inputSize: encryptedData.length,
-      outputSize: unpadded.length,
-    });
-    return unpadded;
-  }
-}

package/stream-manager.js

@@ -1,358 +0,0 @@
-import { prepareImageForMsgItem } from "./image-processor.js";
-import { logger } from "./logger.js";
-
-/**
- * Streaming state manager for WeCom responses.
- */
-
-/** WeCom enforces a 20480-byte UTF-8 content limit per stream response. */
-const MAX_STREAM_BYTES = 20480;
-
-/** Truncate content to MAX_STREAM_BYTES if it exceeds the limit. */
-function enforceByteLimit(content) {
-  const contentBytes = Buffer.byteLength(content, "utf8");
-  if (contentBytes <= MAX_STREAM_BYTES) {
-    return content;
-  }
-  logger.warn("Stream content exceeds byte limit, truncating", { bytes: contentBytes });
-  // Truncate at byte boundary, then trim any broken trailing multi-byte char.
-  const buf = Buffer.from(content, "utf8").subarray(0, MAX_STREAM_BYTES);
-  return buf.toString("utf8");
-}
-
-class StreamManager {
-  constructor() {
-    // streamId -> { content, finished, updatedAt, feedbackId, msgItem, pendingImages }
-    this.streams = new Map();
-    this._cleanupInterval = null;
-  }
-
-  /**
-   * Start periodic cleanup lazily to avoid import-time side effects.
-   */
-  startCleanup() {
-    if (this._cleanupInterval) {
-      return;
-    }
-    this._cleanupInterval = setInterval(() => this.cleanup(), 60 * 1000);
-    // Do not keep the process alive for this timer.
-    this._cleanupInterval.unref?.();
-  }
-
-  stopCleanup() {
-    if (!this._cleanupInterval) {
-      return;
-    }
-    clearInterval(this._cleanupInterval);
-    this._cleanupInterval = null;
-  }
-
-  /**
-   * Create a new stream session.
-   * @param {string} streamId - Stream id
-   * @param {object} options - Optional settings
-   * @param {string} options.feedbackId - Optional feedback tracking id
-   */
-  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;
-  }
-
-  /**
-   * Update stream content (replace mode).
-   * @param {string} streamId - Stream id
-   * @param {string} content - Message content (max 20480 bytes in UTF-8)
-   * @param {boolean} finished - Whether stream is completed
-   * @param {object} options - Optional settings
-   * @param {Array} options.msgItem - Mixed media list (supported when finished=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;
-    }
-
-    content = enforceByteLimit(content);
-
-    stream.content = content;
-    stream.finished = finished;
-    stream.updatedAt = Date.now();
-
-    // Mixed media items are only valid for finished responses.
-    if (finished && options.msgItem && options.msgItem.length > 0) {
-      stream.msgItem = options.msgItem.slice(0, 10);
-    }
-
-    logger.debug("Stream updated", {
-      streamId,
-      contentLength: content.length,
-      finished,
-      hasMsgItem: stream.msgItem.length > 0,
-    });
-
-    return true;
-  }
-
-  /**
-   * Append content to an existing stream.
-   */
-  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 = enforceByteLimit(stream.content + chunk);
-    stream.updatedAt = Date.now();
-
-    logger.debug("Stream appended", {
-      streamId,
-      chunkLength: chunk.length,
-      totalLength: stream.content.length,
-    });
-
-    return true;
-  }
-
-  /**
-   * Replace stream content if it currently contains only the placeholder,
-   * otherwise append normally.
-   * @param {string} streamId - Stream id
-   * @param {string} chunk - New content to write
-   * @param {string} placeholder - The placeholder text to detect and replace
-   * @returns {boolean} Whether the operation succeeded
-   */
-  replaceIfPlaceholder(streamId, chunk, placeholder) {
-    this.startCleanup();
-    const stream = this.streams.get(streamId);
-    if (!stream) {
-      logger.warn("Stream not found for replaceIfPlaceholder", { streamId });
-      return false;
-    }
-
-    if (stream.content.trim() === placeholder.trim()) {
-      stream.content = enforceByteLimit(chunk);
-      stream.updatedAt = Date.now();
-      logger.debug("Stream placeholder replaced", {
-        streamId,
-        newContentLength: stream.content.length,
-      });
-      return true;
-    }
-
-    // Normal append behavior.
-    stream.content = enforceByteLimit(stream.content + chunk);
-    stream.updatedAt = Date.now();
-    logger.debug("Stream appended (no placeholder)", {
-      streamId,
-      chunkLength: chunk.length,
-      totalLength: stream.content.length,
-    });
-    return true;
-  }
-
-  /**
-   * Queue image for inclusion when stream finishes
-   * @param {string} streamId - Stream id
-   * @param {string} imagePath - Absolute image path
-   * @returns {boolean} Whether enqueue succeeded
-   */
-  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 - Stream id
-   * @returns {Promise<Array>} msg_item entries
-   */
-  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,
-        });
-        // Keep going even when one image fails.
-      }
-    }
-
-    logger.info("Completed processing images for stream", {
-      streamId,
-      processed: msgItems.length,
-      pending: stream.pendingImages.length,
-    });
-
-    return msgItems;
-  }
-
-  /**
-   * Mark the stream as finished and process queued images.
-   */
-  async finishStream(streamId) {
-    this.startCleanup();
-    const stream = this.streams.get(streamId);
-    if (!stream) {
-      logger.warn("Stream not found for finish", { streamId });
-      return false;
-    }
-
-    if (stream.finished) {
-      return true;
-    }
-
-    // Process pending images before finalizing the stream.
-    if (stream.pendingImages.length > 0) {
-      stream.msgItem = await this.processPendingImages(streamId);
-      stream.pendingImages = [];
-    }
-
-    stream.finished = true;
-    stream.updatedAt = Date.now();
-
-    logger.info("Stream finished", {
-      streamId,
-      contentLength: stream.content.length,
-      imageCount: stream.msgItem.length,
-    });
-
-    return true;
-  }
-
-  /**
-   * Get current stream state.
-   */
-  getStream(streamId) {
-    return this.streams.get(streamId);
-  }
-
-  /**
-   * Check whether a stream exists.
-   */
-  hasStream(streamId) {
-    return this.streams.has(streamId);
-  }
-
-  /**
-   * Delete a stream.
-   */
-  deleteStream(streamId) {
-    const deleted = this.streams.delete(streamId);
-    if (deleted) {
-      logger.debug("Stream deleted", { streamId });
-    }
-    return deleted;
-  }
-
-  /**
-   * Remove streams that were inactive for over 10 minutes.
-   */
-  cleanup() {
-    const now = Date.now();
-    const timeout = 10 * 60 * 1000;
-    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 });
-    }
-  }
-
-  /**
-   * Get in-memory stream stats.
-   */
-  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 };
-  }
-}
-
-// Shared singleton instance used by the plugin runtime.
-export const streamManager = new StreamManager();