@x12i/youtube-video-uploader-cli 1.1.0 → 1.3.0

package/src/actions/replace-background.js

@@ -0,0 +1,154 @@
+import ffmpeg from 'fluent-ffmpeg';
+import ffmpegStatic from 'ffmpeg-static';
+import ffprobeStatic from 'ffprobe-static';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  searchMedia,
+  selectBest,
+  downloadAsset,
+  composeVideo,
+  deriveSearchQuery,
+  getMediaDuration,
+} from '../index.js';
+
+if (ffmpegStatic && fs.existsSync(ffmpegStatic)) {
+  ffmpeg.setFfmpegPath(ffmpegStatic);
+}
+if (ffprobeStatic?.path && fs.existsSync(ffprobeStatic.path)) {
+  ffmpeg.setFfprobePath(ffprobeStatic.path);
+}
+
+/**
+ * Extract audio track from a video file.
+ *
+ * @param {string} inputVideoPath
+ * @param {string} outputAudioPath
+ * @returns {Promise<string>}
+ */
+export function extractAudio(inputVideoPath, outputAudioPath) {
+  if (!fs.existsSync(inputVideoPath)) {
+    throw new Error(`Input video file not found: ${inputVideoPath}`);
+  }
+
+  fs.mkdirSync(path.dirname(path.resolve(outputAudioPath)), { recursive: true });
+
+  return new Promise((resolve, reject) => {
+    ffmpeg(inputVideoPath)
+      .noVideo()
+      .audioCodec('aac')
+      .audioBitrate('192k')
+      .outputOptions(['-movflags', '+faststart'])
+      .output(outputAudioPath)
+      .on('end', () => resolve(outputAudioPath))
+      .on('error', (err) => reject(new Error(`Failed to extract audio from ${inputVideoPath}: ${err.message}`)))
+      .run();
+  });
+}
+
+/**
+ * Replace the background visuals of a video while preserving its audio.
+ *
+ * @param {object} params
+ * @param {string} params.inputPath - Source video path
+ * @param {string} params.outputPath - Output video path
+ * @param {object} params.action - Action definition
+ * @param {object} [params.entry] - Entry metadata object
+ * @param {object} [params.context] - Pipeline context (keys, cacheDir, tempDir, etc.)
+ * @param {boolean} [params.dryRun=false]
+ * @returns {Promise<{ outputPath: string, duration?: number, dryRun?: boolean, command?: string, asset?: object }>}
+ */
+export async function replaceBackground(params) {
+  const {
+    inputPath,
+    outputPath,
+    action = {},
+    entry = {},
+    context = {},
+    dryRun = false,
+  } = params;
+
+  const query = action.query || entry.media?.query || entry.mediaQuery || deriveSearchQuery(entry);
+  const mediaType = action.mediaType || action.assetType || entry.media?.type || 'video';
+  const provider = action.provider || entry.media?.provider || 'auto';
+  const orientation = action.orientation || entry.media?.orientation || 'landscape';
+  const mode = action.mode || entry.media?.mode || 'video-loop';
+
+  if (dryRun) {
+    const plan = `Replace background: query="${query}" (${provider}, ${orientation}, mode: ${mode}) + audio from ${inputPath} -> ${outputPath}`;
+    return {
+      outputPath,
+      dryRun: true,
+      command: plan,
+    };
+  }
+
+  const tempDir = context.tempDir || path.dirname(path.resolve(outputPath));
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  const audioExt = '.m4a';
+  const extractedAudioPath = path.join(
+    tempDir,
+    `extracted_audio_${path.basename(inputPath, path.extname(inputPath))}_${Date.now()}${audioExt}`
+  );
+
+  // 1. Extract audio
+  await extractAudio(inputPath, extractedAudioPath);
+  const audioDuration = await getMediaDuration(extractedAudioPath);
+
+  // 2. Search stock media
+  const searchResults = await searchMedia({
+    query,
+    type: mediaType,
+    provider,
+    orientation,
+    safeSearch: action.safeSearch !== false,
+    pexelsKey: context.pexelsKey,
+    pixabayKey: context.pixabayKey,
+    cacheDir: context.cacheDir,
+    fetchFn: context.fetchFn,
+  });
+
+  // 3. Select best candidate
+  const winningAsset = selectBest(searchResults, {
+    targetDuration: audioDuration,
+    orientation,
+    avoidReuse: action.avoidReuse !== false,
+    cacheDir: context.cacheDir,
+  });
+
+  if (!winningAsset) {
+    throw new Error(`No suitable stock media found for query: "${query}" (provider: ${provider})`);
+  }
+
+  // 4. Download asset
+  const downloaded = await downloadAsset(winningAsset, {
+    cacheDir: context.cacheDir,
+    fetchFn: context.fetchFn,
+  });
+
+  // 5. Compose video
+  const composeResult = await composeVideo({
+    backgroundPath: downloaded.localPath,
+    audioPath: extractedAudioPath,
+    outputPath,
+    mode,
+    targetWidth: action.width || 1920,
+    targetHeight: action.height || 1080,
+    fps: action.fps || 30,
+    dryRun: false,
+  });
+
+  // Clean up temporary extracted audio file
+  if (fs.existsSync(extractedAudioPath)) {
+    try {
+      fs.unlinkSync(extractedAudioPath);
+    } catch {}
+  }
+
+  return {
+    outputPath,
+    duration: composeResult.duration,
+    asset: winningAsset,
+  };
+}

