@soimy/dingtalk 3.3.0 → 3.4.1

package/src/media-utils.ts

@@ -5,7 +5,6 @@
  * Provides functions for media type detection and file upload to DingTalk media servers.
  */
 
-import * as fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -16,17 +15,35 @@ import axios from "axios";
 import FormData from "form-data";
 import type { DingTalkConfig, Logger } from "./types";
 import { formatDingTalkErrorPayloadLog, getProxyBypassOption } from "./utils";
+import { getDingTalkRuntime } from "./runtime";
+
+/**
+ * Extended PluginRuntime with media bridge support.
+ * The `media.loadWebMedia` method resolves sandbox/container paths
+ * through the runtime bridge when direct host filesystem access fails.
+ */
+interface PluginRuntimeWithMedia {
+  media?: {
+    loadWebMedia(
+      mediaPath: string,
+      options?: { mediaLocalRoots?: string[] },
+    ): Promise<{ buffer: Buffer | ArrayBuffer; fileName?: string; contentType?: string } | null>;
+  };
+  [key: string]: unknown;
+}
 
 /**
  * Calculate MP3 duration in seconds by parsing MPEG frame headers
  * Supports CBR and VBR MP3 files
- * @param filePath Path to the MP3 file
+ * @param filePathOrBuffer Path to the MP3 file, or a pre-read Buffer
  * @param log Optional logger
  * @returns Duration in seconds (0 if parsing fails)
  */
