@sylphx/video-reader-mcp 0.1.0 → 0.1.1

package/dist/utils/exec.js

@@ -1,56 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-const DEFAULT_TIMEOUT_MS = 120_000;
-const DEFAULT_MAX_BUFFER = 16 * 1024 * 1024;
-export const execBinary = async (binary, args, options = {}) => {
-    const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
-    try {
-        const { stdout, stderr } = await execFileAsync(binary, [...args], {
-            timeout,
-            maxBuffer,
-            encoding: 'utf8',
-        });
-        return {
-            stdout: typeof stdout === 'string' ? stdout : String(stdout),
-            stderr: typeof stderr === 'string' ? stderr : String(stderr),
-        };
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'killed' in error &&
-            error.killed === true &&
-            'signal' in error &&
-            error.signal === 'SIGTERM') {
-            throw new Error(`${binary} timed out after ${timeout}ms`);
-        }
-        throw error;
-    }
-};
-const binaryCache = new Map();
-export const isBinaryAvailable = async (binary) => {
-    const cached = binaryCache.get(binary);
-    if (cached !== undefined)
-        return cached;
-    try {
-        await execFileAsync(binary, ['-version'], { timeout: 5_000, encoding: 'utf8' });
-        binaryCache.set(binary, true);
-        return true;
-    }
-    catch {
-        try {
-            await execFileAsync(binary, ['--version'], { timeout: 5_000, encoding: 'utf8' });
-            binaryCache.set(binary, true);
-            return true;
-        }
-        catch {
-            binaryCache.set(binary, false);
-            return false;
-        }
-    }
-};
-export const clearBinaryCache = () => {
-    binaryCache.clear();
-};

package/dist/utils/ffmpeg.js

@@ -1,66 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { execBinary, isBinaryAvailable } from './exec.js';
-import { parseSubtitleContent } from './subtitles.js';
-const subtitleFormatForStream = (stream) => {
-    const codec = stream.codec_name?.toLowerCase() ?? '';
-    if (codec.includes('webvtt') || codec === 'vtt')
-        return 'vtt';
-    return 'srt';
-};
-export const extractSubtitles = async (videoPath, subtitleStreams) => {
-    const warnings = [];
-    const subtitles = [];
-    if (subtitleStreams.length === 0) {
-        return { subtitles, warnings: ['No embedded subtitle streams found.'] };
-    }
-    const available = await isBinaryAvailable('ffmpeg');
-    if (!available) {
-        return {
-            subtitles,
-            warnings: ['ffmpeg is not installed; subtitle extraction skipped.'],
-        };
-    }
-    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'video-reader-mcp-'));
-    try {
-        for (const stream of subtitleStreams) {
-            const format = subtitleFormatForStream(stream);
-            const extension = format === 'srt' ? 'srt' : 'vtt';
-            const outputPath = path.join(tempDir, `sub-${stream.index}.${extension}`);
-            try {
-                await execBinary('ffmpeg', [
-                    '-hide_banner',
-                    '-y',
-                    '-i',
-                    videoPath,
-                    '-map',
-                    `0:${stream.index}`,
-                    '-c:s',
-                    format === 'srt' ? 'srt' : 'webvtt',
-                    outputPath,
-                ], { timeoutMs: 120_000 });
-                const content = await readFile(outputPath, 'utf8');
-                const cues = parseSubtitleContent(content, format).map((cue) => ({
-                    ...cue,
-                    index: subtitles.length + cue.index,
-                    stream_index: stream.index,
-                    ...(stream.tags?.language ? { language: stream.tags.language } : {}),
-                    provenance: {
-                        method: 'ffmpeg_extract',
-                        format,
-                    },
-                }));
-                subtitles.push(...cues);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                warnings.push(`Subtitle stream ${stream.index} extraction failed: ${message}`);
-            }
-        }
-    }
-    finally {
-        await rm(tempDir, { recursive: true, force: true });
-    }
-    return { subtitles, warnings };
-};

package/dist/utils/ffprobe.js

