@ascegu/teamily 1.0.28 → 1.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "OpenClaw Teamily channel plugin - Team instant messaging server integration",
   "keywords": [
     "channel",

package/src/monitor.ts

@@ -7,6 +7,7 @@ import type {
   TeamilyAudioContent,
 } from "./types.js";
 import { CONTENT_TYPES, SESSION_TYPES, isGroupSession } from "./types.js";
+import { extractVideoSnapshot, parseVideoMeta } from "./upload.js";
 
 export type TeamilyMessageHandler = (message: TeamilyMessage) => Promise<void> | void;
 export type TeamilyConnectionState = "connecting" | "connected" | "disconnected" | "error";
@@ -300,26 +301,32 @@ export class TeamilyMonitor {
   ): Promise<string> {
     const sdk = this.requireSdk();
     const videoFile = new File([new Uint8Array(buffer)], fileName, { type: contentType });
-    // snapshotFile is required by the SDK; an empty file causes the upload to hang.
-    // Use a minimal valid 1x1 JPEG so the SDK upload succeeds.
-    const snapshotFile = new File([new Uint8Array(MINIMAL_JPEG)], "snapshot.jpg", {
+
+    // Extract real duration/dimensions from the MP4 container so clients
+    // can play the video inline instead of showing a broken player.
+    const meta = parseVideoMeta(buffer);
+
+    // Try to extract a real first-frame snapshot via ffmpeg; fall back to
+    // a minimal 1x1 JPEG placeholder if ffmpeg is unavailable.
+    const snapshotBuf = (await extractVideoSnapshot(buffer)) ?? Buffer.from(MINIMAL_JPEG);
+    const snapshotFile = new File([new Uint8Array(snapshotBuf)], "snapshot.jpg", {
       type: "image/jpeg",
     });
-    // SDK expects a bare extension ("mp4"), not a MIME type ("video/mp4").
+
     const videoExt = fileName.split(".").pop()?.toLowerCase() || "mp4";
     const created = await sdk.createVideoMessageByFile({
       videoPath: "",
-      duration: 0,
+      duration: meta.duration,
       videoType: videoExt,
       snapshotPath: "",
       videoUUID: crypto.randomUUID(),
       videoUrl: "",
       videoSize: buffer.length,
       snapshotUUID: crypto.randomUUID(),
-      snapshotSize: MINIMAL_JPEG.length,
+      snapshotSize: snapshotBuf.length,
       snapshotUrl: "",
-      snapshotWidth: 1,
-      snapshotHeight: 1,
+      snapshotWidth: meta.width || 1,
+      snapshotHeight: meta.height || 1,
       videoFile,
       snapshotFile,
     });

package/src/upload.ts

@@ -117,3 +117,149 @@ export function guessContentType(filePath: string): string {
   };
   return map[ext] ?? "application/octet-stream";
 }
+
+// ---- Video snapshot extraction via ffmpeg ----
+
+/**
+ * Extract the first video frame as a JPEG thumbnail using ffmpeg.
+ * Returns null if ffmpeg is unavailable or extraction fails.
+ * The thumbnail is scaled down to fit within maxDim (default 320px).
+ */
+export async function extractVideoSnapshot(
+  videoBuf: Buffer,
+  maxDim = 320,
+): Promise<Buffer | null> {
+  try {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const { writeFile, readFile, unlink, mkdtemp } = await import("node:fs/promises");
+    const { tmpdir } = await import("node:os");
+    const execFileAsync = promisify(execFile);
+
+    const dir = await mkdtemp(path.join(tmpdir(), "oc-snap-"));
+    const inPath = path.join(dir, "input.mp4");
+    const outPath = path.join(dir, "snapshot.jpg");
+
+    try {
+      await writeFile(inPath, videoBuf);
+      await execFileAsync("ffmpeg", [
+        "-i", inPath,
+        "-vframes", "1",
+        "-vf", `scale='min(${maxDim},iw)':'-1'`,
+        "-q:v", "6",
+        "-y", outPath,
+      ], { timeout: 10_000 });
+      return await readFile(outPath);
+    } finally {
+      await unlink(inPath).catch(() => {});
+      await unlink(outPath).catch(() => {});
+      const { rmdir } = await import("node:fs/promises");
+      await rmdir(dir).catch(() => {});
+    }
+  } catch {
+    return null;
+  }
+}
+
+// ---- MP4 metadata extraction (no external dependencies) ----
+
+export interface VideoMeta {
+  duration: number; // seconds
+  width: number;
+  height: number;
+}
+
+/**
+ * Parse MP4/MOV container to extract duration, width, and height.
+ * Returns zeroed metadata on parse failure (non-MP4, truncated, etc.).
+ */
+export function parseVideoMeta(buf: Buffer): VideoMeta {
+  const fallback: VideoMeta = { duration: 0, width: 0, height: 0 };
+  try {
+    const moov = findBox(buf, 0, buf.length, "moov");
+    if (!moov) return fallback;
+
+    let duration = 0;
+    let width = 0;
+    let height = 0;
+
+    // mvhd → duration & timescale
+    const mvhd = findBox(buf, moov.dataStart, moov.end, "mvhd");
+    if (mvhd) {
+      const ver = buf[mvhd.dataStart];
+      if (ver === 0) {
+        const timescale = buf.readUInt32BE(mvhd.dataStart + 12);
+        const dur = buf.readUInt32BE(mvhd.dataStart + 16);
+        if (timescale > 0) duration = dur / timescale;
+      } else if (ver === 1) {
+        const timescale = buf.readUInt32BE(mvhd.dataStart + 20);
+        // 64-bit duration: read high and low 32-bit parts
+        const durHi = buf.readUInt32BE(mvhd.dataStart + 24);
+        const durLo = buf.readUInt32BE(mvhd.dataStart + 28);
+        const dur = durHi * 0x100000000 + durLo;
+        if (timescale > 0) duration = dur / timescale;
+      }
+    }
+
+    // trak → tkhd → width & height (use first video track)
+    let offset = moov.dataStart;
+    while (offset < moov.end) {
+      const trak = findBox(buf, offset, moov.end, "trak");
+      if (!trak) break;
+      const tkhd = findBox(buf, trak.dataStart, trak.end, "tkhd");
+      if (tkhd) {
+        const ver = buf[tkhd.dataStart];
+        // width/height are fixed-point 16.16 at the end of tkhd
+        const whOffset = ver === 0 ? tkhd.dataStart + 76 : tkhd.dataStart + 88;
+        if (whOffset + 8 <= tkhd.end) {
+          const w = buf.readUInt32BE(whOffset) >> 16;
+          const h = buf.readUInt32BE(whOffset + 4) >> 16;
+          if (w > 0 && h > 0) {
+            width = w;
+            height = h;
+            break; // first video track is enough
+          }
+        }
+      }
+      offset = trak.end;
+    }
+
+    return { duration: Math.round(duration), width, height };
+  } catch {
+    return fallback;
+  }
+}
+
+interface BoxInfo {
+  dataStart: number; // offset right after the 8-byte header
+  end: number; // first byte past this box
+}
+
+/** Find a box by type within [start, end) range. */
+function findBox(
+  buf: Buffer,
+  start: number,
+  end: number,
+  type: string,
+): BoxInfo | null {
+  let offset = start;
+  while (offset + 8 <= end) {
+    let size = buf.readUInt32BE(offset);
+    const boxType = buf.toString("ascii", offset + 4, offset + 8);
+    let headerSize = 8;
+    if (size === 1 && offset + 16 <= end) {
+      // 64-bit extended size
+      const hi = buf.readUInt32BE(offset + 8);
+      const lo = buf.readUInt32BE(offset + 12);
+      size = hi * 0x100000000 + lo;
+      headerSize = 16;
+    }
+    if (size < headerSize) break; // invalid
+    const boxEnd = offset + size;
+    if (boxType === type) {
+      return { dataStart: offset + headerSize, end: Math.min(boxEnd, end) };
+    }
+    offset = boxEnd;
+  }
+  return null;
+}