package/src/actions/shorten.js

@@ -0,0 +1,271 @@
+import ffmpeg from 'fluent-ffmpeg';
+import ffmpegStatic from 'ffmpeg-static';
+import ffprobeStatic from 'ffprobe-static';
+import fs from 'node:fs';
+import path from 'node:path';
+
+if (ffmpegStatic && fs.existsSync(ffmpegStatic)) {
+  ffmpeg.setFfmpegPath(ffmpegStatic);
+}
+if (ffprobeStatic?.path && fs.existsSync(ffprobeStatic.path)) {
+  ffmpeg.setFfprobePath(ffprobeStatic.path);
+}
+
+/**
+ * Parse time expression to seconds.
+ * Supports: 'mm:ss', 'hh:mm:ss', seconds as string or number.
+ *
+ * @param {string | number} time
+ * @returns {number}
+ */
+export function parseTimeSeconds(time) {
+  if (typeof time === 'number') {
+    if (isNaN(time) || time < 0) {
+      throw new Error(`Invalid time duration: ${time}`);
+    }
+    return time;
+  }
+
+  if (typeof time !== 'string') {
+    throw new Error(`Invalid time format: ${time}`);
+  }
+
+  const trimmed = time.trim();
+  if (!trimmed) {
+    throw new Error('Empty time value provided.');
+  }
+
+  if (trimmed.includes(':')) {
+    const parts = trimmed.split(':').map(p => parseFloat(p.trim()));
+    if (parts.some(p => isNaN(p) || p < 0)) {
+      throw new Error(`Invalid time format: "${time}"`);
+    }
+    if (parts.length === 2) {
+      // mm:ss
+      return parts[0] * 60 + parts[1];
+    }
+    if (parts.length === 3) {
+      // hh:mm:ss
+      return parts[0] * 3600 + parts[1] * 60 + parts[2];
+    }
+    throw new Error(`Invalid time format: "${time}"`);
+  }
+
+  const parsed = parseFloat(trimmed);
+  if (isNaN(parsed) || parsed < 0) {
+    throw new Error(`Invalid time format: "${time}"`);
+  }
+  return parsed;
+}
+
+/**
+ * Probe video metadata using ffprobe.
+ *
+ * @param {string} filePath
+ * @returns {Promise<{ duration: number, width: number, height: number, fps: number, sampleRate: number }>}
+ */
+export function getVideoMetadata(filePath) {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(filePath)) {
+      return reject(new Error(`File not found: ${filePath}`));
+    }
+
+    ffmpeg.ffprobe(filePath, (err, metadata) => {
+      if (err) {
+        return reject(new Error(`FFprobe error for ${filePath}: ${err.message}`));
+      }
+
+      const videoStream = metadata.streams?.find(s => s.codec_type === 'video');
+      const audioStream = metadata.streams?.find(s => s.codec_type === 'audio');
+
+      let duration = metadata.format?.duration;
+      if (typeof duration === 'string') duration = parseFloat(duration);
+      if (!duration && videoStream?.duration) {
+        duration = parseFloat(videoStream.duration);
+      }
+      if (!duration && audioStream?.duration) {
+        duration = parseFloat(audioStream.duration);
+      }
+
+      let fps = 30;
+      if (videoStream?.r_frame_rate) {
+        const [num, den] = videoStream.r_frame_rate.split('/').map(Number);
+        if (num && den) {
+          fps = Math.round(num / den);
+        }
+      }
+
+      resolve({
+        duration: duration || 0,
+        width: videoStream?.width || 1920,
+        height: videoStream?.height || 1080,
+        fps: fps || 30,
+        sampleRate: parseInt(audioStream?.sample_rate, 10) || 44100,
+      });
+    });
+  });
+}
+
+/**
+ * Shorten a video by cutting at cutPoint, applying a fade-out before the cutPoint,
+ * and appending silent padding buffer after the cut.
+ *
+ * @param {object} params
+ * @param {string} params.inputPath - Source video path
+ * @param {string} params.outputPath - Output video path
+ * @param {string | number} params.cutPoint - Cut timestamp/seconds
+ * @param {number} [params.fadeDuration=3] - Duration of fade out in seconds
+ * @param {number} [params.paddingDuration=2] - Duration of silent buffer in seconds
+ * @param {'black' | 'freeze-frame'} [params.paddingFill='black']
+ * @param {Array<'audio' | 'video'>} [params.fadeTargets=['audio', 'video']]
+ * @param {boolean} [params.dryRun=false]
+ * @param {(msg: string) => void} [params.onWarn]
+ * @returns {Promise<{ outputPath: string, duration: number, dryRun?: boolean, command?: string }>}
+ */
+export async function shortenVideo(params) {
+  const {
+    inputPath,
+    outputPath,
+    cutPoint,
+    fadeDuration = 3,
+    paddingDuration = 2,
+    paddingFill = 'black',
+    fadeTargets = ['audio', 'video'],
+    dryRun = false,
+    onWarn,
+  } = params;
+
+  if (cutPoint === undefined || cutPoint === null) {
+    throw new Error('Action "shorten" requires "cutPoint" parameter.');
+  }
+
+  const cutSeconds = parseTimeSeconds(cutPoint);
+  if (cutSeconds <= 0) {
+    throw new Error(`Action "shorten" cutPoint must be greater than 0 (received: ${cutPoint}).`);
+  }
+
+  let videoMeta = { duration: 0, width: 1920, height: 1080, fps: 30, sampleRate: 44100 };
+  if (fs.existsSync(inputPath)) {
+    try {
+      videoMeta = await getVideoMetadata(inputPath);
+    } catch (err) {
+      if (!dryRun) {
+        throw err;
+      }
+    }
+  }
+
+  if (videoMeta.duration > 0 && cutSeconds >= videoMeta.duration) {
+    throw new Error(
+      `cutPoint (${cutSeconds}s) is greater than or equal to source video duration (${videoMeta.duration.toFixed(1)}s).`
+    );
+  }
+
+  let effectiveFadeDuration = Math.max(0, fadeDuration);
+  let fadeStart = cutSeconds - effectiveFadeDuration;
+  if (fadeStart < 0) {
+    if (onWarn) {
+      onWarn(`fadeDuration (${fadeDuration}s) exceeds cutPoint (${cutSeconds}s); clamping fade start to 0s.`);
+    }
+    fadeStart = 0;
+    effectiveFadeDuration = cutSeconds;
+  }
+
+  const totalDuration = cutSeconds + paddingDuration;
+  const width = videoMeta.width || 1920;
+  const height = videoMeta.height || 1080;
+  const fps = videoMeta.fps || 30;
+  const sampleRate = videoMeta.sampleRate || 44100;
+
+  const shouldFadeVideo = fadeTargets.includes('video');
+  const shouldFadeAudio = fadeTargets.includes('audio');
+
+  if (dryRun) {
+    const videoFadePart = shouldFadeVideo ? `, fade out at ${fadeStart.toFixed(1)}s for ${effectiveFadeDuration.toFixed(1)}s` : '';
+    const audioFadePart = shouldFadeAudio ? `, audio fade out at ${fadeStart.toFixed(1)}s for ${effectiveFadeDuration.toFixed(1)}s` : '';
+    const plan = `Shorten: trim to ${cutSeconds.toFixed(1)}s${videoFadePart}${audioFadePart} + ${paddingDuration}s silent padding (${paddingFill}) -> ${outputPath}`;
+    return {
+      outputPath,
+      duration: totalDuration,
+      dryRun: true,
+      command: plan,
+    };
+  }
+
+  fs.mkdirSync(path.dirname(path.resolve(outputPath)), { recursive: true });
+
+  return new Promise((resolve, reject) => {
+    const command = ffmpeg();
+
+    // Input 0: source video
+    command.input(inputPath);
+
+    const complexFilters = [];
+
+    // Filter video 0
+    let v0Filter = `trim=0:${cutSeconds},setpts=PTS-STARTPTS`;
+    if (shouldFadeVideo && effectiveFadeDuration > 0) {
+      v0Filter += `,fade=t=out:st=${fadeStart}:d=${effectiveFadeDuration}`;
+    }
+    complexFilters.push(`[0:v]${v0Filter}[v0]`);
+
+    // Filter audio 0
+    let a0Filter = `atrim=0:${cutSeconds},asetpts=PTS-STARTPTS`;
+    if (shouldFadeAudio && effectiveFadeDuration > 0) {
+      a0Filter += `,afade=t=out:st=${fadeStart}:d=${effectiveFadeDuration}`;
+    }
+    complexFilters.push(`[0:a]${a0Filter}[a0]`);
+
+    if (paddingDuration > 0) {
+      // Input 1 for audio padding: anullsrc
+      command.input(`anullsrc=r=${sampleRate}:cl=stereo`).inputOptions(['-f', 'lavfi', '-t', `${paddingDuration}`]);
+
+      if (paddingFill === 'freeze-frame') {
+        // Use the last frame of the trimmed portion as padding
+        complexFilters.push(`[v0]split=2[v0_out][v0_last]`);
+        complexFilters.push(`[v0_last]trim=${Math.max(0, cutSeconds - 0.04)}:${cutSeconds},setpts=PTS-STARTPTS,loop=loop=-1:size=1:start=0,trim=0:${paddingDuration},setpts=PTS-STARTPTS[vpad]`);
+        complexFilters.push(`[v0_out][a0][vpad][1:a]concat=n=2:v=1:a=1[outv][outa]`);
+      } else {
+        // Plain black padding via lavfi color, forced to match the trimmed video
+        command.input(`color=c=black:s=${width}x${height}:r=${fps}:d=${paddingDuration}`).inputOptions(['-f', 'lavfi']);
+        complexFilters.push(`[v0]format=yuv420p,setsar=1[v0f]`);
+        complexFilters.push(`[2:v]scale=${width}:${height}:flags=neighbor,setsar=1,fps=${fps},format=yuv420p[vpad]`);
+        complexFilters.push(`[v0f][a0][vpad][1:a]concat=n=2:v=1:a=1[outv][outa]`);
+      }
+    } else {
+      complexFilters.push(`[v0]copy[outv]`);
+      complexFilters.push(`[a0]copy[outa]`);
+    }
+
+    command
+      .complexFilter(complexFilters)
+      .outputOptions([
+        '-map', '[outv]',
+        '-map', '[outa]',
+        '-c:v', 'libx264',
+        '-crf', '18',
+        '-preset', 'veryfast',
+        '-c:a', 'aac',
+        '-b:a', '192k',
+        '-pix_fmt', 'yuv420p',
+        '-movflags', '+faststart',
+        `-t`, `${totalDuration}`,
+      ])
+      .output(outputPath)
+      .on('end', () => {
+        resolve({
+          outputPath,
+          duration: totalDuration,
+        });
+      })
+      .on('error', (err) => {
+        if (fs.existsSync(outputPath)) {
+          try {
+            fs.unlinkSync(outputPath);
+          } catch {}
+        }
+        reject(new Error(`Shorten video failed: ${err.message}`));
+      })
+      .run();
+  });
+}

