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

package/src/cli/apply-actions.js

@@ -0,0 +1,152 @@
+import path from 'node:path';
+import { planBatchActions } from '../batch/plan.js';
+import { cloneMetadataForOutput } from '../batch/clone-metadata.js';
+import { runActionsPipeline } from '../actions/index.js';
+
+/**
+ * Apply actions pipeline across videos in a directory.
+ *
+ * @param {string} targetDir
+ * @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]
+ * @param {string} [options.pexelsKey]
+ * @param {string} [options.pixabayKey]
+ * @param {string} [options.cacheDir]
+ * @param {typeof fetch} [options.fetchFn]
+ * @param {(event: { type: string, [key: string]: any }) => void} [options.onEvent]
+ * @returns {Promise<{
+ *   sourceDir: string,
+ *   outputDir: string,
+ *   total: number,
+ *   processed: Array<object>,
+ *   skipped: Array<object>,
+ *   failed: Array<object>,
+ *   dryRun: boolean
+ * }>}
+ */
+export async function batchApplyActions(targetDir, options = {}) {
+  const plan = planBatchActions(targetDir, options);
+  const onEvent = options.onEvent;
+
+  if (onEvent) {
+    onEvent({
+      type: 'actions_plan',
+      sourceDir: plan.sourceDir,
+      outputDir: plan.outputDir,
+      hasShorten: plan.hasShorten,
+      total: plan.entries.length,
+      entries: plan.entries,
+      dryRun: plan.dryRun,
+    });
+  }
+
+  const results = [];
+  const skipped = [];
+  const failed = [];
+
+  const context = {
+    sourceDir: plan.sourceDir,
+    outputDir: plan.outputDir,
+    rawMetadata: plan.rawMetadata,
+    journeyConfig: plan.journeyConfig,
+    dryRun: plan.dryRun,
+    force: plan.force,
+    pexelsKey: options.pexelsKey,
+    pixabayKey: options.pixabayKey,
+    cacheDir: options.cacheDir,
+    fetchFn: options.fetchFn,
+    onEvent,
+    onWarn: (msg) => {
+      if (onEvent) {
+        onEvent({ type: 'action_warn', message: msg });
+      }
+    },
+  };
+
+  for (let i = 0; i < plan.entries.length; i++) {
+    const entry = plan.entries[i];
+
+    if (onEvent) {
+      onEvent({
+        type: 'entry_start',
+        index: i,
+        total: plan.entries.length,
+        songKey: entry.songKey,
+        filename: entry.filename,
+        actionsCount: entry.actions.length,
+      });
+    }
+
+    try {
+      const res = await runActionsPipeline(entry, entry.actions, context);
+      if (res.skipped) {
+        skipped.push(res);
+        if (onEvent) {
+          onEvent({
+            type: 'entry_skipped',
+            songKey: entry.songKey,
+            filename: entry.filename,
+            reason: res.reason,
+          });
+        }
+      } else {
+        results.push(res);
+        if (onEvent) {
+          onEvent({
+            type: 'entry_success',
+            index: i,
+            total: plan.entries.length,
+            songKey: entry.songKey,
+            filename: entry.filename,
+            outputPath: res.outputPath,
+            actionsApplied: res.actionsApplied,
+            steps: res.steps,
+          });
+        }
+      }
+    } catch (err) {
+      failed.push({
+        songKey: entry.songKey,
+        filename: entry.filename,
+        error: err,
+      });
+      if (onEvent) {
+        onEvent({
+          type: 'entry_error',
+          index: i,
+          total: plan.entries.length,
+          songKey: entry.songKey,
+          filename: entry.filename,
+          error: err,
+        });
+      }
+    }
+  }
+
+  if (!plan.dryRun && results.length > 0) {
+    cloneMetadataForOutput(plan.rawMetadata, plan.outputDir, results);
+    if (onEvent) {
+      onEvent({
+        type: 'metadata_cloned',
+        outputDir: plan.outputDir,
+        outputPath: path.join(plan.outputDir, 'metadata.json'),
+      });
+    }
+  }
+
+  return {
+    sourceDir: plan.sourceDir,
+    outputDir: plan.outputDir,
+    total: plan.entries.length,
+    processed: results,
+    skipped,
+    failed,
+    dryRun: plan.dryRun,
+  };
+}

package/src/cli/preview-journey.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  generateJourneySvg,
+  renderSvgToPng,
+  resolveJourneyTracks,
+  truncate,
+} from '../actions/journey-overlay.js';
+
+/**
+ * Preview journey overlay as a standalone PNG image.
+ *
+ * @param {string} songKey - Song key or filename to preview
+ * @param {object} [options]
+ * @param {string} [options.dir] - Target source folder containing metadata.json
+ * @param {string} [options.metadata] - Path to custom metadata.json
+ * @param {string} [options.centerText] - Override center text for preview
+ * @param {string} [options.output] - Output path for the PNG file
+ * @param {number} [options.width=1920]
+ * @param {number} [options.height=1080]
+ * @returns {Promise<{ outputPath: string, width: number, height: number, tracksCount: number }>}
+ */
+export async function previewJourney(songKey, options = {}) {
+  const targetDir = path.resolve(options.dir || process.cwd());
+  const metadataPath = options.metadata
+    ? path.resolve(options.metadata)
+    : path.join(targetDir, '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}`);
+    }
+  }
+
+  const journeyConfig = {
+    enabled: true,
+    mode: 'before-current',
+    position: 'left',
+    displayDuration: 5,
+    sidebarDisplayDuration: undefined,
+    sidebarLabel: 'title',
+    theme: 'dark',
+    maxCenterChars: 60,
+    maxVisibleRows: 8,
+    ...(rawMetadata.journey || {}),
+  };
+
+  const songData = rawMetadata.songs?.[songKey] || {};
+  const journeyAction = Array.isArray(songData.actions)
+    ? songData.actions.find(a => a.type === 'journey-overlay')
+    : null;
+
+  let centerText = options.centerText;
+  if (centerText === undefined) {
+    if (Array.isArray(journeyAction?.centerConcepts) && journeyAction.centerConcepts.length > 0) {
+      const idx = options.conceptIndex !== undefined ? parseInt(options.conceptIndex, 10) : 0;
+      centerText = journeyAction.centerConcepts[idx] || journeyAction.centerConcepts[0];
+    } else {
+      centerText = journeyAction?.centerText || '';
+    }
+  }
+
+  if (centerText && centerText.length > journeyConfig.maxCenterChars) {
+    centerText = truncate(centerText, journeyConfig.maxCenterChars);
+  }
+
+  const tracks = resolveJourneyTracks({
+    currentSongKey: songKey,
+    rawMetadata,
+    mode: journeyConfig.mode,
+    maxVisibleRows: journeyConfig.maxVisibleRows,
+    sidebarLabel: journeyConfig.sidebarLabel,
+  });
+
+  const width = options.width || 1920;
+  const height = options.height || 1080;
+
+  const svgContent = generateJourneySvg({
+    width,
+    height,
+    tracks,
+    centerText,
+    showSidebar: journeyConfig.enabled !== false,
+    theme: journeyConfig.theme,
+    position: journeyConfig.position,
+  });
+
+  const pngBuffer = renderSvgToPng(svgContent, width, height);
+
+  const outputPath = options.output
+    ? path.resolve(options.output)
+    : path.join(targetDir, `journey-preview-${path.basename(songKey, path.extname(songKey))}.png`);
+
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, pngBuffer);
+
+  return {
+    outputPath,
+    width,
+    height,
+    tracksCount: tracks.length,
+  };
+}