opencode-feishu 0.3.7 → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NeverMore93
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -98761,6 +98761,256 @@ function isDuplicate(messageId) {
   return false;
 }
 
+// src/feishu/resource.ts
+var MAX_RESOURCE_SIZE = 10 * 1024 * 1024;
+async function downloadMessageResource(client, messageId, fileKey, type, log) {
+  try {
+    const res = await client.im.messageResource.get({
+      path: { message_id: messageId, file_key: fileKey },
+      params: { type }
+    });
+    if (!res) {
+      log("warn", "\u8D44\u6E90\u4E0B\u8F7D\u8FD4\u56DE\u7A7A\u6570\u636E", { messageId, fileKey, type });
+      return null;
+    }
+    const stream4 = res.getReadableStream();
+    const chunks = [];
+    let totalSize = 0;
+    for await (const chunk of stream4) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      totalSize += buf.length;
+      if (totalSize > MAX_RESOURCE_SIZE) {
+        log("warn", "\u8D44\u6E90\u8FC7\u5927\uFF0C\u8DF3\u8FC7\u4E0B\u8F7D", { messageId, fileKey, totalSize });
+        stream4.destroy();
+        return null;
+      }
+      chunks.push(buf);
+    }
+    const buffer = Buffer.concat(chunks);
+    const headers = res.headers;
+    const contentType = headers?.["content-type"] ?? guessMimeByType(type);
+    const base64 = buffer.toString("base64");
+    const dataUrl = `data:${contentType};base64,${base64}`;
+    return { dataUrl, mime: contentType };
+  } catch (err) {
+    log("warn", "\u8D44\u6E90\u4E0B\u8F7D\u5931\u8D25", {
+      messageId,
+      fileKey,
+      type,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+function guessMimeByType(type) {
+  return type === "image" ? "image/png" : "application/octet-stream";
+}
+function guessMimeByFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  const map = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    bmp: "image/bmp",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    txt: "text/plain",
+    csv: "text/csv",
+    json: "application/json",
+    xml: "application/xml",
+    zip: "application/zip",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    opus: "audio/opus",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
+// src/feishu/content-extractor.ts
+async function extractParts(feishuClient, messageId, messageType, rawContent, log) {
+  try {
+    switch (messageType) {
+      case "text":
+        return extractText(rawContent);
+      case "image":
+        return await extractImage(feishuClient, messageId, rawContent, log);
+      case "post":
+        return extractPost(rawContent);
+      case "file":
+        return await extractFile(feishuClient, messageId, rawContent, log);
+      case "audio":
+        return await extractAudio(feishuClient, messageId, rawContent, log);
+      case "media":
+        return extractMediaFallback();
+      case "sticker":
+        return [{ type: "text", text: "[\u8868\u60C5\u5305]" }];
+      case "interactive":
+        return extractInteractive(rawContent);
+      case "share_chat":
+        return extractShareChat(rawContent);
+      case "share_user":
+        return [{ type: "text", text: "[\u5206\u4EAB\u4E86\u4E00\u4E2A\u7528\u6237\u540D\u7247]" }];
+      case "merge_forward":
+        return [{ type: "text", text: "[\u5408\u5E76\u8F6C\u53D1\u6D88\u606F]" }];
+      default:
+        return [{ type: "text", text: `[\u4E0D\u652F\u6301\u7684\u6D88\u606F\u7C7B\u578B: ${messageType}]` }];
+    }
+  } catch (err) {
+    log("warn", "\u6D88\u606F\u5185\u5BB9\u63D0\u53D6\u5931\u8D25", {
+      messageId,
+      messageType,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return [{ type: "text", text: `[\u6D88\u606F\u5185\u5BB9\u63D0\u53D6\u5931\u8D25: ${messageType}]` }];
+  }
+}
+function describeMessageType(messageType, rawContent) {
+  switch (messageType) {
+    case "text": {
+      try {
+        const parsed = JSON.parse(rawContent);
+        return (parsed.text ?? "").trim();
+      } catch {
+        return "";
+      }
+    }
+    case "image":
+      return "[\u56FE\u7247]";
+    case "post":
+      return extractPostText(rawContent);
+    case "file": {
+      try {
+        const parsed = JSON.parse(rawContent);
+        return `[\u6587\u4EF6: ${parsed.file_name ?? "\u672A\u77E5\u6587\u4EF6"}]`;
+      } catch {
+        return "[\u6587\u4EF6]";
+      }
+    }
+    case "audio":
+      return "[\u8BED\u97F3\u6D88\u606F]";
+    case "media":
+      return "[\u89C6\u9891\u6D88\u606F]";
+    case "sticker":
+      return "[\u8868\u60C5\u5305]";
+    case "interactive":
+      return "[\u5361\u7247\u6D88\u606F]";
+    case "share_chat":
+      return "[\u7FA4\u5206\u4EAB]";
+    case "share_user":
+      return "[\u7528\u6237\u540D\u7247]";
+    case "merge_forward":
+      return "[\u5408\u5E76\u8F6C\u53D1]";
+    default:
+      return `[${messageType}]`;
+  }
+}
+function extractText(rawContent) {
+  const parsed = JSON.parse(rawContent);
+  const text2 = (parsed.text ?? "").trim();
+  if (!text2) return [];
+  return [{ type: "text", text: text2 }];
+}
+async function extractImage(client, messageId, rawContent, log) {
+  const parsed = JSON.parse(rawContent);
+  const imageKey = parsed.image_key;
+  if (!imageKey) return [{ type: "text", text: "[\u56FE\u7247: \u65E0\u6CD5\u83B7\u53D6]" }];
+  const resource = await downloadMessageResource(client, messageId, imageKey, "image", log);
+  if (!resource) return [{ type: "text", text: "[\u56FE\u7247: \u4E0B\u8F7D\u5931\u8D25]" }];
+  return [{ type: "file", mime: resource.mime, url: resource.dataUrl }];
+}
+function extractPost(rawContent) {
+  const text2 = extractPostText(rawContent);
+  if (!text2) return [];
+  return [{ type: "text", text: text2 }];
+}
+function extractPostText(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    const lines = [];
+    if (parsed.title) lines.push(parsed.title);
+    if (Array.isArray(parsed.content)) {
+      for (const paragraph of parsed.content) {
+        if (!Array.isArray(paragraph)) continue;
+        const segments = [];
+        for (const element of paragraph) {
+          if (element.tag === "text" && element.text) {
+            segments.push(element.text);
+          } else if (element.tag === "a" && element.text) {
+            segments.push(element.href ? `${element.text}(${element.href})` : element.text);
+          } else if (element.tag === "at" && element.text) {
+            segments.push(element.text);
+          } else if (element.tag === "img") {
+            segments.push("[\u56FE\u7247]");
+          }
+        }
+        if (segments.length) lines.push(segments.join(""));
+      }
+    }
+    return lines.join("\n").trim();
+  } catch {
+    return "";
+  }
+}
+async function extractFile(client, messageId, rawContent, log) {
+  const parsed = JSON.parse(rawContent);
+  const fileKey = parsed.file_key;
+  const fileName = parsed.file_name ?? "\u672A\u77E5\u6587\u4EF6";
+  if (!fileKey) return [{ type: "text", text: `[\u6587\u4EF6: ${fileName}]` }];
+  const mime = guessMimeByFilename(fileName);
+  const resource = await downloadMessageResource(client, messageId, fileKey, "file", log);
+  if (!resource) return [{ type: "text", text: `[\u6587\u4EF6\u4E0B\u8F7D\u5931\u8D25: ${fileName}]` }];
+  return [{ type: "file", mime: resource.mime || mime, url: resource.dataUrl, filename: fileName }];
+}
+async function extractAudio(client, messageId, rawContent, log) {
+  const parsed = JSON.parse(rawContent);
+  const fileKey = parsed.file_key;
+  if (!fileKey) return [{ type: "text", text: "[\u8BED\u97F3: \u65E0\u6CD5\u83B7\u53D6]" }];
+  const resource = await downloadMessageResource(client, messageId, fileKey, "file", log);
+  if (!resource) return [{ type: "text", text: "[\u8BED\u97F3: \u4E0B\u8F7D\u5931\u8D25]" }];
+  return [{ type: "file", mime: resource.mime || "audio/opus", url: resource.dataUrl }];
+}
+function extractMediaFallback() {
+  return [{ type: "text", text: "[\u89C6\u9891\u6D88\u606F]" }];
+}
+function extractInteractive(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    const texts = [];
+    if (parsed.header?.title?.content) texts.push(parsed.header.title.content);
+    if (Array.isArray(parsed.elements)) {
+      for (const el of parsed.elements) {
+        if (el.tag === "div" && el.text?.content) texts.push(el.text.content);
+        else if (el.tag === "markdown" && el.content) texts.push(el.content);
+      }
+    }
+    const text2 = texts.join("\n").trim();
+    return text2 ? [{ type: "text", text: `[\u5361\u7247\u6D88\u606F]
+${text2}` }] : [{ type: "text", text: "[\u5361\u7247\u6D88\u606F]" }];
+  } catch {
+    return [{ type: "text", text: "[\u5361\u7247\u6D88\u606F]" }];
+  }
+}
+function extractShareChat(rawContent) {
+  try {
+    const parsed = JSON.parse(rawContent);
+    return [{ type: "text", text: `[\u5206\u4EAB\u4E86\u4E00\u4E2A\u7FA4\u804A${parsed.chat_id ? `: ${parsed.chat_id}` : ""}]` }];
+  } catch {
+    return [{ type: "text", text: "[\u7FA4\u5206\u4EAB]" }];
+  }
+}
+
 // src/feishu/group-filter.ts
 function isBotMentioned(mentions, botOpenId) {
   return mentions.some((m) => m.id?.open_id === botOpenId);
@@ -98796,21 +99046,18 @@ function startFeishuGateway(options) {
         const messageId = message.message_id;
         if (isDuplicate(messageId)) return;
         const messageType = message.message_type ?? "text";
+        const rawContent = message.content ?? "";
         log("info", "\u98DE\u4E66\u6D88\u606F\u5143\u4FE1\u606F", {
           chatId,
           messageId: messageId ?? "",
           messageType,
-          hasContent: !!message.content
+          hasContent: !!rawContent
         });
-        if (messageType !== "text" || !message.content) return;
-        let text2;
-        try {
-          const parsed = JSON.parse(message.content);
-          text2 = (parsed.text ?? "").trim();
-        } catch {
-          return;
+        if (!rawContent) return;
+        let text2 = describeMessageType(messageType, rawContent);
+        if (messageType === "text") {
+          text2 = text2.replace(/@_user_\d+\s*/g, "").trim();
         }
-        text2 = text2.replace(/@_user_\d+\s*/g, "").trim();
         if (!text2) return;
         const chatType = message.chat_type === "group" ? "group" : "p2p";
         let shouldReply = true;
@@ -98830,6 +99077,7 @@ function startFeishuGateway(options) {
           messageId: messageId ?? "",
           messageType,
           content: text2,
+          rawContent,
           chatType,
           senderId,
           rootId,
@@ -98945,14 +99193,19 @@ async function handleEvent(event) {
       if (!sessionId) break;
       const payload = pendingBySession.get(sessionId);
       if (!payload) break;
-      const added = extractPartText(part);
-      if (added) {
-        payload.textBuffer += added;
-        try {
-          await updateMessage(payload.feishuClient, payload.placeholderId, payload.textBuffer.trim());
-        } catch {
+      const delta = event.properties.delta;
+      if (delta) {
+        payload.textBuffer += delta;
+      } else {
+        const fullText = extractPartText(part);
+        if (fullText) {
+          payload.textBuffer = fullText;
         }
       }
+      if (payload.textBuffer) {
+        const res = await updateMessage(payload.feishuClient, payload.placeholderId, payload.textBuffer.trim());
+        if (!res.ok) ;
+      }
       break;
     }
     case "session.error": {
@@ -98962,9 +99215,8 @@ async function handleEvent(event) {
       const payload = pendingBySession.get(sessionId);
       if (!payload) break;
       const errMsg = props.error?.message ?? String(props.error);
-      try {
-        await updateMessage(payload.feishuClient, payload.placeholderId, `\u274C \u4F1A\u8BDD\u9519\u8BEF: ${errMsg}`);
-      } catch {
+      const updateRes = await updateMessage(payload.feishuClient, payload.placeholderId, `\u274C \u4F1A\u8BDD\u9519\u8BEF: ${errMsg}`);
+      if (!updateRes.ok) {
         await sendTextMessage(payload.feishuClient, payload.chatId, `\u274C \u4F1A\u8BDD\u9519\u8BEF: ${errMsg}`);
       }
       break;
@@ -99016,26 +99268,21 @@ async function getOrCreateSession(client, sessionKey, directory) {
 
 // src/handler/chat.ts
 async function handleChat(ctx, deps) {
-  const { content, chatId, chatType, senderId, createTime, shouldReply } = ctx;
-  if (!content.trim()) return;
+  const { content, chatId, chatType, senderId, shouldReply, messageType, rawContent, messageId } = ctx;
+  if (!content.trim() && messageType === "text") return;
   const { config, client, feishuClient, log, directory } = deps;
   const query = directory ? { directory } : void 0;
   const sessionKey = buildSessionKey(chatType, chatType === "p2p" ? senderId : chatId);
   const session = await getOrCreateSession(client, sessionKey, directory);
-  const timeStr = createTime ? new Date(Number(createTime)).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }) : "";
-  let promptContent = content;
-  if (chatType === "group" && senderId) {
-    promptContent = timeStr ? `[${timeStr}] [${senderId}]: ${content}` : `[${senderId}]: ${content}`;
-  } else if (timeStr) {
-    promptContent = `[${timeStr}] ${content}`;
-  }
+  const parts = await buildPromptParts(feishuClient, messageId, messageType, rawContent, content, chatType, senderId, log);
+  if (!parts.length) return;
   if (!shouldReply) {
     try {
       await client.session.prompt({
         path: { id: session.id },
         query,
         body: {
-          parts: [{ type: "text", text: promptContent }],
+          parts,
           noReply: true
         }
       });
@@ -99056,11 +99303,16 @@ async function handleChat(ctx, deps) {
     if (done) return;
     try {
       const res = await sendTextMessage(feishuClient, chatId, "\u6B63\u5728\u601D\u8003\u2026");
+      if (done) return;
       if (res.ok && res.messageId) {
         placeholderId = res.messageId;
         registerPending(session.id, { chatId, placeholderId, feishuClient });
       }
-    } catch {
+    } catch (err) {
+      log("warn", "\u53D1\u9001\u5360\u4F4D\u6D88\u606F\u5931\u8D25", {
+        chatId,
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   }, thinkingDelay) : null;
   try {
@@ -99068,7 +99320,7 @@ async function handleChat(ctx, deps) {
       path: { id: session.id },
       query,
       body: {
-        parts: [{ type: "text", text: promptContent }]
+        parts
       }
     });
     const start = Date.now();
@@ -99081,12 +99333,6 @@ async function handleChat(ctx, deps) {
       if (text2 && text2 !== lastText) {
         lastText = text2;
         sameCount = 0;
-        if (placeholderId) {
-          try {
-            await updateMessage(feishuClient, placeholderId, text2);
-          } catch {
-          }
-        }
       } else if (text2 && text2.length > 0) {
         sameCount++;
         if (sameCount >= stablePolls) break;
@@ -99107,11 +99353,24 @@ async function handleChat(ctx, deps) {
     unregisterPending(session.id);
   }
 }
+async function buildPromptParts(feishuClient, messageId, messageType, rawContent, textContent, chatType, senderId, log) {
+  if (messageType === "text") {
+    let promptText = textContent;
+    if (chatType === "group" && senderId) {
+      promptText = `[${senderId}]: ${textContent}`;
+    }
+    return [{ type: "text", text: promptText }];
+  }
+  const parts = await extractParts(feishuClient, messageId, messageType, rawContent, log);
+  if (chatType === "group" && senderId && parts.length > 0) {
+    return [{ type: "text", text: `[${senderId}]:` }, ...parts];
+  }
+  return parts;
+}
 async function replyOrUpdate(feishuClient, chatId, placeholderId, text2) {
   if (placeholderId) {
-    try {
-      await updateMessage(feishuClient, placeholderId, text2);
-    } catch {
+    const res = await updateMessage(feishuClient, placeholderId, text2);
+    if (!res.ok) {
       await sendTextMessage(feishuClient, chatId, text2);
     }
   } else {
@@ -99127,7 +99386,8 @@ function extractLastAssistantText(messages) {
 // src/feishu/history.ts
 var DEFAULT_PAGE_SIZE = 50;
 async function ingestGroupHistory(feishuClient, opencodeClient, chatId, options) {
-  const { maxMessages, log } = options;
+  const { maxMessages, log, directory } = options;
+  const query = directory ? { directory } : void 0;
   log("info", "\u5F00\u59CB\u6444\u5165\u7FA4\u804A\u5386\u53F2\u4E0A\u4E0B\u6587", { chatId, maxMessages });
   const messages = await fetchRecentMessages(feishuClient, chatId, maxMessages, log);
   if (!messages.length) {
@@ -99135,10 +99395,11 @@ async function ingestGroupHistory(feishuClient, opencodeClient, chatId, options)
     return;
   }
   const sessionKey = buildSessionKey("group", chatId);
-  const session = await getOrCreateSession(opencodeClient, sessionKey);
+  const session = await getOrCreateSession(opencodeClient, sessionKey, directory);
   const contextText = formatHistoryAsContext(messages);
   await opencodeClient.session.prompt({
     path: { id: session.id },
+    query,
     body: {
       parts: [{ type: "text", text: contextText }],
       noReply: true
@@ -99164,14 +99425,10 @@ async function fetchRecentMessages(client, chatId, maxMessages, log) {
       if (!items || items.length === 0) break;
       for (const item of items) {
         if (item.deleted) continue;
-        if (item.msg_type !== "text" || !item.body?.content) continue;
-        let text2;
-        try {
-          const parsed = JSON.parse(item.body.content);
-          text2 = (parsed.text ?? "").trim();
-        } catch {
-          continue;
-        }
+        if (!item.body?.content) continue;
+        const msgType = item.msg_type ?? "text";
+        const rawContent = item.body.content;
+        const text2 = describeMessageType(msgType, rawContent);
         if (!text2) continue;
         result.push({
           senderType: item.sender?.sender_type ?? "unknown",
@@ -99218,7 +99475,8 @@ var DEFAULT_CONFIG = {
   maxHistoryMessages: 200,
   pollInterval: 1e3,
   stablePolls: 3,
-  dedupTtl: 10 * 60 * 1e3
+  dedupTtl: 10 * 60 * 1e3,
+  directory: ""
 };
 var FeishuPlugin = async (ctx) => {
   const { client } = ctx;
@@ -99251,6 +99509,12 @@ var FeishuPlugin = async (ctx) => {
   } catch (parseErr) {
     throw new Error(`\u98DE\u4E66\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1A${configPath} \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON (${parseErr})`);
   }
+  if (feishuRaw.directory !== void 0 && typeof feishuRaw.directory !== "string") {
+    log("warn", `\u98DE\u4E66\u914D\u7F6E\u8B66\u544A\uFF1A${configPath} \u4E2D\u7684 'directory' \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF0C\u5DF2\u5FFD\u7565`, {
+      actualType: typeof feishuRaw.directory
+    });
+    feishuRaw.directory = void 0;
+  }
   if (!feishuRaw.appId || !feishuRaw.appSecret) {
     throw new Error(
       `\u98DE\u4E66\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1A${configPath} \u4E2D\u5FC5\u987B\u5305\u542B appId \u548C appSecret`
@@ -99265,7 +99529,8 @@ var FeishuPlugin = async (ctx) => {
     maxHistoryMessages: feishuRaw.maxHistoryMessages ?? DEFAULT_CONFIG.maxHistoryMessages,
     pollInterval: feishuRaw.pollInterval ?? DEFAULT_CONFIG.pollInterval,
     stablePolls: feishuRaw.stablePolls ?? DEFAULT_CONFIG.stablePolls,
-    dedupTtl: feishuRaw.dedupTtl ?? DEFAULT_CONFIG.dedupTtl
+    dedupTtl: feishuRaw.dedupTtl ?? DEFAULT_CONFIG.dedupTtl,
+    directory: expandDirectoryPath(feishuRaw.directory ?? ctx.directory ?? DEFAULT_CONFIG.directory)
   };
   initDedup(resolvedConfig.dedupTtl);
   const botOpenId = await fetchBotOpenId(resolvedConfig.appId, resolvedConfig.appSecret, log);
@@ -99279,14 +99544,15 @@ var FeishuPlugin = async (ctx) => {
         client,
         feishuClient: gateway.client,
         log,
-        directory: ctx.directory
+        directory: resolvedConfig.directory
       });
     },
     onBotAdded: (chatId) => {
       if (!gateway) return;
       ingestGroupHistory(gateway.client, client, chatId, {
         maxMessages: resolvedConfig.maxHistoryMessages,
-        log
+        log,
+        directory: resolvedConfig.directory
       }).catch((err) => {
         log("error", "\u7FA4\u804A\u5386\u53F2\u6444\u5165\u5931\u8D25", {
           chatId,
@@ -99308,6 +99574,20 @@ var FeishuPlugin = async (ctx) => {
   };
   return hooks;
 };
+function expandDirectoryPath(dir) {
+  if (!dir) return dir;
+  if (dir.startsWith("~")) {
+    dir = join(homedir(), dir.slice(1));
+  }
+  dir = dir.replace(/\$\{(\w+)\}/g, (_match, name) => {
+    const val = process.env[name];
+    if (val === void 0) {
+      throw new Error(`\u73AF\u5883\u53D8\u91CF ${name} \u672A\u8BBE\u7F6E\uFF08directory \u5F15\u7528\u4E86 \${${name}}\uFF09`);
+    }
+    return val;
+  });
+  return dir;
+}
 function resolveEnvPlaceholders(obj) {
   if (typeof obj === "string") {
     if (!obj.includes("${")) return obj;