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

package/src/uploader.js

@@ -7,8 +7,36 @@ import { authenticate } from './auth.js';
 
 export const QUOTA_PER_VIDEO_UPLOAD = 1600;
 export const QUOTA_PER_PLAYLIST_ITEM = 50;
+export const QUOTA_PER_PLAYLIST_CREATE = 50;
 export const DAILY_DEFAULT_QUOTA = 10000;
 
+import { interpolateTemplates } from './metadata.js';
+
+/**
+ * Create a YouTube Playlist.
+ * 
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {object} snippet
+ * @param {object} [status={ privacyStatus: 'private' }]
+ * @returns {Promise<{ playlistId: string, url: string, data: any }>}
+ */
+export async function createPlaylist(youtube, snippet, status = { privacyStatus: 'private' }) {
+  const res = await youtube.playlists.insert({
+    part: ['snippet', 'status'],
+    requestBody: {
+      snippet,
+      status,
+    },
+  });
+
+  const playlistId = res.data.id;
+  return {
+    playlistId,
+    url: `https://www.youtube.com/playlist?list=${playlistId}`,
+    data: res.data,
+  };
+}
+
 /**
  * Upload a single video file to YouTube via YouTube Data API v3.
  * 
@@ -29,23 +57,37 @@ export async function uploadVideo(youtube, filePath, meta, defaultPrivacy = 'pri
     throw new Error(`Video file is empty (0 bytes): ${filePath}`);
   }
 
-  const res = await youtube.videos.insert({
+  const snippet = {
+    title: meta.title,
+    description: meta.description || '',
+    tags: meta.tags || [],
+    categoryId: String(meta.categoryId || defaultCategory || '10'),
+  };
+
+  if (meta.defaultLanguage) snippet.defaultLanguage = meta.defaultLanguage;
+  if (meta.defaultAudioLanguage) snippet.defaultAudioLanguage = meta.defaultAudioLanguage;
+
+  const status = {
+    privacyStatus: meta.privacyStatus || defaultPrivacy || 'private',
+    license: meta.license || 'youtube',
+    embeddable: meta.embeddable !== undefined ? meta.embeddable : true,
+    publicStatsViewable: meta.publicStatsViewable !== undefined ? meta.publicStatsViewable : true,
+    selfDeclaredMadeForKids: meta.selfDeclaredMadeForKids !== undefined ? meta.selfDeclaredMadeForKids : false,
+  };
+
+  const insertParams = {
     part: ['snippet', 'status'],
+    notifySubscribers: meta.notifySubscribers !== undefined ? meta.notifySubscribers : false,
     requestBody: {
-      snippet: {
-        title: meta.title,
-        description: meta.description || '',
-        tags: meta.tags || [],
-        categoryId: meta.categoryId || defaultCategory || '10',
-      },
-      status: {
-        privacyStatus: meta.privacyStatus || defaultPrivacy || 'private',
-      },
+      snippet,
+      status,
     },
     media: {
       body: fs.createReadStream(filePath),
     },
-  });
+  };
+
+  const res = await youtube.videos.insert(insertParams);
 
   const videoId = res.data.id;
   return {
@@ -60,19 +102,25 @@ export async function uploadVideo(youtube, filePath, meta, defaultPrivacy = 'pri
  * @param {import('googleapis').youtube_v3.Youtube} youtube
  * @param {string} playlistId
  * @param {string} videoId
+ * @param {number} [position]
  * @returns {Promise<any>}
  */
