@soimy/dingtalk 3.6.2 → 3.6.3

package/dist/index.js

@@ -1814,7 +1814,7 @@ async function updateCardVariables(outTrackId, params, token, config) {
     {
       outTrackId,
       cardData: { cardParamMap: stringMap },
-      cardUpdateOptions: { updateCardDataByKey: true, updatePrivateDataByKey: true }
+      cardUpdateOptions: { updateCardDataByKey: true }
     },
     {
       headers: {
@@ -2614,6 +2614,19 @@ async function createAICard(config, conversationId, log, options = {}) {
       upsertPendingCard(aiCardInstance, options.storePath, log);
     }
     clearAICardDegrade(accountId, log);
+    try {
+      await putAICardStreamingField(aiCardInstance, template.contentKey, "", false, log, {
+        suppressDegrade: true
+      });
+      aiCardInstance.state = AICardStatus.INPUTING;
+      if (shouldPersistPending) {
+        upsertPendingCard(aiCardInstance, options.storePath, log);
+      }
+    } catch (kickErr) {
+      log?.debug?.(
+        `[DingTalk][AICard] Non-critical: failed to kick card into streaming mode: ${kickErr.message}`
+      );
+    }
     return aiCardInstance;
   } catch (err) {
     log?.error?.(`[DingTalk][AICard] Create failed: ${err.message}`);
@@ -2712,13 +2725,13 @@ async function clearAICardStreamingContent(card, log) {
     log?.debug?.(`[DingTalk][AICard] Non-critical: failed to clear streaming content: ${message}`);
   }
 }
-async function finalizeAICardStreamingLifecycleIfNeeded(card, content, log) {
+async function finalizeAICardStreamingLifecycleIfNeeded(card, log) {
   if (!card.streamLifecycleOpened) {
     return;
   }
   const template = DINGTALK_CARD_TEMPLATE;
   try {
-    await putAICardStreamingField(card, template.streamingKey, content, true, log, {
+    await putAICardStreamingField(card, template.streamingKey, "", true, log, {
       suppressDegrade: true
     });
   } catch (err) {
@@ -2734,7 +2747,7 @@ async function commitAICardBlocks(card, options, log) {
     return;
   }
   await ensureFreshToken(card, log);
-  await finalizeAICardStreamingLifecycleIfNeeded(card, options.content, log);
+  await finalizeAICardStreamingLifecycleIfNeeded(card, log);
   const template = DINGTALK_CARD_TEMPLATE;
   const updates = {
     [template.blockListKey]: options.blockListJson,
@@ -2797,7 +2810,7 @@ async function finalizeStoppedAICard(card, options, log) {
   await ensureFreshToken(card, log);
   const template = DINGTALK_CARD_TEMPLATE;
   const payload = buildStoppedCardFinalizePayload(options);
-  await finalizeAICardStreamingLifecycleIfNeeded(card, payload.content, log);
+  await finalizeAICardStreamingLifecycleIfNeeded(card, log);
   try {
     await updateCardVariables(
       card.outTrackId || card.cardInstanceId,
@@ -4475,7 +4488,7 @@ function stripLeadingInvisibleChars(value) {
 
 // src/inbound-handler.ts
 import fs6 from "node:fs";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
 import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
 
@@ -6716,7 +6729,7 @@ function isMarkdownTableSeparator(line) {
     return false;
   }
   const cells = normalized.replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
-  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+  return cells.length > 0 && cells.every((cell) => /^:?-{1,}:?$/.test(cell));
 }
 function isMarkdownTableRow(line) {
   const trimmed = line.trim();
@@ -6725,9 +6738,58 @@ function isMarkdownTableRow(line) {
 function parseMarkdownTableRow(line) {
   return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
 }
-function renderMarkdownTable(lines) {
-  const rows = lines.map(parseMarkdownTableRow).filter((cells) => cells.length > 0);
-  return rows.map((cells) => cells.join(" | ")).join("  \n");
+function parseSeparatorAlignment(cell) {
+  const trimmed = cell.trim();
+  const hasLeftColon = trimmed.startsWith(":");
+  const hasRightColon = trimmed.endsWith(":");
+  if (hasLeftColon && hasRightColon) {
+    return "center";
+  }
+  if (hasRightColon) {
+    return "right";
+  }
+  if (hasLeftColon) {
+    return "left";
+  }
+  return "center";
+}
+function buildSeparatorRow(alignments) {
+  const cells = alignments.map((align) => {
+    if (align === "left") {
+      return ":---";
+    }
+    if (align === "right") {
+      return "---:";
+    }
+    return ":---:";
+  });
+  return "|" + cells.join("|") + "|";
+}
+function renderMarkdownTable(headerLine, separatorLine, dataLines) {
+  const headerCells = parseMarkdownTableRow(headerLine);
+  const separatorCells = parseMarkdownTableRow(separatorLine);
+  const dataRows = dataLines.map(parseMarkdownTableRow).filter((cells) => cells.length > 0);
+  if (headerCells.length === 0) {
+    return "";
+  }
+  const colCount = Math.max(
+    headerCells.length,
+    separatorCells.length,
+    ...dataRows.map((cells) => cells.length)
+  );
+  const alignments = [];
+  for (let i = 0; i < colCount; i++) {
+    const sepCell = separatorCells[i] || "";
+    alignments.push(parseSeparatorAlignment(sepCell));
+  }
+  const separator = buildSeparatorRow(alignments);
+  const allRows = [headerCells, ...dataRows];
+  const rendered = allRows.map((cells) => {
+    const padded = cells.length < colCount ? [...cells, ...Array(colCount - cells.length).fill("")] : cells;
+    return "|" + padded.join("|") + "|";
+  });
+  rendered.splice(1, 0, separator);
+  return rendered.join("\n");
 }
 function convertMarkdownTablesToPlainText(text) {
   const lines = text.split("\n");
@@ -6743,13 +6805,20 @@ function convertMarkdownTablesToPlainText(text) {
       continue;
     }
     if (!inCodeFence && index + 1 < lines.length && isMarkdownTableRow(line) && isMarkdownTableSeparator(lines[index + 1] || "")) {
-      const tableLines = [line];
+      const headerLine = line;
+      const separatorLine = lines[index + 1] || "";
+      const dataLines = [];
       index += 2;
       while (index < lines.length && isMarkdownTableRow(lines[index] || "")) {
-        tableLines.push(lines[index] || "");
+        dataLines.push(lines[index] || "");
         index += 1;
       }
-      output.push(renderMarkdownTable(tableLines));
+      const renderedTable = renderMarkdownTable(headerLine, separatorLine, dataLines);
+      const lastOutput = output[output.length - 1];
+      if (lastOutput !== void 0 && lastOutput.trim() !== "") {
+        output.push("");
+      }
+      output.push(renderedTable);
       continue;
     }
     output.push(line);
@@ -7247,6 +7316,9 @@ function buildPersistedOutboundText(text, options) {
   }
   return text;
 }
+function shouldRouteSessionMediaViaProactive(mediaType) {
+  return mediaType === "voice" || mediaType === "video" || mediaType === "file";
+}
 var DINGTALK_TEXT_CHUNK_LIMIT = 3800;
 var CARD_MEDIA_CONTROLLER_ATTACH_WAIT_MS = 150;
 var CARD_MEDIA_CONTROLLER_ATTACH_POLL_MS = 25;
@@ -7643,51 +7715,33 @@ async function sendBySession(config, sessionWebhook, text, options = {}) {
   const token = await getAccessToken(config, options.log);
   const log = options.log || getLogger();
   if (options.mediaPath && options.mediaType) {
-    const uploadResult = await uploadMedia2(config, options.mediaPath, options.mediaType, log, {
-      mediaLocalRoots: options.mediaLocalRoots
-    });
-    if (uploadResult) {
-      const { mediaId, buffer, durationMs: uploadedDurationMs } = uploadResult;
-      let body;
-      if (options.mediaType === "image") {
-        body = { msgtype: "image", image: { media_id: mediaId } };
-      } else if (options.mediaType === "voice") {
-        const durationMs = uploadedDurationMs ?? await getVoiceDurationMs(options.mediaPath, options.mediaType, log, { preReadBuffer: buffer });
-        body = { msgtype: "voice", voice: { media_id: mediaId, duration: String(durationMs) } };
-        log?.debug?.(
-          `[DingTalk] Sending session voice message mediaId=${mediaId} durationMs=${durationMs}`
-        );
-      } else if (options.mediaType === "video") {
-        body = { msgtype: "video", video: { media_id: mediaId } };
-      } else if (options.mediaType === "file") {
-        body = { msgtype: "file", file: { media_id: mediaId } };
-      }
-      if (body) {
-        const result = await http_client_default({
-          url: sessionWebhook,
-          method: "POST",
-          data: body,
-          headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" },
-          ...getProxyBypassOption(config)
-        });
+    if (options.mediaType === "image") {
+      const uploadResult = await uploadMedia2(config, options.mediaPath, options.mediaType, log, {
+        mediaLocalRoots: options.mediaLocalRoots
+      });
+      if (uploadResult) {
+        const imageMarkdown = `![${path7.basename(options.mediaPath)}](${uploadResult.mediaId})`;
+        text = text ? `${text}
+
+${imageMarkdown}` : imageMarkdown;
         log?.debug?.(
-          `[DingTalk] Session webhook response msgtype=${body.msgtype} ${summarizeSessionWebhookResponse(result.data)}`
+          `[DingTalk] Session webhook image will be delivered as markdown media reference mediaId=${uploadResult.mediaId}`
         );
-        ensureSessionWebhookBusinessSuccess(result.data, { msgtype: body.msgtype });
-        const delivery = extractOutboundDeliveryMetadata(result.data);
-        if (!delivery.messageId && !delivery.processQueryKey && !delivery.outTrackId) {
-          log?.warn?.(
-            `[DingTalk] Session webhook ${body.msgtype} response missing delivery metadata; ` + summarizeSessionWebhookResponse(result.data)
-          );
-        }
-        return result.data;
+      } else {
+        const mediaHint = options.mediaUrl || options.mediaPath || options.filePath || "(\u5A92\u4F53\u53D1\u9001\u5931\u8D25)";
+        text = `${text}
+
+\u{1F4CE} \u5A92\u4F53\u53D1\u9001\u5931\u8D25\uFF0C\u515C\u5E95\u94FE\u63A5/\u8DEF\u5F84\uFF1A${mediaHint}`.trim();
+        log?.warn?.("[DingTalk] Media upload failed, falling back to text description");
       }
     } else {
       const mediaHint = options.mediaUrl || options.mediaPath || options.filePath || "(\u5A92\u4F53\u53D1\u9001\u5931\u8D25)";
       text = `${text}
 
-\u{1F4CE} \u5A92\u4F53\u53D1\u9001\u5931\u8D25\uFF0C\u515C\u5E95\u94FE\u63A5/\u8DEF\u5F84\uFF1A${mediaHint}`.trim();
-      log?.warn?.("[DingTalk] Media upload failed, falling back to text description");
+\u{1F4CE} \u5F53\u524D\u4F1A\u8BDD\u65E0\u6CD5\u76F4\u63A5\u53D1\u9001 ${options.mediaType}\uFF0C\u515C\u5E95\u94FE\u63A5/\u8DEF\u5F84\uFF1A${mediaHint}`.trim();
+      log?.warn?.(
+        `[DingTalk] Session webhook does not support native ${options.mediaType} replies; falling back to text description`
+      );
     }
   }
   const textWithUploadedLocalImages = await replaceMarkdownLocalImages({
@@ -7733,6 +7787,48 @@ async function sendMessage(config, conversationId, text, options = {}) {
   try {
     const messageType = config.messageType || "markdown";
     const log = options.log || getLogger();
+    if (options.sessionWebhook && options.mediaPath && shouldRouteSessionMediaViaProactive(options.mediaType)) {
+      log?.debug?.(
+        `[DingTalk] Session webhook does not support ${options.mediaType} replies reliably; using proactive media API instead`
+      );
+      const proactiveMediaResult = await sendProactiveMedia(
+        config,
+        conversationId,
+        options.mediaPath,
+        options.mediaType,
+        options
+      );
+      if (!proactiveMediaResult.ok) {
+        log?.warn?.(
+          `[DingTalk] Proactive ${options.mediaType} reply failed; falling back to session markdown: ` + (proactiveMediaResult.error || "unknown")
+        );
+        const data = await sendBySession(config, options.sessionWebhook, text, options);
+        const delivery2 = extractOutboundDeliveryMetadata(data);
+        const messageId2 = delivery2.messageId || delivery2.processQueryKey || delivery2.outTrackId;
+        const persistedText = buildPersistedOutboundText(text, options);
+        persistOutboundMessageContext({
+          storePath: options.storePath,
+          accountId: options.accountId,
+          conversationId: options.conversationId || conversationId,
+          text: persistedText,
+          messageType: "outbound-media",
+          quotedRef: options.quotedRef,
+          log,
+          ...DEFAULT_OUTBOUND_SENDER,
+          chatType: inferConversationChatType(options.conversationId || conversationId),
+          delivery: {
+            ...delivery2,
+            kind: "session"
+          }
+        });
+        return { ok: true, data, messageId: messageId2 };
+      }
+      return {
+        ok: true,
+        data: proactiveMediaResult.data,
+        messageId: proactiveMediaResult.messageId
+      };
+    }
     if (messageType === "card" && options.card && !options.forceMarkdown) {
       const card = options.card;
       if (isCardInTerminalState(card.state)) {
@@ -7754,26 +7850,6 @@ async function sendMessage(config, conversationId, text, options = {}) {
         };
       }
     }
-    if (options.sessionWebhook && options.mediaPath && options.mediaType === "voice") {
-      log?.debug?.(
-        "[DingTalk] Session webhook does not support voice replies reliably; using proactive media API for this voice response"
-      );
-      const proactiveVoiceResult = await sendProactiveMedia(
-        config,
-        conversationId,
-        options.mediaPath,
-        options.mediaType,
-        options
-      );
-      if (!proactiveVoiceResult.ok) {
-        return { ok: false, error: proactiveVoiceResult.error || "Voice reply send failed" };
-      }
-      return {
-        ok: true,
-        data: proactiveVoiceResult.data,
-        messageId: proactiveVoiceResult.messageId
-      };
-    }
     if (options.sessionWebhook) {
       const data = await sendBySession(config, options.sessionWebhook, text, options);
       const delivery2 = extractOutboundDeliveryMetadata(data);
@@ -9061,8 +9137,6 @@ function createCardDraftController(params) {
     if (stopped || failed) {
       return;
     }
-    await contentLoop.flush();
-    await contentLoop.waitForInFlight();
     if (hasStreamingContent) {
       await clearStreamingContentFromCard();
     }
@@ -9265,6 +9339,7 @@ function createCardDraftController(params) {
         discardCurrentAnswer();
       } else {
         sealCurrentAnswer();
+        queueRender();
       }
       await beginBoundaryFlush();
       return;
@@ -9482,7 +9557,6 @@ function createCardReplyStrategy(ctx) {
   };
   const { mode, usedDeprecatedCardRealTimeStream } = resolveCardStreamingMode(config);
   const streamAnswerLive = mode === "answer" || mode === "all";
-  const renderAnswerBlocksLive = mode === "all";
   const streamThinkingLive = mode === "all";
   let lifecycleState = "open";
   const shouldAcceptAnswerSnapshot = () => lifecycleState === "open";
@@ -9616,7 +9690,10 @@ function createCardReplyStrategy(ctx) {
         finalTextForFallback = normalized.answerText;
         return;
       }
-      await controller.updateAnswer(normalized.answerText);
+      await controller.updateAnswer(normalized.answerText, {
+        stream: streamAnswerLive,
+        renderBlocks: !streamAnswerLive
+      });
     }
   };
   const rewriteLocalMarkdownImagesToPlaceholders = (text) => {
@@ -9652,7 +9729,8 @@ function createCardReplyStrategy(ctx) {
     }
     await controller.updateAnswer(answerSnapshot, {
       stream: streamAnswerLive,
-      renderBlocks: renderAnswerBlocksLive
+      // Active answer previews live in the content field; blockList is committed at boundaries/finalize.
+      renderBlocks: false
     });
   };
   const applySplitTextToTimeline = async (text, options = {}) => {
@@ -9712,6 +9790,11 @@ function createCardReplyStrategy(ctx) {
         // Card mode keeps runtime block streaming disabled, but still consumes
         // reasoning blocks through explicit callbacks and delivery metadata.
         disableBlockStreaming: ctx.disableBlockStreaming ?? true,
+        // DingTalk card mode owns the visible reply surface. In group chats,
+        // OpenClaw defaults source replies to message-tool-only; override that
+        // so final replies are delivered into this card instead of spawning a
+        // separate visible message/card via the message tool.
+        sourceReplyDeliveryMode: "automatic",
         onAssistantMessageStart: async () => {
           if (isLifecycleSealed() || isStopRequested?.()) {
             return;
@@ -9951,6 +10034,7 @@ function createCardReplyStrategy(ctx) {
       }
       try {
         await flushPendingReasoning();
+        await controller.clearStreamingContent?.();
         await controller.flush();
         await controller.waitForInFlight();
         const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : void 0);
@@ -10066,6 +10150,7 @@ function createCardReplyStrategy(ctx) {
 }
 
 // src/reply-strategy-markdown.ts
+import path8 from "node:path";
 var EMPTY_FINAL_FALLBACK_TEXT = "\u2705 Done";
 function renderQuotedSegment(text) {
   return text.split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n");
@@ -10102,6 +10187,10 @@ function computeSharedPrefixTail(previous, next) {
   const suffix = current.slice(sharedPrefixLength);
   return suffix.trim() ? suffix : "";
 }
+function renderMarkdownImage(mediaPath) {
+  const filename = path8.basename(mediaPath) || "image";
+  return `![${filename}](${mediaPath})`;
+}
 function createMarkdownReplyStrategy(ctx) {
   let finalText;
   let activeAnswerText = "";
@@ -10125,7 +10214,7 @@ function createMarkdownReplyStrategy(ctx) {
     }
     sentVisibleContent = true;
   };
-  const emitAnswerSuffix = async (text) => {
+  const prepareAnswerSuffix = (text) => {
     const current = typeof text === "string" ? text : "";
     if (current.length > 0) {
       activeAnswerText = current;
@@ -10133,37 +10222,118 @@ function createMarkdownReplyStrategy(ctx) {
     }
     const suffix = computeIncrementalSuffix(lastSentAnswerText, current);
     if (suffix) {
-      await sendMarkdownSegment(suffix);
-      lastSentAnswerText = current;
-      return;
+      return {
+        text: suffix,
+        markSent: () => {
+          lastSentAnswerText = current;
+        }
+      };
     }
     if (current.trim() && lastSentAnswerText && !current.startsWith(lastSentAnswerText)) {
       const suffix2 = computeSharedPrefixTail(lastSentAnswerText, current);
       ctx.log?.warn?.(
         `[DingTalk][Markdown] answer prefix drift detected; falling back to shared-prefix tail prevLen=${lastSentAnswerText.length} currentLen=${current.length}`
       );
-      lastSentAnswerText = "";
       if (suffix2) {
-        await sendMarkdownSegment(suffix2);
-        lastSentAnswerText = current;
-        return;
+        return {
+          text: suffix2,
+          markSent: () => {
+            lastSentAnswerText = current;
+          }
+        };
+      }
+      return {
+        text: current,
+        markSent: () => {
+          lastSentAnswerText = current;
+        }
+      };
+    }
+    return null;
+  };
+  const emitAnswerSuffix = async (text) => {
+    const suffix = prepareAnswerSuffix(text);
+    if (suffix) {
+      await sendMarkdownSegment(suffix.text);
+      suffix.markSent();
+    }
+  };
+  const prepareMarkdownImageAttachments = async (mediaUrls) => {
+    const imageMarkdown = [];
+    const passthroughMediaUrls = [];
+    const cleanups = [];
+    for (const rawMediaUrl of mediaUrls) {
+      const preparedMedia = await prepareMediaInput(
+        rawMediaUrl,
+        ctx.log,
+        ctx.config.mediaUrlAllowlist
+      );
+      const actualMediaPath = preparedMedia.cleanup ? preparedMedia.path : resolveRelativePath(preparedMedia.path);
+      const mediaType = resolveOutboundMediaType({
+        mediaPath: actualMediaPath,
+        asVoice: false
+      });
+      if (mediaType === "image") {
+        imageMarkdown.push(renderMarkdownImage(actualMediaPath));
+        if (preparedMedia.cleanup) {
+          cleanups.push(preparedMedia.cleanup);
+        }
+      } else {
+        await preparedMedia.cleanup?.();
+        passthroughMediaUrls.push(rawMediaUrl);
       }
-      await sendMarkdownSegment(current);
-      lastSentAnswerText = current;
     }
+    return { imageMarkdown, passthroughMediaUrls, cleanups };
   };
   return {
     getReplyOptions() {
       return {
-        disableBlockStreaming: ctx.disableBlockStreaming === true
+        disableBlockStreaming: ctx.disableBlockStreaming === true,
+        // DingTalk markdown/sessionWebhook mode owns the visible reply surface.
+        // Keep runtime final replies on this strategy even when group chats
+        // default source replies to message-tool-only.
+        sourceReplyDeliveryMode: "automatic"
       };
     },
     async deliver(payload) {
+      let answerTextSentWithImages = false;
+      let toolTextSentWithImages = false;
       if (payload.mediaUrls.length > 0) {
-        await ctx.deliverMedia(payload.mediaUrls, { audioAsVoice: payload.audioAsVoice });
-        sentVisibleContent = true;
+        const prepared = payload.audioAsVoice === true ? {
+          imageMarkdown: [],
+          passthroughMediaUrls: payload.mediaUrls,
+          cleanups: []
+        } : await prepareMarkdownImageAttachments(payload.mediaUrls);
+        try {
+          if (prepared.passthroughMediaUrls.length > 0) {
+            await ctx.deliverMedia(prepared.passthroughMediaUrls, {
+              audioAsVoice: payload.audioAsVoice
+            });
+            sentVisibleContent = true;
+          }
+          if (prepared.imageMarkdown.length > 0) {
+            const answerSuffix = payload.kind === "block" || payload.kind === "final" ? prepareAnswerSuffix(payload.text) : typeof payload.text === "string" ? { text: renderQuotedSegment(payload.text), markSent: () => {
+            } } : null;
+            const markdownParts = [answerSuffix?.text || "", ...prepared.imageMarkdown].filter(
+              (part) => part.trim().length > 0
+            );
+            if (markdownParts.length > 0) {
+              await sendMarkdownSegment(markdownParts.join("\n\n"));
+              answerSuffix?.markSent();
+            }
+            answerTextSentWithImages = payload.kind === "block" || payload.kind === "final";
+            toolTextSentWithImages = payload.kind === "tool";
+          }
+        } finally {
+          for (const cleanup of prepared.cleanups) {
+            await cleanup();
+          }
+        }
       }
       if (payload.kind === "tool") {
+        if (toolTextSentWithImages) {
+          return;
+        }
         const text = typeof payload.text === "string" ? payload.text : "";
         if (!text.trim()) {
           return;
@@ -10171,7 +10341,7 @@ function createMarkdownReplyStrategy(ctx) {
         await sendMarkdownSegment(renderQuotedSegment(text));
         return;
       }
-      if ((payload.kind === "block" || payload.kind === "final") && typeof payload.text === "string") {
+      if ((payload.kind === "block" || payload.kind === "final") && typeof payload.text === "string" && !answerTextSentWithImages) {
         await emitAnswerSuffix(payload.text);
       }
     },
@@ -10495,12 +10665,12 @@ async function dispatchSubAgents(params) {
 
 // src/targeting/group-members-store.ts
 import * as fs5 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var GROUP_MEMBERS_NAMESPACE = "members.group-roster";
 function groupMembersFilePath(storePath, groupId) {
-  const dir = path8.join(path8.dirname(storePath), "dingtalk-members");
+  const dir = path9.join(path9.dirname(storePath), "dingtalk-members");
   const safeId = groupId.replace(/\+/g, "-").replace(/\//g, "_");
-  return path8.join(dir, `${safeId}.json`);
+  return path9.join(dir, `${safeId}.json`);
 }
 function readLegacyRoster(storePath, groupId) {
   const filePath = groupMembersFilePath(storePath, groupId);
@@ -11581,7 +11751,7 @@ async function handleDingTalkMessage(params) {
       if (!hasPathLikeShape) {
         return void 0;
       }
-      return STANDALONE_MEDIA_PATH_EXTENSIONS.has(path9.extname(trimmed).toLowerCase()) ? trimmed : void 0;
+      return STANDALONE_MEDIA_PATH_EXTENSIONS.has(path10.extname(trimmed).toLowerCase()) ? trimmed : void 0;
     }, extractSharedAudioAsVoice = function(payload, inlineReplyPayload) {
       const richPayload = payload;
       const sharedValue = parseBooleanLike(richPayload.audioAsVoice);
@@ -13025,14 +13195,14 @@ var RegistrationError = class extends Error {
 function asString(value) {
   return typeof value === "string" ? value : "";
 }
-async function apiPost(path10, payload) {
-  const url = `${REGISTRATION_BASE_URL}${path10}`;
+async function apiPost(path11, payload) {
+  const url = `${REGISTRATION_BASE_URL}${path11}`;
   const resp = await http_client_default.post(url, payload, { timeout: 15e3 });
   const data = resp.data;
   const errcode = data.errcode;
   if (errcode !== void 0 && errcode !== 0) {
     const errmsg = asString(data.errmsg) || "unknown error";
-    throw new RegistrationError(`API error [${path10}]: ${errmsg} (errcode=${typeof errcode === "number" ? errcode : asString(errcode)})`);
+    throw new RegistrationError(`API error [${path11}]: ${errmsg} (errcode=${typeof errcode === "number" ? errcode : asString(errcode)})`);
   }
   return data;
 }