@zhin.js/adapter-weixin-ilink 1.1.10 → 1.1.13

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @zhin.js/adapter-weixin-ilink
 
+## 1.1.13
+
+### Patch Changes
+
+- Updated dependencies [db06de8]
+  - @zhin.js/core@1.1.48
+
+## 1.1.12
+
+### Patch Changes
+
+- f30be42: Stop publishing unit test files (`src/**/*.test.ts`, `client/**/*.test.ts`) in the npm tarball.
+- Updated dependencies [5be09ae]
+- Updated dependencies [a3ab153]
+- Updated dependencies [e8f7309]
+- Updated dependencies [5afc18f]
+- Updated dependencies [d3563d9]
+- Updated dependencies [c618eb7]
+- Updated dependencies [fbfefb7]
+  - @zhin.js/core@1.1.47
+  - @zhin.js/adapter@1.1.21
+  - @zhin.js/feature-kit@1.1.7
+  - @zhin.js/im-contract@1.1.5
+
+## 1.1.11
+
+### Patch Changes
+
+- 9816c18: 将应用插件装配改为 configVersion: 2：主配置 plugins 映射实例名到包，disable_plugins 控制启停，业务配置使用顶层同名块。package.json 继续保留 features、entry、engine 等包契约，并支持静态 displayName/icon。
+
+  这是配置格式的破坏性更新：旧配置不能继续运行，请先停止 Bot，运行 `zhin migrate instances` 预览，再使用 `--apply` 转换；提供备份与中断继续/回滚，无法无损转换的嵌套、optional 和别名碰撞需人工迁移。Runtime、Console、CLI 与创建向导统一使用新声明。
+
+  保留框架顶层 `menuKeyword` / `menuStyle`，通过当前 generation 的 Root 配置视图供 Command Feature 消费；严格校验和配置修改不会丢失菜单设置，子实例配置保持隔离。
+
+- Updated dependencies [c407bd2]
+- Updated dependencies [064b06d]
+- Updated dependencies [b58548a]
+- Updated dependencies [e914a93]
+- Updated dependencies [e914a93]
+- Updated dependencies [064b06d]
+  - @zhin.js/core@1.1.46
+  - @zhin.js/feature-kit@1.1.6
+  - @zhin.js/adapter@1.1.20
+
 ## 1.1.10
 
 ### Patch Changes

package/README.md

@@ -23,15 +23,17 @@
 ## 最小配置
 
 ```yaml
+configVersion: 2
 plugins:
-  weixin-ilink:
-    # botAgent: "Zhin.js/1.0.0"
-    # longPollTimeoutMs: 35000
-    # baseUrl: https://ilinkai.weixin.qq.com
-    # dataDir: data/weixin-ilink
-    endpoints:
-      - id: my-wechat
-        # botToken: "..."                 # 可选；不填则读取状态文件或扫码
+  weixin-ilink: "@zhin.js/adapter-weixin-ilink"
+weixin-ilink:
+  # botAgent: "Zhin.js/1.0.0"
+  # longPollTimeoutMs: 35000
+  # baseUrl: https://ilinkai.weixin.qq.com
+  # dataDir: data/weixin-ilink
+  endpoints:
+    - id: my-wechat
+      # botToken: "..."                 # 可选；不填则读取状态文件或扫码
 ```
 
 `AdapterIndex` 会把实例默认值与 endpoint 覆盖值合并后再调用 adapter。协议层只接受这份

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/adapter-weixin-ilink",
-  "version": "1.1.10",
+  "version": "1.1.13",
   "type": "module",
   "description": "Zhin.js Weixin iLink (ClawBot) adapter for Plugin Runtime (long-poll)",
   "main": "./lib/index.js",
@@ -32,6 +32,7 @@
     "plugin.js",
     "schema.json",
     "src",
+    "!src/**/*.test.ts",
     "lib",
     "README.md",
     "CHANGELOG.md"
