@x12i/youtube-video-uploader-cli 1.4.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,
 };
 
 /**
@@ -144,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}`);
       }
@@ -232,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}`);
       }

package/src/actions/remove-watermark.js

@@ -0,0 +1,109 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  DEFAULT_WATERMARK_PROVIDER,
+  removeWatermarkWithProvider,
+} from '../providers/watermark/index.js';
+
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.tif', '.tiff', '.bmp']);
+const VIDEO_EXTS = new Set(['.mp4', '.webm', '.mov', '.mkv', '.m4v']);
+
+/**
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function isWatermarkSupportedMedia(filePath) {
+  const ext = path.extname(filePath || '').toLowerCase();
+  return IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext);
+}
+
+/**
+ * Default cleaned output path next to the input (stem-clean.ext).
+ * @param {string} inputPath
+ * @returns {string}
+ */
+export function defaultCleanOutputPath(inputPath) {
+  const dir = path.dirname(inputPath);
+  const ext = path.extname(inputPath);
+  const stem = path.basename(inputPath, ext);
+  return path.join(dir, `${stem}-clean${ext}`);
+}
+
+/**
+ * Default out-dir for batch cleaning a folder (sibling `basename-clean`).
+ * @param {string} inputDir
+ * @returns {string}
+ */
+export function defaultCleanOutDir(inputDir) {
+  const resolved = path.resolve(inputDir);
+  return `${resolved}-clean`;
+}
+
+/**
+ * Remove Gemini/Veo visible watermarks from a single media file.
+ *
+ * Matches other action executors: dryRun returns `{ command }` without writing.
+ *
+ * @param {object} params
+ * @param {string} params.inputPath
+ * @param {string} params.outputPath
+ * @param {object} [params.action]
+ * @param {string} [params.action.provider]
+ * @param {boolean} [params.action.overwrite]
+ * @param {boolean} [params.action.json]
+ * @param {number} [params.action.videoBitrateMbps]
+ * @param {boolean} [params.dryRun=false]
+ * @param {(msg: string) => void} [params.onWarn]
+ * @param {(chunk: string) => void} [params.onStderr]
+ * @returns {Promise<{ outputPath: string, dryRun?: boolean, command: string, provider: string }>}
+ */
+export async function removeWatermark(params = {}) {
+  const {
+    inputPath,
+    outputPath,
+    action = {},
+    dryRun = false,
+    onWarn,
+    onStderr,
+  } = params;
+
+  if (!inputPath) {
+    throw new Error('inputPath is required for remove-watermark');
+  }
+  if (!outputPath) {
+    throw new Error('outputPath is required for remove-watermark');
+  }
+
+  const provider = action.provider || DEFAULT_WATERMARK_PROVIDER;
+  const overwrite = action.overwrite !== undefined ? Boolean(action.overwrite) : true;
+  const json = Boolean(action.json);
+  const videoBitrateMbps = action.videoBitrateMbps;
+
+  if (!dryRun && !fs.existsSync(inputPath)) {
+    throw new Error(`Input file not found: ${inputPath}`);
+  }
+
+  if (!isWatermarkSupportedMedia(inputPath) && onWarn) {
+    onWarn(`File extension may be unsupported by watermark remover: ${path.extname(inputPath)}`);
+  }
+
+  const result = await removeWatermarkWithProvider({
+    inputPath,
+    outputPath,
+    provider,
+    overwrite,
+    json,
+    videoBitrateMbps,
+    dryRun,
+    onStderr,
+  });
+
+  return {
+    outputPath,
+    dryRun: result.dryRun,
+    command: result.command.startsWith('Remove watermark')
+      ? result.command
+      : `Remove watermark (${provider}): ${result.command}`,
+    provider,
+  };
+}