@@ -1,79 +0,0 @@
-import { execBinary, isBinaryAvailable } from './exec.js';
-export const parseFfprobeJson = (raw) => {
-    const parsed = JSON.parse(raw);
-    return {
-        streams: Array.isArray(parsed.streams) ? parsed.streams : [],
-        format: parsed.format ?? {},
-        chapters: Array.isArray(parsed.chapters) ? parsed.chapters : [],
-    };
-};
-export const secondsToMs = (value) => {
-    if (value === undefined)
-        return 0;
-    const seconds = typeof value === 'number' ? value : Number.parseFloat(value);
-    if (!Number.isFinite(seconds))
-        return 0;
-    return Math.round(seconds * 1000);
-};
-export const mapStreams = (streams) => streams.map((stream) => ({
-    index: stream.index,
-    codec_type: stream.codec_type,
-    ...(stream.codec_name ? { codec_name: stream.codec_name } : {}),
-    ...(stream.tags?.language ? { language: stream.tags.language } : {}),
-    ...(stream.channels !== undefined ? { channels: stream.channels } : {}),
-    ...(stream.sample_rate ? { sample_rate: Number.parseInt(stream.sample_rate, 10) } : {}),
-    ...(stream.width !== undefined ? { width: stream.width } : {}),
-    ...(stream.height !== undefined ? { height: stream.height } : {}),
-    ...(stream.avg_frame_rate ? { avg_frame_rate: stream.avg_frame_rate } : {}),
-    ...(stream.r_frame_rate ? { r_frame_rate: stream.r_frame_rate } : {}),
-    ...(stream.bit_rate ? { bit_rate: Number.parseInt(stream.bit_rate, 10) } : {}),
-    ...(stream.disposition ? { disposition: stream.disposition } : {}),
-    ...(stream.tags ? { tags: stream.tags } : {}),
-}));
-export const mapChapters = (chapters) => (chapters ?? []).map((chapter) => ({
-    id: chapter.id,
-    start_ms: secondsToMs(chapter.start),
-    end_ms: secondsToMs(chapter.end),
-    ...(chapter.tags?.title ? { title: chapter.tags.title } : {}),
-}));
-export const collectProbeWarnings = (probe, includeStreams) => {
-    const warnings = [];
-    const videoStreams = probe.streams.filter((s) => s.codec_type === 'video');
-    const audioStreams = probe.streams.filter((s) => s.codec_type === 'audio');
-    if (includeStreams && videoStreams.length === 0) {
-        warnings.push('No video stream detected.');
-    }
-    if (includeStreams && audioStreams.length === 0) {
-        warnings.push('No audio stream detected.');
-    }
-    for (const stream of videoStreams) {
-        if (stream.avg_frame_rate &&
-            stream.r_frame_rate &&
-            stream.avg_frame_rate !== stream.r_frame_rate) {
-            warnings.push(`Stream ${stream.index}: variable frame rate suspected (avg_frame_rate=${stream.avg_frame_rate}, r_frame_rate=${stream.r_frame_rate}).`);
-        }
-    }
-    const duration = probe.format.duration;
-    if (!duration || Number.parseFloat(duration) <= 0) {
-        warnings.push('Duration unavailable or zero; timeline bounds may be incomplete.');
-    }
-    return warnings;
-};
-export const runFfprobe = async (videoPath) => {
-    const available = await isBinaryAvailable('ffprobe');
-    if (!available) {
-        throw new Error('ffprobe is not installed or not on PATH');
-    }
-    const { stdout } = await execBinary('ffprobe', [
-        '-v',
-        'quiet',
-        '-print_format',
-        'json',
-        '-show_format',
-        '-show_streams',
-        '-show_chapters',
-        videoPath,
-    ], { timeoutMs: 60_000 });
-    return parseFfprobeJson(stdout);
-};
-export const findSubtitleStreams = (streams) => streams.filter((stream) => stream.codec_type === 'subtitle');

package/dist/utils/pathUtils.js

@@ -1,31 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { ErrorCode, VideoError } from './errors.js';
-export const PROJECT_ROOT = process.cwd();
-const canonicalize = (p) => {
-    try {
-        return fs.realpathSync(p);
-    }
-    catch (err) {
-        if (typeof err === 'object' &&
-            err !== null &&
-            'code' in err &&
-            (err.code === 'ENOENT' || err.code === 'ENOTDIR')) {
-            const parent = path.dirname(p);
-            if (parent === p)
-                return p;
-            return path.join(canonicalize(parent), path.basename(p));
-        }
-        throw err;
-    }
-};
-export const resolvePath = (userPath) => {
-    if (typeof userPath !== 'string') {
-        throw new VideoError(ErrorCode.InvalidParams, 'Path must be a string.');
-    }
-    const normalizedUserPath = path.normalize(userPath);
-    const resolved = path.isAbsolute(normalizedUserPath)
-        ? normalizedUserPath
-        : path.resolve(PROJECT_ROOT, normalizedUserPath);
-    return canonicalize(resolved);
-};

