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

package/src/access/privacy.js

@@ -0,0 +1,113 @@
+import { VALID_PRIVACY_STATUSES } from '../metadata.js';
+
+/**
+ * @typedef {'private' | 'unlisted' | 'public'} PrivacyStatus
+ */
+
+/**
+ * Normalize and validate a privacy status string.
+ * @param {string} value
+ * @returns {PrivacyStatus}
+ */
+export function normalizePrivacyStatus(value) {
+  const status = String(value || '').toLowerCase().trim();
+  if (!VALID_PRIVACY_STATUSES.has(status)) {
+    throw new Error(`Invalid privacy status: ${value}. Use private, unlisted, or public.`);
+  }
+  return /** @type {PrivacyStatus} */ (status);
+}
+
+/**
+ * Fetch privacy status for videos (batch up to 50 ids per call).
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string[]} videoIds
+ * @returns {Promise<Map<string, PrivacyStatus>>}
+ */
+export async function getVideosPrivacy(youtube, videoIds) {
+  const map = new Map();
+  const ids = [...new Set(videoIds.filter(Boolean))];
+  for (let i = 0; i < ids.length; i += 50) {
+    const chunk = ids.slice(i, i + 50);
+    const { data } = await youtube.videos.list({
+      part: ['status', 'snippet'],
+      id: chunk,
+    });
+    for (const item of data.items || []) {
+      map.set(item.id, /** @type {PrivacyStatus} */ (item.status?.privacyStatus || 'private'));
+    }
+  }
+  return map;
+}
+
+/**
+ * Fetch playlist privacy status.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} playlistId
+ * @returns {Promise<PrivacyStatus>}
+ */
+export async function getPlaylistPrivacy(youtube, playlistId) {
+  const { data } = await youtube.playlists.list({
+    part: ['status'],
+    id: [playlistId],
+  });
+  const item = data.items?.[0];
+  if (!item) {
+    throw new Error(`Playlist not found or inaccessible: ${playlistId}`);
+  }
+  return /** @type {PrivacyStatus} */ (item.status?.privacyStatus || 'private');
+}
+
+/**
+ * Update a single video's privacy status.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} videoId
+ * @param {PrivacyStatus} privacyStatus
+ * @returns {Promise<{ videoId: string, privacyStatus: PrivacyStatus }>}
+ */
+export async function setVideoPrivacy(youtube, videoId, privacyStatus) {
+  const status = normalizePrivacyStatus(privacyStatus);
+  await youtube.videos.update({
+    part: ['status'],
+    requestBody: {
+      id: videoId,
+      status: { privacyStatus: status },
+    },
+  });
+  return { videoId, privacyStatus: status };
+}
+
+/**
+ * Update a playlist's privacy status.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} playlistId
+ * @param {PrivacyStatus} privacyStatus
+ * @returns {Promise<{ playlistId: string, privacyStatus: PrivacyStatus }>}
+ */
+export async function setPlaylistPrivacy(youtube, playlistId, privacyStatus) {
+  const status = normalizePrivacyStatus(privacyStatus);
+
+  const { data } = await youtube.playlists.list({
+    part: ['snippet', 'status'],
+    id: [playlistId],
+  });
+  const existing = data.items?.[0];
+  if (!existing?.snippet) {
+    throw new Error(`Playlist not found or inaccessible: ${playlistId}`);
+  }
+
+  await youtube.playlists.update({
+    part: ['snippet', 'status'],
+    requestBody: {
+      id: playlistId,
+      snippet: existing.snippet,
+      status: { privacyStatus: status },
+    },
+  });
+  return { playlistId, privacyStatus: status };
+}
+
+export const QUOTA_PER_PRIVACY_UPDATE = 50;

package/src/access/set-access.js

