@ascegu/teamily 1.0.28 → 1.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.28",
+  "version": "1.0.29",
   "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 { parseVideoMeta } from "./upload.js";
 
 export type TeamilyMessageHandler = (message: TeamilyMessage) => Promise<void> | void;
 export type TeamilyConnectionState = "connecting" | "connected" | "disconnected" | "error";
@@ -305,11 +306,13 @@ export class TeamilyMonitor {
     const snapshotFile = new File([new Uint8Array(MINIMAL_JPEG)], "snapshot.jpg", {
       type: "image/jpeg",
     });
-    // SDK expects a bare extension ("mp4"), not a MIME type ("video/mp4").
+    // 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);
     const videoExt = fileName.split(".").pop()?.toLowerCase() || "mp4";
     const created = await sdk.createVideoMessageByFile({
       videoPath: "",
-      duration: 0,
+      duration: meta.duration,
       videoType: videoExt,
       snapshotPath: "",
       videoUUID: crypto.randomUUID(),
@@ -318,8 +321,8 @@ export class TeamilyMonitor {
       snapshotUUID: crypto.randomUUID(),
       snapshotSize: MINIMAL_JPEG.length,
       snapshotUrl: "",
-      snapshotWidth: 1,
-      snapshotHeight: 1,
+      snapshotWidth: meta.width || 1,
+      snapshotHeight: meta.height || 1,
       videoFile,
       snapshotFile,
     });

package/src/upload.ts

@@ -117,3 +117,106 @@ export function guessContentType(filePath: string): string {
   };
   return map[ext] ?? "application/octet-stream";
 }
+
+// ---- 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;
+}