@@ -47,17 +48,17 @@
     }
   },
   "dependencies": {
-    "@zhin.js/adapter": "1.1.19",
-    "@zhin.js/core": "1.1.45",
-    "@zhin.js/feature-kit": "1.1.5",
-    "@zhin.js/im-contract": "1.1.4",
+    "@zhin.js/adapter": "1.1.21",
+    "@zhin.js/core": "1.1.48",
+    "@zhin.js/feature-kit": "1.1.7",
+    "@zhin.js/im-contract": "1.1.5",
     "@zhin.js/logger": "1.1.2"
   },
   "peerDependencies": {
-    "@zhin.js/adapter": "^1.1.19",
-    "@zhin.js/command": "^1.1.7",
-    "@zhin.js/core": "^1.1.45",
-    "zhin.js": "^1.1.10"
+    "@zhin.js/adapter": "^1.1.21",
+    "@zhin.js/command": "^1.1.9",
+    "@zhin.js/core": "^1.1.48",
+    "zhin.js": "^1.1.13"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {
@@ -71,7 +72,7 @@
     "@types/node": "^26.1.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
-    "zhin.js": "1.1.10"
+    "zhin.js": "1.1.13"
   },
   "ilink_appid": "bot",
   "engines": {

package/src/cdn-upload.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../util/logger.js", () => ({
-  logger: {
-    info: vi.fn(),
-    debug: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  },
-}));
-
-const { mockFetch } = vi.hoisted(() => ({
-  mockFetch: vi.fn(),
-}));
-vi.stubGlobal("fetch", mockFetch);
-
-import { encryptAesEcb, aesEcbPaddedSize } from "./aes-ecb.js";
-import { uploadBufferToCdn } from "./cdn-upload.js";
-import crypto from "node:crypto";
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("aesEcbPaddedSize", () => {
-  it("pads to 16-byte boundary", () => {
-    expect(aesEcbPaddedSize(0)).toBe(16);
-    expect(aesEcbPaddedSize(1)).toBe(16);
-    expect(aesEcbPaddedSize(15)).toBe(16);
-    expect(aesEcbPaddedSize(16)).toBe(32);
-    expect(aesEcbPaddedSize(31)).toBe(32);
-    expect(aesEcbPaddedSize(32)).toBe(48);
-  });
-});
-
-describe("encryptAesEcb", () => {
-  it("encrypts and produces correct ciphertext length", () => {
-    const key = crypto.randomBytes(16);
-    const plaintext = Buffer.from("hello world 1234");
-    const ct = encryptAesEcb(plaintext, key);
-    // 16 bytes plaintext + PKCS7 padding = 32 bytes ciphertext
-    expect(ct.length).toBe(32);
-  });
-});
-
-describe("uploadBufferToCdn", () => {
-  const aeskey = crypto.randomBytes(16);
-
-  it("uploads successfully and returns downloadParam", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({ "x-encrypted-param": "dl-param" }),
-    });
-
-    const result = await uploadBufferToCdn({
-      buf: Buffer.from("data"),
-      uploadParam: "up",
-      filekey: "fk",
-      cdnBaseUrl: "https://cdn.com",
-      label: "test",
-      aeskey,
-    });
-    expect(result.downloadParam).toBe("dl-param");
-  });
-
-  it("POSTs to uploadFullUrl when provided", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers({ "x-encrypted-param": "dl-full" }),
-    });
-
-    const fullUrl = "http://host/c2c/upload?q=1";
-    const result = await uploadBufferToCdn({
-      buf: Buffer.from("data"),
-      uploadFullUrl: fullUrl,
-      filekey: "fk",
-      cdnBaseUrl: "https://unused.example",
-      label: "test",
-      aeskey,
-    });
-    expect(result.downloadParam).toBe("dl-full");
-    expect(mockFetch).toHaveBeenCalledWith(
-      fullUrl,
-      expect.objectContaining({ method: "POST" }),
-    );
-  });
-
-  it("retries on server error then succeeds", async () => {
-    mockFetch
-      .mockResolvedValueOnce({
-        ok: false,
-        status: 500,
-        headers: new Headers({ "x-error-message": "busy" }),
-        text: () => Promise.resolve("busy"),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Headers({ "x-encrypted-param": "dl" }),
-      });
-
-    const result = await uploadBufferToCdn({
-      buf: Buffer.from("data"),
-      uploadParam: "up",
-      filekey: "fk",
-      cdnBaseUrl: "https://cdn.com",
-      label: "test",
-      aeskey,
-    });
-    expect(result.downloadParam).toBe("dl");
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-  });
-
-  it("throws immediately on 4xx client error", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 403,
-      headers: new Headers({}),
-      text: () => Promise.resolve("forbidden"),
-    });
-
-    await expect(
-      uploadBufferToCdn({
-        buf: Buffer.from("data"),
-        uploadParam: "up",
-        filekey: "fk",
-        cdnBaseUrl: "https://cdn.com",
-        label: "test",
-        aeskey,
-      }),
-    ).rejects.toThrow("client error");
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it("throws when x-encrypted-param header is missing after all retries", async () => {
-    for (let i = 0; i < 3; i++) {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        headers: new Headers({}),
-      });
-    }
-
-    await expect(
-      uploadBufferToCdn({
-        buf: Buffer.from("data"),
-        uploadParam: "up",
-        filekey: "fk",
-        cdnBaseUrl: "https://cdn.com",
-        label: "test",
-        aeskey,
-      }),
-    ).rejects.toThrow("x-encrypted-param");
-  });
-
-  it("uses x-error-message header for 4xx when available", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      headers: new Headers({ "x-error-message": "bad request detail" }),
-      text: () => Promise.resolve("fallback text"),
-    });
-
-    await expect(
-      uploadBufferToCdn({
-        buf: Buffer.from("data"),
-        uploadParam: "up",
-        filekey: "fk",
-        cdnBaseUrl: "https://cdn.com",
-        label: "test",
-        aeskey,
-      }),
-    ).rejects.toThrow("bad request detail");
-  });
-});