package/dist/utils/scenes.js

@@ -1,49 +0,0 @@
-import { execBinary, isBinaryAvailable } from './exec.js';
-const SCENE_PTS_TIME_RE = /pts_time:([0-9.]+)/g;
-export const parseSceneFilterOutput = (stderr, threshold) => {
-    const scenes = [];
-    let match;
-    while ((match = SCENE_PTS_TIME_RE.exec(stderr)) !== null) {
-        const seconds = Number.parseFloat(match[1]);
-        if (!Number.isFinite(seconds))
-            continue;
-        scenes.push({
-            index: scenes.length,
-            time_ms: Math.round(seconds * 1000),
-            provenance: {
-                method: 'ffmpeg_scene_filter',
-                threshold,
-            },
-        });
-    }
-    return scenes;
-};
-export const detectScenes = async (videoPath, threshold) => {
-    const available = await isBinaryAvailable('ffmpeg');
-    if (!available) {
-        return {
-            scenes: [],
-            warning: 'ffmpeg is not installed; scene detection skipped.',
-        };
-    }
-    try {
-        const { stderr } = await execBinary('ffmpeg', [
-            '-hide_banner',
-            '-i',
-            videoPath,
-            '-vf',
-            `select='gt(scene,${threshold})',showinfo`,
-            '-f',
-            'null',
-            '-',
-        ], { timeoutMs: 300_000 });
-        return { scenes: parseSceneFilterOutput(stderr, threshold) };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            scenes: [],
-            warning: `Scene detection failed: ${message}`,
-        };
-    }
-};

package/dist/utils/subtitles.js

@@ -1,85 +0,0 @@
-const parseTimestampToMs = (timestamp) => {
-    const normalized = timestamp.trim().replace(',', '.');
-    const parts = normalized.split(':');
-    if (parts.length !== 3)
-        return 0;
-    const [hours, minutes, secondsPart] = parts;
-    const [seconds, millis = '0'] = secondsPart.split('.');
-    const h = Number.parseInt(hours, 10);
-    const m = Number.parseInt(minutes, 10);
-    const s = Number.parseInt(seconds, 10);
-    const ms = Number.parseInt(millis.padEnd(3, '0').slice(0, 3), 10);
-    return ((h * 60 + m) * 60 + s) * 1000 + ms;
-};
-const stripTags = (text) => text
-    .replace(/<[^>]+>/g, '')
-    .replace(/\{[^}]+\}/g, '')
-    .trim();
-export const parseSrt = (content) => {
-    const blocks = content
-        .replace(/\r\n/g, '\n')
-        .split(/\n{2,}/)
-        .map((block) => block.trim())
-        .filter(Boolean);
-    const cues = [];
-    for (const block of blocks) {
-        const lines = block.split('\n');
-        if (lines.length < 2)
-            continue;
-        const timingLine = lines.find((line) => line.includes('-->'));
-        if (!timingLine)
-            continue;
-        const [startRaw, endRaw] = timingLine.split('-->').map((part) => part.trim());
-        const textLines = lines.filter((line) => line !== lines[0] && !line.includes('-->'));
-        const text = stripTags(textLines.join('\n'));
-        if (!text)
-            continue;
-        cues.push({
-            index: cues.length,
-            start_ms: parseTimestampToMs(startRaw),
-            end_ms: parseTimestampToMs(endRaw),
-            text,
-            provenance: {
-                method: 'embedded_parse',
-                format: 'srt',
-            },
-        });
-    }
-    return cues;
-};
-export const parseVtt = (content) => {
-    const normalized = content.replace(/\r\n/g, '\n');
-    const blocks = normalized
-        .split(/\n{2,}/)
-        .map((block) => block.trim())
-        .filter((block) => block && !block.startsWith('WEBVTT') && !block.startsWith('NOTE'));
-    const cues = [];
-    for (const block of blocks) {
-        const lines = block.split('\n');
-        const timingLine = lines.find((line) => line.includes('-->'));
-        if (!timingLine)
-            continue;
-        const timing = timingLine.split('-->')[0]?.trim() ?? '';
-        const endTiming = timingLine.split('-->')[1]?.trim().split(' ')[0] ?? '';
-        const textLines = lines.filter((line) => !line.includes('-->') && !/^\d+$/.test(line));
-        const text = stripTags(textLines.join('\n'));
-        if (!text)
-            continue;
-        cues.push({
-            index: cues.length,
-            start_ms: parseTimestampToMs(timing),
-            end_ms: parseTimestampToMs(endTiming),
-            text,
-            provenance: {
-                method: 'embedded_parse',
-                format: 'vtt',
-            },
-        });
-    }
-    return cues;
-};
-export const parseSubtitleContent = (content, format) => {
-    if (format === 'srt')
-        return parseSrt(content);
-    return parseVtt(content);
-};

