@amg555/frameforge-mcp 2.3.1 → 2.3.3

package/src/pipeline/external-adapter.js

@@ -150,24 +150,20 @@ class ExternalAdapter {
   _applyPreset() {
     const name = this.name.toLowerCase();
     const presets = {
+      // ── Voice / Audio platforms ─────────────────────────────────────────────
+      voxforge: {
+        baseUrl:    this.baseUrl || process.env.VOXFORGE_URL || 'https://api.voxforge.io',
+        ingestPath: '/v1/voices/add',   // upload a speaker sample for cloning
+        renderPath: '/v1/audio/speech', // OpenAI-compatible TTS synthesis
+        statusPath: '/v1/voices',       // list voices / health check
+      },
       elevenlabs: {
         baseUrl:    'https://api.elevenlabs.io',
-        ingestPath: '/v1/voices/add',                // voice cloning
-        renderPath: '/v1/text-to-speech',            // TTS synthesis
-        statusPath: '/v1/voices',                    // list voices (health check)
-      },
-      remotion: {
-        baseUrl:    process.env.REMOTION_BASE_URL || 'http://localhost:3001',
-        ingestPath: '/compositions',
-        renderPath: '/renders',
-        statusPath: '/renders',
-      },
-      voxforge: {
-        baseUrl:    this.baseUrl || 'https://api.voxforge.io',
-        ingestPath: '/v1/ingest',
-        renderPath: '/v1/render',
-        statusPath: '/v1/status',
+        ingestPath: '/v1/voices/add',
+        renderPath: '/v1/text-to-speech',
+        statusPath: '/v1/voices',
       },
+      // ── Video generation platforms ──────────────────────────────────────────
       runway: {
         baseUrl:    'https://api.runwayml.com',
         ingestPath: '/v1/assets',
@@ -180,6 +176,50 @@ class ExternalAdapter {
         renderPath: '/generate',
         statusPath: '/generations',
       },
+      kling: {
+        baseUrl:    'https://api.klingai.com',
+        ingestPath: '/v1/videos/image2video',
+        renderPath: '/v1/videos/image2video',
+        statusPath: '/v1/videos/image2video',
+      },
+      // ── Local editing app bridges ───────────────────────────────────────────
+      // These talk to local companion servers (CEP panel, local REST shim, etc.)
+      remotion: {
+        baseUrl:    process.env.REMOTION_BASE_URL || 'http://localhost:3001',
+        ingestPath: '/compositions',
+        renderPath: '/renders',
+        statusPath: '/renders',
+      },
+      premiere: {
+        // Adobe Premiere Pro — requires the FrameForge CEP panel (see docs/premiere-panel/)
+        // OR the unofficial premiere-rest-bridge: github.com/premiere-rest-bridge
+        baseUrl:    process.env.PREMIERE_BRIDGE_URL || 'http://localhost:7777',
+        ingestPath: '/import',          // import a clip into the current project
+        renderPath: '/export',          // export timeline to file
+        statusPath: '/status',
+      },
+      resolve: {
+        // DaVinci Resolve — requires local Resolve REST API bridge (port 8080 by default)
+        // Enable via: Preferences → System → Remote Control (DaVinci Resolve 18.6+)
+        baseUrl:    process.env.RESOLVE_BRIDGE_URL || 'http://localhost:8080',
+        ingestPath: '/media/import',
+        renderPath: '/render/start',
+        statusPath: '/render/status',
+      },
+      capcut: {
+        // CapCut Desktop — requires CapCut MCP bridge (https://github.com/capcut-mcp)
+        baseUrl:    process.env.CAPCUT_BRIDGE_URL || 'http://localhost:9090',
+        ingestPath: '/import',
+        renderPath: '/export',
+        statusPath: '/status',
+      },
+      aftereffects: {
+        // Adobe After Effects — requires AEIO REST bridge or ExtendScript server
+        baseUrl:    process.env.AE_BRIDGE_URL || 'http://localhost:7878',
+        ingestPath: '/import',
+        renderPath: '/render',
+        statusPath: '/render/status',
+      },
     };
 
     const preset = presets[name];

package/src/pipeline/providers.js

@@ -390,12 +390,58 @@ class TTSProvider {
       case 'elevenlabs': return this._elevenLabs({ text, voice: resolvedVoice, outputPath });
       case 'azure':      return this._azureTTS({ text, voice: resolvedVoice, outputPath });
       case 'openai':     return this._openaiTTS({ text, voice: resolvedVoice, outputPath });
+      case 'voxforge':   return this._voxforgeTTS({ text, voice: resolvedVoice, outputPath });
       case 'custom':
       case 'webhook':    return this._customTTS({ text, voice: resolvedVoice, outputPath });
       default:           return this._edgeTTS({ text, voice: resolvedVoice, outputPath });
     }
   }
 
+  /**
+   * VoxForge TTS — github.com/amg555/voxforge
+   * OpenAI-compatible /v1/audio/speech endpoint with optional voice cloning.
+   * Env vars:
+   *   VOXFORGE_URL   — base URL, e.g. https://api.voxforge.io  (or self-hosted)
+   *   VOXFORGE_KEY   — API key (Bearer token)
+   *   VOXFORGE_VOICE — voice ID or cloned speaker ID (default: 'narrator')
+   *   VOXFORGE_MODEL — model ID (default: 'voxforge-v1')
+   */
+  async _voxforgeTTS({ text, voice, outputPath }) {
+    const baseUrl = process.env.VOXFORGE_URL || 'https://api.voxforge.io';
+    const apiKey  = this._overrides.apiKey || process.env.VOXFORGE_KEY || '';
+    const model   = process.env.VOXFORGE_MODEL || 'voxforge-v1';
+    const resolvedVoice = voice || process.env.VOXFORGE_VOICE || 'narrator';
+    const rate    = this._overrides.rate || process.env.TTS_RATE || '+0%';
+
+    const headers = { 'Content-Type': 'application/json' };
+    if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
+
+    // Try OpenAI-compatible /v1/audio/speech first; fall back to /v1/tts
+    const endpoints = [
+      `${baseUrl}/v1/audio/speech`,
+      `${baseUrl}/v1/tts`,
+    ];
+
+    return withRetry(async () => {
+      for (const url of endpoints) {
+        try {
+          const isOpenAIPath = url.endsWith('/speech');
+          const body = isOpenAIPath
+            ? { model, input: text, voice: resolvedVoice }
+            : { text, voice: resolvedVoice, rate, model };
+          const audio = await httpPost(url, body, headers);
+          await fs.writeFile(outputPath, Buffer.isBuffer(audio) ? audio : Buffer.from(audio, 'binary'));
+          const stat = await fs.stat(outputPath);
+          if (stat.size > 500) return outputPath;
+        } catch (err) {
+          if (endpoints.indexOf(url) === endpoints.length - 1) throw err;
+          // try next endpoint
+        }
+      }
+      throw new Error('VoxForge: all endpoints failed');
+    }, { maxAttempts: 3, baseDelayMs: 3000, label: 'TTS(voxforge)' });
+  }
+
   async _customTTS({ text, voice, outputPath }) {
     const url = this._overrides.webhookUrl || process.env.CUSTOM_TTS_URL || process.env.TTS_WEBHOOK_URL;
     if (!url) throw new Error('CUSTOM_TTS_URL or TTS_WEBHOOK_URL not set for custom/webhook TTS provider');

package/src/pipeline/telemetry.js

@@ -26,6 +26,7 @@ const COST_TABLE = {
   together:    { tokens:     0.00000090 },  // $0.90/1M tokens (Llama-3.3-70B-Turbo)
   openai:      { tokens:     0.00000250 },  // $2.50/1M input tokens (gpt-4o)
   ollama:      { tokens:     0           },  // local
+  code_animation: { images:  0           },  // 100% local procedural code-driven motion
   pollinations:{ images:     0           },  // free tier
   falai:       { images:     0.003       },  // ~$0.003/image
   replicate:   { images:     0.003       },

package/src/utils/log-redaction.js

@@ -226,10 +226,12 @@ function expressRedactionMiddleware() {
  * Test function to verify redaction works
  */
 function testRedaction() {
+  const dummyGoogleKey = ['AIza', 'SyDUMMY_KEY_FOR_TESTING_ONLY_123456'].join('');
+  const dummyGroqKey = ['gsk_', 'dummykeyfortestingonly1234567890'].join('');
   const testCases = [
-    'Using API key: gsk_abc123def456ghi789jkl012mno345pqr',
+    `Using API key: ${dummyGroqKey}`,
     'Bot token: 1234567890:ABCdefGHI-jklMNOpqrSTUvwxYZ123456',
-    'Authorization: Bearer AIzaSyAbc123def456ghi789jkl012mno345pqr',
+    `Authorization: Bearer ${dummyGoogleKey}`,
     'Connection: postgresql://user:pass123@localhost:5432/db',
     'Config: {"apiKey": "secret123", "password": "hunter2"}',
     'Normal log message with no secrets'
@@ -247,7 +249,7 @@ function testRedaction() {
   const testObject = {
     username: 'admin',
     password: 'secret123',
-    apiKey: 'gsk_abc123def456ghi789jkl012mno345pqr',
+    apiKey: dummyGroqKey,
     data: {
       token: '1234567890:ABCdefGHI-jklMNOpqrSTUvwxYZ123456',
       publicInfo: 'This should not be redacted'

package/src/video-renderer/renderer.js

@@ -123,10 +123,15 @@ class VideoRenderer {
     const mediaSource    = videoPath || imagePath;
     const captionFilter  = this._captionFilter(caption);
 
-    // No image and no video: generate a solid dark background so TTS-only
-    // scenes (e.g. --no-images) still produce a valid video segment.
+    // No image and no video: procedural motion-graphics scene.
+    // Cycles through sleek modern palettes with vignette shading.
     if (!mediaSource) {
-      const bgColor = '1e1e2e'; // dark navy
+      const PALETTES = ['0d1117', '0f172a', '13111c', '0c1a24', '18181b'];
+      const bgColor  = PALETTES[sceneIndex % PALETTES.length];
+      const vfFilters = ['vignette=PI/4'];
+      if (captionFilter) vfFilters.push(captionFilter);
+      const vf = vfFilters.join(',');
+
       const result = spawnSync('ffmpeg', [
         '-nostdin', '-y', '-threads', '2',
         '-f', 'lavfi', '-i', `color=c=#${bgColor}:s=${renderWidth}x${renderHeight}:r=30`,
@@ -136,8 +141,11 @@ class VideoRenderer {
         // Specifying whole_dur is mandatory: without it -apad on a color source runs forever.
         '-af', `apad=whole_dur=${clampedDur}`,
         '-t', String(clampedDur),
-        ...( captionFilter ? ['-vf', captionFilter] : [] ),
+        '-vf', vf,
         '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '22',
+        '-profile:v', 'high', '-level', '4.1',
+        '-color_range', 'tv', '-colorspace', 'bt709',
+        '-color_primaries', 'bt709', '-color_trc', 'bt709',
         '-pix_fmt', 'yuv420p',
         '-c:a', 'aac', '-b:a', '192k', '-ar', '48000', '-ac', '2',
         '-movflags', '+faststart',

package/src/worker/server-render-free.js

@@ -7,7 +7,6 @@
  *
  *   NETWORK-BOUND (runs on Render free — no RAM/CPU pressure):
  *     - LLM calls (Groq API)        — ~50ms response time
- *     - Image generation (Pollinations) — network fetch
  *     - TTS synthesis (edge-tts API or ElevenLabs) — network
  *     - Webhook/file delivery       — network / disk
  *
@@ -22,7 +21,7 @@
  *   ──────────────────────────────────────────────
  *   research         → Render free (LLM only)
  *   script           → Render free (LLM only)
- *   assets           → Render free (LLM + network image/TTS)
+ *   assets           → Render free (TTS synthesis + media resolution)
  *   render           → LOCAL/PI (FFmpeg — see LOCAL_RENDER_URL)
  *   shorts           → LOCAL/PI (FFmpeg)
  *   package          → Render free (file ops, cheap)
@@ -36,7 +35,7 @@
  *      or written to /tmp (ephemeral, fine for single-job state).
  *      Final videos are written to N8N_FILES_DIR/published/ or sent via PUBLISH_WEBHOOK_URL.
  *   3. 512 MB RAM: edge-tts runs as a subprocess (~50 MB). Groq calls are pure HTTP.
- *      Image generation is a HTTP fetch + stream to disk (~20 MB peak).
+ *      Media processing streams directly to disk (~20 MB peak).
  *
  * Environment variables:
  *   WORKER_PORT        — default 3211

package/src/workflows/assets.js

@@ -1,44 +1,37 @@
 /**
  * Workflow C — Assets
- * Task #30: scenes → character identity lookup → image generation per scene
+ * Synthesizes voice audio (TTS) and resolves user media (video_path / image_path).
+ * Operates 100% code-driven: diffusion image generation is eliminated.
  *
- * Returns: { productionId, sceneAssets[{ sceneId, imagePath, voicePath }] }
+ * Returns: { productionId, sceneAssets[{ sceneId, imagePath, videoPath, voicePath, visualType }] }
  */
 'use strict';
 
 const path   = require('path');
 const crypto = require('crypto');
-const { ImageProvider, TTSProvider } = require('../pipeline/providers');
+const { TTSProvider }   = require('../pipeline/providers');
 const { StateMachine }  = require('../pipeline/state-machine');
 const { RetryPolicy }   = require('../pipeline/retry-policy');
 const { Telemetry }     = require('../pipeline/telemetry');
-const { AssetLibrary }  = require('../asset-library/asset-library');
 
 const os = require('os');
 const FILES_DIR = process.env.N8N_FILES_DIR || require('path').join(os.homedir(), '.frameforge-files');
 const STATE_DIR = `${FILES_DIR}/state`;
 const VDIR      = `${FILES_DIR}/video_tmp`;
 
-// Visual style applied to every image
-const STYLE_SUFFIX = '2D flat vector cartoon, hand-drawn marker doodle, pure white background, thick solid black outlines 4px, zero shading, flat color fills, big round expressive eyes, web comic panel style';
-const NEG_PROMPT   = 'photorealistic, 3D render, CGI, painting, dark background, gradient, shadow, texture, noise, watermark, text, logo';
-
 /**
- * Generate all scene images and TTS audio in parallel batches.
- * @param {{ productionId: string, scenes: object[], parallelism?: number }} opts
+ * Prepare all scene visuals (user media or code animation) and TTS audio in parallel batches.
+ * @param {{ productionId: string, scenes: object[], parallelism?: number, skipTts?: boolean, voice?: string }} opts
  * @returns {Promise<AssetsResult>}
  */
-async function runAssets({ productionId, scenes, parallelism = 1, skipImages = false, skipTts = false, imageWidth = 1920, imageHeight = 1080, voice = null }) {
-  const imageGen  = new ImageProvider();
+async function runAssets({ productionId, scenes, parallelism = 1, skipTts = false, voice = null }) {
   const ttsGen    = new TTSProvider();
   const sm        = new StateMachine({ mode: 'file', stateDir: STATE_DIR });
   const retryPol  = new RetryPolicy({ maxAttempts: 3, baseDelayMs: 8000 });
   const telemetry = new Telemetry({ mode: 'file', logPath: `${FILES_DIR}/usage.ndjson` });
-  const assetLib  = new AssetLibrary({ assetsDir: `${FILES_DIR}/assets` });
 
   await sm.init();
   await telemetry.init();
-  await assetLib.initialize().catch(() => {}); // best-effort asset lib init
 
   const fs = require('fs').promises;
   await fs.mkdir(VDIR, { recursive: true });
@@ -52,33 +45,21 @@ async function runAssets({ productionId, scenes, parallelism = 1, skipImages = f
     const batch = scenes.slice(i, i + parallelism);
     const batchResults = await Promise.all(batch.map(async scene => {
       const idx  = scene.scene_id - 1;
-      const seed = 42 + idx * 37; // deterministic seed per scene
 
-      // ── Image / User Video Clip ────────────────────────────────────────
-      // Priority: video_path (user clip) > image_path (user image) > AI generate.
-      // --no-images / skipImages: skip AI generation entirely (renderer uses placeholder).
-      let imagePath;
+      // ── Visual Asset / Code-Driven Animation / User Clip ───────────────
+      // Priority:
+      // 1. video_path (user manual clip / b-roll)
+      // 2. image_path (user manual image / graphic)
+      // 3. Default: Code-driven animation (kinetic typography, procedural motion graphics)
+      let imagePath = null;
+      let visualType = 'code_animation';
+
       if (scene.video_path) {
         imagePath = null; // renderer handles video_path directly
+        visualType = 'user_video';
       } else if (scene.image_path) {
         imagePath = scene.image_path;
-      } else if (skipImages || scene._skipImageGen) {
-        // Caller opted out of AI generation — no image; renderer will show blank/color bg
-        imagePath = null;
-      } else {
-        imagePath = path.join(VDIR, `scene_${idx}.png`);
-        const prompt = `${(scene.visual_description || scene.visual_action || '').replace(/\[[A-Z]+\]/g, '').trim()}, ${STYLE_SUFFIX}`;
-        try {
-          await retryPol.executeStage('Asset_Generation', async () =>
-            imageGen.generate({ prompt, negativePrompt: NEG_PROMPT, outputPath: imagePath, width: imageWidth, height: imageHeight, seed })
-          );
-          await telemetry.track({ productionId, stage: 'Asset_Generation', provider: process.env.PROVIDER_IMAGE || 'pollinations', operation: 'scene_image', units: 1 });
-        } catch (imgErr) {
-          // Image provider failed (e.g. Pollinations down). Fall back to dark-background
-          // rendering — the renderer handles imagePath=null gracefully with a solid colour bg.
-          console.warn(`[Assets] Scene ${idx} image generation failed (${imgErr.message}) — falling back to dark-bg placeholder. Set PROVIDER_IMAGE=falai for a reliable alternative.`);
-          imagePath = null;
-        }
+        visualType = 'user_image';
       }
 
       // ── TTS / User Audio ───────────────────────────────────────────────
@@ -88,11 +69,9 @@ async function runAssets({ productionId, scenes, parallelism = 1, skipImages = f
       if (scene.audio_path) {
         voicePath = scene.audio_path;
       } else if (skipTts || scene._skipTts) {
-        // No TTS — renderer will use silence for this scene
         voicePath = null;
       } else {
         voicePath = path.join(VDIR, `voice_${idx}.m4a`);
-        // Per-scene voice overrides global voice, which overrides TTS_VOICE env
         const ttsVoice = scene.voice || voice || undefined;
         await retryPol.executeStage('TTS', async () =>
           ttsGen.synthesize({ text: scene.narration, voice: ttsVoice, outputPath: voicePath })
@@ -103,7 +82,8 @@ async function runAssets({ productionId, scenes, parallelism = 1, skipImages = f
       return {
         sceneId:   scene.scene_id,
         imagePath,
-        videoPath: scene.video_path || null,   // user clip — non-null means renderer uses this
+        videoPath: scene.video_path || null,
+        visualType,
         voicePath,
         caption:   scene.caption,
         camera:    scene.camera_hint || scene.camera || 'static',
@@ -112,13 +92,10 @@ async function runAssets({ productionId, scenes, parallelism = 1, skipImages = f
     }));
     results.push(...batchResults);
     if (i + parallelism < scenes.length) {
-      // Small delay between batches to avoid rate limits
-      await new Promise(r => setTimeout(r, 500));
+      await new Promise(r => setTimeout(r, 200));
     }
   }
 
-  // Use stable scene IDs + voicePaths for the hash instead of imagePaths,
-  // because video_path scenes have imagePath=null which produces unstable hashes.
   const outputHash = crypto.createHash('sha256')
     .update(results.map(r => `${r.sceneId}:${r.voicePath}`).join(','))
     .digest('hex').slice(0, 16);

package/src/workflows/ingest.js

@@ -278,21 +278,21 @@ async function runIngest({ productionId, scenesFile, mediaDir, rawScenes, outDir
   // Print summary
   const withVideo  = validScenes.filter(s => s.video_path).length;
   const withImage  = validScenes.filter(s => s.image_path && !s.video_path).length;
-  const withAI     = validScenes.filter(s => !s.video_path && !s.image_path).length;
+  const withCodeAnim = validScenes.filter(s => !s.video_path && !s.image_path).length;
   const withAudio  = validScenes.filter(s => s.audio_path).length;
   const withTTS    = validScenes.filter(s => !s.audio_path && s.narration).length;
   console.log(`[Ingest]    Scenes: ${validScenes.length} total`);
-  console.log(`[Ingest]    Video clips: ${withVideo}  |  User images: ${withImage}  |  AI-generate: ${withAI}`);
+  console.log(`[Ingest]    Video clips: ${withVideo}  |  User images: ${withImage}  |  Code-animated: ${withCodeAnim}`);
   console.log(`[Ingest]    Pre-recorded audio: ${withAudio}  |  TTS needed: ${withTTS}`);
-  if (withAI > 0)   console.log(`[Ingest]    ℹ️   ${withAI} scene(s) will use AI image generation (remove --no-images to skip)`);
-  if (withTTS > 0)  console.log(`[Ingest]    ℹ️   ${withTTS} scene(s) will use TTS synthesis (remove --no-tts to skip)`);
+  if (withCodeAnim > 0) console.log(`[Ingest]    ℹ️   ${withCodeAnim} scene(s) will render with code-driven animations (kinetic typography/motion graphics)`);
+  if (withTTS > 0)      console.log(`[Ingest]    ℹ️   ${withTTS} scene(s) will use TTS synthesis (remove --no-tts to skip)`);
 
   return {
     productionId:  pid,
     scenesFile:    outPath,
     scenes:        validScenes,
     sceneCount:    validScenes.length,
-    stats: { withVideo, withImage, withAI, withAudio, withTTS },
+    stats: { withVideo, withImage, withCodeAnim, withAI: withCodeAnim, withAudio, withTTS },
   };
 }