-export async function getMp3DurationSeconds(filePath: string, log?: Logger): Promise<number> {
+export async function getMp3DurationSeconds(filePathOrBuffer: string | Buffer, log?: Logger): Promise<number> {
   try {
-    const buffer = await fsPromises.readFile(filePath);
+    const buffer = typeof filePathOrBuffer === "string"
+      ? await fsPromises.readFile(filePathOrBuffer)
+      : filePathOrBuffer;
     let offset = 0;
 
     // Skip ID3v2 tag if present
@@ -181,7 +198,7 @@ export async function getMp3DurationSeconds(filePath: string, log?: Logger): Pro
       return Math.floor(duration);
     }
 
-    log?.warn?.(`[DingTalk] Could not parse MP3 duration from ${filePath} (found ${frameCount} frames)`);
+    log?.warn?.(`[DingTalk] Could not parse MP3 duration from ${typeof filePathOrBuffer === "string" ? filePathOrBuffer : "<buffer>"} (found ${frameCount} frames)`);
     return 0;
   } catch (err: unknown) {
     log?.error?.(`[DingTalk] Failed to get MP3 duration: ${err instanceof Error ? err.message : String(err)}`);
@@ -195,6 +212,7 @@ export async function getVoiceDurationMs(
   filePath: string,
   mediaType: DingTalkMediaType,
   log?: Logger,
+  options?: { mediaLocalRoots?: string[]; preReadBuffer?: Buffer },
 ): Promise<number> {
   if (mediaType !== "voice") {
     return DEFAULT_VOICE_DURATION_MS;
@@ -203,7 +221,15 @@ export async function getVoiceDurationMs(
   const ext = path.extname(filePath).toLowerCase();
 
   if (ext === ".mp3") {
-    const durationSec = await getMp3DurationSeconds(filePath, log);
+    let durationSec: number;
+    try {
+      // Reuse pre-read buffer from uploadMedia when available to avoid double read
+      const buffer = options?.preReadBuffer
+        ?? (await readMediaBuffer(filePath, options, log)).buffer;
+      durationSec = await getMp3DurationSeconds(buffer, log);
+    } catch {
+      durationSec = 0;
+    }
     if (durationSec > 0) {
       return Math.max(1, Math.round(durationSec * 1000));
     }
@@ -607,36 +633,80 @@ const FILE_SIZE_LIMITS: Record<DingTalkMediaType, number> = {
 };
 
 /**
- * Upload media file to DingTalk and get media_id
- * Uses DingTalk's media upload API: https://oapi.dingtalk.com/media/upload
+ * Read a media file, resolving sandbox/container paths via the runtime bridge
+ * when direct host filesystem access fails.
  *
- * Note: Media files are stored temporarily by DingTalk (not in permanent storage).
- * The media_id can be used in subsequent message sends.
- *
- * @param config DingTalk configuration
- * @param mediaPath Local path to the media file
- * @param mediaType Type of media: 'image' | 'voice' | 'video' | 'file'
- * @param getAccessToken Function to get DingTalk access token
- * @param log Optional logger
- * @returns media_id on success, null on failure
+ * Precedence:
+ *   1. Direct fs.readFile (works for host-local paths)
+ *   2. rt.media.loadWebMedia (resolves sandbox workspace paths via bridge)
  */
+async function readMediaBuffer(
+  mediaPath: string,
+  options?: { mediaLocalRoots?: string[] },
+  log?: Logger,
+): Promise<{ buffer: Buffer; size: number }> {
+  // Try direct host filesystem first
+  try {
+    const buffer = await fsPromises.readFile(mediaPath);
+    return { buffer, size: buffer.length };
+  } catch (err: unknown) {
+    const errno = err as NodeJS.ErrnoException;
+    if (errno.code !== "ENOENT") {
+      throw err; // Permission errors etc. should propagate immediately
+    }
+  }
+
+  // File not found on host — try runtime media bridge (sandbox/container paths)
+  log?.debug?.(`[DingTalk] File not found on host, trying runtime media bridge: ${mediaPath}`);
+  const rt = getDingTalkRuntime() as PluginRuntimeWithMedia;
+  if (!rt.media?.loadWebMedia) {
+    throw Object.assign(
+      new Error(`File not found and runtime media bridge unavailable: ${mediaPath}`),
+      { code: "ENOENT" },
+    );
+  }
+
+  const media = await rt.media.loadWebMedia(mediaPath, {
+    mediaLocalRoots: options?.mediaLocalRoots,
+  });
+
+  if (!media || !media.buffer) {
+    throw Object.assign(
+      new Error(`Runtime media bridge returned no data for: ${mediaPath}`),
+      { code: "ENOENT" },
+    );
+  }
+
+  const buffer = Buffer.isBuffer(media.buffer)
+    ? media.buffer
+    : Buffer.from(media.buffer);
+  return { buffer, size: buffer.length };
+}
+
+export interface UploadMediaResult {
+  mediaId: string;
+  /** The file buffer read during upload, reusable for voice duration parsing etc. */
+  buffer: Buffer;
+}
+
 export async function uploadMedia(
   config: DingTalkConfig,
   mediaPath: string,
   mediaType: DingTalkMediaType,
   getAccessToken: (config: DingTalkConfig, log?: Logger) => Promise<string>,
   log?: Logger,
-): Promise<string | null> {
-  let fileStream: fs.ReadStream | null = null;
-
+  options?: { mediaLocalRoots?: string[] },
+): Promise<UploadMediaResult | null> {
   try {
     const token = await getAccessToken(config, log);
 
-    // Check file size (stat will throw if file doesn't exist)
-    const stats = await fsPromises.stat(mediaPath);
+    // Read file via sandbox-aware bridge (falls back to direct fs for host paths)
+    const { buffer, size } = await readMediaBuffer(mediaPath, options, log);
+
+    // Check file size
     const sizeLimit = FILE_SIZE_LIMITS[mediaType];
-    if (stats.size > sizeLimit) {
-      const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+    if (size > sizeLimit) {
+      const sizeMB = (size / (1024 * 1024)).toFixed(2);
       const limitMB = (sizeLimit / (1024 * 1024)).toFixed(2);
       log?.error?.(
         `[DingTalk] Media file too large: ${sizeMB}MB exceeds ${limitMB}MB limit for ${mediaType}`,
@@ -644,17 +714,15 @@ export async function uploadMedia(
       return null;
     }
 
-    // Read file as a stream for better memory efficiency
-    fileStream = fs.createReadStream(mediaPath);
     const filename = path.basename(mediaPath);
 
     // Upload to DingTalk's media server using form-data
     const form = new FormData();
-    form.append("media", fileStream, { filename });
+    form.append("media", buffer, { filename });
 
     const uploadUrl = `https://oapi.dingtalk.com/media/upload?access_token=${token}&type=${mediaType}`;
 
-    log?.debug?.(`[DingTalk] Uploading media: ${filename} (${stats.size} bytes) as ${mediaType}`);
+    log?.debug?.(`[DingTalk] Uploading media: ${filename} (${size} bytes) as ${mediaType}`);
 
     const response = await axios.post(uploadUrl, form, {
       headers: form.getHeaders(),
@@ -665,9 +733,9 @@ export async function uploadMedia(
 
     if (response.data?.errcode === 0 && response.data?.media_id) {
       log?.debug?.(
-        `[DingTalk] Media uploaded successfully: ${response.data.media_id} (${stats.size} bytes)`,
+        `[DingTalk] Media uploaded successfully: ${response.data.media_id} (${size} bytes)`,
       );
-      return response.data.media_id;
+      return { mediaId: response.data.media_id, buffer };
     } else {
       log?.error?.(`[DingTalk] Media upload failed: ${JSON.stringify(response.data)}`);
       return null;
@@ -676,7 +744,7 @@ export async function uploadMedia(
     // Handle file system errors (e.g., file not found, permission denied)
     const errno = err as NodeJS.ErrnoException;
     if (errno.code === "ENOENT") {
-      log?.error?.(`[DingTalk] Media file not found: ${mediaPath}`);
+      log?.error?.(`[DingTalk] Media file not found (host and sandbox): ${mediaPath}`);
     } else if (errno.code === "EACCES") {
       log?.error?.(`[DingTalk] Permission denied accessing media file: ${mediaPath}`);
     } else {
@@ -690,10 +758,5 @@ export async function uploadMedia(
       }
     }
     return null;
-  } finally {
-    // Ensure file stream is closed even on error
-    if (fileStream) {
-      fileStream.destroy();
-    }
   }
 }