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

package/src/media/cache.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const DEFAULT_MEDIA_CACHE_DIR = '.media-cache';
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+/**
+ * Generate normalized cache key for media searches.
+ * @param {object} params
+ * @param {string} params.provider
+ * @param {string} params.type
+ * @param {string} params.query
+ * @param {string} [params.orientation]
+ * @returns {string}
+ */
+export function createSearchCacheKey({ provider, type, query, orientation }) {
+  const normalizedQuery = (query || '').toLowerCase().trim().replace(/\s+/g, ' ');
+  const normOrientation = orientation || 'any';
+  return `${provider}:${type}:${normalizedQuery}:${normOrientation}`;
+}
+
+/**
+ * Read the search cache file if it exists.
+ * @param {string} [cacheDir=DEFAULT_MEDIA_CACHE_DIR]
+ * @returns {Record<string, { timestamp: number, results: any[] }>}
+ */
+export function readSearchCache(cacheDir = DEFAULT_MEDIA_CACHE_DIR) {
+  const filePath = path.join(cacheDir, 'search-cache.json');
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Get cached search results if valid and not expired.
+ * @param {string} cacheDir
+ * @param {string} cacheKey
+ * @param {number} [ttlMs=CACHE_TTL_MS]
+ * @returns {any[] | null}
+ */
+export function getCachedSearch(cacheDir, cacheKey, ttlMs = CACHE_TTL_MS) {
+  const cache = readSearchCache(cacheDir);
+  const entry = cache[cacheKey];
+  if (!entry || !entry.timestamp || !Array.isArray(entry.results)) {
+    return null;
+  }
+  const isExpired = Date.now() - entry.timestamp > ttlMs;
+  if (isExpired) {
+    return null;
+  }
+  return entry.results;
+}
+
+/**
+ * Store search results in search cache.
+ * @param {string} cacheDir
+ * @param {string} cacheKey
+ * @param {any[]} results
+ */
+export function setCachedSearch(cacheDir, cacheKey, results) {
+  const dir = path.resolve(cacheDir || DEFAULT_MEDIA_CACHE_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, 'search-cache.json');
+
+  const cache = readSearchCache(dir);
+  cache[cacheKey] = {
+    timestamp: Date.now(),
+    results,
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(cache, null, 2), 'utf-8');
+}
+
+/**
+ * Read the used-assets ledger.
+ * @param {string} [cacheDir=DEFAULT_MEDIA_CACHE_DIR]
+ * @returns {Record<string, { provider: string, assetId: string, usedAt: string, songKey?: string }>}
+ */
+export function readUsedAssetsLedger(cacheDir = DEFAULT_MEDIA_CACHE_DIR) {
+  const filePath = path.join(cacheDir, 'used-assets.json');
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Check if an asset has already been used.
+ * @param {string} cacheDir
+ * @param {string} provider
+ * @param {string} assetId
+ * @returns {boolean}
+ */
+export function isAssetUsed(cacheDir, provider, assetId) {
+  const ledger = readUsedAssetsLedger(cacheDir);
+  const key = `${provider}:${assetId}`;
+  return Boolean(ledger[key]);
+}
+
+/**
+ * Record an asset as used in the ledger.
+ * @param {string} cacheDir
+ * @param {object} assetInfo
+ * @param {string} assetInfo.provider
+ * @param {string} assetInfo.assetId
+ * @param {string} [assetInfo.songKey]
+ */
+export function recordUsedAsset(cacheDir, { provider, assetId, songKey }) {
+  const dir = path.resolve(cacheDir || DEFAULT_MEDIA_CACHE_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, 'used-assets.json');
+
+  const ledger = readUsedAssetsLedger(dir);
+  const key = `${provider}:${assetId}`;
+  ledger[key] = {
+    provider,
+    assetId: String(assetId),
+    songKey: songKey || undefined,
+    usedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(ledger, null, 2), 'utf-8');
+}

package/src/media/compose.js

@@ -0,0 +1,227 @@
+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';
+
+// Configure ffmpeg and ffprobe paths if available
+if (ffmpegStatic && fs.existsSync(ffmpegStatic)) {
+  ffmpeg.setFfmpegPath(ffmpegStatic);
+}
+if (ffprobeStatic?.path && fs.existsSync(ffprobeStatic.path)) {
+  ffmpeg.setFfprobePath(ffprobeStatic.path);
+}
+
+/**
+ * Get the duration of an audio or video file in seconds using ffprobe.
+ *
+ * @param {string} filePath
+ * @returns {Promise<number>} Duration in seconds
+ */
+export function getMediaDuration(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 duration = metadata.format?.duration;
+      if (typeof duration === 'number') {
+        return resolve(duration);
+      }
+      if (typeof duration === 'string') {
+        const parsed = parseFloat(duration);
+        if (!isNaN(parsed)) {
+          return resolve(parsed);
+        }
+      }
+      // Check streams if format duration is missing
+      const streamWithDuration = metadata.streams?.find(s => s.duration);
+      if (streamWithDuration?.duration) {
+        return resolve(parseFloat(streamWithDuration.duration));
+      }
+      reject(new Error(`Could not determine duration for: ${filePath}`));
+    });
+  });
+}
+
+/**
+ * Compose a background video/photo and audio track into an MP4 file using ffmpeg.
+ *
+ * @param {object} options
+ * @param {string} options.backgroundPath - Local path to background video or image
+ * @param {string} options.audioPath - Local path to audio track
+ * @param {string} options.outputPath - Destination path for final MP4
+ * @param {'video-loop' | 'video-trim' | 'ken-burns'} [options.mode='video-loop'] - Composition mode
+ * @param {number} [options.targetWidth=1920]
+ * @param {number} [options.targetHeight=1080]
+ * @param {number} [options.fps=30]
+ * @param {boolean} [options.dryRun=false]
+ * @param {(progress: { percent?: number, timemark?: string }) => void} [options.onProgress]
+ * @returns {Promise<{ outputPath: string, duration: number, dryRun?: boolean, command?: string }>}
+ */
+export async function composeVideo(options) {
+  const {
+    backgroundPath,
+    audioPath,
+    outputPath,
+    mode = 'video-loop',
+    targetWidth = 1920,
+    targetHeight = 1080,
+    fps = 30,
+    dryRun = false,
+    onProgress,
+  } = options;
+
+  if (!fs.existsSync(backgroundPath)) {
+    throw new Error(`Background media file not found: ${backgroundPath}`);
+  }
+  if (!fs.existsSync(audioPath)) {
+    throw new Error(`Audio file not found: ${audioPath}`);
+  }
+  if (!outputPath) {
+    throw new Error('Output path is required for video composition.');
+  }
+
+  // Ensure output directory exists
+  fs.mkdirSync(path.dirname(path.resolve(outputPath)), { recursive: true });
+
+  const audioDuration = await getMediaDuration(audioPath);
+  let bgDuration = 0;
+  try {
+    bgDuration = await getMediaDuration(backgroundPath);
+  } catch {
+    // Might be static photo
+    bgDuration = 0;
+  }
+
+  const isImage = bgDuration === 0 || mode === 'ken-burns';
+  const scaleCropFilter = `scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=increase,crop=${targetWidth}:${targetHeight},format=yuv420p`;
+
+  if (dryRun) {
+    const planDescription = isImage
+      ? `Image (${backgroundPath}) + Audio (${audioPath}, ${audioDuration.toFixed(1)}s) -> ${outputPath} [${targetWidth}x${targetHeight} @ ${fps}fps, mode: ${mode}]`
+      : `Video (${backgroundPath}, ${bgDuration.toFixed(1)}s) + Audio (${audioPath}, ${audioDuration.toFixed(1)}s) -> ${outputPath} [${targetWidth}x${targetHeight} @ ${fps}fps, mode: ${mode}]`;
+
+    return {
+      outputPath,
+      duration: audioDuration,
+      dryRun: true,
+      command: planDescription,
+    };
+  }
+
+  return new Promise((resolve, reject) => {
+    const command = ffmpeg();
+
+    if (isImage) {
+      if (mode === 'ken-burns') {
+        const totalFrames = Math.max(30, Math.ceil(audioDuration * fps));
+        command
+          .input(backgroundPath)
+          .inputOptions(['-loop', '1'])
+          .input(audioPath)
+          .complexFilter([
+            `scale=8000:-1,zoompan=z='min(zoom+0.0008,1.25)':d=${totalFrames}:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':s=${targetWidth}x${targetHeight}:fps=${fps},${scaleCropFilter}[v]`,
+          ])
+          .outputOptions([
+            '-map', '[v]',
+            '-map', '1:a',
+            '-c:v', 'libx264',
+            '-preset', 'veryfast',
+            '-crf', '20',
+            '-c:a', 'aac',
+            '-b:a', '192k',
+            '-shortest',
+            `-t`, `${audioDuration}`,
+            '-pix_fmt', 'yuv420p',
+            '-movflags', '+faststart',
+          ]);
+      } else {
+        // Simple static image loop
+        command
+          .input(backgroundPath)
+          .inputOptions(['-loop', '1'])
+          .input(audioPath)
+          .videoFilters([scaleCropFilter])
+          .outputOptions([
+            '-c:v', 'libx264',
+            '-preset', 'veryfast',
+            '-crf', '20',
+            '-c:a', 'aac',
+            '-b:a', '192k',
+            '-shortest',
+            `-t`, `${audioDuration}`,
+            `-r`, `${fps}`,
+            '-pix_fmt', 'yuv420p',
+            '-movflags', '+faststart',
+          ]);
+      }
+    } else {
+      // Video background
+      if (bgDuration > 0 && bgDuration < audioDuration) {
+        // Video is shorter than audio -> stream loop
+        command
+          .input(backgroundPath)
+          .inputOptions(['-stream_loop', '-1'])
+          .input(audioPath)
+          .videoFilters([scaleCropFilter])
+          .outputOptions([
+            '-c:v', 'libx264',
+            '-preset', 'veryfast',
+            '-crf', '20',
+            '-c:a', 'aac',
+            '-b:a', '192k',
+            '-shortest',
+            `-t`, `${audioDuration}`,
+            `-r`, `${fps}`,
+            '-pix_fmt', 'yuv420p',
+            '-movflags', '+faststart',
+          ]);
+      } else {
+        // Video is longer or equal -> trim to audioDuration
+        command
+          .input(backgroundPath)
+          .input(audioPath)
+          .videoFilters([scaleCropFilter])
+          .outputOptions([
+            '-c:v', 'libx264',
+            '-preset', 'veryfast',
+            '-crf', '20',
+            '-c:a', 'aac',
+            '-b:a', '192k',
+            '-shortest',
+            `-t`, `${audioDuration}`,
+            `-r`, `${fps}`,
+            '-pix_fmt', 'yuv420p',
+            '-movflags', '+faststart',
+          ]);
+      }
+    }
+
+    if (onProgress) {
+      command.on('progress', onProgress);
+    }
+
+    command
+      .output(outputPath)
+      .on('end', () => {
+        resolve({
+          outputPath,
+          duration: audioDuration,
+        });
+      })
+      .on('error', (err) => {
+        // Clean up partial output if any
+        if (fs.existsSync(outputPath)) {
+          try {
+            fs.unlinkSync(outputPath);
+          } catch {}
+        }
+        reject(new Error(`FFmpeg composition failed: ${err.message}`));
+      })
+      .run();
+  });
+}