package/src/auth.js

@@ -8,7 +8,7 @@ import pc from 'picocolors';
 
 export const YOUTUBE_SCOPES = [
   'https://www.googleapis.com/auth/youtube.upload',
-  'https://www.googleapis.com/auth/youtube',
+  'https://www.googleapis.com/auth/youtube.force-ssl',
 ];
 
 export const DEFAULT_REDIRECT_URI = 'http://localhost:3000/oauth2callback';

package/src/batch/clone-metadata.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Deep clone and update metadata for the output directory.
+ *
+ * @param {object} rawMetadata - Original raw metadata object
+ * @param {string} outputDir - Path to output directory
+ * @param {Array<object>} results - Array of action pipeline results per entry
+ * @returns {object} Cloned metadata object that was written
+ */
+export function cloneMetadataForOutput(rawMetadata, outputDir, results = []) {
+  if (!outputDir) {
+    throw new Error('outputDir is required to clone metadata.');
+  }
+
+  const cloned = JSON.parse(JSON.stringify(rawMetadata || {}));
+  const resultMap = new Map(results.map(r => [r.songKey || r.filename, r]));
+
+  if (cloned.songs && typeof cloned.songs === 'object' && !Array.isArray(cloned.songs)) {
+    for (const [songKey, songData] of Object.entries(cloned.songs)) {
+      const res = resultMap.get(songKey);
+      if (res) {
+        if (res.actionsApplied && res.actionsApplied.length > 0) {
+          songData.actionsApplied = res.actionsApplied;
+        }
+        if (res.generatedFilename) {
+          songData.filename = res.generatedFilename;
+        }
+      }
+    }
+  } else if (Array.isArray(cloned.videos)) {
+    for (const video of cloned.videos) {
+      const res = resultMap.get(video.filename);
+      if (res) {
+        if (res.actionsApplied && res.actionsApplied.length > 0) {
+          video.actionsApplied = res.actionsApplied;
+        }
+        if (res.generatedFilename) {
+          video.filename = res.generatedFilename;
+        }
+      }
+    }
+  }
+
+  fs.mkdirSync(outputDir, { recursive: true });
+  const outputMetadataPath = path.join(outputDir, 'metadata.json');
+  fs.writeFileSync(outputMetadataPath, JSON.stringify(cloned, null, 2) + '\n', 'utf-8');
+
+  return cloned;
+}