package/src/mime.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getMimeFromFilename, getExtensionFromMime, getExtensionFromContentTypeOrUrl } from "./mime.js";
-
-describe("getMimeFromFilename", () => {
-  it("returns correct MIME for known extensions", () => {
-    expect(getMimeFromFilename("photo.png")).toBe("image/png");
-    expect(getMimeFromFilename("doc.pdf")).toBe("application/pdf");
-    expect(getMimeFromFilename("video.mp4")).toBe("video/mp4");
-    expect(getMimeFromFilename("audio.mp3")).toBe("audio/mpeg");
-    expect(getMimeFromFilename("image.jpg")).toBe("image/jpeg");
-    expect(getMimeFromFilename("image.jpeg")).toBe("image/jpeg");
-    expect(getMimeFromFilename("data.csv")).toBe("text/csv");
-  });
-
-  it("is case-insensitive", () => {
-    expect(getMimeFromFilename("PHOTO.PNG")).toBe("image/png");
-    expect(getMimeFromFilename("file.PDF")).toBe("application/pdf");
-  });
-
-  it("returns application/octet-stream for unknown extensions", () => {
-    expect(getMimeFromFilename("file.xyz")).toBe("application/octet-stream");
-    expect(getMimeFromFilename("noext")).toBe("application/octet-stream");
-  });
-
-  it("handles paths with directories", () => {
-    expect(getMimeFromFilename("/path/to/photo.png")).toBe("image/png");
-  });
-});
-
-describe("getExtensionFromMime", () => {
-  it("returns correct extension for known MIME types", () => {
-    expect(getExtensionFromMime("image/jpeg")).toBe(".jpg");
-    expect(getExtensionFromMime("image/png")).toBe(".png");
-    expect(getExtensionFromMime("video/mp4")).toBe(".mp4");
-    expect(getExtensionFromMime("application/pdf")).toBe(".pdf");
-  });
-
-  it("handles MIME with parameters", () => {
-    expect(getExtensionFromMime("image/jpeg; charset=utf-8")).toBe(".jpg");
-    expect(getExtensionFromMime("text/plain; boundary=something")).toBe(".txt");
-  });
-
-  it("returns .bin for unknown MIME types", () => {
-    expect(getExtensionFromMime("application/unknown")).toBe(".bin");
-    expect(getExtensionFromMime("x-custom/type")).toBe(".bin");
-  });
-
-  it("handles image/jpg alias", () => {
-    expect(getExtensionFromMime("image/jpg")).toBe(".jpg");
-  });
-});
-
-describe("getExtensionFromContentTypeOrUrl", () => {
-  it("prefers Content-Type when it resolves to a known extension", () => {
-    expect(getExtensionFromContentTypeOrUrl("image/png", "https://example.com/file.jpg")).toBe(".png");
-  });
-
-  it("falls back to URL extension when Content-Type is unknown", () => {
-    expect(getExtensionFromContentTypeOrUrl("application/unknown", "https://example.com/file.jpg")).toBe(".jpg");
-  });
-
-  it("falls back to URL extension when Content-Type is null", () => {
-    expect(getExtensionFromContentTypeOrUrl(null, "https://example.com/file.mp4")).toBe(".mp4");
-  });
-
-  it("returns .bin when neither Content-Type nor URL has a known extension", () => {
-    expect(getExtensionFromContentTypeOrUrl(null, "https://example.com/file")).toBe(".bin");
-    expect(getExtensionFromContentTypeOrUrl("application/unknown", "https://example.com/file.xyz")).toBe(".bin");
-  });
-
-  it("handles URL with query parameters", () => {
-    expect(getExtensionFromContentTypeOrUrl(null, "https://example.com/file.png?token=abc")).toBe(".png");
-  });
-});

