@amg555/frameforge-mcp 2.3.1 → 2.3.2

package/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to FrameForge are documented here.
 
 ---
 
+## [2.3.2] — 2026-11-06
+
+### Added
+
+- **Tool 18: `export_to_editor`** — send a finished animation MP4 + EDL to any local editing app via an HTTP bridge: Premiere Pro (`:7777`), DaVinci Resolve (`:8080`), CapCut (`:9090`), After Effects (`:7878`), or Remotion (`:3001`). Pass `editorUrl` to override any port. Bridge setup docs: `docs/editor-bridges/`.
+- **VoxForge TTS provider** (`PROVIDER_TTS=voxforge`) — named first-class provider in `TTSProvider`. Tries `/v1/audio/speech` (OpenAI-compatible) then falls back to `/v1/tts`. Configured via `VOXFORGE_URL`, `VOXFORGE_KEY`, `VOXFORGE_VOICE`, `VOXFORGE_MODEL`. Also surfaced in `multi_voice_tts` platform enum and `setup-keys.js` wizard.
+- **Editing app presets in `ExternalAdapter`** — `premiere`, `resolve`, `capcut`, `aftereffects` (local bridge), `kling` (cloud), plus updated `voxforge` preset pointing to `/v1/audio/speech`.
+- **`render_animation` mode `"kit"`** — now exposed in the MCP tool enum. Generates an EDL file in `out/` for import into Premiere / Resolve.
+
+### Changed
+
+- **`CLAUDE.md`**: code-driven animation promoted to **primary path**; FFmpeg + AI images demoted to "quick draft"; new sections for VoxForge voice and editor bridge workflow; tool table reorganised into Primary / Secondary / Auto-research groups (18 tools).
+- **`START_HERE.md`**: opening question set updated to surface animated explainer as a first-class format choice.
+- **`setup-keys.js`**: VoxForge added to TTS provider menu (second option, right after edge-tts). Four new config keys persisted: `VOXFORGE_URL`, `VOXFORGE_KEY`, `VOXFORGE_VOICE`, `VOXFORGE_MODEL`.
+- **`scripts/deep-validate.js`**: +3 checks (`export_to_editor`, `voxforge`, tool count label updated to 18).
+- Version bump: `2.3.1` → `2.3.2` across all version strings.
+
+---
+
 ## [2.3.1] — 2026-11-04
 
 ### Added

package/CLAUDE.md

@@ -58,7 +58,9 @@ If you're not sure what a tool does — call it with the obvious parameters. The
 
 ## THREE PATHS — PICK ONE
 
-### Path 1 — You write the scenes (default, no LLM key needed)
+> **The primary path is Path 2 (code-driven animation).** Every frame is a pure function of time `t`, rendered by Playwright + FFmpeg. This is what produces the high-quality, viral-style motion graphics clips. Path 1 (FFmpeg + AI images) is the fast fallback when Playwright is unavailable or the user wants a quick draft. Path 3 (auto-research) is for unattended batch.
+
+### Path 1 — You write the scenes + AI images (quick draft)
 
 Your IDE model writes the scenes. FrameForge generates TTS + AI images + renders with FFmpeg.
 
@@ -207,9 +209,20 @@ get_job_status({ jobId })   // poll every 30s until status = "SUCCEEDED"
 
 ---
 
-## ALL 17 MCP TOOLS
+## ALL 18 MCP TOOLS
+
+**Primary — code-driven animation (no LLM key, no image gen API):**
+
+| Tool | What it does |
+|------|-------------|
+| `scaffold_animation_project` | Scaffold a Playwright + FFmpeg animation project (engine, render scripts, STORYBOARD.md) |
+| `validate_storyboard` | Enforce the 4 hard gates before any scene code |
+| `render_animation` | Playwright renderer: `sheet` / `strip` / `storyboard` / `crop` / `full` / `mux` / `kit` / `look` |
+| `multi_voice_tts` | TTS per-call: `edge-tts` · **`voxforge`** · `elevenlabs` · `azure` · `openai` · `webhook` |
+| `export_to_editor` | Send finished animation to Premiere / Resolve / CapCut / After Effects / Remotion |
+| `external_platform_call` | HTTP bridge to VoxForge, Runway, Kling, Pika, or any platform |
 
-**No LLM key needed:**
+**Secondary — FFmpeg + AI images (fast draft, no Playwright needed):**
 
 | Tool | What it does |
 |------|-------------|