@@ -0,0 +1,247 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { UploadState } from '../state.js';
+import { listPlaylistItems } from '../playlist/reorder.js';
+import { resolveDesiredPlaylistOrder } from '../playlist/order.js';
+import {
+  getVideosPrivacy,
+  getPlaylistPrivacy,
+  setVideoPrivacy,
+  setPlaylistPrivacy,
+  normalizePrivacyStatus,
+  QUOTA_PER_PRIVACY_UPDATE,
+} from './privacy.js';
+
+/**
+ * Set privacy/access for a playlist and its member videos.
+ *
+ * @param {object} options
+ * @param {import('googleapis').youtube_v3.Youtube} [options.youtube]
+ * @param {string} options.playlistId
+ * @param {'private' | 'unlisted' | 'public'} options.privacyStatus
+ * @param {string[]} [options.videoIds] - Explicit video IDs (skips playlist listing)
+ * @param {'playlist' | 'history'} [options.videoSource='playlist'] - Resolve videos from YouTube playlist or upload history
+ * @param {string} [options.albumDir]
+ * @param {string} [options.overviewHistoryPath]
+ * @param {string[]} [options.overviewKeys]
+ * @param {boolean} [options.updateMetadata=false]
+ * @param {string} [options.metadataFile]
+ * @param {boolean} [options.dryRun=false]
+ * @param {(event: object) => void} [options.onEvent]
+ * @returns {Promise<object>}
+ */
+export async function setPlaylistAccess(options = {}) {
+  const {
+    youtube,
+    playlistId,
+    privacyStatus: rawPrivacy,
+    videoSource = 'playlist',
+    albumDir,
+    overviewHistoryPath,
+    overviewKeys = [],
+    videoIds: explicitVideoIds,
+    updateMetadata = false,
+    metadataFile,
+    dryRun = false,
+    onEvent = () => {},
+  } = options;
+
+  if (!playlistId) {
+    throw new Error('setPlaylistAccess requires playlistId');
+  }
+
+  const privacyStatus = normalizePrivacyStatus(rawPrivacy);
+
+  /** @type {Array<{ videoId: string, title?: string, position?: number }>} */
+  let targets = [];
+
+  if (Array.isArray(explicitVideoIds) && explicitVideoIds.length > 0) {
+    targets = explicitVideoIds.map((videoId, index) => ({ videoId, position: index }));
+  } else if (videoSource === 'playlist') {
+    if (!youtube && !dryRun) {
+      throw new Error('videoSource "playlist" requires a YouTube client');
+    }
+    if (youtube) {
+      const items = await listPlaylistItems(youtube, playlistId);
+      targets = items.map((item) => ({
+        videoId: item.videoId,
+        title: item.title,
+        position: item.position,
+      }));
+    }
+  } else if (videoSource === 'history') {
+    if (!albumDir) {
+      throw new Error('videoSource "history" requires albumDir');
+    }
+    const albumState = new UploadState(albumDir);
+    const videoIds = resolveDesiredPlaylistOrder({
+      albumDir,
+      albumState,
+      overviewHistoryPath,
+      overviewKeys,
+    });
+    targets = videoIds.map((videoId) => ({ videoId }));
+  } else {
+    throw new Error(`Unsupported videoSource: ${videoSource}`);
+  }
+
+  if (targets.length === 0 && dryRun && videoSource === 'playlist') {
+    // Dry-run without youtube: cannot list playlist — caller should use history
+    throw new Error('Dry-run with videoSource "playlist" requires YouTube auth to list playlist items');
+  }
+
+  let currentPlaylistPrivacy = null;
+  let currentVideoPrivacy = new Map();
+
+  if (youtube) {
+    currentPlaylistPrivacy = await getPlaylistPrivacy(youtube, playlistId);
+    currentVideoPrivacy = await getVideosPrivacy(youtube, targets.map((t) => t.videoId));
+  }
+
+  const videoPlans = targets.map((target) => {
+    const current = currentVideoPrivacy.get(target.videoId) || null;
+    return {
+      ...target,
+      currentPrivacy: current,
+      targetPrivacy: privacyStatus,
+      changed: current !== null ? current !== privacyStatus : true,
+    };
+  });
+
+  const playlistChanged = currentPlaylistPrivacy !== null
+    ? currentPlaylistPrivacy !== privacyStatus
+    : true;
+
+  const changedVideos = videoPlans.filter((v) => v.changed);
+  const estimatedQuota = (playlistChanged ? QUOTA_PER_PRIVACY_UPDATE : 0)
+    + (changedVideos.length * QUOTA_PER_PRIVACY_UPDATE);
+
+  const plan = {
+    playlistId,
+    privacyStatus,
+    videoSource,
+    playlist: {
+      playlistId,
+      currentPrivacy: currentPlaylistPrivacy,
+      targetPrivacy: privacyStatus,
+      changed: playlistChanged,
+    },
+    videos: videoPlans,
+    changedCount: changedVideos.length + (playlistChanged ? 1 : 0),
+    estimatedQuota,
+  };
+
+  onEvent({ type: 'access_plan', plan });
+
+  if (dryRun) {
+    return { dryRun: true, ...plan, updated: { playlist: false, videos: [] } };
+  }
+
+  if (!youtube) {
+    throw new Error('setPlaylistAccess requires a YouTube client when dryRun is false');
+  }
+
+  const updated = { playlist: false, videos: [] };
+
+  if (playlistChanged) {
+    onEvent({ type: 'access_playlist_start', playlistId, privacyStatus });
+    await setPlaylistPrivacy(youtube, playlistId, privacyStatus);
+    updated.playlist = true;
+    onEvent({ type: 'access_playlist_success', playlistId, privacyStatus });
+  }
+
+  for (let i = 0; i < changedVideos.length; i += 1) {
+    const video = changedVideos[i];
+    onEvent({
+      type: 'access_video_start',
+      videoId: video.videoId,
+      title: video.title,
+      index: i,
+      total: changedVideos.length,
+    });
+    await setVideoPrivacy(youtube, video.videoId, privacyStatus);
+    updated.videos.push({ videoId: video.videoId, privacyStatus });
+    onEvent({ type: 'access_video_success', videoId: video.videoId, privacyStatus });
+  }
+
+  if (updateMetadata && albumDir) {
+    const metadataPath = metadataFile
+      ? path.resolve(metadataFile)
+      : path.join(path.resolve(albumDir), 'metadata.json');
+    if (fs.existsSync(metadataPath)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+        if (raw.uploadPolicy) {
+          raw.uploadPolicy.initialVideoPrivacyStatus = privacyStatus;
+          raw.uploadPolicy.initialPlaylistPrivacyStatus = privacyStatus;
+        }
+        if (raw.playlist?.youtube?.status) {
+          raw.playlist.youtube.status.privacyStatus = privacyStatus;
+        } else if (raw.playlist?.status) {
+          raw.playlist.status.privacyStatus = privacyStatus;
+        }
+        if (raw.songs && typeof raw.songs === 'object') {
+          for (const song of Object.values(raw.songs)) {
+            if (song?.youtube?.status) {
+              song.youtube.status.privacyStatus = privacyStatus;
+            }
+          }
+        }
+        fs.writeFileSync(metadataPath, JSON.stringify(raw, null, 2) + '\n', 'utf-8');
+        onEvent({ type: 'access_metadata_saved', metadataPath });
+      } catch (err) {
+        onEvent({ type: 'access_metadata_error', error: err });
+      }
+    }
+  }
+
+  return {
+    dryRun: false,
+    ...plan,
+    updated,
+  };
+}
+
+/**
+ * Set privacy for explicit video IDs (no playlist update).
+ *
+ * @param {object} options
+ * @param {import('googleapis').youtube_v3.Youtube} options.youtube
+ * @param {string[]} options.videoIds
+ * @param {'private' | 'unlisted' | 'public'} options.privacyStatus
+ * @param {boolean} [options.dryRun=false]
+ * @returns {Promise<object>}
+ */
+export async function setVideosAccess(options = {}) {
+  const { youtube, videoIds = [], privacyStatus: rawPrivacy, dryRun = false } = options;
+  const privacyStatus = normalizePrivacyStatus(rawPrivacy);
+  const ids = [...new Set(videoIds.filter(Boolean))];
+
+  if (ids.length === 0) {
+    throw new Error('setVideosAccess requires at least one videoId');
+  }
+
+  const current = youtube ? await getVideosPrivacy(youtube, ids) : new Map();
+  const plans = ids.map((videoId) => ({
+    videoId,
+    currentPrivacy: current.get(videoId) || null,
+    targetPrivacy: privacyStatus,
+    changed: current.get(videoId) !== privacyStatus,
+  }));
+
+  if (dryRun) {
+    return { dryRun: true, videos: plans, changedCount: plans.filter((p) => p.changed).length };
+  }
+
+  if (!youtube) {
+    throw new Error('setVideosAccess requires a YouTube client');
+  }
+
+  const updated = [];
+  for (const plan of plans.filter((p) => p.changed)) {
+    await setVideoPrivacy(youtube, plan.videoId, privacyStatus);
+    updated.push(plan.videoId);
+  }
+
+  return { dryRun: false, videos: plans, updated };
+}

