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

package/src/batch/plan.js

@@ -0,0 +1,195 @@
+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: 'right',
+    displayDuration: 4,
+    sidebarDisplayDuration: undefined,
+    sidebarLabel: 'stage',
+    theme: 'dark',
+    style: 'badge',
+    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),
+  };
+}

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,111 @@
+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: 'right',
+    displayDuration: 4,
+    sidebarDisplayDuration: undefined,
+    sidebarLabel: 'stage',
+    theme: 'dark',
+    style: 'badge',
+    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.style === 'panel' ? journeyConfig.maxVisibleRows : null,
+    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,
+    style: journeyConfig.style,
+    stage: songData.journeyStage || songData.albumRole,
+    step: typeof songData.trackNumber === 'number' ? songData.trackNumber : (songData.playlistPosition !== undefined ? songData.playlistPosition + 1 : undefined),
+    totalSteps: rawMetadata.album?.trackCount || rawMetadata.album?.arc?.length || (tracks[0]?.totalTracks) || 11,
+  });
+
+  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,
+  };
+}