@vibeframe/mcp-server 0.31.1 → 0.33.1

package/dist/index.js

@@ -1464,22 +1464,108 @@ async function handleTimelineToolCall(name, args) {
 // ../cli/src/commands/export.ts
 import { Command } from "commander";
 import { readFile as readFile2, access, stat } from "node:fs/promises";
-import { resolve as resolve3, basename } from "node:path";
+import { resolve as resolve4, basename } from "node:path";
 import { spawn } from "node:child_process";
+import chalk2 from "chalk";
+import ora2 from "ora";
+init_exec_safe();
+
+// ../cli/src/commands/output.ts
 import chalk from "chalk";
 import ora from "ora";
-init_exec_safe();
+function usageError(msg, suggestion) {
+  return { success: false, error: msg, code: "USAGE_ERROR", exitCode: 2 /* USAGE */, suggestion, retryable: false };
+}
+function notFoundError(path) {
+  return { success: false, error: `File not found: ${path}`, code: "NOT_FOUND", exitCode: 3 /* NOT_FOUND */, retryable: false };
+}
+function generalError(msg, suggestion) {
+  return { success: false, error: msg, code: "ERROR", exitCode: 1 /* GENERAL */, suggestion, retryable: false };
+}
+function exitWithError(err) {
+  if (isJsonMode()) {
+    console.error(JSON.stringify(err, null, 2));
+  } else {
+    console.error(chalk.red(`
+  ${err.error}`));
+    if (err.suggestion) {
+      console.error(chalk.dim(`  ${err.suggestion}`));
+    }
+    console.error();
+  }
+  process.exit(err.exitCode);
+}
+function isJsonMode() {
+  return process.env.VIBE_JSON_OUTPUT === "1";
+}
+function isQuietMode() {
+  return process.env.VIBE_QUIET_OUTPUT === "1";
+}
+function outputResult(result) {
+  if (isJsonMode()) {
+    const fields = process.env.VIBE_OUTPUT_FIELDS;
+    if (fields) {
+      const keys = fields.split(",").map((k) => k.trim());
+      const filtered = {};
+      for (const key of keys) {
+        if (key in result) filtered[key] = result[key];
+      }
+      if ("success" in result) filtered.success = result.success;
+      console.log(JSON.stringify(filtered, null, 2));
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  } else if (isQuietMode()) {
+    const primary = result.output ?? result.path ?? result.url ?? result.id ?? result.result;
+    if (primary !== void 0) console.log(String(primary));
+  }
+}
+
+// ../cli/src/commands/validate.ts
+import { resolve as resolve3, relative, isAbsolute } from "node:path";
+function validateOutputPath(path, cwd = process.cwd()) {
+  rejectControlChars(path);
+  if (isAbsolute(path)) {
+    return resolve3(path);
+  }
+  const resolved = resolve3(cwd, path);
+  const rel = relative(cwd, resolved);
+  if (rel.startsWith("..")) {
+    throw new Error(
+      `Output path "${path}" escapes the working directory. Use a path within "${cwd}".`
+    );
+  }
+  return resolved;
+}
+function rejectControlChars(input) {
+  if (/[\x00-\x1f\x7f-\x9f]/.test(input)) {
+    throw new Error("Input contains invalid control characters.");
+  }
+  return input;
+}
+
+// ../cli/src/commands/export.ts
 async function resolveProjectPath(inputPath) {
-  const filePath = resolve3(process.cwd(), inputPath);
+  const filePath = resolve4(process.cwd(), inputPath);
   try {
     const stats = await stat(filePath);
     if (stats.isDirectory()) {
-      return resolve3(filePath, "project.vibe.json");
+      return resolve4(filePath, "project.vibe.json");
     }
   } catch {
   }
   return filePath;
 }
+async function getMediaDuration(filePath, mediaType, defaultImageDuration = 5) {
+  if (mediaType === "image") {
+    return defaultImageDuration;
+  }
+  try {
+    return await ffprobeDuration(filePath);
+  } catch {
+    return defaultImageDuration;
+  }
+}
 async function checkHasAudio(filePath) {
   try {
     const { stdout } = await execSafe("ffprobe", [
@@ -1519,16 +1605,24 @@ async function runExport(projectPath, outputPath, options = {}) {
         message: "Project has no clips to export"
       };
     }
-    const finalOutputPath = resolve3(process.cwd(), outputPath);
+    const finalOutputPath = resolve4(process.cwd(), outputPath);
     const presetSettings = getPresetSettings(preset, summary.aspectRatio);
     const clips = project.getClips().sort((a, b) => a.startTime - b.startTime);
     const sources = project.getSources();
     const sourceAudioMap = /* @__PURE__ */ new Map();
+    const sourceActualDurationMap = /* @__PURE__ */ new Map();
     for (const clip of clips) {
       const source = sources.find((s) => s.id === clip.sourceId);
       if (source) {
         try {
           await access(source.url);
+          if (!sourceActualDurationMap.has(source.id)) {
+            try {
+              const dur = await getMediaDuration(source.url, source.type);
+              if (dur > 0) sourceActualDurationMap.set(source.id, dur);
+            } catch {
+            }
+          }
           if (source.type === "video" && !sourceAudioMap.has(source.id)) {
             sourceAudioMap.set(source.id, await checkHasAudio(source.url));
           }
@@ -1540,7 +1634,7 @@ async function runExport(projectPath, outputPath, options = {}) {
         }
       }
     }
-    const ffmpegArgs = buildFFmpegArgs(clips, sources, presetSettings, finalOutputPath, { overwrite, format, gapFill }, sourceAudioMap);
+    const ffmpegArgs = buildFFmpegArgs(clips, sources, presetSettings, finalOutputPath, { overwrite, format, gapFill }, sourceAudioMap, sourceActualDurationMap);
     await runFFmpegProcess(ffmpegPath, ffmpegArgs, () => {
     });
     return {
@@ -1560,24 +1654,37 @@ var exportCommand = new Command("export").description("Export project to video f
   "-p, --preset <preset>",
   "Quality preset (draft, standard, high, ultra)",
   "standard"
-).option("-y, --overwrite", "Overwrite output file if exists", false).option("-g, --gap-fill <strategy>", "Gap filling strategy (black, extend)", "extend").addHelpText("after", `
+).option("-y, --overwrite", "Overwrite output file if exists", false).option("-g, --gap-fill <strategy>", "Gap filling strategy (black, extend)", "extend").option("--dry-run", "Preview parameters without executing").addHelpText("after", `
 Examples:
   $ vibe export project.vibe.json -o output.mp4
   $ vibe export project.vibe.json -o output.mp4 -p high -y
   $ vibe export project.vibe.json -o output.webm -f webm
 
 No API keys needed. Requires FFmpeg.`).action(async (projectPath, options) => {
-  const spinner = ora("Checking FFmpeg...").start();
+  const spinner = ora2("Checking FFmpeg...").start();
   try {
+    if (options.output) {
+      validateOutputPath(options.output);
+    }
+    if (options.dryRun) {
+      outputResult({
+        dryRun: true,
+        command: "export",
+        params: {
+          project: projectPath,
+          output: options.output || null,
+          format: options.format,
+          preset: options.preset,
+          overwrite: options.overwrite,
+          gapFill: options.gapFill
+        }
+      });
+      return;
+    }
     const ffmpegPath = await findFFmpeg();
     if (!ffmpegPath) {
-      spinner.fail(chalk.red("FFmpeg not found"));
-      console.error();
-      console.error(chalk.yellow("Please install FFmpeg:"));
-      console.error(chalk.dim("  macOS:   brew install ffmpeg"));
-      console.error(chalk.dim("  Ubuntu:  sudo apt install ffmpeg"));
-      console.error(chalk.dim("  Windows: winget install ffmpeg"));
-      process.exit(1);
+      spinner.fail("FFmpeg not found");
+      exitWithError(generalError("FFmpeg not found", "Install with: brew install ffmpeg (macOS), apt install ffmpeg (Linux), or winget install ffmpeg (Windows)"));
     }
     spinner.text = "Loading project...";
     const filePath = await resolveProjectPath(projectPath);
@@ -1586,10 +1693,10 @@ No API keys needed. Requires FFmpeg.`).action(async (projectPath, options) => {
     const project = Project.fromJSON(data);
     const summary = project.getSummary();
     if (summary.clipCount === 0) {
-      spinner.fail(chalk.red("Project has no clips to export"));
-      process.exit(1);
+      spinner.fail("Project has no clips to export");
+      exitWithError(usageError("Project has no clips to export"));
     }
-    const outputPath = options.output ? resolve3(process.cwd(), options.output) : resolve3(
+    const outputPath = options.output ? resolve4(process.cwd(), options.output) : resolve4(
       process.cwd(),
       `${basename(projectPath, ".vibe.json")}.${options.format}`
     );
@@ -1598,23 +1705,31 @@ No API keys needed. Requires FFmpeg.`).action(async (projectPath, options) => {
     const sources = project.getSources();
     spinner.text = "Verifying source files...";
     const sourceAudioMap = /* @__PURE__ */ new Map();
+    const sourceActualDurationMap = /* @__PURE__ */ new Map();
     for (const clip of clips) {
       const source = sources.find((s) => s.id === clip.sourceId);
       if (source) {
         try {
           await access(source.url);
+          if (!sourceActualDurationMap.has(source.id)) {
+            try {
+              const dur = await getMediaDuration(source.url, source.type);
+              if (dur > 0) sourceActualDurationMap.set(source.id, dur);
+            } catch {
+            }
+          }
           if (source.type === "video" && !sourceAudioMap.has(source.id)) {
             sourceAudioMap.set(source.id, await checkHasAudio(source.url));
           }
         } catch {
-          spinner.fail(chalk.red(`Source file not found: ${source.url}`));
-          process.exit(1);
+          spinner.fail(`Source file not found: ${source.url}`);
+          exitWithError(notFoundError(source.url));
         }
       }
     }
     spinner.text = "Building export command...";
     const gapFillStrategy = options.gapFill === "black" ? "black" : "extend";
-    const ffmpegArgs = buildFFmpegArgs(clips, sources, presetSettings, outputPath, { ...options, gapFill: gapFillStrategy }, sourceAudioMap);
+    const ffmpegArgs = buildFFmpegArgs(clips, sources, presetSettings, outputPath, { ...options, gapFill: gapFillStrategy }, sourceAudioMap, sourceActualDurationMap);
     if (process.env.DEBUG) {
       console.log("\nFFmpeg command:");
       console.log("ffmpeg", ffmpegArgs.join(" "));
@@ -1624,23 +1739,18 @@ No API keys needed. Requires FFmpeg.`).action(async (projectPath, options) => {
     await runFFmpegProcess(ffmpegPath, ffmpegArgs, (progress) => {
       spinner.text = `Encoding... ${progress}%`;
     });
-    spinner.succeed(chalk.green(`Exported: ${outputPath}`));
+    spinner.succeed(chalk2.green(`Exported: ${outputPath}`));
     console.log();
-    console.log(chalk.dim("  Duration:"), `${summary.duration.toFixed(1)}s`);
-    console.log(chalk.dim("  Clips:"), summary.clipCount);
-    console.log(chalk.dim("  Format:"), options.format);
-    console.log(chalk.dim("  Preset:"), options.preset);
-    console.log(chalk.dim("  Resolution:"), presetSettings.resolution);
+    console.log(chalk2.dim("  Duration:"), `${summary.duration.toFixed(1)}s`);
+    console.log(chalk2.dim("  Clips:"), summary.clipCount);
+    console.log(chalk2.dim("  Format:"), options.format);
+    console.log(chalk2.dim("  Preset:"), options.preset);
+    console.log(chalk2.dim("  Resolution:"), presetSettings.resolution);
     console.log();
   } catch (error) {
-    spinner.fail(chalk.red("Export failed"));
-    if (error instanceof Error) {
-      console.error(chalk.red(error.message));
-      if (process.env.DEBUG) {
-        console.error(error.stack);
-      }
-    }
-    process.exit(1);
+    spinner.fail("Export failed");
+    const msg = error instanceof Error ? error.message : String(error);
+    exitWithError(generalError(`Export failed: ${msg}`));
   }
 });
 async function findFFmpeg() {
@@ -1743,7 +1853,7 @@ function createGapFillPlans(gaps, clips, sources) {
     return { gap, fills };
   });
 }
-function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, sourceAudioMap = /* @__PURE__ */ new Map()) {
+function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, sourceAudioMap = /* @__PURE__ */ new Map(), sourceActualDurationMap = /* @__PURE__ */ new Map()) {
   const args = [];
   if (options.overwrite) {
     args.push("-y");
@@ -1828,6 +1938,12 @@ function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, so
         const trimStart = clip.sourceStartOffset;
         const trimEnd = clip.sourceStartOffset + clip.duration;
         videoFilter = `[${srcIdx}:v]trim=start=${trimStart}:end=${trimEnd},setpts=PTS-STARTPTS`;
+        const sourceDuration = sourceActualDurationMap.get(source.id) || source.duration || 0;
+        const availableDuration = sourceDuration - clip.sourceStartOffset;
+        if (availableDuration > 0 && availableDuration < clip.duration - 0.1) {
+          const padDuration = clip.duration - availableDuration;
+          videoFilter += `,tpad=stop_mode=clone:stop_duration=${padDuration.toFixed(3)}`;
+        }
       }
       videoFilter += `,scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:(ow-iw)/2:(oh-ih)/2,setsar=1`;
       for (const effect of clip.effects || []) {
@@ -1862,62 +1978,95 @@ function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, so
       videoStreamIdx++;
     }
   }
-  const audioGaps = detectTimelineGaps(audioClips, totalDuration);
-  const audioSegments = [];
+  const audioTrackMap = /* @__PURE__ */ new Map();
   for (const clip of audioClips) {
-    audioSegments.push({ type: "clip", clip, startTime: clip.startTime });
-  }
-  for (const gap of audioGaps) {
-    audioSegments.push({ type: "gap", gap, startTime: gap.start });
+    const trackId = clip.trackId || "audio-track-1";
+    if (!audioTrackMap.has(trackId)) {
+      audioTrackMap.set(trackId, []);
+    }
+    audioTrackMap.get(trackId).push(clip);
   }
-  audioSegments.sort((a, b) => a.startTime - b.startTime);
-  const audioStreams = [];
+  const videoDuration = videoClips.length > 0 ? Math.max(...videoClips.map((c) => c.startTime + c.duration)) : 0;
+  const audioDuration = audioClips.length > 0 ? Math.max(...audioClips.map((c) => c.startTime + c.duration)) : 0;
+  const timelineDuration = totalDuration || Math.max(videoDuration, audioDuration);
+  const trackOutputLabels = [];
   let audioStreamIdx = 0;
-  for (const segment of audioSegments) {
-    if (segment.type === "clip" && segment.clip) {
-      const clip = segment.clip;
-      const source = sources.find((s) => s.id === clip.sourceId);
-      if (!source) continue;
-      const srcIdx = sourceMap.get(source.id);
-      if (srcIdx === void 0) continue;
-      const hasAudio = source.type === "audio" || sourceAudioMap.get(source.id) === true;
-      let audioFilter;
-      if (hasAudio) {
-        const audioTrimStart = clip.sourceStartOffset;
-        const audioTrimEnd = clip.sourceStartOffset + clip.duration;
-        const sourceDuration = source.duration || 0;
-        const clipDuration = clip.duration;
-        if (source.type === "audio" && sourceDuration > clipDuration && audioTrimStart === 0) {
-          const tempo = sourceDuration / clipDuration;
-          if (tempo <= 2) {
-            audioFilter = `[${srcIdx}:a]atempo=${tempo.toFixed(4)},asetpts=PTS-STARTPTS`;
+  for (const [, trackClips] of audioTrackMap) {
+    const sorted = [...trackClips].sort((a, b) => a.startTime - b.startTime);
+    const trackGaps = detectTimelineGaps(sorted, timelineDuration);
+    const segments = [];
+    for (const clip of sorted) {
+      segments.push({ type: "clip", clip, startTime: clip.startTime });
+    }
+    for (const gap of trackGaps) {
+      segments.push({ type: "gap", gap, startTime: gap.start });
+    }
+    segments.sort((a, b) => a.startTime - b.startTime);
+    const segmentLabels = [];
+    for (const segment of segments) {
+      if (segment.type === "clip" && segment.clip) {
+        const clip = segment.clip;
+        const source = sources.find((s) => s.id === clip.sourceId);
+        if (!source) continue;
+        const srcIdx = sourceMap.get(source.id);
+        if (srcIdx === void 0) continue;
+        const hasAudio = source.type === "audio" || sourceAudioMap.get(source.id) === true;
+        let audioFilter;
+        if (hasAudio) {
+          const audioTrimStart = clip.sourceStartOffset;
+          const audioTrimEnd = clip.sourceStartOffset + clip.duration;
+          const sourceDuration = source.duration || 0;
+          const clipDuration = clip.duration;
+          if (source.type === "audio" && sourceDuration > clipDuration && audioTrimStart === 0) {
+            const tempo = sourceDuration / clipDuration;
+            if (tempo <= 2) {
+              audioFilter = `[${srcIdx}:a]atempo=${tempo.toFixed(4)},asetpts=PTS-STARTPTS`;
+            } else {
+              audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+            }
           } else {
             audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
           }
         } else {
-          audioFilter = `[${srcIdx}:a]atrim=start=${audioTrimStart}:end=${audioTrimEnd},asetpts=PTS-STARTPTS`;
+          audioFilter = `anullsrc=r=48000:cl=stereo,atrim=0:${clip.duration},asetpts=PTS-STARTPTS`;
         }
-      } else {
-        audioFilter = `anullsrc=r=48000:cl=stereo,atrim=0:${clip.duration},asetpts=PTS-STARTPTS`;
-      }
-      for (const effect of clip.effects || []) {
-        if (effect.type === "fadeIn") {
-          audioFilter += `,afade=t=in:st=0:d=${effect.duration}`;
-        } else if (effect.type === "fadeOut") {
-          const fadeStart = clip.duration - effect.duration;
-          audioFilter += `,afade=t=out:st=${fadeStart}:d=${effect.duration}`;
+        const clipVolume = clip.volume;
+        if (clipVolume !== void 0 && clipVolume !== 1) {
+          audioFilter += `,volume=${clipVolume.toFixed(2)}`;
+        }
+        for (const effect of clip.effects || []) {
+          if (effect.type === "fadeIn") {
+            audioFilter += `,afade=t=in:st=0:d=${effect.duration}`;
+          } else if (effect.type === "fadeOut") {
+            const fadeStart = clip.duration - effect.duration;
+            audioFilter += `,afade=t=out:st=${fadeStart}:d=${effect.duration}`;
+          } else if (effect.type === "volume" && effect.params?.level !== void 0) {
+            audioFilter += `,volume=${effect.params.level}`;
+          }
+        }
+        const label = `a${audioStreamIdx}`;
+        audioFilter += `[${label}]`;
+        filterParts.push(audioFilter);
+        segmentLabels.push(`[${label}]`);
+        audioStreamIdx++;
+      } else if (segment.type === "gap" && segment.gap) {
+        const gapDuration = segment.gap.end - segment.gap.start;
+        if (gapDuration > 1e-3) {
+          const label = `a${audioStreamIdx}`;
+          filterParts.push(`anullsrc=r=48000:cl=stereo,atrim=0:${gapDuration.toFixed(4)},asetpts=PTS-STARTPTS[${label}]`);
+          segmentLabels.push(`[${label}]`);
+          audioStreamIdx++;
         }
       }
-      audioFilter += `[a${audioStreamIdx}]`;
-      filterParts.push(audioFilter);
-      audioStreams.push(`[a${audioStreamIdx}]`);
-      audioStreamIdx++;
-    } else if (segment.type === "gap" && segment.gap) {
-      const gapDuration = segment.gap.end - segment.gap.start;
-      const audioGapFilter = `anullsrc=r=48000:cl=stereo,atrim=0:${gapDuration},asetpts=PTS-STARTPTS[a${audioStreamIdx}]`;
-      filterParts.push(audioGapFilter);
-      audioStreams.push(`[a${audioStreamIdx}]`);
-      audioStreamIdx++;
+    }
+    if (segmentLabels.length > 1) {
+      const trackLabel = `atrack${trackOutputLabels.length}`;
+      filterParts.push(`${segmentLabels.join("")}concat=n=${segmentLabels.length}:v=0:a=1[${trackLabel}]`);
+      trackOutputLabels.push(`[${trackLabel}]`);
+    } else if (segmentLabels.length === 1) {
+      const trackLabel = `atrack${trackOutputLabels.length}`;
+      filterParts.push(`${segmentLabels[0]}acopy[${trackLabel}]`);
+      trackOutputLabels.push(`[${trackLabel}]`);
     }
   }
   if (videoStreams.length > 1) {
@@ -1927,16 +2076,16 @@ function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, so
   } else if (videoStreams.length === 1) {
     filterParts.push(`${videoStreams[0]}copy[outv]`);
   }
-  if (audioStreams.length > 1) {
+  if (trackOutputLabels.length > 1) {
     filterParts.push(
-      `${audioStreams.join("")}concat=n=${audioStreams.length}:v=0:a=1[outa]`
+      `${trackOutputLabels.join("")}amix=inputs=${trackOutputLabels.length}:duration=longest:normalize=0[outa]`
     );
-  } else if (audioStreams.length === 1) {
-    filterParts.push(`${audioStreams[0]}acopy[outa]`);
+  } else if (trackOutputLabels.length === 1) {
+    filterParts.push(`${trackOutputLabels[0]}acopy[outa]`);
   }
   args.push("-filter_complex", filterParts.join(";"));
   args.push("-map", "[outv]");
-  if (audioStreams.length > 0) {
+  if (trackOutputLabels.length > 0) {
     args.push("-map", "[outa]");
   }
   args.push(...presetSettings.ffmpegArgs);
@@ -1944,7 +2093,7 @@ function buildFFmpegArgs(clips, sources, presetSettings, outputPath, options, so
   return args;
 }
 function runFFmpegProcess(ffmpegPath, args, onProgress) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const ffmpeg = spawn(ffmpegPath, args, {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1968,7 +2117,7 @@ function runFFmpegProcess(ffmpegPath, args, onProgress) {
     });
     ffmpeg.on("close", (code) => {
       if (code === 0) {
-        resolve12();
+        resolve13();
       } else {
         const errorMatch = stderr.match(/Error.*$/m);
         const errorMsg = errorMatch ? errorMatch[0] : `FFmpeg exited with code ${code}`;
@@ -2108,7 +2257,7 @@ async function handleExportToolCall(name, args) {
 }
 
 // ../cli/src/commands/ai-edit.ts
-import { resolve as resolve6, dirname, basename as basename2, extname, join as join2 } from "node:path";
+import { resolve as resolve7, dirname, basename as basename2, extname, join as join2 } from "node:path";
 import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir3 } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 
@@ -2913,7 +3062,7 @@ var GeminiProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve12) => setTimeout(resolve12, ms));
+    return new Promise((resolve13) => setTimeout(resolve13, ms));
   }
   /**
    * Extend a previously generated Veo video
@@ -6756,7 +6905,7 @@ var RunwayProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve12) => setTimeout(resolve12, ms));
+    return new Promise((resolve13) => setTimeout(resolve13, ms));
   }
 };
 var runwayProvider = new RunwayProvider();
@@ -7172,7 +7321,7 @@ var KlingProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve12) => setTimeout(resolve12, ms));
+    return new Promise((resolve13) => setTimeout(resolve13, ms));
   }
 };
 var klingProvider = new KlingProvider();
@@ -7467,7 +7616,7 @@ var GrokProvider = class {
     }
   }
   sleep(ms) {
-    return new Promise((resolve12) => setTimeout(resolve12, ms));
+    return new Promise((resolve13) => setTimeout(resolve13, ms));
   }
 };
 var grokProvider = new GrokProvider();
@@ -7726,7 +7875,7 @@ var ReplicateProvider = class {
    * Sleep helper
    */
   sleep(ms) {
-    return new Promise((resolve12) => setTimeout(resolve12, ms));
+    return new Promise((resolve13) => setTimeout(resolve13, ms));
   }
   /**
    * Generate music from text prompt using MusicGen
@@ -8110,12 +8259,12 @@ var replicateProvider = new ReplicateProvider();
 // ../cli/src/utils/api-key.ts
 import { createInterface } from "node:readline";
 import { readFile as readFile4, writeFile as writeFile3, access as access3 } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import { config } from "dotenv";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // ../cli/src/config/index.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 import { homedir } from "node:os";
 import { readFile as readFile3, writeFile as writeFile2, mkdir, access as access2 } from "node:fs/promises";
 import { parse, stringify } from "yaml";
@@ -8151,8 +8300,8 @@ function createDefaultConfig() {
 }
 
 // ../cli/src/config/index.ts
-var CONFIG_DIR = resolve4(homedir(), ".vibeframe");
-var CONFIG_PATH = resolve4(CONFIG_DIR, "config.yaml");
+var CONFIG_DIR = resolve5(homedir(), ".vibeframe");
+var CONFIG_PATH = resolve5(CONFIG_DIR, "config.yaml");
 async function loadConfig() {
   try {
     await access2(CONFIG_PATH);
@@ -8185,20 +8334,20 @@ async function getApiKeyFromConfig(providerKey) {
 
 // ../cli/src/utils/api-key.ts
 function loadEnv() {
-  config({ path: resolve5(process.cwd(), ".env"), debug: false });
+  config({ path: resolve6(process.cwd(), ".env"), debug: false, quiet: true });
   const monorepoRoot = findMonorepoRoot();
   if (monorepoRoot && monorepoRoot !== process.cwd()) {
-    config({ path: resolve5(monorepoRoot, ".env"), debug: false });
+    config({ path: resolve6(monorepoRoot, ".env"), debug: false, quiet: true });
   }
 }
 function findMonorepoRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
     try {
-      __require.resolve(resolve5(dir, "pnpm-workspace.yaml"));
+      __require.resolve(resolve6(dir, "pnpm-workspace.yaml"));
       return dir;
     } catch {
-      dir = resolve5(dir, "..");
+      dir = resolve6(dir, "..");
     }
   }
   return null;
@@ -8208,7 +8357,7 @@ async function prompt(question, hidden = false) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     if (hidden && process.stdin.isTTY) {
       process.stdout.write(question);
       let input = "";
@@ -8222,7 +8371,7 @@ async function prompt(question, hidden = false) {
           process.stdin.removeListener("data", onData);
           process.stdout.write("\n");
           rl.close();
-          resolve12(input);
+          resolve13(input);
         } else if (char === "") {
           process.exit(1);
         } else if (char === "\x7F" || char === "\b") {
@@ -8237,7 +8386,7 @@ async function prompt(question, hidden = false) {
     } else {
       rl.question(question, (answer) => {
         rl.close();
-        resolve12(answer);
+        resolve13(answer);
       });
     }
   });
@@ -8250,9 +8399,11 @@ async function getApiKey(envVar, providerName, optionValue) {
     ANTHROPIC_API_KEY: "anthropic",
     OPENAI_API_KEY: "openai",
     GOOGLE_API_KEY: "google",
+    XAI_API_KEY: "xai",
     ELEVENLABS_API_KEY: "elevenlabs",
     RUNWAY_API_SECRET: "runway",
     KLING_API_KEY: "kling",
+    OPENROUTER_API_KEY: "openrouter",
     IMGBB_API_KEY: "imgbb",
     REPLICATE_API_TOKEN: "replicate"
   };
@@ -8272,22 +8423,22 @@ async function getApiKey(envVar, providerName, optionValue) {
     return null;
   }
   console.log();
-  console.log(chalk2.yellow(`${providerName} API key not found.`));
-  console.log(chalk2.dim(`Set ${envVar} in .env (current directory), run 'vibe setup', or enter below.`));
+  console.log(chalk3.yellow(`${providerName} API key not found.`));
+  console.log(chalk3.dim(`Set ${envVar} in .env (current directory), run 'vibe setup', or enter below.`));
   console.log();
-  const apiKey = await prompt(chalk2.cyan(`Enter ${providerName} API key: `), true);
+  const apiKey = await prompt(chalk3.cyan(`Enter ${providerName} API key: `), true);
   if (!apiKey || apiKey.trim() === "") {
     return null;
   }
-  const save = await prompt(chalk2.cyan("Save to .env for future use? (y/N): "));
+  const save = await prompt(chalk3.cyan("Save to .env for future use? (y/N): "));
   if (save.toLowerCase() === "y" || save.toLowerCase() === "yes") {
     await saveApiKeyToEnv(envVar, apiKey.trim());
-    console.log(chalk2.green("API key saved to .env"));
+    console.log(chalk3.green("API key saved to .env"));
   }
   return apiKey.trim();
 }
 async function saveApiKeyToEnv(envVar, apiKey) {
-  const envPath = resolve5(process.cwd(), ".env");
+  const envPath = resolve6(process.cwd(), ".env");
   let content = "";
   try {
     await access3(envPath);
@@ -9256,8 +9407,8 @@ async function applyTextOverlays(options) {
   if (!texts || texts.length === 0) {
     return { success: false, error: "No texts provided" };
   }
-  const absVideoPath = resolve6(process.cwd(), videoPath);
-  const absOutputPath = resolve6(process.cwd(), outputPath);
+  const absVideoPath = resolve7(process.cwd(), videoPath);
+  const absOutputPath = resolve7(process.cwd(), outputPath);
   if (!existsSync2(absVideoPath)) {
     return { success: false, error: `Video not found: ${absVideoPath}` };
   }
@@ -9628,10 +9779,10 @@ async function handleAiEditingToolCall(name, args) {
 
 // ../cli/src/commands/ai-analyze.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { extname as extname2, resolve as resolve7 } from "node:path";
+import { extname as extname2, resolve as resolve8 } from "node:path";
 import { existsSync as existsSync3 } from "node:fs";
-import chalk3 from "chalk";
-import ora2 from "ora";
+import chalk4 from "chalk";
+import ora3 from "ora";
 async function executeGeminiVideo(options) {
   try {
     const apiKey = await getApiKey("GOOGLE_API_KEY", "Google");
@@ -9649,7 +9800,7 @@ async function executeGeminiVideo(options) {
     if (isYouTube) {
       videoData = options.source;
     } else {
-      const absPath = resolve7(process.cwd(), options.source);
+      const absPath = resolve8(process.cwd(), options.source);
       if (!existsSync3(absPath)) {
         return { success: false, error: `File not found: ${absPath}` };
       }
@@ -9722,7 +9873,7 @@ async function executeAnalyze(options) {
         }
         imageBuffer = Buffer.from(await response.arrayBuffer());
       } else {
-        const absPath = resolve7(process.cwd(), source);
+        const absPath = resolve8(process.cwd(), source);
         if (!existsSync3(absPath)) {
           return { success: false, error: `File not found: ${absPath}` };
         }
@@ -9757,7 +9908,7 @@ async function executeAnalyze(options) {
       }
       videoData = Buffer.from(await response.arrayBuffer());
     } else {
-      const absPath = resolve7(process.cwd(), source);
+      const absPath = resolve8(process.cwd(), source);
       if (!existsSync3(absPath)) {
         return { success: false, error: `File not found: ${absPath}` };
       }
@@ -9792,10 +9943,10 @@ async function executeAnalyze(options) {
 
 // ../cli/src/commands/ai-review.ts
 import { readFile as readFile7, rename } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { existsSync as existsSync4 } from "node:fs";
-import chalk4 from "chalk";
-import ora3 from "ora";
+import chalk5 from "chalk";
+import ora4 from "ora";
 init_exec_safe();
 function parseReviewFeedback(response) {
   let cleaned = response.trim();
@@ -9820,7 +9971,7 @@ function parseReviewFeedback(response) {
 }
 async function executeReview(options) {
   const { videoPath, storyboardPath, autoApply = false, verify = false, model = "flash" } = options;
-  const absVideoPath = resolve8(process.cwd(), videoPath);
+  const absVideoPath = resolve9(process.cwd(), videoPath);
   if (!existsSync4(absVideoPath)) {
     return { success: false, error: `Video not found: ${absVideoPath}` };
   }
@@ -9830,7 +9981,7 @@ async function executeReview(options) {
   }
   let storyboardContext = "";
   if (storyboardPath) {
-    const absStoryboardPath = resolve8(process.cwd(), storyboardPath);
+    const absStoryboardPath = resolve9(process.cwd(), storyboardPath);
     if (existsSync4(absStoryboardPath)) {
       const content = await readFile7(absStoryboardPath, "utf-8");
       storyboardContext = `
@@ -9886,7 +10037,7 @@ Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFi
   };
   if (autoApply && feedback.autoFixable.length > 0) {
     let currentInput = absVideoPath;
-    const outputBase = options.outputPath ? resolve8(process.cwd(), options.outputPath) : absVideoPath.replace(/(\.[^.]+)$/, "-reviewed$1");
+    const outputBase = options.outputPath ? resolve9(process.cwd(), options.outputPath) : absVideoPath.replace(/(\.[^.]+)$/, "-reviewed$1");
     for (const fix of feedback.autoFixable) {
       if (fix.type === "color_grade" && fix.ffmpegFilter) {
         try {
@@ -9935,8 +10086,8 @@ Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFi
 // ../cli/src/commands/ai-image.ts
 import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir4 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
-import chalk5 from "chalk";
-import ora4 from "ora";
+import chalk6 from "chalk";
+import ora5 from "ora";
 init_exec_safe();
 async function executeThumbnailBestFrame(options) {
   const {
@@ -10158,9 +10309,9 @@ async function handleAiAnalysisToolCall(name, args) {
 
 // ../cli/src/commands/ai-script-pipeline.ts
 import { readFile as readFile9, writeFile as writeFile7, mkdir as mkdir5, unlink, rename as rename2 } from "node:fs/promises";
-import { resolve as resolve9, basename as basename3, extname as extname3 } from "node:path";
+import { resolve as resolve10, basename as basename3, extname as extname3 } from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 init_exec_safe();
 
 // ../cli/src/commands/ai-helpers.ts
@@ -10180,7 +10331,37 @@ async function downloadVideo(url, apiKey) {
 var DEFAULT_VIDEO_RETRIES = 2;
 var RETRY_DELAY_MS = 5e3;
 function sleep(ms) {
-  return new Promise((resolve12) => setTimeout(resolve12, ms));
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
+async function generateVideoWithRetryGrok(grok, segment, options, maxRetries, onProgress) {
+  const prompt2 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await grok.generateVideo(prompt2, {
+        prompt: prompt2,
+        duration: options.duration,
+        aspectRatio: options.aspectRatio,
+        referenceImage: options.referenceImage
+      });
+      if (result.status !== "failed" && result.id) {
+        return { requestId: result.id };
+      }
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Retry ${attempt + 1}/${maxRetries}...`);
+        await sleep(RETRY_DELAY_MS);
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+        await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(chalk7.dim(`
+  [Grok error: ${errMsg}]`));
+      }
+    }
+  }
+  return null;
 }
 async function generateVideoWithRetryKling(kling, segment, options, maxRetries, onProgress) {
   const prompt2 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
@@ -10211,7 +10392,7 @@ async function generateVideoWithRetryKling(kling, segment, options, maxRetries,
         onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
       } else {
-        console.error(chalk6.dim(`
+        console.error(chalk7.dim(`
   [Kling error: ${errMsg}]`));
       }
     }
@@ -10240,7 +10421,7 @@ async function generateVideoWithRetryRunway(runway, segment, referenceImage, opt
         onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
       } else {
-        console.error(chalk6.dim(`
+        console.error(chalk7.dim(`
   [Runway error: ${errMsg}]`));
       }
     }
@@ -10271,7 +10452,7 @@ async function generateVideoWithRetryVeo(gemini, segment, options, maxRetries, o
         onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
       } else {
-        console.error(chalk6.dim(`
+        console.error(chalk7.dim(`
   [Veo error: ${errMsg}]`));
       }
     }
@@ -10326,24 +10507,23 @@ async function executeScriptToVideo(options) {
     }
     let videoApiKey;
     if (!options.imagesOnly) {
-      if (options.generator === "kling") {
-        videoApiKey = await getApiKey("KLING_API_KEY", "Kling") ?? void 0;
-        if (!videoApiKey) {
-          return { success: false, outputDir, scenes: 0, error: "Kling API key required (or use imagesOnly option). Run 'vibe setup' or set KLING_API_KEY in .env" };
-        }
-      } else if (options.generator === "veo") {
-        videoApiKey = await getApiKey("GOOGLE_API_KEY", "Google") ?? void 0;
-        if (!videoApiKey) {
-          return { success: false, outputDir, scenes: 0, error: "Google API key required for Veo video generation (or use imagesOnly option). Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
-        }
-      } else {
-        videoApiKey = await getApiKey("RUNWAY_API_SECRET", "Runway") ?? void 0;
-        if (!videoApiKey) {
-          return { success: false, outputDir, scenes: 0, error: "Runway API key required (or use imagesOnly option). Run 'vibe setup' or set RUNWAY_API_SECRET in .env" };
-        }
+      const generatorKeyMap = {
+        grok: { envVar: "XAI_API_KEY", name: "xAI (Grok)" },
+        kling: { envVar: "KLING_API_KEY", name: "Kling" },
+        runway: { envVar: "RUNWAY_API_SECRET", name: "Runway" },
+        veo: { envVar: "GOOGLE_API_KEY", name: "Google (Veo)" }
+      };
+      const generator = options.generator || "grok";
+      const generatorInfo = generatorKeyMap[generator];
+      if (!generatorInfo) {
+        return { success: false, outputDir, scenes: 0, error: `Invalid generator: ${options.generator}. Available: ${Object.keys(generatorKeyMap).join(", ")}` };
+      }
+      videoApiKey = await getApiKey(generatorInfo.envVar, generatorInfo.name) ?? void 0;
+      if (!videoApiKey) {
+        return { success: false, outputDir, scenes: 0, error: `${generatorInfo.name} API key required (or use imagesOnly option). Run 'vibe setup' or set ${generatorInfo.envVar} in .env` };
       }
     }
-    const absOutputDir = resolve9(process.cwd(), outputDir);
+    const absOutputDir = resolve10(process.cwd(), outputDir);
     if (!existsSync6(absOutputDir)) {
       await mkdir5(absOutputDir, { recursive: true });
     }
@@ -10365,7 +10545,7 @@ async function executeScriptToVideo(options) {
     if (segments.length === 0) {
       return { success: false, outputDir, scenes: 0, error: "Failed to generate storyboard" };
     }
-    const storyboardPath = resolve9(absOutputDir, "storyboard.json");
+    const storyboardPath = resolve10(absOutputDir, "storyboard.json");
     await writeFile7(storyboardPath, JSON.stringify(segments, null, 2), "utf-8");
     const result = {
       success: true,
@@ -10399,7 +10579,7 @@ async function executeScriptToVideo(options) {
           voiceId: options.voice
         });
         if (ttsResult.success && ttsResult.audioBuffer) {
-          const audioPath = resolve9(absOutputDir, `narration-${i + 1}.mp3`);
+          const audioPath = resolve10(absOutputDir, `narration-${i + 1}.mp3`);
           await writeFile7(audioPath, ttsResult.audioBuffer);
           const actualDuration = await getAudioDuration(audioPath);
           segment.duration = actualDuration;
@@ -10487,7 +10667,7 @@ async function executeScriptToVideo(options) {
             }
           }
         }
-        const imagePath = resolve9(absOutputDir, `scene-${i + 1}.png`);
+        const imagePath = resolve10(absOutputDir, `scene-${i + 1}.png`);
         if (imageBuffer) {
           await writeFile7(imagePath, imageBuffer);
           imagePaths.push(imagePath);
@@ -10511,7 +10691,57 @@ async function executeScriptToVideo(options) {
     const videoPaths = [];
     const maxRetries = options.retries ?? DEFAULT_VIDEO_RETRIES;
     if (!options.imagesOnly && videoApiKey) {
-      if (options.generator === "kling") {
+      if (options.generator === "grok") {
+        const grok = new GrokProvider();
+        await grok.initialize({ apiKey: videoApiKey });
+        for (let i = 0; i < segments.length; i++) {
+          if (!imagePaths[i]) {
+            videoPaths.push("");
+            continue;
+          }
+          const segment = segments[i];
+          const videoDuration = Math.min(15, Math.max(1, segment.duration));
+          const imageBuffer = await readFile9(imagePaths[i]);
+          const ext = extname3(imagePaths[i]).toLowerCase().slice(1);
+          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
+          const taskResult = await generateVideoWithRetryGrok(
+            grok,
+            segment,
+            { duration: videoDuration, aspectRatio: options.aspectRatio || "16:9", referenceImage },
+            maxRetries
+          );
+          if (taskResult) {
+            try {
+              const waitResult = await grok.waitForCompletion(taskResult.requestId, void 0, 3e5);
+              if (waitResult.status === "completed" && waitResult.videoUrl) {
+                const videoPath = resolve10(absOutputDir, `scene-${i + 1}.mp4`);
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                await writeFile7(videoPath, buffer);
+                const targetDuration = segment.duration;
+                const actualVideoDuration = await getVideoDuration(videoPath);
+                if (actualVideoDuration < targetDuration - 0.1) {
+                  const extendedPath = resolve10(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                  await unlink(videoPath);
+                  await rename2(extendedPath, videoPath);
+                }
+                videoPaths.push(videoPath);
+                result.videos.push(videoPath);
+              } else {
+                videoPaths.push("");
+                result.failedScenes.push(i + 1);
+              }
+            } catch {
+              videoPaths.push("");
+              result.failedScenes.push(i + 1);
+            }
+          } else {
+            videoPaths.push("");
+            result.failedScenes.push(i + 1);
+          }
+        }
+      } else if (options.generator === "kling") {
         const kling = new KlingProvider();
         await kling.initialize({ apiKey: videoApiKey });
         if (!kling.isConfigured()) {
@@ -10534,13 +10764,13 @@ async function executeScriptToVideo(options) {
             try {
               const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, void 0, 6e5);
               if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const videoPath = resolve9(absOutputDir, `scene-${i + 1}.mp4`);
+                const videoPath = resolve10(absOutputDir, `scene-${i + 1}.mp4`);
                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile7(videoPath, buffer);
                 const targetDuration = segment.duration;
                 const actualVideoDuration = await getVideoDuration(videoPath);
                 if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve9(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                  const extendedPath = resolve10(absOutputDir, `scene-${i + 1}-extended.mp4`);
                   await extendVideoNaturally(videoPath, targetDuration, extendedPath);
                   await unlink(videoPath);
                   await rename2(extendedPath, videoPath);
@@ -10580,13 +10810,13 @@ async function executeScriptToVideo(options) {
             try {
               const waitResult = await veo.waitForVideoCompletion(taskResult.operationName, void 0, 3e5);
               if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const videoPath = resolve9(absOutputDir, `scene-${i + 1}.mp4`);
+                const videoPath = resolve10(absOutputDir, `scene-${i + 1}.mp4`);
                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile7(videoPath, buffer);
                 const targetDuration = segment.duration;
                 const actualVideoDuration = await getVideoDuration(videoPath);
                 if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve9(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                  const extendedPath = resolve10(absOutputDir, `scene-${i + 1}-extended.mp4`);
                   await extendVideoNaturally(videoPath, targetDuration, extendedPath);
                   await unlink(videoPath);
                   await rename2(extendedPath, videoPath);
@@ -10632,13 +10862,13 @@ async function executeScriptToVideo(options) {
             try {
               const waitResult = await runway.waitForCompletion(taskResult.taskId, void 0, 3e5);
               if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const videoPath = resolve9(absOutputDir, `scene-${i + 1}.mp4`);
+                const videoPath = resolve10(absOutputDir, `scene-${i + 1}.mp4`);
                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile7(videoPath, buffer);
                 const targetDuration = segment.duration;
                 const actualVideoDuration = await getVideoDuration(videoPath);
                 if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve9(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                  const extendedPath = resolve10(absOutputDir, `scene-${i + 1}-extended.mp4`);
                   await extendVideoNaturally(videoPath, targetDuration, extendedPath);
                   await unlink(videoPath);
                   await rename2(extendedPath, videoPath);
@@ -10751,13 +10981,13 @@ async function executeScriptToVideo(options) {
       });
       currentTime += actualDuration;
     }
-    const projectPath = resolve9(absOutputDir, "project.vibe.json");
+    const projectPath = resolve10(absOutputDir, "project.vibe.json");
     await writeFile7(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
     result.projectPath = projectPath;
     result.totalDuration = currentTime;
     if (options.review) {
       try {
-        const storyboardFile = resolve9(absOutputDir, "storyboard.json");
+        const storyboardFile = resolve10(absOutputDir, "storyboard.json");
         const reviewTarget = videoPaths.find((p) => p && p !== "") || imagePaths.find((p) => p && p !== "");
         if (reviewTarget) {
           const reviewResult = await executeReview({
@@ -10788,10 +11018,10 @@ async function executeScriptToVideo(options) {
 
 // ../cli/src/commands/ai-highlights.ts
 import { readFile as readFile10, writeFile as writeFile8, mkdir as mkdir6 } from "node:fs/promises";
-import { resolve as resolve10, dirname as dirname2, basename as basename4, extname as extname4 } from "node:path";
+import { resolve as resolve11, dirname as dirname2, basename as basename4, extname as extname4 } from "node:path";
 import { existsSync as existsSync7 } from "node:fs";
-import chalk7 from "chalk";
-import ora5 from "ora";
+import chalk8 from "chalk";
+import ora6 from "ora";
 init_exec_safe();
 function filterHighlights(highlights, options) {
   let filtered = highlights.filter((h) => h.confidence >= options.threshold);
@@ -10815,7 +11045,7 @@ function filterHighlights(highlights, options) {
 }
 async function executeHighlights(options) {
   try {
-    const absPath = resolve10(process.cwd(), options.media);
+    const absPath = resolve11(process.cwd(), options.media);
     if (!existsSync7(absPath)) {
       return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: `File not found: ${absPath}` };
     }
@@ -10963,7 +11193,7 @@ Analyze both what is SHOWN (visual cues, actions, expressions) and what is SAID
       totalHighlightDuration
     };
     if (options.output) {
-      const outputPath = resolve10(process.cwd(), options.output);
+      const outputPath = resolve11(process.cwd(), options.output);
       await writeFile8(outputPath, JSON.stringify({
         sourceFile: absPath,
         totalDuration: sourceDuration,
@@ -10998,7 +11228,7 @@ Analyze both what is SHOWN (visual cues, actions, expressions) and what is SAID
           currentTime += highlight.duration;
         }
       }
-      const projectPath = resolve10(process.cwd(), options.project);
+      const projectPath = resolve11(process.cwd(), options.project);
       await writeFile8(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       extractResult.projectPath = projectPath;
     }
@@ -11018,7 +11248,7 @@ async function executeAutoShorts(options) {
     if (!commandExists("ffmpeg")) {
       return { success: false, shorts: [], error: "FFmpeg not found" };
     }
-    const absPath = resolve10(process.cwd(), options.video);
+    const absPath = resolve11(process.cwd(), options.video);
     if (!existsSync7(absPath)) {
       return { success: false, shorts: [], error: `File not found: ${absPath}` };
     }
@@ -11146,7 +11376,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
         }))
       };
     }
-    const outputDir = options.outputDir ? resolve10(process.cwd(), options.outputDir) : dirname2(absPath);
+    const outputDir = options.outputDir ? resolve11(process.cwd(), options.outputDir) : dirname2(absPath);
     if (options.outputDir && !existsSync7(outputDir)) {
       await mkdir6(outputDir, { recursive: true });
     }
@@ -11157,7 +11387,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
     for (let i = 0; i < selectedHighlights.length; i++) {
       const h = selectedHighlights[i];
       const baseName = basename4(absPath, extname4(absPath));
-      const outputPath = resolve10(outputDir, `${baseName}-short-${i + 1}.mp4`);
+      const outputPath = resolve11(outputDir, `${baseName}-short-${i + 1}.mp4`);
       const { stdout: probeOut } = await execSafe("ffprobe", [
         "-v",
         "error",
@@ -11449,7 +11679,7 @@ async function handleToolCall(name, args) {
 
 // src/resources/index.ts
 import { readFile as readFile11 } from "node:fs/promises";
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 var resources = [
   {
     uri: "vibe://project/current",
@@ -11484,7 +11714,7 @@ var resources = [
 ];
 var currentProjectPath = process.env.VIBE_PROJECT_PATH || null;
 async function loadProject2(projectPath) {
-  const absPath = resolve11(process.cwd(), projectPath);
+  const absPath = resolve12(process.cwd(), projectPath);
   const content = await readFile11(absPath, "utf-8");
   const data = JSON.parse(content);
   return Project.fromJSON(data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeframe/mcp-server",
-  "version": "0.31.1",
+  "version": "0.33.1",
   "description": "VibeFrame MCP Server - AI-native video editing via Model Context Protocol",
   "type": "module",
   "bin": {
@@ -57,8 +57,8 @@
     "tsx": "^4.21.0",
     "typescript": "^5.3.3",
     "vitest": "^1.2.2",
-    "@vibeframe/cli": "0.31.1",
-    "@vibeframe/core": "0.31.1"
+    "@vibeframe/cli": "0.33.1",
+    "@vibeframe/core": "0.33.1"
   },
   "engines": {
     "node": ">=20"