fix(feishu): normalize media upload multipart data

mikasa0818 · mikasa0818 · commit c6bc27f8e6ab · 2026-07-17T20:46:31.000+08:00
Convert Feishu SDK multipart Buffer upload parts into explicit FormData
before they reach the wrapped HTTP transport. The SDK upload helpers
pass multipart data as a plain object with Buffer media parts; relying on
implicit serialization in the timeout/proxy-aware HTTP wrapper was fragile
and caused file/image delivery failures (400 volc-dcdn / write ECONNRESET)
even though the same credentials succeeded via a standalone SDK upload.

Adds normalizeMultipartUploadData, applied on the request path of the
shared Feishu HTTP instance, plus a regression test covering the
multipart-to-FormData normalization.

Rebased onto current origin/main, which replaced the old synchronous
injectTimeout path with the async proxy-aware injectRequestOptions flow;
the multipart normalization is now applied before that flow.
diff --git a/extensions/feishu/src/client.test.ts b/extensions/feishu/src/client.test.ts
@@ -325,6 +325,40 @@ describe("createFeishuClient HTTP timeout", () => {
     });
   });
 
+  it("normalizes Feishu SDK multipart uploads to explicit FormData", async () => {
+    createFeishuClient({
+      appId: "app_upload",
+      appSecret: "secret_upload", // pragma: allowlist secret
+      accountId: "multipart-upload",
+    });
+
+    const httpInstance = readLastClientHttpInstance();
+
+    await httpInstance.request({
+      url: "https://open.feishu.cn/open-apis/im/v1/files",
+      method: "POST",
+      headers: { "Content-Type": "multipart/form-data", Authorization: "Bearer token" },
+      data: {
+        file_type: "stream",
+        file_name: "tiny.txt",
+        file: Buffer.from("tiny"),
+      },
+    });
+
+    const delegated = readCallOptions(mockBaseHttpInstance.request);
+    expect(delegated.timeout).toBe(FEISHU_HTTP_TIMEOUT_MS);
+    expect(delegated.headers).toEqual({
+      "Content-Type": "multipart/form-data",
+      Authorization: "Bearer token",
+    });
+    expect(delegated.data).toBeInstanceOf(FormData);
+    expect(delegated.data).not.toEqual({
+      file_type: "stream",
+      file_name: "tiny.txt",
+      file: Buffer.from("tiny"),
+    });
+  });
+
   it("uses config-configured default timeout when provided", async () => {
     createFeishuClient({
       appId: "app_4",
diff --git a/extensions/feishu/src/client.ts b/extensions/feishu/src/client.ts
@@ -85,6 +85,90 @@ type FeishuHttpInstanceLike = Pick<
   "request" | "get" | "post" | "put" | "patch" | "delete" | "head" | "options"
 >;
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readHeader(headers: unknown, name: string): string | undefined {
+  if (!isRecord(headers)) {
+    return undefined;
+  }
+  const normalizedName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== normalizedName) {
+      continue;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      const first = value.find((entry) => typeof entry === "string");
+      return typeof first === "string" ? first : undefined;
+    }
+  }
+  return undefined;
+}
+
+function isMultipartFormRequest(opts: Lark.HttpRequestOptions<unknown>): boolean {
+  return /^multipart\/form-data(?:;|$)/i.test(readHeader(opts.headers, "content-type") ?? "");
+}
+
+function hasFeishuUploadPart(data: Record<string, unknown>): boolean {
+  return Buffer.isBuffer(data.file) || Buffer.isBuffer(data.image);
+}
+
+function stringifyMultipartFieldValue(value: unknown): string | undefined {
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(value);
+    default:
+      return undefined;
+  }
+}
+
+function bufferToBlobPart(value: Buffer): Uint8Array<ArrayBuffer> {
+  const bytes = new Uint8Array(value.byteLength);
+  bytes.set(value);
+  return bytes;
+}
+
+function normalizeMultipartUploadData<D>(
+  opts: Lark.HttpRequestOptions<D>,
+): Lark.HttpRequestOptions<D> {
+  if (!isMultipartFormRequest(opts) || !isRecord(opts.data) || !hasFeishuUploadPart(opts.data)) {
+    return opts;
+  }
+
+  const form = new FormData();
+  const fileName =
+    typeof opts.data.file_name === "string" && opts.data.file_name
+      ? opts.data.file_name
+      : undefined;
+  for (const [key, value] of Object.entries(opts.data)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+    if (Buffer.isBuffer(value)) {
+      form.append(
+        key,
+        new Blob([bufferToBlobPart(value)]),
+        key === "file" && fileName ? fileName : `${key}.bin`,
+      );
+      continue;
+    }
+    const fieldValue = stringifyMultipartFieldValue(value);
+    if (fieldValue !== undefined) {
+      form.append(key, fieldValue);
+    }
+  }
+
+  return { ...opts, data: form as D };
+}
+
 function isManagedProxyActive() {
   return process.env["OPENCLAW_PROXY_ACTIVE"] === "1";
 }
@@ -193,7 +277,8 @@ function createFeishuHttpInstance(defaultTimeoutMs: number): Lark.HttpInstance {
   }
 
   return {
-    request: async (opts) => base.request(await injectRequestOptions(opts)),
+    request: async (opts) =>
+      base.request(await injectRequestOptions(normalizeMultipartUploadData(opts))),
     get: async (url, opts) => base.get(url, await injectRequestOptions(opts)),
     post: async (url, data, opts) => base.post(url, data, await injectRequestOptions(opts)),
     put: async (url, data, opts) => base.put(url, data, await injectRequestOptions(opts)),
