@sylphx/video-reader-mcp 0.1.0 → 0.1.2

package/dist/mcp.js

@@ -1,181 +0,0 @@
-import { createHash, timingSafeEqual } from 'node:crypto';
-import { createServer as createHttpServer } from 'node:http';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { z } from 'zod';
-export const text = (value) => ({ type: 'text', text: value });
-export const image = (data, mimeType) => ({
-    type: 'image',
-    data,
-    mimeType,
-});
-export const toolError = (message) => ({
-    content: [text(message)],
-    isError: true,
-});
-class ToolBuilder {
-    #description;
-    #inputSchema;
-    constructor(descriptionValue, inputSchema) {
-        this.#description = descriptionValue;
-        this.#inputSchema = inputSchema;
-    }
-    description(value) {
-        return new ToolBuilder(value, this.#inputSchema);
-    }
-    input(schema) {
-        return new ToolBuilder(this.#description, schema);
-    }
-    handler(handler) {
-        return {
-            description: this.#description ?? '',
-            inputSchema: this.#inputSchema ?? z.object({}),
-            handler,
-        };
-    }
-}
-export const tool = () => new ToolBuilder();
-export const stdio = () => ({ kind: 'stdio' });
-export const http = (config) => ({ kind: 'http', ...config });
-const isCallToolResult = (result) => typeof result === 'object' && result !== null && 'content' in result;
-const isContentArray = (result) => Array.isArray(result);
-const normalizeToolResult = (result) => {
-    if (isContentArray(result))
-        return { content: [...result] };
-    if (isCallToolResult(result))
-        return result;
-    return { content: [result] };
-};
-const withCors = (res, origin) => {
-    if (!origin)
-        return;
-    res.setHeader('Access-Control-Allow-Origin', origin);
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, MCP-Protocol-Version, Mcp-Session-Id, X-API-Key');
-};
-const isApiKeyValid = (configuredKey, presented) => {
-    const provided = Array.isArray(presented) ? presented[0] : presented;
-    if (typeof provided !== 'string' || provided.length === 0)
-        return false;
-    const expected = createHash('sha256').update(configuredKey).digest();
-    const actual = createHash('sha256').update(provided).digest();
-    return timingSafeEqual(expected, actual);
-};
-const unauthorized = (res) => {
-    res.writeHead(401, { 'Content-Type': 'application/json', 'WWW-Authenticate': 'X-API-Key' });
-    res.end(JSON.stringify({
-        jsonrpc: '2.0',
-        id: null,
-        error: { code: -32001, message: 'Unauthorized: missing or invalid X-API-Key header' },
-    }));
-};
-const ensureStreamableAcceptHeader = (req) => {
-    const accept = req.headers.accept;
-    const acceptValues = Array.isArray(accept) ? accept.join(', ') : (accept ?? '');
-    if (acceptValues.includes('application/json') && acceptValues.includes('text/event-stream')) {
-        return;
-    }
-    req.headers.accept = 'application/json, text/event-stream';
-    const rawAcceptIndex = req.rawHeaders.findIndex((value, index) => index % 2 === 0 && value.toLowerCase() === 'accept');
-    if (rawAcceptIndex >= 0) {
-        req.rawHeaders[rawAcceptIndex + 1] = 'application/json, text/event-stream';
-        return;
-    }
-    req.rawHeaders.push('Accept', 'application/json, text/event-stream');
-};
-const handleNonMcpRoute = (req, res, pathname, transportConfig) => {
-    if (pathname === '/mcp/health' && req.method === 'GET') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok' }));
-        return true;
-    }
-    if (pathname !== '/mcp') {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
-        return true;
-    }
-    if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
-        return true;
-    }
-    if (transportConfig.apiKey !== undefined &&
-        !isApiKeyValid(transportConfig.apiKey, req.headers['x-api-key'])) {
-        unauthorized(res);
-        return true;
-    }
-    return false;
-};
-const handleHttpRequest = async (req, res, mcpServer, transportConfig) => {
-    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? transportConfig.hostname}`);
-    withCors(res, transportConfig.cors);
-    if (handleNonMcpRoute(req, res, url.pathname, transportConfig))
-        return;
-    ensureStreamableAcceptHeader(req);
-    const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
-    try {
-        await mcpServer.connect(transport);
-        await transport.handleRequest(req, res);
-    }
-    finally {
-        await mcpServer.close();
-    }
-};
-const startHttpServer = async (serverInfo, transportConfig) => {
-    const mcpServer = buildMcpServer(serverInfo);
-    const httpServer = createHttpServer((req, res) => {
-        void handleHttpRequest(req, res, mcpServer, transportConfig);
-    });
-    await new Promise((resolve, reject) => {
-        httpServer.once('error', reject);
-        httpServer.listen(transportConfig.port, transportConfig.hostname, () => {
-            httpServer.off('error', reject);
-            resolve();
-        });
-    });
-    return { mcpServer, httpServer };
-};
-const buildMcpServer = ({ name, version, instructions, tools, }) => {
-    const mcpServer = new McpServer({ name, version }, {
-        ...(instructions ? { instructions } : {}),
-    });
-    for (const [toolName, definition] of Object.entries(tools)) {
-        mcpServer.registerTool(toolName, {
-            description: definition.description,
-            inputSchema: definition.inputSchema,
-        }, async (input, ctx) => normalizeToolResult(await definition.handler({ input, ctx })));
-    }
-    return mcpServer;
-};
-export const createServer = (options) => {
-    let mcpServer;
-    let httpServer;
-    return {
-        async start() {
-            if (options.transport.kind === 'stdio') {
-                mcpServer = buildMcpServer(options);
-                await mcpServer.connect(new StdioServerTransport());
-                return;
-            }
-            const started = await startHttpServer(options, options.transport);
-            mcpServer = started.mcpServer;
-            httpServer = started.httpServer;
-        },
-        async close() {
-            await mcpServer?.close();
-            const serverToClose = httpServer;
-            if (!serverToClose)
-                return;
-            await new Promise((resolve, reject) => {
-                serverToClose.close((error) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-        },
-    };
-};

package/dist/schemas/readVideo.js

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-export const videoSourceSchema = z.object({
-    path: z.string().min(1).describe('Path to the local video file (absolute or relative to cwd).'),
-});
-export const readVideoArgsSchema = z.object({
-    sources: z.array(videoSourceSchema).min(1).describe('One or more local video sources to read.'),
-    include_streams: z
-        .boolean()
-        .optional()
-        .describe('Include stream metadata from ffprobe. Defaults to true.'),
-    include_chapters: z
-        .boolean()
-        .optional()
-        .describe('Include chapter markers when present. Defaults to true.'),
-    include_subtitles: z
-        .boolean()
-        .optional()
-        .describe('Extract embedded subtitles when available. Defaults to true.'),
-    include_scenes: z
-        .boolean()
-        .optional()
-        .describe('Detect scene boundaries with ffmpeg scene filter. Defaults to true.'),
-    scene_threshold: z
-        .number()
-        .min(0)
-        .max(1)
-        .optional()
-        .describe('Scene detection sensitivity for ffmpeg gt(scene,threshold). Defaults to 0.4.'),
-    include_transcript: z
-        .boolean()
-        .optional()
-        .describe('Attempt optional local ASR transcript when an adapter is installed. Defaults to false.'),
-});

package/dist/types/timeline.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/asr.js

@@ -1,26 +0,0 @@
-import { isBinaryAvailable } from './exec.js';
-const ASR_CANDIDATES = ['whisper', 'whisper-cpp', 'vosk-transcriber'];
-export const detectAsrAdapter = async () => {
-    for (const candidate of ASR_CANDIDATES) {
-        if (await isBinaryAvailable(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-};
-export const tryAsrTranscript = async (_videoPath, enabled) => {
-    if (!enabled) {
-        return { transcript: [] };
-    }
-    const adapter = await detectAsrAdapter();
-    if (!adapter) {
-        return {
-            transcript: [],
-            warning: 'ASR requested but no local adapter found (checked whisper, whisper-cpp, vosk-transcriber); transcript skipped.',
-        };
-    }
-    return {
-        transcript: [],
-        warning: `ASR adapter "${adapter}" detected but transcription is not wired in v0.1.0; transcript skipped.`,
-    };
-};

package/dist/utils/errors.js

@@ -1,14 +0,0 @@
-export var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
-    ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
-    ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
-})(ErrorCode || (ErrorCode = {}));
-export class VideoError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options?.cause ? { cause: options.cause } : undefined);
-        this.code = code;
-        this.name = 'VideoError';
-    }
-}

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);
-};