package/src/media/download.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import mime from 'mime-types';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import { DEFAULT_MEDIA_CACHE_DIR } from './cache.js';
+
+/**
+ * Infer extension from Content-Type header or download URL.
+ *
+ * @param {string} [contentType]
+ * @param {string} [url]
+ * @param {'video' | 'photo'} [type='video']
+ * @returns {string}
+ */
+export function inferExtension(contentType, url, type = 'video') {
+  if (contentType) {
+    const ext = mime.extension(contentType.split(';')[0].trim());
+    if (ext) {
+      if (ext === 'jpeg') return 'jpg';
+      return ext;
+    }
+  }
+
+  if (url) {
+    try {
+      const parsedUrl = new URL(url);
+      const extname = path.extname(parsedUrl.pathname).toLowerCase().replace('.', '');
+      if (extname && /^[a-z0-9]+$/i.test(extname)) {
+        if (extname === 'jpeg') return 'jpg';
+        return extname;
+      }
+    } catch {
+      // Ignore URL parse errors
+    }
+  }
+
+  return type === 'video' ? 'mp4' : 'jpg';
+}
+
+/**
+ * Download a media asset and save it locally in cache.
+ *
+ * @param {import('../providers/index.js').UnifiedResult} asset
+ * @param {object} [options]
+ * @param {string} [options.cacheDir=DEFAULT_MEDIA_CACHE_DIR]
+ * @param {string} [options.targetPath]
+ * @param {boolean} [options.force=false]
+ * @param {number} [options.maxRetries=3]
+ * @param {typeof fetch} [options.fetchFn=fetch]
+ * @returns {Promise<{ localPath: string, size: number, ext: string, fromCache: boolean }>}
+ */
+export async function downloadAsset(asset, options = {}) {
+  const {
+    cacheDir = DEFAULT_MEDIA_CACHE_DIR,
+    targetPath,
+    force = false,
+    maxRetries = 3,
+    fetchFn = fetch,
+  } = options;
+
+  if (!asset || !asset.downloadUrl) {
+    throw new Error('Cannot download asset: missing downloadUrl.');
+  }
+
+  const assetsDir = path.resolve(cacheDir, 'assets');
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  // If a specific targetPath is given, use it; otherwise standard naming: <provider>-<id>.<ext>
+  // Check if file already exists with any valid extension
+  if (!force && !targetPath) {
+    const candidateExts = asset.type === 'video' ? ['mp4', 'webm', 'mov'] : ['jpg', 'jpeg', 'png', 'webp'];
+    for (const ext of candidateExts) {
+      const existing = path.join(assetsDir, `${asset.provider}-${asset.id}.${ext}`);
+      if (fs.existsSync(existing)) {
+        const stat = fs.statSync(existing);
+        if (stat.size > 0) {
+          return { localPath: existing, size: stat.size, ext, fromCache: true };
+        }
+      }
+    }
+  }
+
+  let attempt = 0;
+  let lastError = null;
+
+  while (attempt < maxRetries) {
+    attempt++;
+    try {
+      const res = await fetchFn(asset.downloadUrl, {
+        headers: {
+          'User-Agent': 'youtube-video-uploader-cli',
+        },
+      });
+
+      if (!res.ok) {
+        throw new Error(`Download failed with status ${res.status} (${res.statusText})`);
+      }
+
+      const contentType = res.headers.get('content-type') || '';
+      const ext = inferExtension(contentType, asset.downloadUrl, asset.type);
+      const destination = targetPath
+        ? path.resolve(targetPath)
+        : path.join(assetsDir, `${asset.provider}-${asset.id}.${ext}`);
+
+      fs.mkdirSync(path.dirname(destination), { recursive: true });
+      const tempPath = `${destination}.${Date.now()}-${Math.random().toString(36).slice(2, 7)}.tmp`;
+
+      if (res.body && typeof res.body.getReader === 'function') {
+        // Node 18+ web stream
+        const nodeStream = Readable.fromWeb(res.body);
+        const fileStream = fs.createWriteStream(tempPath);
+        await pipeline(nodeStream, fileStream);
+      } else if (res.body && typeof res.body.pipe === 'function') {
+        // Node readable stream
+        const fileStream = fs.createWriteStream(tempPath);
+        await pipeline(res.body, fileStream);
+      } else {
+        // Fallback buffer write
+        const arrayBuffer = await res.arrayBuffer();
+        fs.writeFileSync(tempPath, Buffer.from(arrayBuffer));
+      }
+
+      const stat = fs.statSync(tempPath);
+      if (stat.size === 0) {
+        fs.unlinkSync(tempPath);
+        throw new Error('Downloaded file was 0 bytes.');
+      }
+
+      // Atomic rename
+      if (fs.existsSync(destination)) {
+        fs.unlinkSync(destination);
+      }
+      fs.renameSync(tempPath, destination);
+
+      return {
+        localPath: destination,
+        size: stat.size,
+        ext,
+        fromCache: false,
+      };
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, 1000 * attempt));
+      }
+    }
+  }
+
+  throw new Error(`Failed to download asset ${asset.provider}:${asset.id} after ${maxRetries} attempts: ${lastError?.message}`);
+}