package/src/batch/plan.js

@@ -0,0 +1,194 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { loadMetadata } from '../metadata.js';
+
+/**
+ * Determine the output directory based on source directory and options.
+ *
+ * @param {string} sourceDir
+ * @param {object} [options]
+ * @param {string} [options.outputDir]
+ * @param {string} [options.outputSuffix]
+ * @param {boolean} [options.hasShorten=false]
+ * @returns {string}
+ */
+export function resolveOutputDirectory(sourceDir, options = {}) {
+  const resolvedSource = path.resolve(sourceDir || process.cwd());
+  if (options.outputDir) {
+    return path.resolve(options.outputDir);
+  }
+  const suffix = options.outputSuffix !== undefined
+    ? options.outputSuffix
+    : (options.hasShorten ? ' (short)' : ' (edited)');
+  return path.join(path.dirname(resolvedSource), path.basename(resolvedSource) + suffix);
+}
+
+/**
+ * Resolve actions configuration for a specific entry.
+ *
+ * @param {object} params
+ * @param {string} params.songKey
+ * @param {string} params.filename
+ * @param {object} [params.rawEntry]
+ * @param {object} [params.rawMetadata]
+ * @param {object} [params.actionsFileConfig]
+ * @returns {Array<object>}
+ */
+export function resolveEntryActions({ songKey, filename, rawEntry, rawMetadata, actionsFileConfig }) {
+  // If actions file is provided, check it first
+  if (actionsFileConfig) {
+    if (actionsFileConfig.songs && actionsFileConfig.songs[songKey]?.actions) {
+      return actionsFileConfig.songs[songKey].actions;
+    }
+    if (Array.isArray(actionsFileConfig.videos)) {
+      const match = actionsFileConfig.videos.find(v => v.filename === filename || v.songKey === songKey);
+      if (match?.actions) return match.actions;
+    }
+    if (Array.isArray(actionsFileConfig.defaultActions)) {
+      return actionsFileConfig.defaultActions;
+    }
+    if (Array.isArray(actionsFileConfig.actions)) {
+      return actionsFileConfig.actions;
+    }
+  }
+
+  // Next check entry specific actions
+  if (Array.isArray(rawEntry?.actions)) {
+    return rawEntry.actions;
+  }
+
+  // Check raw metadata songs[songKey].actions
+  if (rawMetadata?.songs && rawMetadata.songs[songKey]?.actions) {
+    return rawMetadata.songs[songKey].actions;
+  }
+
+  // Check raw metadata defaultActions
+  if (Array.isArray(rawMetadata?.defaultActions)) {
+    return rawMetadata.defaultActions;
+  }
+
+  return [];
+}
+
+/**
+ * Plan batch actions for a directory.
+ *
+ * @param {string} sourceDir
+ * @param {object} [options]
+ * @param {string} [options.metadataFile]
+ * @param {string} [options.actionsFile]
+ * @param {string} [options.outputDir]
+ * @param {string} [options.outputSuffix]
+ * @param {string} [options.only]
+ * @param {boolean} [options.force=false]
+ * @param {boolean} [options.dryRun=false]
+ * @returns {object}
+ */
+export function planBatchActions(sourceDir, options = {}) {
+  const resolvedSource = path.resolve(sourceDir || process.cwd());
+  const metadataPath = options.metadataFile
+    ? path.resolve(options.metadataFile)
+    : path.join(resolvedSource, 'metadata.json');
+
+  let rawMetadata = {};
+  if (fs.existsSync(metadataPath)) {
+    try {
+      rawMetadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+    } catch (err) {
+      throw new Error(`Failed to parse metadata file (${metadataPath}): ${err.message}`);
+    }
+  }
+
+  let actionsFileConfig = null;
+  if (options.actionsFile) {
+    const actionsPath = path.resolve(options.actionsFile);
+    if (!fs.existsSync(actionsPath)) {
+      throw new Error(`Actions file not found: ${actionsPath}`);
+    }
+    try {
+      actionsFileConfig = JSON.parse(fs.readFileSync(actionsPath, 'utf-8'));
+    } catch (err) {
+      throw new Error(`Failed to parse actions file (${actionsPath}): ${err.message}`);
+    }
+  }
+
+  const normalized = loadMetadata(resolvedSource, options.metadataFile);
+  const journeyConfig = {
+    enabled: true,
+    mode: 'before-current',
+    position: 'left',
+    displayDuration: 5,
+    sidebarDisplayDuration: undefined,
+    sidebarLabel: 'title',
+    theme: 'dark',
+    maxCenterChars: 60,
+    maxVisibleRows: 8,
+    ...(rawMetadata.journey || {}),
+    ...(actionsFileConfig?.journey || {}),
+  };
+
+  const rawSongs = rawMetadata.songs || {};
+  let entries = normalized.videos.map((v, index) => {
+    const songKey = v.filename;
+    const rawEntry = rawSongs[songKey] || v;
+    const actions = resolveEntryActions({
+      songKey,
+      filename: v.filename,
+      rawEntry,
+      rawMetadata,
+      actionsFileConfig,
+    });
+
+    return {
+      index,
+      songKey,
+      filename: v.filename,
+      title: v.title,
+      sourcePath: v.filePath,
+      actions,
+      rawEntry,
+    };
+  });
+
+  if (options.only) {
+    const onlyTarget = String(options.only).trim();
+    entries = entries.filter(
+      e => e.songKey === onlyTarget || e.filename === onlyTarget || path.basename(e.filename, path.extname(e.filename)) === onlyTarget
+    );
+    if (entries.length === 0) {
+      throw new Error(`No video matching --only "${options.only}" was found.`);
+    }
+  }
+
+  const hasShorten = entries.some(e => e.actions.some(a => a.type === 'shorten'));
+  const outputDir = resolveOutputDirectory(resolvedSource, {
+    outputDir: options.outputDir,
+    outputSuffix: options.outputSuffix,
+    hasShorten,
+  });
+
+  if (fs.existsSync(outputDir) && !options.force && !options.outputDir) {
+    const files = fs.readdirSync(outputDir).filter(f => !f.startsWith('.'));
+    if (files.length > 0) {
+      throw new Error(
+        `Output directory already exists and is not empty: ${outputDir}. Use --force to overwrite or specify --output-dir.`
+      );
+    }
+  }
+
+  const plannedEntries = entries.map(e => ({
+    ...e,
+    targetPath: path.join(outputDir, e.filename),
+  }));
+
+  return {
+    sourceDir: resolvedSource,
+    outputDir,
+    hasShorten,
+    rawMetadata,
+    journeyConfig,
+    entries: plannedEntries,
+    dryRun: Boolean(options.dryRun),
+    force: Boolean(options.force),
+  };
+}