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

package/src/update.js

@@ -0,0 +1,392 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { google } from 'googleapis';
+import { loadMetadata } from './metadata.js';
+import { UploadState } from './state.js';
+import { authenticate } from './auth.js';
+
+export const QUOTA_PER_VIDEO_UPDATE = 50;
+export const QUOTA_PER_PLAYLIST_UPDATE = 50;
+export const QUOTA_PER_LIST = 1;
+
+/**
+ * Update snippet fields of a YouTube video while preserving other metadata.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} videoId
+ * @param {object} snippetUpdates - Fields to update (title, description, tags, categoryId, etc.)
+ * @returns {Promise<{ videoId: string, title: string, data: any }>}
+ */
+export async function updateVideoSnippet(youtube, videoId, snippetUpdates) {
+  if (!videoId) {
+    throw new Error('updateVideoSnippet requires a videoId');
+  }
+
+  // Fetch current snippet to preserve mandatory categoryId and other existing fields
+  const res = await youtube.videos.list({
+    part: ['snippet'],
+    id: [videoId],
+  });
+
+  const existing = res.data.items?.[0];
+  if (!existing || !existing.snippet) {
+    throw new Error(`Video not found or inaccessible: ${videoId}`);
+  }
+
+  const mergedSnippet = {
+    ...existing.snippet,
+    ...snippetUpdates,
+    categoryId: String(snippetUpdates.categoryId || existing.snippet.categoryId || '10'),
+  };
+
+  const updateRes = await youtube.videos.update({
+    part: ['snippet'],
+    requestBody: {
+      id: videoId,
+      snippet: mergedSnippet,
+    },
+  });
+
+  return {
+    videoId,
+    title: updateRes.data.snippet?.title || mergedSnippet.title,
+    data: updateRes.data,
+  };
+}
+
+/**
+ * Update a YouTube video's title.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} videoId
+ * @param {string} newTitle
+ * @returns {Promise<{ videoId: string, title: string, data: any }>}
+ */
+export async function updateVideoTitle(youtube, videoId, newTitle) {
+  return updateVideoSnippet(youtube, videoId, { title: newTitle });
+}
+
+/**
+ * Update snippet fields of a YouTube playlist while preserving existing description/tags.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} playlistId
+ * @param {object} snippetUpdates
+ * @returns {Promise<{ playlistId: string, title: string, data: any }>}
+ */
+export async function updatePlaylistSnippet(youtube, playlistId, snippetUpdates) {
+  if (!playlistId) {
+    throw new Error('updatePlaylistSnippet requires a playlistId');
+  }
+
+  const res = await youtube.playlists.list({
+    part: ['snippet'],
+    id: [playlistId],
+  });
+
+  const existing = res.data.items?.[0];
+  if (!existing || !existing.snippet) {
+    throw new Error(`Playlist not found or inaccessible: ${playlistId}`);
+  }
+
+  const mergedSnippet = {
+    ...existing.snippet,
+    ...snippetUpdates,
+  };
+
+  const updateRes = await youtube.playlists.update({
+    part: ['snippet'],
+    requestBody: {
+      id: playlistId,
+      snippet: mergedSnippet,
+    },
+  });
+
+  return {
+    playlistId,
+    title: updateRes.data.snippet?.title || mergedSnippet.title,
+    data: updateRes.data,
+  };
+}
+
+/**
+ * Update a YouTube playlist's title.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} playlistId
+ * @param {string} newTitle
+ * @returns {Promise<{ playlistId: string, title: string, data: any }>}
+ */
+export async function updatePlaylistTitle(youtube, playlistId, newTitle) {
+  return updatePlaylistSnippet(youtube, playlistId, { title: newTitle });
+}
+
+/**
+ * Batch update titles / metadata for all videos and the playlist in a target directory.
+ *
+ * @param {string} targetFolder
+ * @param {object} [options]
+ * @param {string} [options.titlePostfix] - Postfix to append to video titles
+ * @param {string} [options.titlePrefix] - Prefix to prepend to video titles
+ * @param {string} [options.playlistPostfix] - Postfix to append to playlist title
+ * @param {string} [options.playlistTitle] - Override playlist title
+ * @param {string} [options.replacePattern] - Regex or substring to find in titles
+ * @param {string} [options.replaceWith] - Replacement string
+ * @param {string} [options.metadataFile] - Custom path to metadata.json
+ * @param {boolean} [options.updateLocalMetadata=true] - Update metadata.json on disk
+ * @param {boolean} [options.syncMetadata=false] - Push titles from metadata.json directly to YouTube
+ * @param {string} [options.singleVideoId] - Optional single video ID to target
+ * @param {string} [options.singleVideoTitle] - Optional single video title override
+ * @param {string} [options.singlePlaylistId] - Optional single playlist ID to target
+ * @param {boolean} [options.dryRun=false]
+ * @param {string} [options.tokenFile]
+ * @param {string} [options.clientSecretsFile]
+ * @param {string} [options.clientId]
+ * @param {string} [options.clientSecret]
+ * @param {(event: { type: string, [key: string]: any }) => void} [options.onEvent]
+ * @returns {Promise<{
+ *   playlist?: { playlistId: string, oldTitle: string, newTitle: string, changed: boolean },
+ *   videos: Array<{ filename: string, videoId: string, oldTitle: string, newTitle: string, changed: boolean }>,
+ *   estimatedQuota: number,
+ *   dryRun: boolean
+ * }>}
+ */
+export async function batchUpdateMetadata(targetFolder, options = {}) {
+  const resolvedFolder = path.resolve(targetFolder || process.cwd());
+  const dryRun = Boolean(options.dryRun);
+  const onEvent = options.onEvent || (() => {});
+  const updateLocal = options.updateLocalMetadata !== false;
+
+  const metadataPath = options.metadataFile
+    ? path.resolve(options.metadataFile)
+    : path.join(resolvedFolder, 'metadata.json');
+
+  let rawMetadata = null;
+  if (fs.existsSync(metadataPath)) {
+    try {
+      rawMetadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+    } catch {
+      // Non-fatal if metadata.json is absent or invalid
+    }
+  }
+
+  const state = new UploadState(resolvedFolder);
+  const playlistKey = rawMetadata?.playlist?.key || 'default';
+  const cachedPlaylist = state.getPlaylist(playlistKey);
+  const playlistId = options.singlePlaylistId || rawMetadata?.playlistId || rawMetadata?.playlist?.playlistId || cachedPlaylist?.playlistId || state.getPlaylist('gray_to_light')?.playlistId || null;
+
+  // Build playlist plan
+  let playlistPlan = null;
+  if (playlistId) {
+    let currentTitle = rawMetadata?.playlist?.youtube?.snippet?.title || rawMetadata?.playlist?.snippet?.title || '';
+    let newTitle = currentTitle;
+
+    if (options.syncMetadata) {
+      newTitle = currentTitle;
+    } else if (options.playlistTitle) {
+      newTitle = options.playlistTitle;
+    } else if (options.playlistPostfix) {
+      if (currentTitle && !currentTitle.endsWith(options.playlistPostfix)) {
+        newTitle = currentTitle + options.playlistPostfix;
+      }
+    }
+
+    if (options.replacePattern) {
+      const reg = new RegExp(options.replacePattern, 'g');
+      newTitle = newTitle.replace(reg, options.replaceWith || '');
+    }
+
+    if (currentTitle || newTitle || options.playlistPostfix) {
+      playlistPlan = {
+        playlistId,
+        oldTitle: currentTitle,
+        newTitle: newTitle || currentTitle,
+        changed: (newTitle !== currentTitle) && Boolean(newTitle),
+      };
+    }
+  }
+
+  // Build video plans
+  const videoPlans = [];
+  const songsObj = rawMetadata?.songs || {};
+  const orderedKeys = Array.isArray(rawMetadata?.playlist?.orderedSongKeys)
+    ? rawMetadata.playlist.orderedSongKeys
+    : Object.keys(songsObj);
+
+  const seenFiles = new Set();
+
+  if (options.singleVideoId) {
+    videoPlans.push({
+      filename: path.basename(resolvedFolder),
+      videoId: options.singleVideoId,
+      oldTitle: '',
+      newTitle: options.singleVideoTitle || '',
+      changed: true,
+    });
+  } else {
+    for (const filename of orderedKeys) {
+      seenFiles.add(filename);
+      const songData = songsObj[filename] || {};
+      const uploadRecord = state.getUpload(filename);
+      const videoId = uploadRecord?.videoId || songData.playlistItem?.videoId;
+      if (!videoId) continue;
+
+      let currentTitle = songData.youtube?.snippet?.title || path.basename(filename, path.extname(filename));
+      let newTitle = currentTitle;
+
+      if (options.syncMetadata) {
+        newTitle = currentTitle;
+      } else {
+        if (options.titlePostfix) {
+          if (!currentTitle.endsWith(options.titlePostfix)) {
+            newTitle = currentTitle + options.titlePostfix;
+          }
+        }
+        if (options.titlePrefix) {
+          if (!newTitle.startsWith(options.titlePrefix)) {
+            newTitle = options.titlePrefix + newTitle;
+          }
+        }
+      }
+
+      if (options.replacePattern) {
+        const reg = new RegExp(options.replacePattern, 'g');
+        newTitle = newTitle.replace(reg, options.replaceWith || '');
+      }
+
+      videoPlans.push({
+        filename,
+        videoId,
+        oldTitle: currentTitle,
+        newTitle,
+        changed: (newTitle !== currentTitle),
+      });
+    }
+
+    // Check any additional uploads in state file
+    const stateUploads = state.listUploads();
+    for (const upload of stateUploads) {
+      if (!seenFiles.has(upload.filename) && upload.videoId) {
+        let currentTitle = path.basename(upload.filename, path.extname(upload.filename));
+        let newTitle = currentTitle;
+        if (!options.syncMetadata) {
+          if (options.titlePostfix && !currentTitle.endsWith(options.titlePostfix)) {
+            newTitle = currentTitle + options.titlePostfix;
+          }
+          if (options.titlePrefix && !newTitle.startsWith(options.titlePrefix)) {
+            newTitle = options.titlePrefix + newTitle;
+          }
+        }
+        if (options.replacePattern) {
+          const reg = new RegExp(options.replacePattern, 'g');
+          newTitle = newTitle.replace(reg, options.replaceWith || '');
+        }
+        videoPlans.push({
+          filename: upload.filename,
+          videoId: upload.videoId,
+          oldTitle: currentTitle,
+          newTitle,
+          changed: (newTitle !== currentTitle),
+        });
+      }
+    }
+  }
+
+  const changedVideos = videoPlans.filter(v => v.changed);
+  const playlistChanged = Boolean(playlistPlan && playlistPlan.changed);
+  const estimatedQuota = (changedVideos.length * (QUOTA_PER_VIDEO_UPDATE + QUOTA_PER_LIST)) +
+    (playlistChanged ? (QUOTA_PER_PLAYLIST_UPDATE + QUOTA_PER_LIST) : 0);
+
+  onEvent({
+    type: 'update_plan',
+    playlist: playlistPlan,
+    videos: videoPlans,
+    changedCount: changedVideos.length + (playlistChanged ? 1 : 0),
+    estimatedQuota,
+    dryRun,
+  });
+
+  if (dryRun) {
+    return {
+      playlist: playlistPlan,
+      videos: videoPlans,
+      estimatedQuota,
+      dryRun: true,
+    };
+  }
+
+  if (changedVideos.length === 0 && !playlistChanged) {
+    return {
+      playlist: playlistPlan,
+      videos: videoPlans,
+      estimatedQuota: 0,
+      dryRun: false,
+    };
+  }
+
+  // Authenticate
+  const auth = await authenticate({
+    tokenFile: options.tokenFile,
+    clientSecretsFile: options.clientSecretsFile,
+    clientId: options.clientId,
+    clientSecret: options.clientSecret,
+  });
+
+  const youtube = google.youtube({ version: 'v3', auth });
+
+  // Update Playlist
+  if (playlistPlan && playlistPlan.changed) {
+    onEvent({ type: 'playlist_update_start', playlistId: playlistPlan.playlistId, newTitle: playlistPlan.newTitle });
+    try {
+      await updatePlaylistTitle(youtube, playlistPlan.playlistId, playlistPlan.newTitle);
+      onEvent({ type: 'playlist_update_success', playlistId: playlistPlan.playlistId, newTitle: playlistPlan.newTitle });
+    } catch (err) {
+      onEvent({ type: 'playlist_update_error', playlistId: playlistPlan.playlistId, error: err });
+      throw new Error(`Failed to update playlist title: ${err.message}`);
+    }
+  }
+
+  // Update Videos
+  for (let i = 0; i < changedVideos.length; i++) {
+    const v = changedVideos[i];
+    onEvent({ type: 'video_update_start', item: v, index: i, total: changedVideos.length });
+    try {
+      await updateVideoTitle(youtube, v.videoId, v.newTitle);
+      onEvent({ type: 'video_update_success', item: v, index: i, total: changedVideos.length });
+    } catch (err) {
+      onEvent({ type: 'video_update_error', item: v, error: err });
+      throw new Error(`Failed to update video "${v.filename}" (${v.videoId}): ${err.message}`);
+    }
+  }
+
+  // Update metadata.json on disk if present and requested
+  if (updateLocal && rawMetadata && fs.existsSync(metadataPath)) {
+    try {
+      if (playlistPlan && playlistPlan.changed) {
+        if (rawMetadata.playlist?.youtube?.snippet) {
+          rawMetadata.playlist.youtube.snippet.title = playlistPlan.newTitle;
+        } else if (rawMetadata.playlist?.snippet) {
+          rawMetadata.playlist.snippet.title = playlistPlan.newTitle;
+        }
+      }
+
+      for (const v of videoPlans) {
+        if (v.changed && rawMetadata.songs?.[v.filename]?.youtube?.snippet) {
+          rawMetadata.songs[v.filename].youtube.snippet.title = v.newTitle;
+        }
+      }
+
+      fs.writeFileSync(metadataPath, JSON.stringify(rawMetadata, null, 2) + '\n', 'utf-8');
+      onEvent({ type: 'metadata_file_saved', metadataPath });
+    } catch (err) {
+      onEvent({ type: 'metadata_file_error', error: err });
+    }
+  }
+
+  return {
+    playlist: playlistPlan,
+    videos: videoPlans,
+    estimatedQuota,
+    dryRun: false,
+  };
+}