@@ -219,15 +232,10 @@ get_job_status({ jobId })   // poll every 30s until status = "SUCCEEDED"
 | `edit_scenes` | Patch captions, swap media files, append scenes |
 | `assemble_video` | FFmpeg render + quality gate → master MP4 |
 | `render_tts` | Generate voice audio for one scene |
-| `multi_voice_tts` | Override TTS provider per call without touching `.env` |
 | `generate_scene_image` | Generate one scene image |
 | `publish_video` | Deliver via file copy or HTTP webhook |
-| `external_platform_call` | HTTP bridge to ElevenLabs, Runway, Replicate, etc. |
-| `scaffold_animation_project` | Create a code-driven animation project |
-| `validate_storyboard` | Check STORYBOARD.md against the 4-gate contract |
-| `render_animation` | Playwright renderer: sheet / strip / storyboard / crop / full / look |
 
-**Needs a free LLM key:**
+**Auto-research (needs a free LLM key):**
 
 | Tool | What it does |
 |------|-------------|
@@ -238,6 +246,56 @@ get_job_status({ jobId })   // poll every 30s until status = "SUCCEEDED"
 
 ---
 
+## VOICE — VoxForge custom audio
+
+`multi_voice_tts` with `platform: "voxforge"` routes to your VoxForge instance:
+
+```
+multi_voice_tts({
+  text: "Your narration.",
+  outputPath: ".frameforge-files/voice_0.m4a",
+  platform: "voxforge",
+  voice: "my-cloned-voice-id",   // speaker ID from VoxForge
+  apiKey: "vf-..."               // or set VOXFORGE_KEY in .env
+})
+```
+
+Set in `.env` for all calls:
+```
+PROVIDER_TTS=voxforge
+VOXFORGE_URL=https://api.voxforge.io    # or your self-hosted URL
+VOXFORGE_KEY=vf-...
+VOXFORGE_VOICE=my-cloned-voice-id
+```
+
+---
+
+## EDITOR BRIDGES — send animation to editing apps
+
+After `render_animation full`, send the finished MP4 into any editing app:
+
+```
+// Export EDL timeline first (for apps that support it)
+render_animation({ projectDir: "...", mode: "kit" })
+
+// Send to DaVinci Resolve (default bridge port :8080)
+export_to_editor({ projectDir: "...", editor: "resolve" })
+
+// Send to Premiere Pro (bridge port :7777)
+export_to_editor({ projectDir: "...", editor: "premiere" })
+
+// Send to CapCut (bridge port :9090)
+export_to_editor({ projectDir: "...", editor: "capcut" })
+
+// Custom endpoint
+export_to_editor({ projectDir: "...", editor: "custom", editorUrl: "http://localhost:4000" })
+```
+
+Bridge servers run locally alongside the app. Setup docs: `docs/editor-bridges/`.
+Override ports: `RESOLVE_BRIDGE_URL`, `PREMIERE_BRIDGE_URL`, `CAPCUT_BRIDGE_URL`, `AE_BRIDGE_URL`.
+
+---
+
 ## SCENE FIELDS
 
 | Field | Required | Notes |

package/README.md

