larkup 0.1.46 → 0.1.47

package/.next/standalone/packages/tools/video-audio/dist/ffmpeg-spawn.js

@@ -0,0 +1,127 @@
+/**
+ * Lightweight ffmpeg/ffprobe helpers using child_process.spawn.
+ *
+ * Replaces the deprecated `fluent-ffmpeg` library with direct process
+ * spawning for maximum compatibility and zero third-party runtime deps.
+ */
+import { spawn } from 'node:child_process';
+/* ------------------------------------------------------------------ */
+/* Binary resolution                                                    */
+/* ------------------------------------------------------------------ */
+let _ffmpegPath = null;
+let _ffprobePath = null;
+/**
+ * Resolve the ffmpeg binary path. Prefers the system binary on PATH;
+ * falls back to `@ffmpeg-installer/ffmpeg` if installed.
+ */
+function resolveFfmpegPath() {
+    if (_ffmpegPath)
+        return _ffmpegPath;
+    // Try @ffmpeg-installer first (bundled binary)
+    try {
+        const installerPath = require.resolve('@ffmpeg-installer/ffmpeg');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const installer = require(installerPath);
+        if (installer?.path) {
+            _ffmpegPath = installer.path;
+            return _ffmpegPath;
+        }
+    }
+    catch {
+        // Not installed — fall through to system binary
+    }
+    _ffmpegPath = 'ffmpeg';
+    return _ffmpegPath;
+}
+function resolveFfprobePath() {
+    if (_ffprobePath)
+        return _ffprobePath;
+    // Try @ffprobe-installer first
+    try {
+        const installerPath = require.resolve('@ffprobe-installer/ffprobe');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const installer = require(installerPath);
+        if (installer?.path) {
+            _ffprobePath = installer.path;
+            return _ffprobePath;
+        }
+    }
+    catch {
+        // Not installed — fall through
+    }
+    _ffprobePath = 'ffprobe';
+    return _ffprobePath;
+}
+/**
+ * Probe a media file for metadata using ffprobe.
+ */
+export function ffprobe(filePath) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-v',
+            'quiet',
+            '-print_format',
+            'json',
+            '-show_format',
+            '-show_streams',
+            filePath,
+        ];
+        const proc = spawn(resolveFfprobePath(), args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const chunks = [];
+        let stderr = '';
+        proc.stdout.on('data', (data) => chunks.push(data));
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(`ffprobe exited with code ${code}: ${stderr}`));
+            }
+            try {
+                const json = JSON.parse(Buffer.concat(chunks).toString());
+                resolve(json);
+            }
+            catch (err) {
+                reject(new Error(`Failed to parse ffprobe output: ${err}`));
+            }
+        });
+        proc.on('error', reject);
+    });
+}
+/**
+ * Run an ffmpeg command and return a promise that resolves on success.
+ */
+export function runFfmpeg(options) {
+    return new Promise((resolve, reject) => {
+        const args = ['-y', ...options.args];
+        const proc = spawn(resolveFfmpegPath(), args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderrBuf = '';
+        proc.stderr.on('data', (data) => {
+            stderrBuf += data.toString();
+            // Process line by line
+            const lines = stderrBuf.split('\n');
+            stderrBuf = lines.pop() ?? '';
+            for (const line of lines) {
+                options.onStderr?.(line);
+                // Parse progress: "time=HH:MM:SS.ms" or "time=SS.ms"
+                if (options.onProgress && options.durationSecs && options.durationSecs > 0) {
+                    const timeMatch = line.match(/time=(\d+):(\d+):(\d+)\.(\d+)/);
+                    if (timeMatch) {
+                        const secs = parseInt(timeMatch[1], 10) * 3600 +
+                            parseInt(timeMatch[2], 10) * 60 +
+                            parseInt(timeMatch[3], 10) +
+                            parseInt(timeMatch[4], 10) / 100;
+                        options.onProgress(Math.min(1, secs / options.durationSecs));
+                    }
+                }
+            }
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                return reject(new Error(`ffmpeg exited with code ${code}`));
+            }
+            resolve();
+        });
+        proc.on('error', reject);
+    });
+}