package/src/uploader.js

@@ -4,6 +4,7 @@ import { google } from 'googleapis';
 import { loadMetadata } from './metadata.js';
 import { UploadState } from './state.js';
 import { authenticate } from './auth.js';
+import { resolveMediaForMetadata } from './media/resolve.js';
 
 export const QUOTA_PER_VIDEO_UPLOAD = 1600;
 export const QUOTA_PER_PLAYLIST_ITEM = 50;
@@ -134,6 +135,9 @@ export async function addToPlaylist(youtube, playlistId, videoId, position) {
  * @param {string} [options.metadataFile] - Custom metadata JSON path
  * @param {boolean} [options.force=false] - Re-upload previously uploaded videos
  * @param {boolean} [options.dryRun=false] - Preview without uploading
+ * @param {number} [options.limit] - Max videos to upload in this run
+ * @param {boolean} [options.safeQuota=false] - Cap batch under ~9,950 daily units
+ * @param {number} [options.maxQuota] - Hard quota unit cap for this run
  * @param {string} [options.tokenFile] - Custom token JSON path
  * @param {string} [options.clientSecretsFile] - Custom client_secret.json path
  * @param {(event: { type: string, [key: string]: any }) => void} [options.onEvent]
@@ -142,6 +146,7 @@ export async function addToPlaylist(youtube, playlistId, videoId, position) {
  *   total: number,
  *   uploaded: Array<{ filename: string, videoId: string, url: string, addedToPlaylist: boolean }>,
  *   skipped: Array<{ filename: string, videoId?: string, reason: string }>,
+ *   deferred: Array<{ filename: string, reason: string }>,
  *   failed: Array<{ filename: string, error: Error }>,
  *   estimatedQuota: number,
  *   playlistId?: string | null
@@ -153,6 +158,20 @@ export async function batchUpload(targetFolder, options = {}) {
   const dryRun = Boolean(options.dryRun);
   const onEvent = options.onEvent || (() => {});
 
+  if (options.autoMedia) {
+    onEvent({ type: 'auto_media_start' });
+    await resolveMediaForMetadata(resolvedFolder, {
+      compose: true,
+      provider: options.mediaProvider,
+      force: options.force,
+      dryRun: options.dryRun,
+      pexelsKey: options.pexelsKey,
+      pixabayKey: options.pixabayKey,
+      onEvent,
+    });
+    onEvent({ type: 'auto_media_complete' });
+  }
+
   const config = loadMetadata(resolvedFolder, options.metadataFile);
   const state = new UploadState(resolvedFolder);
 
@@ -369,6 +388,7 @@ export async function batchUpload(targetFolder, options = {}) {
     total: config.videos.length,
     uploaded,
     skipped,
+    deferred,
     failed,
     estimatedQuota,
     playlistId,