package/src/silk-transcode.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("../util/logger.js", () => ({
-  logger: {
-    info: vi.fn(),
-    debug: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  },
-}));
-
-describe("silkToWav", () => {
-  beforeEach(() => {
-    vi.resetModules();
-  });
-
-  it("returns null when silk-wasm is unavailable", async () => {
-    vi.doMock("silk-wasm", () => {
-      throw new Error("Cannot find module 'silk-wasm'");
-    });
-    const { silkToWav } = await import("./silk-transcode.js");
-    const result = await silkToWav(Buffer.from("fake-silk"));
-    expect(result).toBeNull();
-  });
-
-  it("transcodes silk to WAV successfully", async () => {
-    const fakePcm = new Uint8Array(480); // 10ms at 24kHz mono 16-bit
-    vi.doMock("silk-wasm", () => ({
-      decode: vi.fn().mockResolvedValue({
-        data: fakePcm,
-        duration: 10,
-      }),
-    }));
-    const { silkToWav } = await import("./silk-transcode.js");
-    const result = await silkToWav(Buffer.from("fake-silk"));
-    expect(result).not.toBeNull();
-    expect(result!.length).toBe(44 + fakePcm.byteLength); // WAV header + PCM data
-
-    // Verify WAV header
-    expect(result!.toString("ascii", 0, 4)).toBe("RIFF");
-    expect(result!.toString("ascii", 8, 12)).toBe("WAVE");
-    expect(result!.toString("ascii", 12, 16)).toBe("fmt ");
-    expect(result!.readUInt16LE(20)).toBe(1); // PCM format
-    expect(result!.readUInt16LE(22)).toBe(1); // mono
-    expect(result!.readUInt32LE(24)).toBe(24000); // sample rate
-    expect(result!.readUInt16LE(34)).toBe(16); // bits per sample
-    expect(result!.toString("ascii", 36, 40)).toBe("data");
-  });
-
-  it("returns null when decode fails", async () => {
-    vi.doMock("silk-wasm", () => ({
-      decode: vi.fn().mockRejectedValue(new Error("decode error")),
-    }));
-    const { silkToWav } = await import("./silk-transcode.js");
-    const result = await silkToWav(Buffer.from("bad-silk"));
-    expect(result).toBeNull();
-  });
-});

package/src/upload.test.ts

