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

package/src/providers/index.js

@@ -0,0 +1,235 @@
+import pLimit from 'p-limit';
+import { loadDotEnv } from '../auth.js';
+import { searchPexels } from './pexels.js';
+import { searchPixabay } from './pixabay.js';
+import {
+  createSearchCacheKey,
+  getCachedSearch,
+  setCachedSearch,
+  DEFAULT_MEDIA_CACHE_DIR,
+} from '../media/cache.js';
+
+export { searchPexels } from './pexels.js';
+export { searchPixabay } from './pixabay.js';
+
+/**
+ * Global provider request limiters to avoid bursting.
+ */
+const providerLimit = pLimit(3);
+
+/**
+ * Sleep helper for backoff.
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Resolve provider API keys and fallback orders from options and environment variables.
+ * @param {object} [options]
+ * @returns {{
+ *   pexelsKey?: string,
+ *   pixabayKey?: string,
+ *   providerOrder: Array<'pexels' | 'pixabay'>
+ * }}
+ */
+export function resolveProviderCredentials(options = {}) {
+  loadDotEnv();
+
+  const rawPexels = options.pexelsKey !== undefined ? options.pexelsKey : (process.env.PEXELS_KEY || process.env.PEXEL_KEY);
+  const rawPixabay = options.pixabayKey !== undefined ? options.pixabayKey : (process.env.PIXABAY_KEY || process.env.PICABAY_KEY);
+
+  const pexelsKey = rawPexels ? String(rawPexels).trim() : undefined;
+  const pixabayKey = rawPixabay ? String(rawPixabay).trim() : undefined;
+
+  let providerOrder = ['pexels', 'pixabay'];
+  if (Array.isArray(options.providerOrder) && options.providerOrder.length > 0) {
+    providerOrder = options.providerOrder;
+  } else if (process.env.MEDIA_PROVIDER_ORDER) {
+    const parsed = process.env.MEDIA_PROVIDER_ORDER.split(',')
+      .map(s => s.trim().toLowerCase())
+      .filter(s => s === 'pexels' || s === 'pixabay');
+    if (parsed.length > 0) {
+      providerOrder = parsed;
+    }
+  }
+
+  return {
+    pexelsKey,
+    pixabayKey,
+    providerOrder,
+  };
+}
+
+/**
+ * Execute a provider search with exponential backoff on HTTP 429.
+ * @param {() => Promise<any[]>} searchFn
+ * @param {number} [maxAttempts=3]
+ * @returns {Promise<any[]>}
+ */
+async function executeWithRetry(searchFn, maxAttempts = 3) {
+  let attempt = 0;
+  let delayMs = 1000;
+
+  while (attempt < maxAttempts) {
+    attempt++;
+    try {
+      return await providerLimit(() => searchFn());
+    } catch (err) {
+      if (err.status === 429 && attempt < maxAttempts) {
+        const waitTime = (err.retryAfter ? err.retryAfter * 1000 : delayMs) + Math.floor(Math.random() * 500);
+        await sleep(waitTime);
+        delayMs *= 2;
+        continue;
+      }
+      throw err;
+    }
+  }
+  return [];
+}
+
+/**
+ * Unified search across media providers with caching and fallback / merge strategies.
+ *
+ * @param {object} options
+ * @param {string} options.query
+ * @param {'video' | 'photo'} [options.type='video']
+ * @param {'auto' | 'pexels' | 'pixabay'} [options.provider='auto']
+ * @param {'fallback' | 'merge'} [options.mergeStrategy='fallback']
+ * @param {Array<'pexels' | 'pixabay'>} [options.providerOrder]
+ * @param {'landscape' | 'portrait' | 'square'} [options.orientation]
+ * @param {number} [options.page=1]
+ * @param {number} [options.perPage=20]
+ * @param {boolean} [options.safeSearch=true]
+ * @param {string} [options.pexelsKey]
+ * @param {string} [options.pixabayKey]
+ * @param {boolean} [options.useCache=true]
+ * @param {string} [options.cacheDir=DEFAULT_MEDIA_CACHE_DIR]
+ * @param {typeof fetch} [options.fetchFn=fetch]
+ * @returns {Promise<import('./index.js').UnifiedResult[]>}
+ */
+export async function searchMedia(options) {
+  const {
+    query,
+    type = 'video',
+    provider = 'auto',
+    mergeStrategy = 'fallback',
+    orientation,
+    page = 1,
+    perPage = 20,
+    safeSearch = true,
+    useCache = true,
+    cacheDir = DEFAULT_MEDIA_CACHE_DIR,
+    fetchFn = fetch,
+  } = options || {};
+
+  if (!query || typeof query !== 'string' || !query.trim()) {
+    return [];
+  }
+
+  const credentials = resolveProviderCredentials(options);
+
+  // Determine target providers
+  let targetProviders = [];
+  if (provider === 'pexels') {
+    targetProviders = ['pexels'];
+  } else if (provider === 'pixabay') {
+    targetProviders = ['pixabay'];
+  } else {
+    targetProviders = credentials.providerOrder;
+  }
+
+  const availableProviders = targetProviders.filter(p => {
+    if (p === 'pexels') return Boolean(credentials.pexelsKey);
+    if (p === 'pixabay') return Boolean(credentials.pixabayKey);
+    return false;
+  });
+
+  if (availableProviders.length === 0) {
+    throw new Error(
+      `No media provider API keys configured for target provider "${provider}".\n` +
+      `Please provide PEXELS_KEY or PIXABAY_KEY in your environment or via CLI options.`
+    );
+  }
+
+  const performProviderSearch = async (p) => {
+    const cacheKey = createSearchCacheKey({
+      provider: p,
+      type,
+      query,
+      orientation,
+    });
+
+    if (useCache) {
+      const cached = getCachedSearch(cacheDir, cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+
+    let results = [];
+    if (p === 'pexels') {
+      results = await executeWithRetry(() => searchPexels({
+        query,
+        type,
+        orientation,
+        page,
+        perPage,
+        apiKey: credentials.pexelsKey,
+        fetchFn,
+      }));
+    } else if (p === 'pixabay') {
+      results = await executeWithRetry(() => searchPixabay({
+        query,
+        type,
+        orientation,
+        page,
+        perPage,
+        safeSearch,
+        apiKey: credentials.pixabayKey,
+        fetchFn,
+      }));
+    }
+
+    if (useCache && results.length > 0) {
+      setCachedSearch(cacheDir, cacheKey, results);
+    }
+
+    return results;
+  };
+
+  if (mergeStrategy === 'merge') {
+    const allResults = [];
+    for (const p of availableProviders) {
+      try {
+        const results = await performProviderSearch(p);
+        allResults.push(...results);
+      } catch (err) {
+        // In merge mode, if one fails, continue with others
+      }
+    }
+    return allResults;
+  }
+
+  // Fallback strategy (default)
+  let lastError = null;
+  for (const p of availableProviders) {
+    try {
+      const results = await performProviderSearch(p);
+      if (results.length > 0) {
+        return results;
+      }
+    } catch (err) {
+      lastError = err;
+      // Continue to next provider on error
+    }
+  }
+
+  if (lastError && availableProviders.length === 1) {
+    throw lastError;
+  }
+
+  return [];
+}

package/src/providers/pexels.js

@@ -0,0 +1,171 @@
+/**
+ * Pexels API Adapter
+ */
+
+/**
+ * Determine orientation from dimensions.
+ * @param {number} width
+ * @param {number} height
+ * @returns {'landscape' | 'portrait' | 'square'}
+ */
+function getOrientation(width, height) {
+  if (width > height) return 'landscape';
+  if (height > width) return 'portrait';
+  return 'square';
+}
+
+/**
+ * Search Pexels for photos or videos and return UnifiedResult[]
+ *
+ * @param {object} options
+ * @param {string} options.query
+ * @param {'video' | 'photo'} [options.type='video']
+ * @param {'landscape' | 'portrait' | 'square'} [options.orientation]
+ * @param {number} [options.page=1]
+ * @param {number} [options.perPage=20]
+ * @param {string} options.apiKey
+ * @param {typeof fetch} [options.fetchFn=fetch]
+ * @returns {Promise<import('./index.js').UnifiedResult[]>}
+ */
+export async function searchPexels({
+  query,
+  type = 'video',
+  orientation,
+  page = 1,
+  perPage = 20,
+  apiKey,
+  fetchFn = fetch,
+}) {
+  if (!apiKey) {
+    throw new Error('Pexels API key is missing. Set PEXELS_KEY or pass --pexels-key.');
+  }
+  if (!query || typeof query !== 'string' || !query.trim()) {
+    return [];
+  }
+
+  const isVideo = type === 'video';
+  const endpoint = isVideo
+    ? 'https://api.pexels.com/videos/search'
+    : 'https://api.pexels.com/v1/search';
+
+  const url = new URL(endpoint);
+  url.searchParams.set('query', query.trim());
+  url.searchParams.set('page', String(page));
+  url.searchParams.set('per_page', String(Math.min(80, Math.max(1, perPage))));
+  if (orientation) {
+    url.searchParams.set('orientation', orientation);
+  }
+
+  const res = await fetchFn(url.toString(), {
+    method: 'GET',
+    headers: {
+      Authorization: apiKey,
+      'User-Agent': 'youtube-video-uploader-cli',
+    },
+  });
+
+  if (res.status === 401 || res.status === 403) {
+    const text = await res.text().catch(() => '');
+    const err = new Error(`Pexels API Authentication Failed (${res.status}): ${text || 'Invalid API Key'}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  if (res.status === 429) {
+    const retryAfter = res.headers.get('retry-after');
+    const err = new Error(`Pexels API Rate Limit Exceeded (429)`);
+    err.status = 429;
+    err.retryAfter = retryAfter ? parseInt(retryAfter, 10) : null;
+    throw err;
+  }
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    const err = new Error(`Pexels API error (${res.status}): ${text}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  const data = await res.json();
+  const items = isVideo ? (data.videos || []) : (data.photos || []);
+
+  const results = items.map((item, index) => {
+    if (isVideo) {
+      // Find best video file (prefer 1920x1080 or highest resolution MP4)
+      const videoFiles = Array.isArray(item.video_files) ? item.video_files : [];
+      const mp4Files = videoFiles.filter(f => !f.file_type || f.file_type === 'video/mp4' || f.link?.includes('.mp4'));
+      const candidateFiles = mp4Files.length > 0 ? mp4Files : videoFiles;
+
+      // Sort by resolution descending
+      candidateFiles.sort((a, b) => {
+        const resA = (a.width || 0) * (a.height || 0);
+        const resB = (b.width || 0) * (b.height || 0);
+        return resB - resA;
+      });
+
+      // Try to find HD file closest to 1920x1080, else highest available
+      const hdFile = candidateFiles.find(f => f.quality === 'hd' && f.width >= 1280) || candidateFiles[0];
+      const chosenFile = hdFile || candidateFiles[0] || {};
+
+      const width = chosenFile.width || item.width || 1920;
+      const height = chosenFile.height || item.height || 1080;
+      const calculatedOrientation = getOrientation(width, height);
+
+      const previewUrl = item.video_pictures?.[0]?.picture || item.image || '';
+      const tags = Array.isArray(item.tags)
+        ? item.tags.map(t => (typeof t === 'string' ? t : t.name)).filter(Boolean)
+        : [];
+
+      return {
+        provider: 'pexels',
+        id: String(item.id),
+        type: 'video',
+        rank: index,
+        pageUrl: item.url || `https://www.pexels.com/video/${item.id}/`,
+        previewUrl,
+        downloadUrl: chosenFile.link || '',
+        width,
+        height,
+        duration: typeof item.duration === 'number' ? item.duration : undefined,
+        orientation: calculatedOrientation,
+        tags,
+        creator: {
+          name: item.user?.name || 'Pexels Creator',
+          profileUrl: item.user?.url || undefined,
+        },
+        license: 'Pexels License',
+        raw: item,
+      };
+    } else {
+      // Photo
+      const width = item.width || 1920;
+      const height = item.height || 1080;
+      const calculatedOrientation = getOrientation(width, height);
+      const downloadUrl = item.src?.original || item.src?.large2x || item.src?.large || '';
+      const previewUrl = item.src?.small || item.src?.tiny || item.src?.medium || downloadUrl;
+      const tags = item.alt ? item.alt.split(/[,;\s]+/).filter(Boolean) : [];
+
+      return {
+        provider: 'pexels',
+        id: String(item.id),
+        type: 'photo',
+        rank: index,
+        pageUrl: item.url || `https://www.pexels.com/photo/${item.id}/`,
+        previewUrl,
+        downloadUrl,
+        width,
+        height,
+        orientation: calculatedOrientation,
+        tags,
+        creator: {
+          name: item.photographer || 'Pexels Photographer',
+          profileUrl: item.photographer_url || undefined,
+        },
+        license: 'Pexels License',
+        raw: item,
+      };
+    }
+  });
+
+  return results;
+}

package/src/providers/pixabay.js

@@ -0,0 +1,184 @@
+/**
+ * Pixabay API Adapter
+ */
+
+/**
+ * Determine orientation from dimensions.
+ * @param {number} width
+ * @param {number} height
+ * @returns {'landscape' | 'portrait' | 'square'}
+ */
+function getOrientation(width, height) {
+  if (width > height) return 'landscape';
+  if (height > width) return 'portrait';
+  return 'square';
+}
+
+/**
+ * Map generic orientation to Pixabay orientation filter
+ * @param {'landscape' | 'portrait' | 'square'} [orientation]
+ * @returns {string | undefined}
+ */
+function mapPixabayOrientation(orientation) {
+  if (orientation === 'landscape') return 'horizontal';
+  if (orientation === 'portrait') return 'vertical';
+  return undefined;
+}
+
+/**
+ * Search Pixabay for photos or videos and return UnifiedResult[]
+ *
+ * @param {object} options
+ * @param {string} options.query
+ * @param {'video' | 'photo'} [options.type='video']
+ * @param {'landscape' | 'portrait' | 'square'} [options.orientation]
+ * @param {number} [options.page=1]
+ * @param {number} [options.perPage=20]
+ * @param {boolean} [options.safeSearch=true]
+ * @param {string} options.apiKey
+ * @param {typeof fetch} [options.fetchFn=fetch]
+ * @returns {Promise<import('./index.js').UnifiedResult[]>}
+ */
+export async function searchPixabay({
+  query,
+  type = 'video',
+  orientation,
+  page = 1,
+  perPage = 20,
+  safeSearch = true,
+  apiKey,
+  fetchFn = fetch,
+}) {
+  if (!apiKey) {
+    throw new Error('Pixabay API key is missing. Set PIXABAY_KEY or pass --pixabay-key.');
+  }
+  if (!query || typeof query !== 'string' || !query.trim()) {
+    return [];
+  }
+
+  const isVideo = type === 'video';
+  const endpoint = isVideo
+    ? 'https://pixabay.com/api/videos/'
+    : 'https://pixabay.com/api/';
+
+  const url = new URL(endpoint);
+  url.searchParams.set('key', apiKey);
+  url.searchParams.set('q', query.trim());
+  url.searchParams.set('page', String(page));
+  url.searchParams.set('per_page', String(Math.min(200, Math.max(3, perPage))));
+  url.searchParams.set('safesearch', safeSearch ? 'true' : 'false');
+
+  const pixabayOrientation = mapPixabayOrientation(orientation);
+  if (pixabayOrientation) {
+    url.searchParams.set('orientation', pixabayOrientation);
+  }
+
+  if (!isVideo) {
+    url.searchParams.set('image_type', 'photo');
+  }
+
+  const res = await fetchFn(url.toString(), {
+    method: 'GET',
+    headers: {
+      'User-Agent': 'youtube-video-uploader-cli',
+    },
+  });
+
+  if (res.status === 400 || res.status === 401 || res.status === 403) {
+    const text = await res.text().catch(() => '');
+    if (text.includes('Invalid') || text.includes('key') || res.status === 401 || res.status === 403) {
+      const err = new Error(`Pixabay API Authentication Failed (${res.status}): ${text || 'Invalid API Key'}`);
+      err.status = res.status;
+      throw err;
+    }
+  }
+
+  if (res.status === 429) {
+    const retryAfter = res.headers.get('retry-after');
+    const err = new Error(`Pixabay API Rate Limit Exceeded (429)`);
+    err.status = 429;
+    err.retryAfter = retryAfter ? parseInt(retryAfter, 10) : null;
+    throw err;
+  }
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    const err = new Error(`Pixabay API error (${res.status}): ${text}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  const data = await res.json();
+  const items = Array.isArray(data.hits) ? data.hits : [];
+
+  const results = items.map((item, index) => {
+    const tags = typeof item.tags === 'string'
+      ? item.tags.split(',').map(t => t.trim()).filter(Boolean)
+      : [];
+
+    if (isVideo) {
+      const videos = item.videos || {};
+      const chosenVideo = videos.large?.url ? videos.large :
+        videos.medium?.url ? videos.medium :
+        videos.small?.url ? videos.small :
+        videos.tiny || {};
+
+      const width = chosenVideo.width || 1920;
+      const height = chosenVideo.height || 1080;
+      const calculatedOrientation = getOrientation(width, height);
+
+      const previewUrl = item.picture_id
+        ? `https://i.vimeocdn.com/video/${item.picture_id}_640x360.jpg`
+        : (item.userImageURL || '');
+
+      return {
+        provider: 'pixabay',
+        id: String(item.id),
+        type: 'video',
+        rank: index,
+        pageUrl: item.pageURL || `https://pixabay.com/videos/id-${item.id}/`,
+        previewUrl,
+        downloadUrl: chosenVideo.url || '',
+        width,
+        height,
+        duration: typeof item.duration === 'number' ? item.duration : undefined,
+        orientation: calculatedOrientation,
+        tags,
+        creator: {
+          name: item.user || 'Pixabay Creator',
+          profileUrl: item.user_id ? `https://pixabay.com/users/${item.user}-${item.user_id}/` : undefined,
+        },
+        license: 'Pixabay Content License',
+        raw: item,
+      };
+    } else {
+      const width = item.imageWidth || 1920;
+      const height = item.imageHeight || 1080;
+      const calculatedOrientation = getOrientation(width, height);
+      const downloadUrl = item.largeImageURL || item.fullHDURL || item.imageURL || item.webformatURL || '';
+      const previewUrl = item.previewURL || item.webformatURL || downloadUrl;
+
+      return {
+        provider: 'pixabay',
+        id: String(item.id),
+        type: 'photo',
+        rank: index,
+        pageUrl: item.pageURL || `https://pixabay.com/photos/id-${item.id}/`,
+        previewUrl,
+        downloadUrl,
+        width,
+        height,
+        orientation: calculatedOrientation,
+        tags,
+        creator: {
+          name: item.user || 'Pixabay Photographer',
+          profileUrl: item.user_id ? `https://pixabay.com/users/${item.user}-${item.user_id}/` : undefined,
+        },
+        license: 'Pixabay Content License',
+        raw: item,
+      };
+    }
+  });
+
+  return results;
+}

package/src/state.js

@@ -37,6 +37,17 @@ export class UploadState {
     }
   }
 
+  /**
+   * List all upload records.
+   * @returns {Array<{ filename: string, videoId: string, uploadedAt: string, playlistId?: string }>}
+   */
+  listUploads() {
+    return Object.entries(this.data.uploads || {}).map(([filename, record]) => ({
+      filename,
+      ...record,
+    }));
+  }
+
   /**
    * Check if a file has already been uploaded.
    * @param {string} filename