package/.next/standalone/packages/tools/video-audio/dist/video-processor.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { ffprobe, runFfmpeg } from './ffmpeg-spawn';
 export function extractRunningState(text) {
     const stateLines = [];
     const scorePatterns = [
@@ -182,11 +183,10 @@ export function createEndingSamplingPlan(durationSecs, maxAdditionalFrames) {
     };
 }
 export async function processVideo(videoPath, options) {
-    const ffmpeg = await importFfmpeg();
     await fs.mkdir(options.outputDir, { recursive: true });
     const framesDir = path.join(options.outputDir, 'frames');
     await fs.mkdir(framesDir, { recursive: true });
-    const meta = await probeVideo(ffmpeg, videoPath);
+    const meta = await probeVideo(videoPath);
     const audioPath = path.join(options.outputDir, 'audio.wav');
     const interval = options.frameIntervalSecs ?? 10;
     const maxFrames = options.maxFrames ?? 100;
@@ -197,7 +197,7 @@ export async function processVideo(videoPath, options) {
     };
     const extractAudioPromise = options.skipAudioExtraction
         ? Promise.resolve(undefined)
-        : extractAudio(ffmpeg, videoPath, audioPath, options.threads, (progress) => {
+        : extractAudio(videoPath, audioPath, options.threads, (progress) => {
             audioProgress = Math.max(audioProgress, progress);
             reportExtractionProgress();
         })
@@ -235,9 +235,8 @@ export async function processVideo(videoPath, options) {
     return { audioPath: extractedAudioPath, frames, meta };
 }
 export async function extractSceneFrames(videoPath, options) {
-    const ffmpeg = await importFfmpeg();
     await fs.mkdir(options.outputDir, { recursive: true });
-    const duration = options.durationSecs || (await probeVideo(ffmpeg, videoPath)).durationSecs;
+    const duration = options.durationSecs || (await probeVideo(videoPath)).durationSecs;
     const plan = createVideoSamplingPlan(duration, options.intervalSecs, options.maxFrames);
     const totalPlannedWork = Math.max(1, plan.estimatedFrameCount);
     const periodicWeight = plan.periodicFrameCount / totalPlannedWork;
@@ -274,7 +273,7 @@ export async function extractSceneFrames(videoPath, options) {
     const periodicFrames = plan.periodicFrameCount === 0
         ? []
         : duration >= 2 * 60 * 60
-            ? await extractFramesAtTimestamps(ffmpeg, videoPath, Array.from({ length: plan.periodicFrameCount }, (_, index) => Math.min(Math.max(0, duration - 1), index * plan.periodicIntervalSecs)), {
+            ? await extractFramesAtTimestamps(videoPath, Array.from({ length: plan.periodicFrameCount }, (_, index) => Math.min(Math.max(0, duration - 1), index * plan.periodicIntervalSecs)), {
                 outputDir: options.outputDir,
                 threads: options.threads,
                 onProgress: (progress) => reportProgress(progress * periodicWeight),
@@ -294,38 +293,40 @@ export async function extractSceneFrames(videoPath, options) {
     await fs.mkdir(sceneDir, { recursive: true });
     const pattern = path.join(sceneDir, 'scene_%04d.jpg');
     let timestamps = [];
-    await new Promise((resolve) => {
-        const command = ffmpeg.default(videoPath);
-        const isLongRecording = duration >= 2 * 60 * 60;
-        if (isLongRecording) {
-            command.inputOptions(['-skip_frame nokey']);
-        }
-        command
-            .videoFilters(isLongRecording
-            ? `scale='min(640,iw)':-2,select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo`
-            : `select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo,scale='min(1280,iw)':-2`)
-            .outputOptions([
-            '-vsync vfr',
-            `-frames:v ${plan.sceneFrameCount}`,
-            ...(options.threads ? [`-threads ${options.threads}`] : []),
-        ])
-            .output(pattern)
-            .on('stderr', (line) => {
-            const match = line.match(/pts_time:([0-9.]+)/);
-            if (match)
-                timestamps.push(Number(match[1]));
-        })
-            .on('progress', (progress) => {
-            if (typeof progress.percent === 'number') {
-                reportProgress(periodicWeight + Math.min(1, progress.percent / 100) * sceneWeight);
-            }
-        })
-            .on('end', () => resolve())
-            .on('error', () => {
-            resolve();
-        })
-            .run();
-    });
+    const isLongRecording = duration >= 2 * 60 * 60;
+    const vf = isLongRecording
+        ? `scale='min(640,iw)':-2,select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo`
+        : `select='gt(scene,${threshold})*if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${plan.minimumSceneGapSecs}))',showinfo,scale='min(1280,iw)':-2`;
+    const sceneArgs = [
+        ...(isLongRecording ? ['-skip_frame', 'nokey'] : []),
+        '-i',
+        videoPath,
+        '-vf',
+        vf,
+        '-vsync',
+        'vfr',
+        '-frames:v',
+        String(plan.sceneFrameCount),
+        ...(options.threads ? ['-threads', String(options.threads)] : []),
+        pattern,
+    ];
+    try {
+        await runFfmpeg({
+            args: sceneArgs,
+            durationSecs: duration,
+            onProgress: (percent) => {
+                reportProgress(periodicWeight + percent * sceneWeight);
+            },
+            onStderr: (line) => {
+                const match = line.match(/pts_time:([0-9.]+)/);
+                if (match)
+                    timestamps.push(Number(match[1]));
+            },
+        });
+    }
+    catch {
+        // Scene detection may fail on some codecs — continue with periodic frames
+    }
     reportProgress(periodicWeight + sceneWeight);
     const files = (await fs.readdir(sceneDir))
         .filter((name) => /^scene_\d+\.jpg$/.test(name))
@@ -342,7 +343,7 @@ export async function extractSceneFrames(videoPath, options) {
     const deduplicated = merged.filter((frame, index) => index === 0 || Math.abs(frame.timestampSecs - merged[index - 1].timestampSecs) >= 1);
     return addEndingEvidence(deduplicated);
 }
-async function extractFramesAtTimestamps(ffmpeg, videoPath, timestamps, options) {
+async function extractFramesAtTimestamps(videoPath, timestamps, options) {
     await fs.mkdir(options.outputDir, { recursive: true });
     const results = new Array(timestamps.length);
     let cursor = 0;
@@ -352,19 +353,19 @@ async function extractFramesAtTimestamps(ffmpeg, videoPath, timestamps, options)
             const index = cursor++;
             const timestampSecs = timestamps[index];
             const outputPath = path.join(options.outputDir, `frame_${String(index + 1).padStart(4, '0')}.jpg`);
-            await new Promise((resolve, reject) => {
-                ffmpeg
-                    .default(videoPath)
-                    .seekInput(timestampSecs)
-                    .videoFilters(`scale='min(1280,iw)':-2`)
-                    .outputOptions([
-                    '-frames:v 1',
-                    ...(options.threads ? [`-threads ${options.threads}`] : []),
-                ])
-                    .output(outputPath)
-                    .on('end', () => resolve())
-                    .on('error', (error) => reject(error))
-                    .run();
+            await runFfmpeg({
+                args: [
+                    '-ss',
+                    String(timestampSecs),
+                    '-i',
+                    videoPath,
+                    '-vf',
+                    `scale='min(1280,iw)':-2`,
+                    '-frames:v',
+                    '1',
+                    ...(options.threads ? ['-threads', String(options.threads)] : []),
+                    outputPath,
+                ],
             });
             results[index] = { path: outputPath, timestampSecs };
             completed += 1;
@@ -374,37 +375,32 @@ async function extractFramesAtTimestamps(ffmpeg, videoPath, timestamps, options)
     return results;
 }
 export async function extractFrames(videoPath, options) {
-    const ffmpeg = await importFfmpeg();
     await fs.mkdir(options.outputDir, { recursive: true });
     let duration = options.durationSecs;
     if (!duration) {
-        const meta = await probeVideo(ffmpeg, videoPath);
+        const meta = await probeVideo(videoPath);
         duration = meta.durationSecs;
     }
     const startSecs = Math.max(0, Math.min(options.startSecs ?? 0, duration));
     const rangeDuration = Math.max(0, duration - startSecs);
     const frameCount = Math.max(1, Math.min(Math.ceil(rangeDuration / options.intervalSecs), options.maxFrames));
     const pattern = path.join(options.outputDir, 'frame_%04d.jpg');
-    await new Promise((resolve, reject) => {
-        const command = ffmpeg.default(videoPath);
-        if (startSecs > 0)
-            command.seekInput(startSecs);
-        command
-            .videoFilters(`select='if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${options.intervalSecs}))',scale='min(1280,iw)':-2`)
-            .outputOptions([
-            '-vsync vfr',
-            `-frames:v ${frameCount}`,
-            ...(options.threads ? [`-threads ${options.threads}`] : []),
-        ])
-            .output(pattern)
-            .on('progress', (progress) => {
-            if (typeof progress.percent === 'number') {
-                options.onProgress?.(Math.min(1, progress.percent / 100));
-            }
-        })
-            .on('end', () => resolve())
-            .on('error', (err) => reject(err))
-            .run();
+    await runFfmpeg({
+        args: [
+            ...(startSecs > 0 ? ['-ss', String(startSecs)] : []),
+            '-i',
+            videoPath,
+            '-vf',
+            `select='if(isnan(prev_selected_t),1,gte(t-prev_selected_t,${options.intervalSecs}))',scale='min(1280,iw)':-2`,
+            '-vsync',
+            'vfr',
+            '-frames:v',
+            String(frameCount),
+            ...(options.threads ? ['-threads', String(options.threads)] : []),
+            pattern,
+        ],
+        durationSecs: rangeDuration,
+        onProgress: options.onProgress,
     });
     const files = (await fs.readdir(options.outputDir))
         .filter((name) => /^frame_\d+\.jpg$/.test(name))
@@ -415,45 +411,31 @@ export async function extractFrames(videoPath, options) {
         timestampSecs: startSecs + index * options.intervalSecs,
     }));
 }
-async function importFfmpeg() {
-    const mod = await import('fluent-ffmpeg');
-    return mod;
-}
-function extractAudio(ffmpeg, videoPath, outputPath, threads, onProgress) {
-    return new Promise((resolve, reject) => {
-        let cmd = ffmpeg
-            .default(videoPath)
-            .noVideo()
-            .audioChannels(1)
-            .audioFrequency(16000)
-            .format('wav');
-        if (threads) {
-            cmd = cmd.outputOptions([`-threads ${threads}`]);
-        }
-        cmd
-            .output(outputPath)
-            .on('progress', (progress) => {
-            if (typeof progress.percent === 'number') {
-                onProgress?.(Math.min(1, progress.percent / 100));
-            }
-        })
-            .on('end', () => resolve())
-            .on('error', (err) => reject(err))
-            .run();
+function extractAudio(videoPath, outputPath, threads, onProgress) {
+    return runFfmpeg({
+        args: [
+            '-i',
+            videoPath,
+            '-vn',
+            '-ac',
+            '1',
+            '-ar',
+            '16000',
+            '-f',
+            'wav',
+            ...(threads ? ['-threads', String(threads)] : []),
+            outputPath,
+        ],
+        onProgress,
     });
 }
-function probeVideo(ffmpeg, videoPath) {
-    return new Promise((resolve, reject) => {
-        ffmpeg.default.ffprobe(videoPath, (err, data) => {
-            if (err)
-                return reject(err);
-            const videoStream = data.streams?.find((s) => s.codec_type === 'video');
-            resolve({
-                durationSecs: parseFloat(data.format?.duration ?? '0'),
-                width: videoStream?.width ?? 0,
-                height: videoStream?.height ?? 0,
-                codec: videoStream?.codec_name ?? 'unknown',
-            });
-        });
-    });
+async function probeVideo(videoPath) {
+    const data = await ffprobe(videoPath);
+    const videoStream = data.streams?.find((s) => s.codec_type === 'video');
+    return {
+        durationSecs: parseFloat(data.format?.duration ?? '0'),
+        width: videoStream?.width ?? 0,
+        height: videoStream?.height ?? 0,
+        codec: videoStream?.codec_name ?? 'unknown',
+    };
 }

package/.next/standalone/packages/tools/video-audio/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larkup/tool-video-audio",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "publishConfig": {
     "access": "public"
   },
@@ -25,11 +25,6 @@
     "build": "tsc --outDir dist",
     "type-check": "tsc --noEmit"
   },
-  "dependencies": {},
-  "optionalDependencies": {
-    "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "fluent-ffmpeg": "^2.1.3"
-  },
   "peerDependencies": {
     "@larkup/marketplace": ">=0.1.0"
   },
@@ -40,7 +35,7 @@
   },
   "devDependencies": {
     "@larkup/marketplace": "workspace:*",
-    "@types/fluent-ffmpeg": "^2.1.27",
+    "@types/node": "^26.1.2",
     "typescript": "5.7.3"
   },
   "license": "Apache-2.0",

package/.next/standalone/packages/tools/video-audio/src/audio-processor.ts

@@ -595,18 +595,10 @@ function formatProviderName(provider: string): string {
     .join(' ');
 }
 
-async function importFfmpeg() {
-  return import('fluent-ffmpeg');
-}
-
 async function probeAudioDuration(audioPath: string): Promise<number> {
-  const ffmpeg = await importFfmpeg();
-  return new Promise((resolve, reject) => {
-    ffmpeg.default.ffprobe(audioPath, (error: Error | null, data: any) => {
-      if (error) reject(error);
-      else resolve(Number(data.format?.duration ?? 0));
-    });
-  });
+  const { ffprobe } = await import('./ffmpeg-spawn');
+  const data = await ffprobe(audioPath);
+  return Number(data.format?.duration ?? 0);
 }
 
 async function splitAudio(
@@ -615,30 +607,37 @@ async function splitAudio(
   segmentSecs: number,
   onProgress?: (progress: number) => void | Promise<void>,
 ): Promise<string[]> {
-  const ffmpeg = await importFfmpeg();
+  const { runFfmpeg } = await import('./ffmpeg-spawn');
   const path = await import('node:path');
   const { promises: fs } = await import('node:fs');
   const pattern = path.join(outputDir, 'part_%04d.mp3');
 
-  await new Promise<void>((resolve, reject) => {
-    ffmpeg
-      .default(audioPath)
-      .noVideo()
-      .audioChannels(1)
-      .audioFrequency(16_000)
-      .audioCodec('libmp3lame')
-      .audioBitrate('32k')
-      .format('segment')
-      .outputOptions([`-segment_time ${segmentSecs}`, '-reset_timestamps 1'])
-      .output(pattern)
-      .on('progress', (progress: { percent?: number }) => {
-        if (typeof progress.percent === 'number') {
-          void onProgress?.(Math.max(0, Math.min(1, progress.percent / 100)));
-        }
-      })
-      .on('end', () => resolve())
-      .on('error', reject)
-      .run();
+  const duration = await probeAudioDuration(audioPath);
+  await runFfmpeg({
+    args: [
+      '-i',
+      audioPath,
+      '-vn',
+      '-ac',
+      '1',
+      '-ar',
+      '16000',
+      '-codec:a',
+      'libmp3lame',
+      '-b:a',
+      '32k',
+      '-f',
+      'segment',
+      '-segment_time',
+      String(segmentSecs),
+      '-reset_timestamps',
+      '1',
+      pattern,
+    ],
+    durationSecs: duration,
+    onProgress: (percent) => {
+      void onProgress?.(Math.max(0, Math.min(1, percent)));
+    },
   });
 
   return (await fs.readdir(outputDir))