-export async function addToPlaylist(youtube, playlistId, videoId) {
+export async function addToPlaylist(youtube, playlistId, videoId, position) {
+  const snippet = {
+    playlistId,
+    resourceId: {
+      kind: 'youtube#video',
+      videoId,
+    },
+  };
+  if (typeof position === 'number') {
+    snippet.position = position;
+  }
+
   const res = await youtube.playlistItems.insert({
     part: ['snippet'],
     requestBody: {
-      snippet: {
-        playlistId,
-        resourceId: {
-          kind: 'youtube#video',
-          videoId,
-        },
-      },
+      snippet,
     },
   });
   return res.data;
@@ -95,7 +143,8 @@ export async function addToPlaylist(youtube, playlistId, videoId) {
  *   uploaded: Array<{ filename: string, videoId: string, url: string, addedToPlaylist: boolean }>,
  *   skipped: Array<{ filename: string, videoId?: string, reason: string }>,
  *   failed: Array<{ filename: string, error: Error }>,
- *   estimatedQuota: number
+ *   estimatedQuota: number,
+ *   playlistId?: string | null
  * }>}
  */
 export async function batchUpload(targetFolder, options = {}) {
@@ -107,7 +156,11 @@ export async function batchUpload(targetFolder, options = {}) {
   const config = loadMetadata(resolvedFolder, options.metadataFile);
   const state = new UploadState(resolvedFolder);
 
-  const playlistId = config.playlistId;
+  const playlistKey = config.playlist?.key || 'default';
+  const cachedPlaylist = state.getPlaylist(playlistKey);
+  let playlistId = config.playlistId || cachedPlaylist?.playlistId || null;
+  const needsPlaylistCreation = !playlistId && Boolean(config.playlist?.snippet);
+
   const toProcess = [];
   const skipped = [];
 
@@ -132,16 +185,53 @@ export async function batchUpload(targetFolder, options = {}) {
     }
   }
 
-  const estimatedQuota = (toProcess.length * QUOTA_PER_VIDEO_UPLOAD) +
-    (playlistId ? toProcess.length * QUOTA_PER_PLAYLIST_ITEM : 0);
+  const willHavePlaylist = Boolean(playlistId || needsPlaylistCreation);
+  const baseQuota = needsPlaylistCreation ? QUOTA_PER_PLAYLIST_CREATE : 0;
+  const costPerVideo = QUOTA_PER_VIDEO_UPLOAD + (willHavePlaylist ? QUOTA_PER_PLAYLIST_ITEM : 0);
+
+  let limit = Infinity;
+  if (options.limit !== undefined && options.limit !== null && !isNaN(options.limit)) {
+    limit = Math.max(0, parseInt(options.limit, 10));
+  }
+
+  let maxQuota = Infinity;
+  if (options.maxQuota !== undefined && options.maxQuota !== null && !isNaN(options.maxQuota)) {
+    maxQuota = parseInt(options.maxQuota, 10);
+  } else if (options.safeQuota) {
+    maxQuota = DAILY_DEFAULT_QUOTA - 50; // 9,950 units safe limit
+  }
+
+  const activeToProcess = [];
+  const deferred = [];
+
+  for (const item of toProcess) {
+    const candidateQuota = baseQuota + ((activeToProcess.length + 1) * costPerVideo);
+    if (activeToProcess.length < limit && candidateQuota <= maxQuota) {
+      activeToProcess.push(item);
+    } else {
+      deferred.push({
+        filename: item.filename,
+        reason: activeToProcess.length >= limit
+          ? `Deferred by upload limit (${limit})`
+          : `Deferred for next batch to stay under quota limit (${maxQuota} units)`,
+      });
+    }
+  }
+
+  const estimatedQuota = baseQuota + (activeToProcess.length * costPerVideo);
 
   onEvent({
     type: 'plan',
     total: config.videos.length,
-    toProcess,
+    toProcess: activeToProcess,
     skipped,
+    deferred,
     estimatedQuota,
     playlistId,
+    needsPlaylistCreation,
+    playlist: config.playlist,
+    safeQuota: Boolean(options.safeQuota),
+    limit: isFinite(limit) ? limit : null,
   });
 
   if (dryRun) {
@@ -150,19 +240,23 @@ export async function batchUpload(targetFolder, options = {}) {
       total: config.videos.length,
       uploaded: [],
       skipped,
+      deferred,
       failed: [],
       estimatedQuota,
+      playlistId,
     };
   }
 
-  if (toProcess.length === 0) {
+  if (activeToProcess.length === 0 && !needsPlaylistCreation) {
     return {
       targetFolder: resolvedFolder,
       total: config.videos.length,
       uploaded: [],
       skipped,
+      deferred,
       failed: [],
       estimatedQuota: 0,
+      playlistId,
     };
   }
 
@@ -176,12 +270,61 @@ export async function batchUpload(targetFolder, options = {}) {
 
   const youtube = google.youtube({ version: 'v3', auth });
 
+  // Verify and display authenticated channel identity
+  try {
+    const channelRes = await youtube.channels.list({
+      part: ['snippet'],
+      mine: true,
+    });
+    if (channelRes.data.items && channelRes.data.items.length > 0) {
+      const ch = channelRes.data.items[0];
+      const channelInfo = {
+        id: ch.id,
+        title: ch.snippet?.title || 'Unknown',
+        customUrl: ch.snippet?.customUrl || null,
+      };
+      onEvent({ type: 'authenticated_channel', channel: channelInfo });
+    }
+  } catch {
+    // Non-fatal
+  }
+
+  // Create playlist if needed
+  if (needsPlaylistCreation && config.playlist?.snippet) {
+    onEvent({ type: 'playlist_create_start', playlist: config.playlist });
+    try {
+      const created = await createPlaylist(
+        youtube,
+        config.playlist.snippet,
+        config.playlist.status || { privacyStatus: config.privacyStatus }
+      );
+      playlistId = created.playlistId;
+      state.recordPlaylistInfo(playlistKey, created.playlistId, created.url);
+      onEvent({ type: 'playlist_create_success', playlistId, url: created.url });
+    } catch (err) {
+      onEvent({ type: 'playlist_create_error', error: err });
+      throw new Error(`Failed to create YouTube Playlist: ${err.message}`);
+    }
+  }
+
+  // Apply playlistUrl template interpolation to pending video items
+  const playlistUrl = playlistId ? `https://www.youtube.com/playlist?list=${playlistId}` : '';
+  const finalTemplateVars = {
+    ...config.templateVariables,
+    playlistUrl: playlistUrl || config.templateVariables.playlistUrl || '',
+  };
+
+  for (const item of activeToProcess) {
+    item.title = interpolateTemplates(item.title, finalTemplateVars);
+    item.description = interpolateTemplates(item.description, finalTemplateVars);
+  }
+
   const uploaded = [];
   const failed = [];
 
-  for (let i = 0; i < toProcess.length; i++) {
-    const item = toProcess[i];
-    onEvent({ type: 'upload_start', item, index: i, total: toProcess.length });
+  for (let i = 0; i < activeToProcess.length; i++) {
+    const item = activeToProcess[i];
+    onEvent({ type: 'upload_start', item, index: i, total: activeToProcess.length });
 
     try {
       const uploadRes = await uploadVideo(
@@ -196,7 +339,7 @@ export async function batchUpload(targetFolder, options = {}) {
       if (playlistId) {
         onEvent({ type: 'playlist_start', item, videoId: uploadRes.videoId, playlistId });
         try {
-          await addToPlaylist(youtube, playlistId, uploadRes.videoId);
+          await addToPlaylist(youtube, playlistId, uploadRes.videoId, item.playlistPosition);
           addedToPlaylist = true;
           onEvent({ type: 'playlist_success', item, videoId: uploadRes.videoId, playlistId });
         } catch (playlistErr) {
@@ -228,5 +371,6 @@ export async function batchUpload(targetFolder, options = {}) {
     skipped,
     failed,
     estimatedQuota,
+    playlistId,
   };
 }