package/dist/video/readCoordinator.js

@@ -1,81 +0,0 @@
-import { access } from 'node:fs/promises';
-import { tryAsrTranscript } from '../utils/asr.js';
-import { extractSubtitles } from '../utils/ffmpeg.js';
-import { collectProbeWarnings, findSubtitleStreams, mapChapters, mapStreams, runFfprobe, secondsToMs, } from '../utils/ffprobe.js';
-import { resolvePath } from '../utils/pathUtils.js';
-import { detectScenes } from '../utils/scenes.js';
-const DEFAULT_SCENE_THRESHOLD = 0.4;
-export const buildTimelineDocument = async (sourcePath, args, version) => {
-    const includeStreams = args.include_streams ?? true;
-    const includeChapters = args.include_chapters ?? true;
-    const includeSubtitles = args.include_subtitles ?? true;
-    const includeScenes = args.include_scenes ?? true;
-    const includeTranscript = args.include_transcript ?? false;
-    const sceneThreshold = args.scene_threshold ?? DEFAULT_SCENE_THRESHOLD;
-    const warnings = [];
-    const probe = await runFfprobe(sourcePath);
-    warnings.push(...collectProbeWarnings(probe, includeStreams));
-    const format = {
-        ...(probe.format.format_name ? { format_name: probe.format.format_name } : {}),
-        duration_ms: secondsToMs(probe.format.duration),
-        ...(probe.format.bit_rate ? { bit_rate: Number.parseInt(probe.format.bit_rate, 10) } : {}),
-        ...(probe.format.size ? { size_bytes: Number.parseInt(probe.format.size, 10) } : {}),
-        ...(probe.format.tags ? { tags: probe.format.tags } : {}),
-    };
-    let subtitles = [];
-    if (includeSubtitles) {
-        const subtitleStreams = findSubtitleStreams(probe.streams);
-        const extracted = await extractSubtitles(sourcePath, subtitleStreams);
-        subtitles = extracted.subtitles;
-        warnings.push(...extracted.warnings);
-    }
-    let scenes = [];
-    if (includeScenes) {
-        const detected = await detectScenes(sourcePath, sceneThreshold);
-        scenes = detected.scenes;
-        if (detected.warning)
-            warnings.push(detected.warning);
-    }
-    let transcript = [];
-    if (includeTranscript) {
-        const asr = await tryAsrTranscript(sourcePath, true);
-        transcript = asr.transcript;
-        if (asr.warning)
-            warnings.push(asr.warning);
-    }
-    return {
-        provenance: {
-            source: sourcePath,
-            tool: 'read_video',
-            version,
-            extracted_at: new Date().toISOString(),
-        },
-        format,
-        streams: includeStreams ? mapStreams(probe.streams) : [],
-        chapters: includeChapters ? mapChapters(probe.chapters) : [],
-        scenes,
-        subtitles,
-        transcript,
-        warnings,
-    };
-};
-export const processVideoSource = async (userPath, args, version) => {
-    try {
-        const sourcePath = resolvePath(userPath);
-        await access(sourcePath);
-        const data = await buildTimelineDocument(sourcePath, args, version);
-        return {
-            source: userPath,
-            success: true,
-            data,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            source: userPath,
-            success: false,
-            error: message,
-        };
-    }
-};