@@ -9,7 +9,7 @@
 [![npm](https://img.shields.io/npm/v/@amg555/frameforge-mcp.svg?label=npm)](https://www.npmjs.com/package/@amg555/frameforge-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
-[![Version](https://img.shields.io/badge/version-2.3.1-blue.svg)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-2.3.2-blue.svg)](CHANGELOG.md)
 [![MCP Spec](https://img.shields.io/badge/MCP-2024--11--05-blue.svg)](https://modelcontextprotocol.io/)
 [![Tests](https://img.shields.io/badge/tests-512%20passing-brightgreen.svg)](#testing)
 

package/install.sh

@@ -50,7 +50,7 @@ done
 if command -v edge-tts >/dev/null 2>&1; then
   echo "  edge-tts   $(command -v edge-tts) (free TTS, no key)"
 else
-  echo "  edge-tts   not found — run: npm install -g edge-tts"
+  echo "  edge-tts   not found — run: pip install edge-tts"
 fi
 
 echo

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amg555/frameforge-mcp",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "FrameForge — AI video production engine for agentic IDEs. npx @amg555/frameforge-mcp. FFmpeg + TTS run on your machine. 17 MCP tools.",
   "publishConfig": {
     "access": "public"

package/src/cli/doctor.js

@@ -89,7 +89,37 @@ if (edgeTts.status === 0) {
   );
 }
 
-// 5. System Font (for video subtitles/captions)
+// 5. Playwright / Chromium (required for code-driven animation — Path 2)
+const playwright = spawnSync('node', ['-e', "require('playwright')"], {
+  encoding: 'utf8', timeout: 5000,
+  // Look in the project's own node_modules first (how it ships in the npm package)
+  cwd: path.resolve(__dirname, '../..'),
+});
+const playwrightGlobal = spawnSync('node', ['-e', "require('playwright')"], {
+  encoding: 'utf8', timeout: 5000,
+});
+const hasPlaywright = playwright.status === 0 || playwrightGlobal.status === 0;
+
+// Check for a locally installed Chromium browser
+const chromiumPaths = [
+  path.join(require('os').homedir(), '.cache', 'ms-playwright'),   // Linux / macOS default
+  path.join(process.env.LOCALAPPDATA || '', 'ms-playwright'),       // Windows
+  path.join(require('os').homedir(), 'Library', 'Caches', 'ms-playwright'), // macOS alt
+];
+const hasChromium = chromiumPaths.some(p => { try { return require('fs').readdirSync(p).length > 0; } catch { return false; } });
+
+if (hasPlaywright && hasChromium) {
+  pass('Playwright', 'playwright package + Chromium browser installed (code-driven animation ready)');
+} else if (hasPlaywright && !hasChromium) {
+  warn('Playwright', 'playwright package found but Chromium browser not installed',
+    'Run in your animation project dir: npx playwright install chromium');
+} else {
+  warn('Playwright', 'Not installed — required for code-driven animation (Path 2)',
+    'Run in your animation project dir: npm install playwright && npx playwright install chromium\n' +
+    '    (Path 1 via create_video_from_script does not need Playwright)');
+}
+
+// 6. System Font (for video subtitles/captions)
 const FONT_CANDIDATES = [
   'C:\\Windows\\Fonts\\arialbd.ttf',
   'C:\\Windows\\Fonts\\calibrib.ttf',

package/src/cli/setup-keys.js

@@ -240,13 +240,20 @@ Press Enter to accept a default. Ctrl+C to cancel.
 
   cfg.PROVIDER_TTS = await menu('Choose TTS provider', [
     ['edge-tts',   'edge-tts — free, offline, 400+ voices. No key needed.'],
+    ['voxforge',   'VoxForge — custom voice cloning (github.com/amg555/voxforge). Get key: your VoxForge instance.'],
     ['elevenlabs', 'ElevenLabs — best quality + voice cloning. elevenlabs.io'],
     ['azure',      'Azure Cognitive Speech. portal.azure.com'],
     ['openai',     'OpenAI TTS (uses OPENAI_API_KEY above)'],
-    ['webhook',    'Custom/VoxForge/any TTS endpoint'],
+    ['webhook',    'Custom/any OpenAI-compatible TTS endpoint'],
   ], 'edge-tts');
 
-  if (cfg.PROVIDER_TTS === 'elevenlabs') {
+  if (cfg.PROVIDER_TTS === 'voxforge') {
+    cfg.VOXFORGE_URL   = await ask('  VoxForge base URL', 'https://api.voxforge.io');
+    cfg.VOXFORGE_KEY   = await askSecret('  VoxForge API key (leave blank if self-hosted without auth)');
+    cfg.VOXFORGE_VOICE = await ask('  Voice ID or cloned speaker ID', 'narrator');
+    cfg.VOXFORGE_MODEL = await ask('  Model ID (leave blank for default)', 'voxforge-v1');
+    console.log('  ℹ️   Self-hosted? Set VOXFORGE_URL to your instance URL (e.g. http://localhost:8080).');
+  } else if (cfg.PROVIDER_TTS === 'elevenlabs') {
     cfg.ELEVENLABS_API_KEY  = await askSecret('  ElevenLabs API key');
     cfg.ELEVENLABS_VOICE_ID = await ask('  Voice ID (leave blank for default Adam)', 'pNInz6obpgDQGcFmaJgB');
     console.log('  ℹ️   For voice cloning: set ELEVENLABS_VOICE_ID to your cloned voice ID.');
@@ -326,7 +333,7 @@ Press Enter to accept a default. Ctrl+C to cancel.
 
   const groups = {
     '# ── LLM ─────────────────────────────────────────────────────────': ['PROVIDER_LLM','GROQ_API_KEY','CEREBRAS_API_KEY','OPENROUTER_API_KEY','ANTHROPIC_API_KEY','GEMINI_API_KEY','MISTRAL_API_KEY','TOGETHER_API_KEY','OPENAI_API_KEY','OLLAMA_BASE_URL','OLLAMA_MODEL','WEBHOOK_LLM_URL','WEBHOOK_LLM_HEADERS','WEBHOOK_LLM_RESPONSE_PATH','LLM_MODEL'],
-    '# ── TTS ─────────────────────────────────────────────────────────': ['PROVIDER_TTS','ELEVENLABS_API_KEY','ELEVENLABS_VOICE_ID','AZURE_SPEECH_KEY','AZURE_SPEECH_REGION','WEBHOOK_TTS_URL','WEBHOOK_TTS_RESPONSE','WEBHOOK_TTS_RESPONSE_PATH','TTS_VOICE','TTS_RATE'],
+    '# ── TTS ─────────────────────────────────────────────────────────': ['PROVIDER_TTS','VOXFORGE_URL','VOXFORGE_KEY','VOXFORGE_VOICE','VOXFORGE_MODEL','ELEVENLABS_API_KEY','ELEVENLABS_VOICE_ID','AZURE_SPEECH_KEY','AZURE_SPEECH_REGION','WEBHOOK_TTS_URL','WEBHOOK_TTS_RESPONSE','WEBHOOK_TTS_RESPONSE_PATH','TTS_VOICE','TTS_RATE'],
     '# ── Image generation ─────────────────────────────────────────────': ['PROVIDER_IMAGE','FALAI_API_KEY','REPLICATE_API_KEY','WEBHOOK_IMAGE_URL','WEBHOOK_IMAGE_RESPONSE','WEBHOOK_IMAGE_RESPONSE_PATH','POLLINATIONS_MODEL'],
     '# ── Delivery webhooks ────────────────────────────────────────────': ['PUBLISH_WEBHOOK_URL','REVIEW_NOTIFY_URL'],
     '# ── External platform adapter ────────────────────────────────────': ['EXTERNAL_PLATFORM_NAME','EXTERNAL_PLATFORM_URL','EXTERNAL_PLATFORM_KEY','EXTERNAL_PLATFORM_INGEST_PATH','EXTERNAL_PLATFORM_RENDER_PATH','EXTERNAL_PLATFORM_STATUS_PATH'],

package/src/mcp-server/server.js

@@ -592,14 +592,14 @@ Example scene:
   // ── Tool 12: Multi-platform TTS ──────────────────────────────────────────
   // Call any voice platform per-request without changing global .env
   multi_voice_tts: {
-    description: 'Convert text to speech using any supported voice platform per-call. Overrides the global PROVIDER_TTS for this one request. Supports: edge-tts, elevenlabs, azure, openai, custom webhook.',
+    description: 'Convert text to speech using any supported voice platform per-call. Overrides the global PROVIDER_TTS for this one request. Supports: edge-tts, voxforge, elevenlabs, azure, openai, webhook.',
     inputSchema: {
       type: 'object',
       required: ['text', 'outputPath'],
       properties: {
         text:       { type: 'string', description: 'Text to synthesise' },
         outputPath: { type: 'string', description: 'Where to save the audio file (.m4a or .mp3)' },
-        platform:   { type: 'string', enum: ['edge-tts','elevenlabs','azure','openai','webhook'], description: 'TTS platform. Overrides PROVIDER_TTS for this call.' },
+        platform:   { type: 'string', enum: ['edge-tts','voxforge','elevenlabs','azure','openai','webhook'], description: 'TTS platform. Overrides PROVIDER_TTS for this call. "voxforge" = github.com/amg555/voxforge; uses VOXFORGE_URL + VOXFORGE_KEY.' },
         voice:      { type: 'string', description: 'Voice ID. edge-tts: e.g. en-US-GuyNeural. ElevenLabs: voice_id. Azure: short name. OpenAI: alloy/echo/fable/nova/onyx/shimmer.' },
         rate:       { type: 'string', description: 'Speaking rate, e.g. "-10%" for slower, "+20%" for faster (edge-tts)' },
         apiKey:     { type: 'string', description: 'API key for this call (optional — falls back to env var)' },
@@ -608,9 +608,11 @@ Example scene:
         sceneIndex: { type: 'number', description: 'Optional scene index for naming the output file' },
       },
     },
-    handler: async ({ text, outputPath, platform, voice, rate, apiKey, webhookUrl, productionId = 'adhoc', sceneIndex }) => {
+    handler: async ({ text, outputPath, platform: _platform, voice, rate, apiKey, webhookUrl, productionId = 'adhoc', sceneIndex }) => {
       const syncFs  = require('fs');
       const pathMod = require('path');
+      // Normalise platform name so 'voxforge' routes correctly
+      const platform = _platform ? _platform.toLowerCase() : undefined;
 
       // Guard: outputPath must not escape FILES_DIR — prevent path traversal
       if (outputPath) {
@@ -1003,17 +1005,18 @@ Modes:
   "crop"       — focal-point 9:16 mobile crop preview; pass timestamps as [aspect_ratio_string, t]
   "full"       — full render → out/<title>.mp4
   "mux"        — re-mux audio only (no re-render, use after changing audio)
+  "kit"        — export EDL/XML for Premiere Pro / DaVinci Resolve; run after "full"
   "look"       — pre-render linter (fonts, clipped text, NaN transforms, missing assets)
 
 Review budget: at least one "sheet" per shot, one "strip" per key motion/transition, one "crop" per story-carrying face.
-Returns { outputPath, passed } for "full", or { outputPath } for sheet/strip/storyboard.
+Returns { outputPath, passed } for "full", or { outputPath } for sheet/strip/storyboard/kit.
 Requires: npm install playwright && npx playwright install chromium (one-time setup in projectDir).`,
     inputSchema: {
       type: 'object',
       required: ['projectDir', 'mode'],
       properties: {
         projectDir:  { type: 'string', description: 'The directory created by scaffold_animation_project' },
-        mode:        { type: 'string', enum: ['sheet', 'stills', 'strip', 'storyboard', 'crop', 'full', 'mux', 'look'], description: 'Render mode' },
+        mode:        { type: 'string', enum: ['sheet', 'stills', 'strip', 'storyboard', 'crop', 'full', 'mux', 'kit', 'look'], description: 'Render mode' },
         timestamps:  { type: 'array', items: {}, description: 'For mode="stills": [t1, t2, ...]. For mode="strip": [startSeconds, endSeconds]. For mode="crop": ["9:16", t]. For mode="sheet": omit or pass shot times.' },
         audioPath:   { type: 'string', description: 'Audio file to mux in (for mode="full" or "mux")' },
         workers:     { type: 'number', default: 4, description: 'Parallel Playwright pages for mode="full"' },
@@ -1091,6 +1094,9 @@ Requires: npm install playwright && npx playwright install chromium (one-time se
         } else if (mode === 'full' || mode === 'mux') {
           const mp4 = files.find(f => f.endsWith('.mp4') && !f.includes('_preview'));
           if (mp4) outputPath = pathMod.join(outDir, mp4);
+        } else if (mode === 'kit') {
+          const edl = files.find(f => f.endsWith('.edl') || f.endsWith('.xml'));
+          if (edl) outputPath = pathMod.join(outDir, edl);
         } else if (mode === 'stills' || mode === 'strip' || mode === 'crop') {
           const stills = files.filter(f => f.endsWith('.png') || f.endsWith('.jpg'));
           if (stills.length > 0) outputPath = stills.map(f => pathMod.join(outDir, f));
@@ -1114,13 +1120,118 @@ Requires: npm install playwright && npx playwright install chromium (one-time se
     },
   },
 
+  // ── Tool 18: Export to editing app ────────────────────────────────────────
+  // Send a finished animation project to any local editing app via MCP bridge.
+  // Works with Premiere Pro, DaVinci Resolve, CapCut, After Effects, or Remotion.
+  export_to_editor: {
+    description: `Send a finished FrameForge animation to a local editing app for post-production.
+
+Supported editors (configure via env or pass editorUrl directly):
+  "premiere"     — Adobe Premiere Pro via local REST bridge (PREMIERE_BRIDGE_URL, default :7777)
+  "resolve"      — DaVinci Resolve Remote API (RESOLVE_BRIDGE_URL, default :8080)
+  "capcut"       — CapCut Desktop via MCP bridge (CAPCUT_BRIDGE_URL, default :9090)
+  "aftereffects" — Adobe After Effects via AEIO bridge (AE_BRIDGE_URL, default :7878)
+  "remotion"     — Remotion local dev server (REMOTION_BASE_URL, default :3001)
+  "custom"       — any HTTP endpoint (pass editorUrl)
+
+What this does:
+  1. Imports the rendered MP4 (and optionally the audio stem) into the editor
+  2. Exports an EDL/XML timeline from the animation project (render_animation kit mode)
+  3. Returns the editor's import confirmation or render job ID
+
+The bridge servers are lightweight companion apps you run locally alongside the editor.
+They are not installed by FrameForge — see docs/editor-bridges/ for setup instructions.`,
+    inputSchema: {
+      type: 'object',
+      required: ['projectDir'],
+      properties: {
+        projectDir: { type: 'string', description: 'The animation project directory (from scaffold_animation_project)' },
+        editor:     { type: 'string', enum: ['premiere', 'resolve', 'capcut', 'aftereffects', 'remotion', 'custom'], default: 'resolve', description: 'Target editing app' },
+        editorUrl:  { type: 'string', description: 'Override the editor bridge URL (e.g. http://localhost:8080). Useful for custom or remote bridges.' },
+        audioPath:  { type: 'string', description: 'Audio stem to import alongside the video (optional)' },
+        importOnly: { type: 'boolean', default: false, description: 'If true, only import the clip — do not trigger an export/render in the editor.' },
+      },
+    },
+    handler: async ({ projectDir, editor = 'resolve', editorUrl, audioPath, importOnly = false }) => {
+      const syncFs  = require('fs');
+      const pathMod = require('path');
+      const { ExternalAdapter } = require('../pipeline/external-adapter');
+
+      if (!projectDir) throw new Error('projectDir is required');
+      if (!syncFs.existsSync(projectDir)) throw new Error(`Project directory not found: ${projectDir}`);
+
+      // Find the most recently rendered MP4 in out/
+      const outDir = pathMod.join(projectDir, 'out');
+      if (!syncFs.existsSync(outDir)) {
+        throw new Error(`No out/ directory in ${projectDir}. Run render_animation with mode="full" first.`);
+      }
+      const mp4Files = syncFs.readdirSync(outDir)
+        .filter(f => f.endsWith('.mp4') && !f.includes('_preview'))
+        .map(f => pathMod.join(outDir, f))
+        .sort((a, b) => syncFs.statSync(b).mtimeMs - syncFs.statSync(a).mtimeMs);
+
+      if (mp4Files.length === 0) {
+        throw new Error(`No rendered MP4 found in ${outDir}. Run render_animation with mode="full" first.`);
+      }
+      const masterPath = mp4Files[0];
+
+      // Also find the EDL from kit mode (generate it now if missing)
+      const edlFiles = syncFs.readdirSync(outDir).filter(f => f.endsWith('.edl') || f.endsWith('.xml'));
+      let edlPath = edlFiles.length > 0 ? pathMod.join(outDir, edlFiles[0]) : null;
+
+      // Configure the adapter for the target editor
+      // editorUrl overrides the preset base URL
+      const adapterConfig = editorUrl
+        ? { name: editor, baseUrl: editorUrl }
+        : { name: editor };
+
+      const adapter = new ExternalAdapter(adapterConfig);
+
+      // Build the file list to import
+      const files = [masterPath];
+      if (audioPath && syncFs.existsSync(audioPath)) files.push(audioPath);
+      if (edlPath) files.push(edlPath);
+
+      let importResult;
+      try {
+        importResult = await adapter.ingestMedia({
+          files,
+          metadata: {
+            source:    'frameforge',
+            projectDir,
+            editor,
+            importOnly: String(importOnly),
+          },
+        });
+      } catch (err) {
+        // If the bridge is not running, give a clear message instead of a raw HTTP error
+        throw new Error(
+          `Could not reach ${editor} bridge at ${adapter.baseUrl}.\n` +
+          `Make sure the bridge is running.\n` +
+          `Error: ${err.message}\n\n` +
+          `See docs/editor-bridges/${editor}.md for setup instructions.`
+        );
+      }
+
+      return {
+        editor,
+        bridgeUrl: adapter.baseUrl,
+        importedFiles: files.map(f => pathMod.basename(f)),
+        masterPath,
+        edlPath,
+        importResult,
+        message: `Imported into ${editor} at ${adapter.baseUrl}. ${edlPath ? 'EDL/XML timeline included.' : 'Tip: run render_animation mode="kit" to also export an EDL timeline.'}`,
+      };
+    },
+  },
+
 };
 
 // ── MCP protocol handler (MCP 2024-11-05 spec) ───────────────────────────
 
 const SERVER_INFO = {
   name:    'video-pipeline',
-  version: '2.3.1',
+  version: '2.3.2',
 };
 
 const CAPABILITIES = {

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