package/src/actions/index.js

@@ -9,6 +9,12 @@ import {
   renderSvgToPng,
   resolveJourneyTracks,
 } from './journey-overlay.js';
+import {
+  removeWatermark,
+  isWatermarkSupportedMedia,
+  defaultCleanOutputPath,
+  defaultCleanOutDir,
+} from './remove-watermark.js';
 
 export {
   shortenVideo,
@@ -20,6 +26,10 @@ export {
   generateJourneySvg,
   renderSvgToPng,
   resolveJourneyTracks,
+  removeWatermark,
+  isWatermarkSupportedMedia,
+  defaultCleanOutputPath,
+  defaultCleanOutDir,
 };
 
 /**
@@ -116,6 +126,7 @@ export async function runActionsPipeline(entry, actions = [], context = {}) {
         const res = await shortenVideo({
           inputPath: currentInput,
           outputPath: stepOutput,
+          entry,
           ...action,
           dryRun: true,
           onWarn,
@@ -143,6 +154,15 @@ export async function runActionsPipeline(entry, actions = [], context = {}) {
           onWarn,
         });
         steps.push(`[${i + 1}/${actions.length}] ${res.command}`);
+      } else if (action.type === 'remove-watermark') {
+        const res = await removeWatermark({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          action,
+          dryRun: true,
+          onWarn,
+        });
+        steps.push(`[${i + 1}/${actions.length}] ${res.command}`);
       } else {
         throw new Error(`Unknown action type: "${action.type}" on entry ${songKey}`);
       }
@@ -205,6 +225,7 @@ export async function runActionsPipeline(entry, actions = [], context = {}) {
         await shortenVideo({
           inputPath: currentInput,
           outputPath: stepOutput,
+          entry,
           ...action,
           dryRun: false,
           onWarn,
@@ -230,6 +251,18 @@ export async function runActionsPipeline(entry, actions = [], context = {}) {
           dryRun: false,
           onWarn,
         });
+      } else if (action.type === 'remove-watermark') {
+        await removeWatermark({
+          inputPath: currentInput,
+          outputPath: stepOutput,
+          action: {
+            ...action,
+            // Pipeline targets are always freshly planned; allow overwrite of step outputs.
+            overwrite: action.overwrite !== undefined ? action.overwrite : true,
+          },
+          dryRun: false,
+          onWarn,
+        });
       } else {
         throw new Error(`Unknown action type: "${action.type}" on entry ${songKey}`);
       }