dsh-feishu-bot 0.19.8 → 0.19.9

package/dist/cli.js

@@ -12138,6 +12138,34 @@ async function tryHandleCommand(text, ctx) {
 import { createHash } from "crypto";
 var CARD_STREAM_THROTTLE_MS = 100;
 var CARD_PATCH_ATTEMPTS = 2;
+var MAX_CARD_WITHDRAW_RECOVERIES = 3;
+function isMessageWithdrawn(error) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [error];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || node === void 0) continue;
+    if (typeof node === "string") {
+      if (node.toLowerCase().includes("withdrawn")) return true;
+      continue;
+    }
+    if (typeof node !== "object" || seen.has(node)) continue;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const item of node) stack.push(item);
+      continue;
+    }
+    const record = node;
+    if (record["code"] === 230011) return true;
+    if (typeof record["message"] === "string" && record["message"].toLowerCase().includes("withdrawn")) return true;
+    if (typeof record["msg"] === "string" && record["msg"].toLowerCase().includes("withdrawn")) return true;
+    for (const key of ["response", "data", "error", "errors"]) {
+      const value = record[key];
+      if (value !== void 0 && value !== null) stack.push(value);
+    }
+  }
+  return false;
+}
 function toLarkSendOptions(options) {
   const sendOptions = {};
   if (options?.replyTo) sendOptions.replyTo = options.replyTo;
@@ -12172,6 +12200,7 @@ var ResilientCardStreamController = class {
   timer;
   inFlight;
   reanchorInFlight;
+  recoveries = 0;
   async update(card) {
     if (this.closed || this.failed) return;
     this.latest = card;
@@ -12219,6 +12248,7 @@ var ResilientCardStreamController = class {
     for (let attempt = 1; attempt <= CARD_PATCH_ATTEMPTS; attempt += 1) {
       try {
         await this.channel.updateCard(this.messageId, snapshot);
+        this.recoveries = 0;
         return;
       } catch (error) {
         lastError = error;
@@ -12227,6 +12257,19 @@ var ResilientCardStreamController = class {
           attempt,
           error: error instanceof Error ? error.message : String(error)
         });
+        if (isMessageWithdrawn(error) && this.recoveries < MAX_CARD_WITHDRAW_RECOVERIES) {
+          try {
+            await this.healFromWithdrawal();
+          } catch (healError) {
+            log.warn("lark-card-stream", "heal-failed", {
+              messageId: this.messageId,
+              error: healError instanceof Error ? healError.message : String(healError)
+            });
+            break;
+          }
+          attempt -= 1;
+          continue;
+        }
       }
     }
     this.failed = true;
@@ -12246,6 +12289,26 @@ var ResilientCardStreamController = class {
       });
     }
   }
+  /**
+   * Re-create the process card at the conversation tail after the target message
+   * was withdrawn (Feishu `230011` / "The message was withdrawn"). The message
+   * is already gone, so there is nothing to recall: we send a fresh card carrying
+   * the latest snapshot and rebind the controller to its new message id. Unlike
+   * `reanchor()` this must NOT `await this.inFlight`, because we are already
+   * running inside the in-flight flush; the recovery budget
+   * (`MAX_CARD_WITHDRAW_RECOVERIES`) is enforced by the caller so a hostile loop
+   * cannot spawn cards forever.
+   */
+  async healFromWithdrawal() {
+    const card = this.latest;
+    if (card === void 0) throw new Error("Feishu card re-creation has no snapshot to send");
+    this.dirty = false;
+    const sent = await this.channel.send(this.chatId, { card }, {});
+    if (!sent.messageId) throw new Error("Feishu card re-creation returned no message_id");
+    this.messageId = sent.messageId;
+    this.failed = false;
+    this.recoveries += 1;
+  }
   /**
    * Recall the current card and re-create it as the newest top-level message in
    * the chat, rebinding the controller to the fresh message id. Because Feishu