@studiomeyer/mcp-video 1.0.0

package/src/handlers/editing.ts

@@ -0,0 +1,260 @@
+/**
+ * Editing tool handlers — speed, color, effects, crop, reverse, extract,
+ * subtitles, auto captions, keyframes, PiP, audio ducking
+ */
+
+import { jsonResponse, type ToolHandler } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+import {
+  adjustVideoSpeed,
+  applyColorGrade,
+  applyVideoEffect,
+  cropVideo,
+  reverseClip,
+  extractAudio,
+  burnSubtitles,
+  autoCaption,
+  addKeyframeAnimation,
+  composePip,
+  addAudioDucking,
+} from '../tools/index.js';
+import type {
+  VideoEffect,
+  PipPosition,
+  Keyframe,
+} from '../tools/index.js';
+
+export const editingHandlers: Record<string, ToolHandler> = {
+
+  adjust_video_speed: async (args) => {
+    try {
+      const result = await adjustVideoSpeed({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        speed: args.speed,
+        audioMode: args.audioMode ?? 'match',
+      });
+      return jsonResponse({
+        success: true, outputPath: result, speed: args.speed,
+        message: `Video speed changed to ${args.speed}x. Audio ${args.audioMode ?? 'match'}ed.`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`adjust_video_speed failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  apply_color_grade: async (args) => {
+    try {
+      const result = await applyColorGrade({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        brightness: args.brightness,
+        contrast: args.contrast,
+        saturation: args.saturation,
+        gamma: args.gamma,
+        temperature: args.temperature,
+      });
+      const params = ['brightness', 'contrast', 'saturation', 'gamma', 'temperature']
+        .filter(p => args[p] !== undefined)
+        .map(p => `${p}=${args[p]}`)
+        .join(', ');
+      return jsonResponse({ success: true, outputPath: result, applied: params || 'defaults' });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`apply_color_grade failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  apply_video_effect: async (args) => {
+    try {
+      const result = await applyVideoEffect({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        effect: args.effect as VideoEffect,
+        intensity: args.intensity ?? 0.5,
+      });
+      return jsonResponse({
+        success: true, outputPath: result, effect: args.effect,
+        intensity: args.intensity ?? 0.5,
+        message: `Applied ${args.effect} effect (intensity: ${args.intensity ?? 0.5}).`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`apply_video_effect failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  crop_video: async (args) => {
+    try {
+      const result = await cropVideo({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        width: args.width,
+        height: args.height,
+        x: args.x ?? 'center',
+        y: args.y ?? 'center',
+      });
+      return jsonResponse({
+        success: true, outputPath: result,
+        crop: { width: args.width, height: args.height, x: args.x ?? 'center', y: args.y ?? 'center' },
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`crop_video failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  reverse_clip: async (args) => {
+    try {
+      const result = await reverseClip({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        reverseAudio: args.reverseAudio ?? true,
+      });
+      return jsonResponse({
+        success: true, outputPath: result,
+        message: `Video reversed${(args.reverseAudio ?? true) ? ' (audio also reversed)' : ' (audio kept forward)'}.`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`reverse_clip failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  extract_audio: async (args) => {
+    try {
+      const result = await extractAudio({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        format: args.format ?? 'mp3',
+        bitrate: args.bitrate ?? '192k',
+      });
+      return jsonResponse({
+        success: true, outputPath: result, format: args.format ?? 'mp3',
+        message: `Audio extracted as ${args.format ?? 'mp3'} (${args.bitrate ?? '192k'}).`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`extract_audio failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  burn_subtitles: async (args) => {
+    try {
+      const result = await burnSubtitles({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        subtitlePath: args.subtitlePath,
+        fontSize: args.fontSize ?? 24,
+        fontColor: args.fontColor ?? '&Hffffff',
+        outlineColor: args.outlineColor ?? '&H000000',
+        outlineWidth: args.outlineWidth ?? 2,
+        position: args.position ?? 'bottom',
+      });
+      return jsonResponse({
+        success: true, outputPath: result,
+        message: `Subtitles burned into video (${args.position ?? 'bottom'}, size: ${args.fontSize ?? 24}).`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`burn_subtitles failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  auto_caption: async (args) => {
+    try {
+      const result = await autoCaption({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        language: args.language,
+        fontSize: args.fontSize ?? 28,
+        position: args.position ?? 'bottom',
+        keepSrt: args.keepSrt ?? true,
+      });
+      return jsonResponse({
+        success: true,
+        videoPath: result.videoPath,
+        srtPath: result.srtPath,
+        message: 'Video captioned with Whisper AI. SRT file also generated.',
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`auto_caption failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  add_keyframe_animation: async (args) => {
+    try {
+      const result = await addKeyframeAnimation({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        keyframes: args.keyframes as Keyframe[],
+        outputWidth: args.outputWidth,
+        outputHeight: args.outputHeight,
+      });
+      return jsonResponse({
+        success: true,
+        outputPath: result,
+        keyframeCount: (args.keyframes as Keyframe[]).length,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`add_keyframe_animation failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  compose_picture_in_pip: async (args) => {
+    try {
+      const result = await composePip({
+        mainVideo: args.mainVideo,
+        overlayVideo: args.overlayVideo,
+        outputPath: args.outputPath,
+        position: (args.position as PipPosition) ?? 'bottom-right',
+        scale: args.scale ?? 0.3,
+        startTime: args.startTime ?? 0,
+        endTime: args.endTime,
+        borderWidth: args.borderWidth ?? 0,
+        borderColor: args.borderColor ?? 'white',
+      });
+      return jsonResponse({
+        success: true, outputPath: result,
+        pip: { position: args.position ?? 'bottom-right', scale: args.scale ?? 0.3 },
+        message: `PiP composed: overlay at ${args.position ?? 'bottom-right'} (${Math.round((args.scale ?? 0.3) * 100)}% size).`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`compose_picture_in_pip failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  add_audio_ducking: async (args) => {
+    try {
+      const result = await addAudioDucking({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        duckLevel: args.duckLevel ?? 0.3,
+        attack: args.attack ?? 0.5,
+        release: args.release ?? 1.0,
+      });
+      return jsonResponse({
+        success: true, outputPath: result,
+        message: `Audio ducking applied (reduce to ${Math.round((args.duckLevel ?? 0.3) * 100)}% volume).`,
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`add_audio_ducking failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+};

package/src/handlers/index.ts

@@ -0,0 +1,34 @@
+import { type ToolHandler, type ToolResponse } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+import { videoHandlers } from './video.js';
+import { postProductionHandlers } from './post-production.js';
+import { ttsHandlers } from './tts.js';
+import { smartScreenshotHandlers } from './smart-screenshot.js';
+import { editingHandlers } from './editing.js';
+import { capcutHandlers } from './capcut.js';
+
+const HANDLER_REGISTRY: Record<string, ToolHandler> = {
+  ...videoHandlers,
+  ...postProductionHandlers,
+  ...ttsHandlers,
+  ...smartScreenshotHandlers,
+  ...editingHandlers,
+  ...capcutHandlers,
+};
+
+export async function handleToolCall(name: string, args: unknown): Promise<ToolResponse> {
+  const handler = HANDLER_REGISTRY[name];
+  if (!handler) {
+    return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  }
+  try {
+    return await handler(args);
+  } catch (error) {
+    logger.logError('Tool execution failed', error, { tool: name });
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ success: false, error: message, code: 'INTERNAL_ERROR' }, null, 2) }],
+      isError: true,
+    };
+  }
+}

package/src/handlers/post-production.ts

@@ -0,0 +1,136 @@
+/**
+ * Post-production tool handlers
+ */
+
+import { jsonResponse, type ToolHandler } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+import {
+  addBackgroundMusic,
+  concatenateVideos,
+  generateIntro,
+  convertToSocialFormat,
+  convertToAllFormats,
+  addTextOverlays,
+} from '../tools/index.js';
+import type {
+  AddMusicConfig,
+  ConcatClip,
+  TransitionType,
+  SocialFormat,
+  CropStrategy,
+  TextOverlay,
+} from '../tools/index.js';
+import * as path from 'path';
+
+const OUTPUT_DIR = process.env.VIDEO_OUTPUT_DIR || './output';
+
+export const postProductionHandlers: Record<string, ToolHandler> = {
+
+  add_background_music: async (args) => {
+    try {
+      const config: AddMusicConfig = {
+        videoPath: args.videoPath,
+        musicPath: args.musicPath,
+        outputPath: args.outputPath ?? addSuffix(args.videoPath, '-music'),
+        musicVolume: args.musicVolume ?? 0.25,
+        fadeInDuration: args.fadeInDuration ?? 2,
+        fadeOutDuration: args.fadeOutDuration ?? 3,
+        loopMusic: args.loopMusic ?? true,
+      };
+      const result = await addBackgroundMusic(config);
+      return jsonResponse({ success: true, outputPath: result });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`add_background_music failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  concatenate_videos: async (args) => {
+    try {
+      const result = await concatenateVideos({
+        clips: args.clips as ConcatClip[],
+        outputPath: args.outputPath,
+        transition: (args.transition as TransitionType) ?? 'fade',
+        transitionDuration: args.transitionDuration ?? 1,
+      });
+      return jsonResponse({ success: true, outputPath: result });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`concatenate_videos failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  generate_intro: async (args) => {
+    try {
+      const result = await generateIntro({
+        text: args.text,
+        subtitle: args.subtitle,
+        duration: args.duration ?? 3,
+        backgroundColor: args.backgroundColor ?? '#0a0a0a',
+        textColor: args.textColor ?? 'white',
+        outputPath: args.outputPath,
+      });
+      return jsonResponse({ success: true, outputPath: result });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`generate_intro failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  convert_social_format: async (args) => {
+    try {
+      const result = await convertToSocialFormat({
+        inputPath: args.inputPath,
+        outputPath: args.outputPath,
+        format: args.format as SocialFormat,
+        strategy: (args.strategy as CropStrategy) ?? 'blur-background',
+      });
+      return jsonResponse({ success: true, outputPath: result, format: args.format });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`convert_social_format failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  convert_all_social_formats: async (args) => {
+    try {
+      const formats = args.formats as SocialFormat[] | undefined;
+      const result = await convertToAllFormats(
+        args.inputPath,
+        args.outputDir ?? OUTPUT_DIR,
+        formats ?? ['instagram-reel', 'instagram-feed', 'youtube', 'tiktok'],
+        (args.strategy as CropStrategy) ?? 'blur-background',
+      );
+      return jsonResponse({ success: true, files: result, totalFormats: Object.keys(result).length });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`convert_all_social_formats failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  add_text_overlay: async (args) => {
+    try {
+      const result = await addTextOverlays(
+        args.inputPath,
+        args.outputPath,
+        args.overlays as TextOverlay[],
+      );
+      return jsonResponse({ success: true, outputPath: result });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`add_text_overlay failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+};
+
+function addSuffix(filePath: string, suffix: string): string {
+  const ext = path.extname(filePath);
+  const base = filePath.slice(0, -ext.length);
+  return `${base}${suffix}${ext}`;
+}

package/src/handlers/smart-screenshot.ts

@@ -0,0 +1,86 @@
+/**
+ * Smart Screenshot tool handlers
+ */
+
+import { jsonResponse, type ToolHandler } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+import { smartScreenshot } from '../tools/engine/smart-screenshot.js';
+import type { SmartScreenshotConfig, SmartTarget } from '../tools/engine/smart-screenshot.js';
+
+export const smartScreenshotHandlers: Record<string, ToolHandler> = {
+  /**
+   * Take element-aware screenshots of specific page features
+   */
+  screenshot_element: async (args) => {
+    try {
+      const config: SmartScreenshotConfig = {
+        url: args.url,
+        targets: normalizeTargetArgs(args.targets),
+        outputDir: args.outputDir,
+        viewport: args.viewport ?? { width: 1920, height: 1080 },
+        deviceScaleFactor: args.deviceScaleFactor ?? 1,
+        darkMode: args.darkMode ?? false,
+        includeFullPage: args.includeFullPage ?? false,
+      };
+
+      const result = await smartScreenshot(config);
+      return jsonResponse(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`screenshot_element failed: ${message}`);
+      return jsonResponse({ success: false, error: message }, true);
+    }
+  },
+
+  /**
+   * Detect page features without taking screenshots
+   */
+  detect_page_features: async (args) => {
+    try {
+      const config: SmartScreenshotConfig = {
+        url: args.url,
+        targets: ['all'],
+        viewport: args.viewport ?? { width: 1920, height: 1080 },
+        includeFullPage: false,
+      };
+
+      // Use smartScreenshot with includeFullPage=false to just detect
+      // We'll capture a quick version that only detects without taking actual screenshots
+      const result = await smartScreenshot(config);
+      return jsonResponse({
+        success: true,
+        url: args.url,
+        features: result.detected.map(f => ({
+          name: f.name,
+          selector: f.selector,
+          size: `${f.bounds.width}x${f.bounds.height}`,
+          position: `(${Math.round(f.bounds.x)}, ${Math.round(f.bounds.y)})`,
+          matchMethod: f.matchMethod,
+          confidence: f.confidence,
+        })),
+        total: result.detected.length,
+        screenshots: result.screenshots.map(s => ({
+          feature: s.feature,
+          path: s.path,
+        })),
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`detect_page_features failed: ${message}`);
+      return jsonResponse({ success: false, error: message }, true);
+    }
+  },
+};
+
+function normalizeTargetArgs(targets: unknown): (string | SmartTarget)[] {
+  if (!Array.isArray(targets)) {
+    return [String(targets)];
+  }
+  return targets.map(t => {
+    if (typeof t === 'string') return t;
+    if (typeof t === 'object' && t !== null && 'feature' in t) {
+      return t as SmartTarget;
+    }
+    return String(t);
+  });
+}

package/src/handlers/tts.ts

@@ -0,0 +1,103 @@
+/**
+ * TTS & Narrated Video tool handlers
+ */
+
+import { jsonResponse, type ToolHandler } from '../lib/types.js';
+import { logger } from '../lib/logger.js';
+import {
+  generateSpeech,
+  listElevenLabsVoices,
+  createNarratedVideo,
+} from '../tools/index.js';
+import type {
+  TTSConfig,
+  TTSProvider,
+  NarrationSegment,
+} from '../tools/index.js';
+import type { ViewportPreset, Scene } from '../tools/engine/types.js';
+
+const OUTPUT_DIR = process.env.VIDEO_OUTPUT_DIR || './output';
+
+export const ttsHandlers: Record<string, ToolHandler> = {
+
+  generate_speech: async (args) => {
+    try {
+      const config: TTSConfig = {
+        text: args.text,
+        outputPath: args.outputPath ?? `${OUTPUT_DIR}/speech-${Date.now()}.mp3`,
+        provider: args.provider as TTSProvider | undefined,
+        language: args.language ?? 'en',
+        speed: args.speed,
+        elevenLabsVoice: args.elevenLabsVoice,
+        elevenLabsModel: args.elevenLabsModel,
+        openaiVoice: args.openaiVoice,
+        openaiModel: args.openaiModel,
+        stability: args.stability,
+        similarityBoost: args.similarityBoost,
+      };
+
+      const result = await generateSpeech(config);
+      return jsonResponse(result);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`generate_speech failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  list_voices: async () => {
+    try {
+      const voices = await listElevenLabsVoices();
+      return jsonResponse({
+        success: true,
+        voices,
+        totalVoices: voices.length,
+        premade: [
+          'rachel (F)', 'sarah (F)', 'emily (F)', 'charlotte (F)', 'alice (F)',
+          'brian (M)', 'adam (M)', 'daniel (M)', 'josh (M)', 'james (M)', 'liam (M)',
+        ],
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`list_voices failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+
+  create_narrated_video: async (args) => {
+    try {
+      const segments: NarrationSegment[] = (args.segments as Array<{
+        text: string;
+        scene: Scene;
+        paddingAfter?: number;
+      }>).map((s) => ({
+        text: s.text,
+        scene: s.scene,
+        paddingAfter: s.paddingAfter,
+      }));
+
+      const hostname = new URL(args.url).hostname.replace(/^www\./, '').replace(/\./g, '-');
+      const defaultOutput = `${OUTPUT_DIR}/narrated-${hostname}-${new Date().toISOString().slice(0, 10)}`;
+
+      const result = await createNarratedVideo({
+        url: args.url,
+        segments,
+        outputPath: args.outputPath ?? defaultOutput,
+        provider: args.provider as TTSProvider | undefined,
+        language: args.language ?? 'en',
+        viewport: (args.viewport as ViewportPreset) ?? 'desktop',
+        elevenLabsVoice: args.elevenLabsVoice,
+        openaiVoice: args.openaiVoice,
+        speed: args.speed,
+        backgroundMusicPath: args.backgroundMusicPath,
+        backgroundMusicVolume: args.backgroundMusicVolume,
+      });
+
+      return jsonResponse(result);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`create_narrated_video failed: ${msg}`);
+      return jsonResponse({ success: false, error: msg }, true);
+    }
+  },
+};