dsh-feishu-bot 0.19.8 → 0.19.10

package/dist/cli.js

@@ -4693,7 +4693,7 @@ async function fetchNpmLatestVersion(packageName, registryUrl = defaultRegistryU
   }
   return void 0;
 }
-async function fetchNpmLatestVersionOnce(packageName, registryUrl = defaultRegistryUrl(), timeoutMs = 5e3, fetcher = fetch) {
+async function fetchNpmLatestVersionOnce(packageName, registryUrl = defaultRegistryUrl(), timeoutMs = NPM_LATEST_TIMEOUT_MS, fetcher = fetch) {
   try {
     const response = await fetcher(
       `${registryUrl}/${encodeURIComponent(packageName)}/latest`,
@@ -10879,6 +10879,7 @@ async function reply6(ctx, zh, en) {
 // src/upgrade/update-check.ts
 init_own_package();
 var UPDATE_CHECK_CACHE_MS = 60 * 6e4;
+var UPDATE_CHECK_FAILURE_CACHE_MS = 15e3;
 var cache;
 function upgradeCheckEnabled() {
   return (process.env.DSH_LARK_UPGRADE_CHECK ?? "1") !== "0";
@@ -10894,16 +10895,22 @@ function isNewer(latest, current) {
 async function latestVersion(options = {}) {
   if (!upgradeCheckEnabled()) return void 0;
   const now = Date.now();
-  if (cache !== void 0 && now - cache.at < (options.cacheMs ?? UPDATE_CHECK_CACHE_MS)) {
-    return cache.latest;
+  if (cache !== void 0) {
+    const ttl = options.cacheMs !== void 0 ? options.cacheMs : cache.failed ? UPDATE_CHECK_FAILURE_CACHE_MS : UPDATE_CHECK_CACHE_MS;
+    if (now - cache.at < ttl) return cache.latest;
   }
   const probe = options.probe ?? fetchNpmLatestVersionOnce;
   const latest = await probe(options.packageName ?? ownPackageInfo().name);
-  cache = { at: now, latest, notified: cache?.notified ?? /* @__PURE__ */ new Set() };
+  cache = {
+    at: now,
+    latest,
+    failed: latest === void 0,
+    notified: cache?.notified ?? /* @__PURE__ */ new Set()
+  };
   return latest;
 }
 function markNotified(latest) {
-  if (cache === void 0) cache = { at: 0, latest, notified: /* @__PURE__ */ new Set() };
+  if (cache === void 0) cache = { at: 0, latest, failed: false, notified: /* @__PURE__ */ new Set() };
   if (cache.notified.has(latest)) return false;
   cache.notified.add(latest);
   return true;
@@ -12138,6 +12145,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 +12207,7 @@ var ResilientCardStreamController = class {
   timer;
   inFlight;
   reanchorInFlight;
+  recoveries = 0;
   async update(card) {
     if (this.closed || this.failed) return;
     this.latest = card;
@@ -12219,6 +12255,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 +12264,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 +12296,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