@x12i/youtube-video-uploader-cli 1.2.0 → 1.4.0

package/src/actions/index.js

@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { shortenVideo, parseTimeSeconds, getVideoMetadata } from './shorten.js';
+import { replaceBackground, extractAudio } from './replace-background.js';
+import {
+  applyJourneyOverlay,
+  generateJourneySvg,
+  renderSvgToPng,
+  resolveJourneyTracks,
+} from './journey-overlay.js';
+
+export {
+  shortenVideo,
+  parseTimeSeconds,
+  getVideoMetadata,
+  replaceBackground,
+  extractAudio,
+  applyJourneyOverlay,
+  generateJourneySvg,
+  renderSvgToPng,
+  resolveJourneyTracks,
+};
+
+/**
+ * Run actions pipeline for a single entry.
+ *
+ * @param {object} entry - Video entry object
+ * @param {Array<object>} actions - List of actions to execute sequentially
+ * @param {object} context - Pipeline context options and metadata
+ * @returns {Promise<{
+ *   songKey: string,
+ *   filename: string,
+ *   outputPath: string,
+ *   actionsApplied: string[],
+ *   skipped?: boolean,
+ *   reason?: string,
+ *   dryRun?: boolean,
+ *   steps?: string[]
+ * }>}
+ */
+export async function runActionsPipeline(entry, actions = [], context = {}) {
+  const {
+    outputDir,
+    rawMetadata = {},
+    journeyConfig = {},
+    dryRun = false,
+    force = false,
+    pexelsKey,
+    pixabayKey,
+    cacheDir,
+    fetchFn,
+    onEvent,
+    onWarn,
+  } = context;
+
+  const songKey = entry.songKey || entry.filename;
+  const filename = entry.filename;
+  const sourcePath = entry.sourcePath;
+  const targetPath = entry.targetPath || path.join(outputDir, filename);
+
+  // Check if output already exists and force is not set
+  if (fs.existsSync(targetPath) && !force && !dryRun) {
+    return {
+      songKey,
+      filename,
+      sourcePath,
+      outputPath: targetPath,
+      actionsApplied: [],
+      skipped: true,
+      reason: 'Output file already exists (use --force to overwrite)',
+    };
+  }
+
+  // If no actions defined, pass-through copy
+  if (!actions || actions.length === 0) {
+    if (dryRun) {
+      return {
+        songKey,
+        filename,
+        sourcePath,
+        outputPath: targetPath,
+        actionsApplied: [],
+        dryRun: true,
+        steps: [`Copy without modifications: ${sourcePath} -> ${targetPath}`],
+      };
+    }
+
+    if (onEvent) {
+      onEvent({ type: 'action_passthrough', songKey, filename, sourcePath, targetPath });
+    }
+
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.copyFileSync(sourcePath, targetPath);
+
+    return {
+      songKey,
+      filename,
+      sourcePath,
+      outputPath: targetPath,
+      actionsApplied: [],
+    };
+  }
+
+  // Dry run mode: calculate plan for each action
+  if (dryRun) {
+    const steps = [];
+    let currentInput = sourcePath;
+
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      const isLast = i === actions.length - 1;
+      const stepOutput = isLast ? targetPath : `temp_step_${i + 1}_${filename}`;
+
+      if (action.type === 'shorten') {
+        const res = await shortenVideo({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          entry,
+          ...action,
+          dryRun: true,
+          onWarn,
+        });
+        steps.push(`[${i + 1}/${actions.length}] ${res.command}`);
+      } else if (action.type === 'replace-background') {
+        const res = await replaceBackground({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          action,
+          entry,
+          context: { pexelsKey, pixabayKey, cacheDir, fetchFn },
+          dryRun: true,
+        });
+        steps.push(`[${i + 1}/${actions.length}] ${res.command}`);
+      } else if (action.type === 'journey-overlay') {
+        const res = await applyJourneyOverlay({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          action,
+          entry,
+          rawMetadata,
+          journeyConfig,
+          dryRun: true,
+          onWarn,
+        });
+        steps.push(`[${i + 1}/${actions.length}] ${res.command}`);
+      } else {
+        throw new Error(`Unknown action type: "${action.type}" on entry ${songKey}`);
+      }
+
+      currentInput = stepOutput;
+    }
+
+    return {
+      songKey,
+      filename,
+      sourcePath,
+      outputPath: targetPath,
+      actionsApplied: actions.map(a => a.type),
+      dryRun: true,
+      steps,
+    };
+  }
+
+  // Real execution
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`Source video file not found: ${sourcePath}`);
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+
+  const tempDir = path.join(
+    os.tmpdir(),
+    `actions_pipeline_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`
+  );
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  const intermediateFiles = [];
+  let currentInput = sourcePath;
+
+  try {
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      const isLast = i === actions.length - 1;
+      const stepOutput = isLast
+        ? targetPath
+        : path.join(tempDir, `step_${i}_${Date.now()}_${filename}`);
+
+      if (!isLast) {
+        intermediateFiles.push(stepOutput);
+      }
+
+      if (onEvent) {
+        onEvent({
+          type: 'action_start',
+          songKey,
+          filename,
+          actionIndex: i,
+          totalActions: actions.length,
+          actionType: action.type,
+          action,
+        });
+      }
+
+      if (action.type === 'shorten') {
+        await shortenVideo({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          entry,
+          ...action,
+          dryRun: false,
+          onWarn,
+        });
+      } else if (action.type === 'replace-background') {
+        await replaceBackground({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          action,
+          entry,
+          context: { pexelsKey, pixabayKey, cacheDir, fetchFn, tempDir },
+          dryRun: false,
+        });
+      } else if (action.type === 'journey-overlay') {
+        await applyJourneyOverlay({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          action,
+          entry,
+          rawMetadata,
+          journeyConfig,
+          context: { pexelsKey, pixabayKey, cacheDir, fetchFn, tempDir },
+          dryRun: false,
+          onWarn,
+        });
+      } else {
+        throw new Error(`Unknown action type: "${action.type}" on entry ${songKey}`);
+      }
+
+      if (onEvent) {
+        onEvent({
+          type: 'action_complete',
+          songKey,
+          filename,
+          actionIndex: i,
+          totalActions: actions.length,
+          actionType: action.type,
+          outputPath: stepOutput,
+        });
+      }
+
+      currentInput = stepOutput;
+    }
+
+    return {
+      songKey,
+      filename,
+      sourcePath,
+      outputPath: targetPath,
+      actionsApplied: actions.map(a => a.type),
+    };
+  } finally {
+    // Cleanup temporary files
+    for (const file of intermediateFiles) {
+      if (fs.existsSync(file)) {
+        try {
+          fs.unlinkSync(file);
+        } catch {}
+      }
+    }
+    if (fs.existsSync(tempDir)) {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+}