openclaw-channel-dmwork 0.5.6 → 0.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",

package/src/actions.test.ts

@@ -1,6 +1,12 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { ChannelType } from "./types.js";
 
+// Mock uploadAndSendMedia — the streaming COS upload uses its own SDK internals
+// that can't be tested via fetch mocks alone. Upload logic is tested in inbound.test.ts.
+vi.mock("./inbound.js", () => ({
+  uploadAndSendMedia: vi.fn().mockResolvedValue(undefined),
+}));
+
 /**
  * Tests for message action handlers.
  * All API calls are mocked via global.fetch.
@@ -171,29 +177,9 @@ describe("handleDmworkMessageAction", () => {
 
   describe("send — media only (no text)", () => {
     it("should upload and send media without text", async () => {
-      let uploadCalled = false;
-      let mediaSentPayload: any = null;
-
-      globalThis.fetch = mockFetch({
-        "/v1/bot/upload/credentials": async () => {
-          // Return 404 to trigger fallback to legacy upload
-          return new Response("Not implemented in test", { status: 404 });
-        },
-        "/v1/bot/file/upload": async () => {
-          uploadCalled = true;
-          return jsonResponse({ url: "https://cdn.example.com/file/chat/img.png" });
-        },
-        "/v1/bot/sendMessage": async (_url, init) => {
-          mediaSentPayload = JSON.parse(init?.body as string);
-          return jsonResponse({ message_id: 1, message_seq: 1 });
-        },
-        "https://example.com/image.png": async () => {
-          return new Response(Buffer.from("fake-image"), {
-            status: 200,
-            headers: { "Content-Type": "image/png" },
-          });
-        },
-      });
+      const { uploadAndSendMedia } = await import("./inbound.js");
+      const uploadSpy = vi.mocked(uploadAndSendMedia);
+      uploadSpy.mockClear();
 
       const { handleDmworkMessageAction } = await import("./actions.js");
       const result = await handleDmworkMessageAction({
@@ -204,35 +190,28 @@ describe("handleDmworkMessageAction", () => {
       });
 
       expect(result.ok).toBe(true);
-      expect(uploadCalled).toBe(true);
+      expect(uploadSpy).toHaveBeenCalledOnce();
+      expect(uploadSpy.mock.calls[0][0]).toMatchObject({
+        mediaUrl: "https://example.com/image.png",
+        channelId: "uid1",
+      });
     });
   });
 
   describe("send — media + text", () => {
     it("should send both text and media", async () => {
       let textSent = false;
-      let uploadCalled = false;
+
+      const { uploadAndSendMedia } = await import("./inbound.js");
+      const uploadSpy = vi.mocked(uploadAndSendMedia);
+      uploadSpy.mockClear();
 
       globalThis.fetch = mockFetch({
-        "/v1/bot/upload/credentials": async () => {
-          // Return 404 to trigger fallback to legacy upload
-          return new Response("Not implemented in test", { status: 404 });
-        },
-        "/v1/bot/file/upload": async () => {
-          uploadCalled = true;
-          return jsonResponse({ url: "https://cdn.example.com/file/chat/doc.pdf" });
-        },
         "/v1/bot/sendMessage": async (_url, init) => {
           const body = JSON.parse(init?.body as string);
           if (body.payload?.content) textSent = true;
           return jsonResponse({ message_id: 1, message_seq: 1 });
         },
-        "https://example.com/doc.pdf": async () => {
-          return new Response(Buffer.from("fake-pdf"), {
-            status: 200,
-            headers: { "Content-Type": "application/pdf" },
-          });
-        },
       });
 
       const { handleDmworkMessageAction } = await import("./actions.js");
@@ -249,7 +228,7 @@ describe("handleDmworkMessageAction", () => {
 
       expect(result.ok).toBe(true);
       expect(textSent).toBe(true);
-      expect(uploadCalled).toBe(true);
+      expect(uploadSpy).toHaveBeenCalledOnce();
     });
   });
 

package/src/api-fetch.test.ts

@@ -494,6 +494,144 @@ describe("fetchBotGroups — null response", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// parseImageDimensionsFromFile — streaming dimension parser
+// ---------------------------------------------------------------------------
+describe("parseImageDimensionsFromFile", () => {
+  it("should parse dimensions from a valid PNG file", async () => {
+    const { writeFileSync, mkdirSync, unlinkSync } = await import("node:fs");
+    const { join } = await import("node:path");
+
+    // Create a minimal valid PNG (1x1 pixel)
+    const pngHeader = Buffer.from([
+      0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature
+      0x00, 0x00, 0x00, 0x0D, // IHDR chunk length
+      0x49, 0x48, 0x44, 0x52, // "IHDR"
+      0x00, 0x00, 0x00, 0x64, // width = 100
+      0x00, 0x00, 0x00, 0xC8, // height = 200
+      0x08, 0x02, 0x00, 0x00, 0x00, // bit depth, color type, etc.
+    ]);
+    const tmpDir = join("/tmp", "test-dims");
+    mkdirSync(tmpDir, { recursive: true });
+    const tmpFile = join(tmpDir, "test.png");
+    writeFileSync(tmpFile, pngHeader);
+
+    try {
+      const { parseImageDimensionsFromFile } = await import("./api-fetch.js");
+      const dims = await parseImageDimensionsFromFile(tmpFile, "image/png");
+      expect(dims).toEqual({ width: 100, height: 200 });
+    } finally {
+      unlinkSync(tmpFile);
+    }
+  });
+
+  it("should return null for non-existent file", async () => {
+    const { parseImageDimensionsFromFile } = await import("./api-fetch.js");
+    const dims = await parseImageDimensionsFromFile("/tmp/nonexistent-test-file.png", "image/png");
+    expect(dims).toBeNull();
+  });
+
+  it("should return null for unsupported mime type", async () => {
+    const { writeFileSync, mkdirSync, unlinkSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const tmpFile = join("/tmp", "test-dims", "test.txt");
+    mkdirSync(join("/tmp", "test-dims"), { recursive: true });
+    writeFileSync(tmpFile, "not an image");
+
+    try {
+      const { parseImageDimensionsFromFile } = await import("./api-fetch.js");
+      const dims = await parseImageDimensionsFromFile(tmpFile, "text/plain");
+      expect(dims).toBeNull();
+    } finally {
+      unlinkSync(tmpFile);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getUploadCredentials — validates response shape
+// ---------------------------------------------------------------------------
+describe("getUploadCredentials", () => {
+  const originalFetch = global.fetch;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  it("should return credentials on valid response", async () => {
+    const fakeCreds = {
+      bucket: "my-bucket",
+      region: "ap-guangzhou",
+      key: "uploads/test.png",
+      credentials: {
+        tmpSecretId: "id123",
+        tmpSecretKey: "key456",
+        sessionToken: "tok789",
+      },
+      startTime: 1000,
+      expiredTime: 2000,
+      cdnBaseUrl: "https://cdn.example.com",
+    };
+
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue(fakeCreds),
+    }) as unknown as typeof fetch;
+
+    const { getUploadCredentials } = await import("./api-fetch.js");
+    const result = await getUploadCredentials({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+      filename: "test.png",
+    });
+
+    expect(result.bucket).toBe("my-bucket");
+    expect(result.credentials.tmpSecretId).toBe("id123");
+  });
+
+  it("should throw on non-ok response", async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 403,
+      text: vi.fn().mockResolvedValue("Forbidden"),
+      statusText: "Forbidden",
+    }) as unknown as typeof fetch;
+
+    const { getUploadCredentials } = await import("./api-fetch.js");
+    await expect(
+      getUploadCredentials({
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+        filename: "test.png",
+      }),
+    ).rejects.toThrow("403");
+  });
+
+  it("should throw on incomplete response (missing bucket)", async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue({
+        region: "ap-guangzhou",
+        key: "uploads/test.png",
+        credentials: { tmpSecretId: "id", tmpSecretKey: "key", sessionToken: "tok" },
+      }),
+    }) as unknown as typeof fetch;
+
+    const { getUploadCredentials } = await import("./api-fetch.js");
+    await expect(
+      getUploadCredentials({
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+        filename: "test.png",
+      }),
+    ).rejects.toThrow("incomplete");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // sendMediaMessage — Image vs File payload shape
 // ---------------------------------------------------------------------------

package/src/api-fetch.ts

@@ -5,6 +5,7 @@
 
 import { ChannelType, MessageType } from "./types.js";
 import path from "path";
+import { open } from "node:fs/promises";
 // @ts-ignore — cos-nodejs-sdk-v5 has incomplete TypeScript definitions
 import COS from "cos-nodejs-sdk-v5";
 
@@ -144,6 +145,23 @@ export function parseImageDimensions(buf: Buffer, mime: string): { width: number
   return null;
 }
 
+/**
+ * Parse image dimensions from a file path by reading only the first 64KB.
+ * Avoids loading the entire file into memory.
+ */
+export async function parseImageDimensionsFromFile(filePath: string, mime: string): Promise<{ width: number; height: number } | null> {
+  const HEADER_SIZE = 65536; // 64KB — enough for PNG/JPEG/GIF/WebP headers
+  let fh: Awaited<ReturnType<typeof open>> | undefined;
+  try {
+    fh = await open(filePath, "r");
+    const buf = Buffer.alloc(HEADER_SIZE);
+    const { bytesRead } = await fh.read(buf, 0, HEADER_SIZE, 0);
+    return parseImageDimensions(buf.subarray(0, bytesRead), mime);
+  } catch { /* ignore read/parse errors */ }
+  finally { await fh?.close(); }
+  return null;
+}
+
 export async function sendMessage(params: {
   apiUrl: string;
   botToken: string;
@@ -522,7 +540,8 @@ export async function uploadFileToCOS(params: {
   bucket: string;
   region: string;
   key: string;
-  fileBuffer: Buffer;
+  fileBody: Buffer | NodeJS.ReadableStream;
+  fileSize?: number;
   contentType: string;
   cdnBaseUrl?: string;
 }): Promise<{ url: string }> {
@@ -534,13 +553,18 @@ export async function uploadFileToCOS(params: {
     ExpiredTime: params.expiredTime,
   } as any);
 
+  const putParams: Record<string, unknown> = {
+    Bucket: params.bucket,
+    Region: params.region,
+    Key: params.key,
+    Body: params.fileBody,
+  };
+  if (params.fileSize != null) {
+    putParams.ContentLength = params.fileSize;
+  }
+
   return new Promise((resolve, reject) => {
-    cos.putObject({
-      Bucket: params.bucket,
-      Region: params.region,
-      Key: params.key,
-      Body: params.fileBuffer,
-    } as any, (err: any, data: any) => {
+    cos.putObject(putParams as any, (err: any, data: any) => {
       if (err) {
         reject(new Error(`COS upload failed: ${err.message || JSON.stringify(err)}`));
       } else {

package/src/channel.ts

@@ -11,7 +11,7 @@ import {
   resolveDmworkAccount,
   type ResolvedDmworkAccount,
 } from "./accounts.js";
-import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContentType, fetchBotGroups, getGroupMd, parseImageDimensions, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
+import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContentType, fetchBotGroups, getGroupMd, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
 import { WKSocket } from "./socket.js";
 import { handleInboundMessage, type DmworkStatusSink } from "./inbound.js";
 import { ChannelType, MessageType, type BotMessage, type MessagePayload } from "./types.js";
@@ -19,13 +19,64 @@ import { parseMentions } from "./mention-utils.js";
 import { handleDmworkMessageAction, parseTarget } from "./actions.js";
 import { createDmworkManagementTools } from "./agent-tools.js";
 import { getOrCreateGroupMdCache, registerBotGroupIds, getKnownGroupIds } from "./group-md.js";
-import path from "path";
-import os from "os";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { mkdir, readFile, writeFile, unlink } from "node:fs/promises";
+import { createReadStream, createWriteStream, statSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
 // HistoryEntry type - compatible with any version
 type HistoryEntry = { sender: string; body: string; timestamp: number };
 const DEFAULT_GROUP_HISTORY_LIMIT = 20;
 
+const MAX_UPLOAD_SIZE = 500 * 1024 * 1024; // 500 MB
+const UPLOAD_TEMP_DIR = path.join("/tmp", "dmwork-upload");
+
+/** Download a URL to a temp file with backpressure, return the temp path. */
+async function downloadToTempFile(url: string, filename: string, signal?: AbortSignal): Promise<{ tempPath: string; contentType: string | undefined }> {
+  await mkdir(UPLOAD_TEMP_DIR, { recursive: true });
+  const tempPath = path.join(UPLOAD_TEMP_DIR, `${randomUUID()}-${filename}`);
+
+  // HEAD to check size first
+  const head = await fetch(url, { method: "HEAD", signal: signal ?? AbortSignal.timeout(30_000) });
+  const contentLength = Number(head.headers.get("content-length") || 0);
+  if (contentLength > MAX_UPLOAD_SIZE) {
+    throw new Error(`File too large (${contentLength} bytes, max ${MAX_UPLOAD_SIZE})`);
+  }
+
+  const resp = await fetch(url, { signal: signal ?? AbortSignal.timeout(300_000) });
+  if (!resp.ok) throw new Error(`Failed to download media from ${url}: ${resp.status}`);
+  const contentType = resp.headers.get("content-type") ?? undefined;
+
+  const body = resp.body;
+  if (!body) throw new Error(`No response body from ${url}`);
+  const nodeStream = Readable.fromWeb(body as any);
+  const ws = createWriteStream(tempPath);
+  try {
+    await pipeline(nodeStream, ws);
+  } catch (err) {
+    // Cleanup partial temp file on download failure
+    await unlink(tempPath).catch(() => {});
+    throw err;
+  }
+  return { tempPath, contentType };
+}
+
+/** Cleanup old temp upload files (>1h). Called opportunistically. */
+async function cleanupOldUploadTempFiles(): Promise<void> {
+  try {
+    const { readdir, stat, unlink: rm } = await import("node:fs/promises");
+    const files = await readdir(UPLOAD_TEMP_DIR);
+    const now = Date.now();
+    for (const f of files) {
+      const fp = path.join(UPLOAD_TEMP_DIR, f);
+      const st = await stat(fp).catch(() => null);
+      if (st && now - st.mtimeMs > 3600_000) await rm(fp).catch(() => {});
+    }
+  } catch { /* dir may not exist */ }
+}
+
 // Module-level history storage — survives auto-restarts
 const _historyMaps = new Map<string, Map<string, any[]>>();
 function getOrCreateHistoryMap(accountId: string): Map<string, any[]> {
@@ -337,10 +388,16 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         throw new Error("sendMedia called without mediaUrl");
       }
 
-      // 1. Download the file
-      let fileBuffer: Buffer;
+      // 1. Resolve file — stream-based for HTTP/file paths, Buffer for data URIs
+      let fileBody: Buffer | NodeJS.ReadableStream;
+      let fileSize: number;
       let contentType: string | undefined;
       let filename: string;
+      let tempPath: string | undefined; // temp file we created (will be cleaned up)
+      let localFilePath: string | undefined; // path for parseImageDimensionsFromFile
+
+      // Opportunistic cleanup of stale temp files
+      cleanupOldUploadTempFiles().catch(() => {});
 
       if (mediaUrl.startsWith("data:")) {
         // Parse data URI: data:[<mediatype>][;base64],<data>
@@ -349,7 +406,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           throw new Error("Invalid data URI format");
         }
         contentType = match[1] || "application/octet-stream";
-        fileBuffer = Buffer.from(match[2], "base64");
+        const buf = Buffer.from(match[2], "base64");
+        fileBody = buf;
+        fileSize = buf.length;
         // Generate a reasonable filename from MIME type
         const extMap: Record<string, string> = {
           "text/markdown": ".md", "text/plain": ".txt", "application/pdf": ".pdf",
@@ -365,81 +424,97 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         }
       } else if (mediaUrl.startsWith("file://")) {
         const filePath = decodeURIComponent(mediaUrl.slice(7));
-        fileBuffer = await readFile(filePath);
+        const st = statSync(filePath);
+        if (st.size > MAX_UPLOAD_SIZE) {
+          throw new Error(`File too large (${st.size} bytes, max ${MAX_UPLOAD_SIZE})`);
+        }
+        localFilePath = filePath;
+        fileBody = createReadStream(filePath);
+        fileSize = st.size;
         filename = path.basename(filePath);
         contentType = inferContentType(filename);
       } else {
-        const resp = await fetch(mediaUrl, { signal: AbortSignal.timeout(300_000) });
-        if (!resp.ok) {
-          throw new Error(`Failed to download media from ${mediaUrl}: ${resp.status}`);
-        }
-        fileBuffer = Buffer.from(await resp.arrayBuffer());
-        contentType = resp.headers.get("content-type") ?? undefined;
-        // Extract filename from URL path
+        // HTTP(S) URL — stream download to temp file to avoid buffering in memory
         const urlPath = new URL(mediaUrl).pathname;
         filename = path.basename(urlPath) || "file";
-        if (!contentType) {
-          contentType = inferContentType(filename);
-        }
+        const dl = await downloadToTempFile(mediaUrl, filename);
+        tempPath = dl.tempPath;
+        localFilePath = dl.tempPath;
+        contentType = dl.contentType;
+        if (!contentType) contentType = inferContentType(filename);
+        const st = statSync(tempPath);
+        fileBody = createReadStream(tempPath);
+        fileSize = st.size;
       }
 
       contentType = contentType || "application/octet-stream";
 
-      // 2. Upload to COS via STS credentials (putObject supports Buffer directly)
-      const creds = await getUploadCredentials({
-        apiUrl: account.config.apiUrl,
-        botToken: account.config.botToken,
-        filename,
-      });
-      const { url: cdnUrl } = await uploadFileToCOS({
-        credentials: creds.credentials,
-        startTime: creds.startTime,
-        expiredTime: creds.expiredTime,
-        bucket: creds.bucket,
-        region: creds.region,
-        key: creds.key,
-        fileBuffer,
-        contentType,
-        cdnBaseUrl: creds.cdnBaseUrl,
-      });
-
-      // 4. Parse target using shared parseTarget + knownGroupIds
-      let targetForParse = ctx.to;
-      if (ctx.to.startsWith("group:")) {
-        const groupPart = ctx.to.slice(6);
-        const atIdx = groupPart.indexOf("@");
-        if (atIdx >= 0) targetForParse = "group:" + groupPart.slice(0, atIdx);
-      }
-      const { channelId, channelType } = parseTarget(targetForParse, undefined, getKnownGroupIds());
-
-      // 5. Determine message type and send
-      const msgType = contentType.startsWith("image/")
-        ? MessageType.Image
-        : MessageType.File;
-
-      if (msgType === MessageType.Image) {
-        const dims = parseImageDimensions(fileBuffer, contentType);
-        await sendMediaMessage({
+      try {
+        // 2. Upload to COS via STS credentials (stream mode)
+        const creds = await getUploadCredentials({
           apiUrl: account.config.apiUrl,
           botToken: account.config.botToken,
-          channelId,
-          channelType,
-          type: msgType,
-          url: cdnUrl,
-          width: dims?.width,
-          height: dims?.height,
+          filename,
         });
-      } else {
-        await sendMediaMessage({
-          apiUrl: account.config.apiUrl,
-          botToken: account.config.botToken,
-          channelId,
-          channelType,
-          type: msgType,
-          url: cdnUrl,
-          name: filename,
-          size: fileBuffer.length,
+        const { url: cdnUrl } = await uploadFileToCOS({
+          credentials: creds.credentials,
+          startTime: creds.startTime,
+          expiredTime: creds.expiredTime,
+          bucket: creds.bucket,
+          region: creds.region,
+          key: creds.key,
+          fileBody,
+          fileSize,
+          contentType,
+          cdnBaseUrl: creds.cdnBaseUrl,
         });
+
+        // 3. Parse target using shared parseTarget + knownGroupIds
+        let targetForParse = ctx.to;
+        if (ctx.to.startsWith("group:")) {
+          const groupPart = ctx.to.slice(6);
+          const atIdx = groupPart.indexOf("@");
+          if (atIdx >= 0) targetForParse = "group:" + groupPart.slice(0, atIdx);
+        }
+        const { channelId, channelType } = parseTarget(targetForParse, undefined, getKnownGroupIds());
+
+        // 4. Determine message type and send
+        const msgType = contentType.startsWith("image/")
+          ? MessageType.Image
+          : MessageType.File;
+
+        if (msgType === MessageType.Image) {
+          // For images, parse dimensions from file or buffer
+          const dims = localFilePath
+            ? await parseImageDimensionsFromFile(localFilePath, contentType)
+            : Buffer.isBuffer(fileBody)
+              ? parseImageDimensions(fileBody, contentType)
+              : null;
+          await sendMediaMessage({
+            apiUrl: account.config.apiUrl,
+            botToken: account.config.botToken,
+            channelId,
+            channelType,
+            type: msgType,
+            url: cdnUrl,
+            width: dims?.width,
+            height: dims?.height,
+          });
+        } else {
+          await sendMediaMessage({
+            apiUrl: account.config.apiUrl,
+            botToken: account.config.botToken,
+            channelId,
+            channelType,
+            type: msgType,
+            url: cdnUrl,
+            name: filename,
+            size: fileSize,
+          });
+        }
+      } finally {
+        // Cleanup temp file
+        if (tempPath) await unlink(tempPath).catch(() => {});
       }
 
       return { channel: "dmwork", to: ctx.to, messageId: "" };

package/src/inbound.ts

@@ -1,5 +1,5 @@
 import type { ChannelLogSink, OpenClawConfig } from "openclaw/plugin-sdk";
-import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, postJson, sendMediaMessage, inferContentType, parseImageDimensions, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
+import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, postJson, sendMediaMessage, inferContentType, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
 import type { ResolvedDmworkAccount } from "./accounts.js";
 import type { BotMessage } from "./types.js";
 import { ChannelType, MessageType } from "./types.js";
@@ -77,68 +77,110 @@ export async function uploadAndSendMedia(params: {
 }): Promise<void> {
   const { mediaUrl, apiUrl, botToken, channelId, channelType, log } = params;
 
-  // Handle local file path or remote URL
-  let buffer: Buffer;
+  const { createReadStream: fsCreateReadStream, statSync: fsStatSync, createWriteStream: fsCreateWriteStream } = await import("node:fs");
+  const { basename, join: pathJoin } = await import("node:path");
+  const { mkdir: fsMkdir, unlink: fsUnlink } = await import("node:fs/promises");
+  const { randomUUID } = await import("node:crypto");
+  const { pipeline } = await import("node:stream/promises");
+  const { Readable } = await import("node:stream");
+
+  const MAX_UPLOAD = 500 * 1024 * 1024;
+  const TEMP_DIR = pathJoin("/tmp", "dmwork-upload");
+
+  let fileBody: Buffer | NodeJS.ReadableStream;
+  let fileSize: number;
   let contentType: string;
   let filename: string;
+  let tempPath: string | undefined;
 
   if (mediaUrl.startsWith("http://") || mediaUrl.startsWith("https://")) {
+    filename = extractFilename(mediaUrl);
+    // Stream download to temp file
+    await fsMkdir(TEMP_DIR, { recursive: true });
+    tempPath = pathJoin(TEMP_DIR, `${randomUUID()}-${filename}`);
+
+    const head = await fetch(mediaUrl, { method: "HEAD" });
+    const cl = Number(head.headers.get("content-length") || 0);
+    if (cl > MAX_UPLOAD) throw new Error(`File too large (${cl} bytes, max ${MAX_UPLOAD})`);
+
     const resp = await fetch(mediaUrl);
     if (!resp.ok) throw new Error(`Failed to fetch media: ${resp.status}`);
-    buffer = Buffer.from(await resp.arrayBuffer());
     contentType = resp.headers.get("content-type") || "application/octet-stream";
-    filename = extractFilename(mediaUrl);
+
+    const body = resp.body;
+    if (!body) throw new Error(`No response body from ${mediaUrl}`);
+    const nodeStream = Readable.fromWeb(body as any);
+    const ws = fsCreateWriteStream(tempPath);
+    try {
+      await pipeline(nodeStream, ws);
+    } catch (err) {
+      // Cleanup partial temp file on download failure
+      await fsUnlink(tempPath).catch(() => {});
+      tempPath = undefined;
+      throw err;
+    }
+
+    const st = fsStatSync(tempPath);
+    fileBody = fsCreateReadStream(tempPath);
+    fileSize = st.size;
   } else {
-    // Local file path
-    const { readFileSync } = await import("node:fs");
-    const { basename } = await import("node:path");
-    buffer = readFileSync(mediaUrl);
+    // Local file path — stream, don't buffer
+    const st = fsStatSync(mediaUrl);
+    if (st.size > MAX_UPLOAD) throw new Error(`File too large (${st.size} bytes, max ${MAX_UPLOAD})`);
+    fileBody = fsCreateReadStream(mediaUrl);
+    fileSize = st.size;
     filename = basename(mediaUrl);
     contentType = inferContentType(filename);
   }
 
-  // Upload directly to COS via STS credentials (putObject supports Buffer directly)
-  const creds = await getUploadCredentials({ apiUrl, botToken, filename });
-  const { url: uploadedUrl } = await uploadFileToCOS({
-    credentials: creds.credentials,
-    startTime: creds.startTime,
-    expiredTime: creds.expiredTime,
-    bucket: creds.bucket,
-    region: creds.region,
-    key: creds.key,
-    fileBuffer: buffer,
-    contentType,
-    cdnBaseUrl: creds.cdnBaseUrl,
-  });
+  try {
+    // Upload to COS via STS credentials (stream mode)
+    const creds = await getUploadCredentials({ apiUrl, botToken, filename });
+    const { url: uploadedUrl } = await uploadFileToCOS({
+      credentials: creds.credentials,
+      startTime: creds.startTime,
+      expiredTime: creds.expiredTime,
+      bucket: creds.bucket,
+      region: creds.region,
+      key: creds.key,
+      fileBody,
+      fileSize,
+      contentType,
+      cdnBaseUrl: creds.cdnBaseUrl,
+    });
 
-  // Determine message type from MIME
-  const isImage = contentType.startsWith("image/");
-  const msgType = isImage ? MessageType.Image : MessageType.File;
-
-  // For images, try to read dimensions from the buffer
-  let width: number | undefined;
-  let height: number | undefined;
-  if (isImage) {
-    const dims = parseImageDimensions(buffer, contentType);
-    width = dims?.width;
-    height = dims?.height;
-  }
+    // Determine message type from MIME
+    const isImage = contentType.startsWith("image/");
+    const msgType = isImage ? MessageType.Image : MessageType.File;
+
+    // For images, parse dimensions from file (not full buffer)
+    let width: number | undefined;
+    let height: number | undefined;
+    if (isImage) {
+      const fileToParse = tempPath ?? mediaUrl;
+      const dims = await parseImageDimensionsFromFile(fileToParse, contentType);
+      width = dims?.width;
+      height = dims?.height;
+    }
 
-  log?.info?.(`dmwork: uploaded media as ${isImage ? "image" : "file"}: ${filename}${width ? ` (${width}x${height})` : ""}`);
-
-  // Send via sendMessage
-  await sendMediaMessage({
-    apiUrl,
-    botToken,
-    channelId,
-    channelType,
-    type: msgType,
-    url: uploadedUrl,
-    name: isImage ? undefined : filename,
-    size: isImage ? undefined : buffer.length,
-    width,
-    height,
-  });
+    log?.info?.(`dmwork: uploaded media as ${isImage ? "image" : "file"}: ${filename}${width ? ` (${width}x${height})` : ""}`);
+
+    // Send via sendMessage
+    await sendMediaMessage({
+      apiUrl,
+      botToken,
+      channelId,
+      channelType,
+      type: msgType,
+      url: uploadedUrl,
+      name: isImage ? undefined : filename,
+      size: isImage ? undefined : fileSize,
+      width,
+      height,
+    });
+  } finally {
+    if (tempPath) await fsUnlink(tempPath).catch(() => {});
+  }
 }
 
 /** Guess MIME type from file extension */