@@ -1,308 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import fs from "node:fs/promises";
-import fsSync from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { IlinkClientMetadata } from "./ilink-meta.js";
-
-vi.mock("./ilink-logger.js", () => ({
-  logger: {
-    info: vi.fn(),
-    debug: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  },
-}));
-
-const { mockGetUploadUrl } = vi.hoisted(() => ({
-  mockGetUploadUrl: vi.fn(),
-}));
-
-vi.mock("./ilink-api.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./ilink-api.js")>();
-  return {
-    ...actual,
-    getUploadUrl: mockGetUploadUrl,
-  };
-});
-
-const { mockFetch } = vi.hoisted(() => ({
-  mockFetch: vi.fn(),
-}));
-vi.stubGlobal("fetch", mockFetch);
-
-const metadata = new IlinkClientMetadata({ version: "1.2.3" });
-
-function mockCdnResponse(params: {
-  ok?: boolean;
-  status?: number;
-  headers?: Record<string, string>;
-  body?: string;
-}) {
-  const headers = new Headers(params.headers ?? {});
-  return {
-    ok: params.ok ?? true,
-    status: params.status ?? 200,
-    headers,
-    text: () => Promise.resolve(params.body ?? ""),
-  };
-}
-
-import { downloadRemoteImageToTemp, uploadFileToWeixin, uploadVideoToWeixin, uploadFileAttachmentToWeixin } from "./upload.js";
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("downloadRemoteImageToTemp", () => {
-  it("downloads and saves file to temp dir", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-test-"));
-    try {
-      const imageBytes = Buffer.from("fake-image-data");
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        arrayBuffer: () => Promise.resolve(imageBytes.buffer.slice(imageBytes.byteOffset, imageBytes.byteOffset + imageBytes.byteLength)),
-        headers: new Headers({ "content-type": "image/png" }),
-      });
-      const filePath = await downloadRemoteImageToTemp("https://example.com/photo.png", tmpDir);
-      expect(filePath).toContain(tmpDir);
-      expect(filePath).toMatch(/\.png$/);
-      const content = await fs.readFile(filePath);
-      expect(content.toString()).toBe("fake-image-data");
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("throws on non-ok response", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 404,
-      statusText: "Not Found",
-    });
-    await expect(
-      downloadRemoteImageToTemp("https://example.com/missing.png", "/tmp/test"),
-    ).rejects.toThrow("remote media download failed");
-  });
-});
-
-describe("uploadFileToWeixin", () => {
-  it("uploads image file and returns info", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-img-test-"));
-    try {
-      const filePath = path.join(tmpDir, "test.png");
-      await fs.writeFile(filePath, "fake-image-data");
-
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up-param" });
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({ headers: { "x-encrypted-param": "dl-param" } }),
-      );
-
-      const result = await uploadFileToWeixin({
-        filePath,
-        toUserId: "user1",
-        opts: { baseUrl: "https://api.com", metadata, token: "tok" },
-        cdnBaseUrl: "https://cdn.com",
-      });
-
-      expect(result.filekey).toBeDefined();
-      expect(result.downloadEncryptedQueryParam).toBe("dl-param");
-      expect(result.fileSize).toBe(15);
-      expect(result.fileSizeCiphertext).toBe(16);
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("uploads via upload_full_url when upload_param is absent", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-fullurl-test-"));
-    try {
-      const filePath = path.join(tmpDir, "test.png");
-      await fs.writeFile(filePath, "fake-image-data");
-
-      const fullUrl = "http://cdn.example/c2c/upload?encrypted_query_param=x&filekey=y";
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_full_url: fullUrl });
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({ headers: { "x-encrypted-param": "dl-full" } }),
-      );
-
-      const result = await uploadFileToWeixin({
-        filePath,
-        toUserId: "user1",
-        opts: { baseUrl: "https://api.com", metadata, token: "tok" },
-        cdnBaseUrl: "https://ignored-cdn.com",
-      });
-
-      expect(result.downloadEncryptedQueryParam).toBe("dl-full");
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const [calledUrl] = mockFetch.mock.calls[0] as [string, RequestInit];
-      expect(calledUrl).toBe(fullUrl);
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("throws when getUploadUrl returns neither upload_full_url nor upload_param", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-fail-test-"));
-    try {
-      const filePath = path.join(tmpDir, "test.txt");
-      await fs.writeFile(filePath, "data");
-
-      mockGetUploadUrl.mockResolvedValueOnce({});
-
-      await expect(
-        uploadFileToWeixin({
-          filePath,
-          toUserId: "user1",
-          opts: { baseUrl: "https://api.com", metadata },
-          cdnBaseUrl: "https://cdn.com",
-        }),
-      ).rejects.toThrow("no upload URL");
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("retries CDN upload on server error then succeeds", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-retry-test-"));
-    try {
-      const filePath = path.join(tmpDir, "data.bin");
-      await fs.writeFile(filePath, "some data for upload");
-
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
-
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({
-          ok: false,
-          status: 500,
-          headers: { "x-error-message": "server busy" },
-          body: "server busy",
-        }),
-      );
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({ headers: { "x-encrypted-param": "dl-retry" } }),
-      );
-
-      const result = await uploadFileToWeixin({
-        filePath,
-        toUserId: "user1",
-        opts: { baseUrl: "https://api.com", metadata },
-        cdnBaseUrl: "https://cdn.com",
-      });
-      expect(result.downloadEncryptedQueryParam).toBe("dl-retry");
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("throws immediately on CDN client error (4xx)", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-4xx-test-"));
-    try {
-      const filePath = path.join(tmpDir, "data.bin");
-      await fs.writeFile(filePath, "data");
-
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({
-          ok: false,
-          status: 403,
-          headers: { "x-error-message": "forbidden" },
-          body: "forbidden",
-        }),
-      );
-
-      await expect(
-        uploadFileToWeixin({
-          filePath,
-          toUserId: "user1",
-          opts: { baseUrl: "https://api.com", metadata },
-          cdnBaseUrl: "https://cdn.com",
-        }),
-      ).rejects.toThrow("client error");
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("throws when CDN returns no x-encrypted-param after all retries", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-no-param-test-"));
-    try {
-      const filePath = path.join(tmpDir, "data.bin");
-      await fs.writeFile(filePath, "data");
-
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
-
-      for (let i = 0; i < 3; i++) {
-        mockFetch.mockResolvedValueOnce(mockCdnResponse({ headers: {} }));
-      }
-
-      await expect(
-        uploadFileToWeixin({
-          filePath,
-          toUserId: "user1",
-          opts: { baseUrl: "https://api.com", metadata },
-          cdnBaseUrl: "https://cdn.com",
-        }),
-      ).rejects.toThrow("x-encrypted-param");
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("uploadVideoToWeixin", () => {
-  it("uploads video file", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-vid-test-"));
-    try {
-      const filePath = path.join(tmpDir, "clip.mp4");
-      await fs.writeFile(filePath, "fake-video-content");
-
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up-vid" });
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({ headers: { "x-encrypted-param": "dl-vid" } }),
-      );
-
-      const result = await uploadVideoToWeixin({
-        filePath,
-        toUserId: "user1",
-        opts: { baseUrl: "https://api.com", metadata },
-        cdnBaseUrl: "https://cdn.com",
-      });
-
-      expect(result.filekey).toBeDefined();
-      expect(result.downloadEncryptedQueryParam).toBe("dl-vid");
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("uploadFileAttachmentToWeixin", () => {
-  it("uploads file attachment", async () => {
-    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-att-test-"));
-    try {
-      const filePath = path.join(tmpDir, "doc.pdf");
-      await fs.writeFile(filePath, "pdf-content");
-
-      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
-      mockFetch.mockResolvedValueOnce(
-        mockCdnResponse({ headers: { "x-encrypted-param": "dl" } }),
-      );
-
-      const result = await uploadFileAttachmentToWeixin({
-        filePath,
-        fileName: "doc.pdf",
-        toUserId: "user1",
-        opts: { baseUrl: "https://api.com", metadata },
-        cdnBaseUrl: "https://cdn.com",
-      });
-      expect(result.filekey).toBeDefined();
-      expect(result.downloadEncryptedQueryParam).toBe("dl");
-    } finally {
-      fsSync.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-});