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

package/src/providers/watermark/pilio.js

@@ -0,0 +1,201 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PILIO_PROVIDER_ID = 'pilio';
+export const PILIO_LICENSE = 'MIT';
+export const PILIO_PACKAGE = '@pilio/gemini-watermark-remover';
+
+/**
+ * Locate the installed package root and gwr binary path.
+ * @returns {{ root: string, binPath: string }}
+ */
+export function resolvePilioBin() {
+  let entryUrl;
+  try {
+    entryUrl = import.meta.resolve(PILIO_PACKAGE);
+  } catch (err) {
+    throw new Error(
+      `Watermark provider "${PILIO_PROVIDER_ID}" requires ${PILIO_PACKAGE} (license: ${PILIO_LICENSE}). ` +
+      `Install it with: npm install ${PILIO_PACKAGE} sharp\n` +
+      `Original error: ${err.message}`
+    );
+  }
+
+  const entryPath = fileURLToPath(entryUrl);
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (pkg.name === PILIO_PACKAGE) {
+          const binRel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.gwr;
+          if (!binRel) {
+            throw new Error(`${PILIO_PACKAGE} package.json is missing a "gwr" bin entry`);
+          }
+          const binPath = path.resolve(dir, binRel);
+          if (!fs.existsSync(binPath)) {
+            throw new Error(`gwr binary not found at ${binPath}`);
+          }
+          return { root: dir, binPath };
+        }
+      } catch (err) {
+        if (err.message.includes('gwr binary') || err.message.includes('bin entry')) {
+          throw err;
+        }
+      }
+    }
+    dir = path.dirname(dir);
+  }
+
+  throw new Error(
+    `Could not locate ${PILIO_PACKAGE} package root after resolving ${entryPath}. ` +
+    `Reinstall with: npm install ${PILIO_PACKAGE} sharp`
+  );
+}
+
+/**
+ * Build the gwr argv for a remove operation.
+ *
+ * @param {object} options
+ * @param {string} options.inputPath
+ * @param {string} [options.outputPath]
+ * @param {string} [options.outDir]
+ * @param {boolean} [options.overwrite=false]
+ * @param {boolean} [options.json=false]
+ * @param {number} [options.videoBitrateMbps]
+ * @returns {string[]}
+ */
+export function buildPilioArgs(options = {}) {
+  const {
+    inputPath,
+    outputPath,
+    outDir,
+    overwrite = false,
+    json = false,
+    videoBitrateMbps,
+  } = options;
+
+  if (!inputPath) {
+    throw new Error('inputPath is required for pilio watermark removal');
+  }
+
+  const args = ['remove', inputPath];
+
+  if (outDir) {
+    args.push('--out-dir', outDir);
+  } else if (outputPath) {
+    args.push('--output', outputPath);
+  } else {
+    throw new Error('Either outputPath or outDir is required for pilio watermark removal');
+  }
+
+  if (overwrite) {
+    args.push('--overwrite');
+  }
+  if (json) {
+    args.push('--json');
+  }
+  if (videoBitrateMbps !== undefined && videoBitrateMbps !== null && videoBitrateMbps !== '') {
+    const n = Number(videoBitrateMbps);
+    if (!Number.isFinite(n) || n <= 0) {
+      throw new Error(`Invalid videoBitrateMbps: ${videoBitrateMbps}`);
+    }
+    args.push('--video-bitrate-mbps', String(n));
+  }
+
+  return args;
+}
+
+/**
+ * Format a human-readable command string (for dry-run / logs).
+ *
+ * @param {string[]} args
+ * @param {string} [binPath='gwr']
+ * @returns {string}
+ */
+export function formatPilioCommand(args, binPath = 'gwr') {
+  const quote = (s) => (/\s/.test(s) ? JSON.stringify(s) : s);
+  return [quote(binPath), ...args.map(quote)].join(' ');
+}
+
+/**
+ * Run the pilio gwr CLI.
+ *
+ * @param {object} options
+ * @param {string} options.inputPath
+ * @param {string} [options.outputPath]
+ * @param {string} [options.outDir]
+ * @param {boolean} [options.overwrite=false]
+ * @param {boolean} [options.json=false]
+ * @param {number} [options.videoBitrateMbps]
+ * @param {boolean} [options.dryRun=false]
+ * @param {(chunk: string) => void} [options.onStderr]
+ * @returns {Promise<{ outputPath?: string, outDir?: string, dryRun?: boolean, command: string, exitCode?: number, stdout?: string }>}
+ */
+export async function runPilioRemove(options = {}) {
+  const { dryRun = false, onStderr } = options;
+  const { binPath } = resolvePilioBin();
+  const args = buildPilioArgs(options);
+  const command = formatPilioCommand(args, binPath);
+
+  if (dryRun) {
+    return {
+      outputPath: options.outputPath,
+      outDir: options.outDir,
+      dryRun: true,
+      command,
+    };
+  }
+
+  if (options.outputPath) {
+    fs.mkdirSync(path.dirname(path.resolve(options.outputPath)), { recursive: true });
+  }
+  if (options.outDir) {
+    fs.mkdirSync(path.resolve(options.outDir), { recursive: true });
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [binPath, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (onStderr) onStderr(text);
+    });
+
+    child.on('error', (err) => {
+      reject(new Error(
+        `Failed to execute watermark provider "${PILIO_PROVIDER_ID}" (${PILIO_PACKAGE}): ${err.message}`
+      ));
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        const detail = (stderr || stdout || '').trim() || `exit code ${code}`;
+        reject(new Error(
+          `Watermark provider "${PILIO_PROVIDER_ID}" failed for ${options.inputPath}: ${detail}`
+        ));
+        return;
+      }
+      resolve({
+        outputPath: options.outputPath,
+        outDir: options.outDir,
+        command,
+        exitCode: code,
+        stdout,
+      });
+    });
+  });
+}

package/src/swap/steps.js

@@ -8,10 +8,7 @@ import { uploadVideo } from '../uploader.js';
  */
 
 /**
- * Step 1 — Upload the new video as unlisted (never straight to public).
- *
- * Metadata (title/description/tags/category) is carried over from the old
- * video's snippet when available so the replacement stays continuous.
+ * Upload the new video for a playlist swap.
  *
  * @param {import('googleapis').youtube_v3.Youtube} youtube
  * @param {string} newVideoPath
@@ -19,6 +16,7 @@ import { uploadVideo } from '../uploader.js';
  * @param {string} [opts.oldVideoId] - Fetch old video's snippet to carry over
  * @param {object} [opts.meta] - Explicit metadata overrides
  * @param {number} [opts.retries=3]
+ * @param {'private' | 'unlisted' | 'public'} [opts.uploadPrivacy='unlisted']
  * @returns {Promise<{ videoId: string, url: string }>}
  */
 export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
@@ -26,12 +24,14 @@ export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
     throw new Error(`New video file not found: ${newVideoPath}`);
   }
 
+  const uploadPrivacy = opts.uploadPrivacy || opts.meta?.privacyStatus || 'unlisted';
+
   let meta = {
     title: opts.meta?.title,
     description: opts.meta?.description,
     tags: opts.meta?.tags,
     categoryId: opts.meta?.categoryId,
-    privacyStatus: 'unlisted',
+    privacyStatus: uploadPrivacy,
     selfDeclaredMadeForKids: opts.meta?.selfDeclaredMadeForKids ?? false,
   };
 
@@ -49,7 +49,7 @@ export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
           description: meta.description ?? old.snippet?.description,
           tags: meta.tags || old.snippet?.tags || [],
           categoryId: meta.categoryId || old.snippet?.categoryId,
-          privacyStatus: 'unlisted',
+          privacyStatus: uploadPrivacy,
           selfDeclaredMadeForKids: meta.selfDeclaredMadeForKids
             ?? (old.status?.madeForKids !== undefined ? old.status.madeForKids : false),
         };
@@ -68,7 +68,7 @@ export async function uploadNewVideo(youtube, newVideoPath, opts = {}) {
   let lastErr;
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
-      return await uploadVideo(youtube, newVideoPath, meta, 'unlisted');
+      return await uploadVideo(youtube, newVideoPath, meta, uploadPrivacy);
     } catch (err) {
       lastErr = err;
       if (attempt < retries) {
@@ -142,20 +142,25 @@ export async function removeOldItem(youtube, oldPlaylistItemId) {
 }
 
 /**
- * Step 5 — Finalize: unlist the old video (never delete), then publish the
- * new one. Ordered so any earlier failure leaves the old video untouched.
+ * Step 5 — Finalize swap privacy on old and new videos.
  *
  * @param {import('googleapis').youtube_v3.Youtube} youtube
  * @param {string} oldVideoId
  * @param {string} newVideoId
+ * @param {object} [options]
+ * @param {'private' | 'unlisted' | 'public'} [options.newPrivacyStatus='public']
+ * @param {'private' | 'unlisted' | 'public'} [options.oldPrivacyStatus='unlisted']
  */
-export async function finalizeSwap(youtube, oldVideoId, newVideoId) {
+export async function finalizeSwap(youtube, oldVideoId, newVideoId, options = {}) {
+  const newPrivacyStatus = options.newPrivacyStatus || 'public';
+  const oldPrivacyStatus = options.oldPrivacyStatus || 'unlisted';
+
   await youtube.videos.update({
     part: ['status'],
-    requestBody: { id: oldVideoId, status: { privacyStatus: 'unlisted' } },
+    requestBody: { id: oldVideoId, status: { privacyStatus: oldPrivacyStatus } },
   });
   await youtube.videos.update({
     part: ['status'],
-    requestBody: { id: newVideoId, status: { privacyStatus: 'public' } },
+    requestBody: { id: newVideoId, status: { privacyStatus: newPrivacyStatus } },
   });
 }

package/src/swap/swapSong.js

@@ -33,6 +33,7 @@ export const QUOTA_PER_SWAP = 150 + 1; // ~150 shared units + 1 upload-bucket un
  * @param {string} [params.stateDir] - Where the swap state file lives (default: cwd)
  * @param {string} [params.stateFile] - Custom state filename
  * @param {boolean} [params.fresh=false] - Reset any existing record for songKey
+ * @param {'preserve' | 'private' | 'public'} [params.privacyMode='public'] - Final privacy for new video; preserve reads old video status
  * @param {(event: { type: string, [key: string]: any }) => void} [params.onEvent]
  * @returns {Promise<{ record: any, dryRunPlan?: string[] }>}
  */
@@ -47,6 +48,7 @@ export async function swapSong(params) {
     stateDir,
     stateFile,
     fresh = false,
+    privacyMode = 'public',
     onEvent = () => {},
   } = params;
 
@@ -84,13 +86,46 @@ export async function swapSong(params) {
   }
 
   try {
+    let resolvedNewPrivacy = 'public';
+    let resolvedOldPrivacy = 'unlisted';
+    let uploadPrivacy = 'unlisted';
+
+    if (privacyMode === 'private') {
+      resolvedNewPrivacy = 'private';
+      resolvedOldPrivacy = 'unlisted';
+      uploadPrivacy = 'private';
+    } else if (privacyMode === 'preserve') {
+      try {
+        const res = await youtube.videos.list({
+          part: ['status'],
+          id: [oldVideoId],
+        });
+        const oldStatus = res.data.items?.[0]?.status?.privacyStatus;
+        if (oldStatus === 'private' || oldStatus === 'unlisted' || oldStatus === 'public') {
+          resolvedNewPrivacy = oldStatus;
+          uploadPrivacy = oldStatus;
+        } else {
+          resolvedNewPrivacy = 'private';
+          uploadPrivacy = 'private';
+        }
+      } catch {
+        resolvedNewPrivacy = 'private';
+        uploadPrivacy = 'private';
+      }
+      resolvedOldPrivacy = 'unlisted';
+    }
+
     // 1. UPLOAD
     await step('uploaded', async () => {
       const alreadyUploaded = store.getRecord(songKey).newVideoId;
       if (alreadyUploaded) {
         return { videoId: alreadyUploaded };
       }
-      const up = await uploadNewVideo(youtube, newVideoPath, { oldVideoId, meta });
+      const up = await uploadNewVideo(youtube, newVideoPath, {
+        oldVideoId,
+        meta,
+        uploadPrivacy,
+      });
       onEvent({ type: 'swap_uploaded', songKey, newVideoId: up.videoId, url: up.url });
       return up;
     }, r => ({ newVideoId: r.videoId }));
@@ -128,7 +163,10 @@ export async function swapSong(params) {
 
     // 5. FINALIZE
     await step('finalized', async () => {
-      await finalizeSwap(youtube, oldVideoId, newVideoId);
+      await finalizeSwap(youtube, oldVideoId, newVideoId, {
+        newPrivacyStatus: resolvedNewPrivacy,
+        oldPrivacyStatus: resolvedOldPrivacy,
+      });
     });
 
     onEvent({ type: 'swap_complete', songKey, oldVideoId, newVideoId, playlistId });

package/src/update.js

@@ -4,11 +4,50 @@ import { google } from 'googleapis';
 import { loadMetadata } from './metadata.js';
 import { UploadState } from './state.js';
 import { authenticate } from './auth.js';
+import { listPlaylistItems } from './playlist/reorder.js';
 
 export const QUOTA_PER_VIDEO_UPDATE = 50;
 export const QUOTA_PER_PLAYLIST_UPDATE = 50;
 export const QUOTA_PER_LIST = 1;
 
+/**
+ * Apply a find/replace to a string.
+ * @param {string} text
+ * @param {string} pattern
+ * @param {string} [replacement]
+ * @param {boolean} [literal=false]
+ */
+export function applyTextReplace(text, pattern, replacement = '', literal = false) {
+  if (!pattern || text == null) return text;
+  const value = String(text);
+  if (literal) {
+    return value.split(pattern).join(replacement);
+  }
+  return value.replace(new RegExp(pattern, 'g'), replacement);
+}
+
+/**
+ * Deep-replace matching strings anywhere in a JSON-serializable object.
+ * @param {unknown} value
+ * @param {string} pattern
+ * @param {string} [replacement]
+ * @param {boolean} [literal=false]
+ */
+export function deepReplaceInObject(value, pattern, replacement = '', literal = false) {
+  if (typeof value === 'string') {
+    return applyTextReplace(value, pattern, replacement, literal);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepReplaceInObject(item, pattern, replacement, literal));
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, deepReplaceInObject(item, pattern, replacement, literal)])
+    );
+  }
+  return value;
+}
+
 /**
  * Update snippet fields of a YouTube video while preserving other metadata.
  *
@@ -132,6 +171,9 @@ export async function updatePlaylistTitle(youtube, playlistId, newTitle) {
  * @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 {boolean} [options.replaceLiteral=false] - Treat replacePattern as a plain substring
+ * @param {boolean} [options.replaceInSnippet=false] - Also replace in descriptions/tags on YouTube
+ * @param {string} [options.includePlaylistId] - Include every video in this playlist (e.g. overview prefix videos)
  * @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
@@ -156,6 +198,14 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
   const dryRun = Boolean(options.dryRun);
   const onEvent = options.onEvent || (() => {});
   const updateLocal = options.updateLocalMetadata !== false;
+  const replaceLiteral = Boolean(options.replaceLiteral);
+  const replaceInSnippet = Boolean(options.replaceInSnippet);
+  const includePlaylistId = options.includePlaylistId || null;
+
+  const replaceText = (text) => {
+    if (!options.replacePattern) return text;
+    return applyTextReplace(text, options.replacePattern, options.replaceWith || '', replaceLiteral);
+  };
 
   const metadataPath = options.metadataFile
     ? path.resolve(options.metadataFile)
@@ -175,10 +225,30 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
   const cachedPlaylist = state.getPlaylist(playlistKey);
   const playlistId = options.singlePlaylistId || rawMetadata?.playlistId || rawMetadata?.playlist?.playlistId || cachedPlaylist?.playlistId || state.getPlaylist('gray_to_light')?.playlistId || null;
 
+  let youtube = null;
+  const needsYoutubeForPlan = Boolean(includePlaylistId && options.replacePattern);
+  if (needsYoutubeForPlan) {
+    const auth = await authenticate({
+      tokenFile: options.tokenFile,
+      clientSecretsFile: options.clientSecretsFile,
+      clientId: options.clientId,
+      clientSecret: options.clientSecret,
+    });
+    youtube = google.youtube({ version: 'v3', auth });
+  }
+
   // Build playlist plan
   let playlistPlan = null;
   if (playlistId) {
     let currentTitle = rawMetadata?.playlist?.youtube?.snippet?.title || rawMetadata?.playlist?.snippet?.title || '';
+    if (!currentTitle && youtube) {
+      try {
+        const { data } = await youtube.playlists.list({ part: ['snippet'], id: [playlistId] });
+        currentTitle = data.items?.[0]?.snippet?.title || '';
+      } catch {
+        // Non-fatal during planning
+      }
+    }
     let newTitle = currentTitle;
 
     if (options.syncMetadata) {
@@ -192,8 +262,7 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
     }
 
     if (options.replacePattern) {
-      const reg = new RegExp(options.replacePattern, 'g');
-      newTitle = newTitle.replace(reg, options.replaceWith || '');
+      newTitle = replaceText(newTitle);
     }
 
     if (currentTitle || newTitle || options.playlistPostfix) {
@@ -207,6 +276,7 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
   }
 
   // Build video plans
+  /** @type {Array<{ filename: string, videoId: string, oldTitle: string, newTitle: string, changed: boolean, snippetUpdates?: object }>} */
   const videoPlans = [];
   const songsObj = rawMetadata?.songs || {};
   const orderedKeys = Array.isArray(rawMetadata?.playlist?.orderedSongKeys)
@@ -233,6 +303,9 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
 
       let currentTitle = songData.youtube?.snippet?.title || path.basename(filename, path.extname(filename));
       let newTitle = currentTitle;
+      const snippet = songData.youtube?.snippet || {};
+      let newDescription = snippet.description || '';
+      let newTags = Array.isArray(snippet.tags) ? [...snippet.tags] : [];
 
       if (options.syncMetadata) {
         newTitle = currentTitle;
@@ -250,8 +323,20 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
       }
 
       if (options.replacePattern) {
-        const reg = new RegExp(options.replacePattern, 'g');
-        newTitle = newTitle.replace(reg, options.replaceWith || '');
+        newTitle = replaceText(newTitle);
+        if (replaceInSnippet) {
+          newDescription = replaceText(newDescription);
+          newTags = newTags.map((tag) => replaceText(tag));
+        }
+      }
+
+      const snippetUpdates = {};
+      if (newTitle !== currentTitle) snippetUpdates.title = newTitle;
+      if (replaceInSnippet && newDescription !== (snippet.description || '')) {
+        snippetUpdates.description = newDescription;
+      }
+      if (replaceInSnippet && JSON.stringify(newTags) !== JSON.stringify(snippet.tags || [])) {
+        snippetUpdates.tags = newTags;
       }
 
       videoPlans.push({
@@ -259,7 +344,8 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
         videoId,
         oldTitle: currentTitle,
         newTitle,
-        changed: (newTitle !== currentTitle),
+        changed: Object.keys(snippetUpdates).length > 0,
+        snippetUpdates: Object.keys(snippetUpdates).length > 0 ? snippetUpdates : undefined,
       });
     }
 
@@ -278,8 +364,7 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
           }
         }
         if (options.replacePattern) {
-          const reg = new RegExp(options.replacePattern, 'g');
-          newTitle = newTitle.replace(reg, options.replaceWith || '');
+          newTitle = replaceText(newTitle);
         }
         videoPlans.push({
           filename: upload.filename,
@@ -287,6 +372,41 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
           oldTitle: currentTitle,
           newTitle,
           changed: (newTitle !== currentTitle),
+          snippetUpdates: newTitle !== currentTitle ? { title: newTitle } : undefined,
+        });
+      }
+    }
+  }
+
+  if (includePlaylistId && youtube && options.replacePattern) {
+    const items = await listPlaylistItems(youtube, includePlaylistId);
+    const plannedIds = new Set(videoPlans.map((plan) => plan.videoId));
+    const missingIds = items.map((item) => item.videoId).filter((videoId) => videoId && !plannedIds.has(videoId));
+    for (let i = 0; i < missingIds.length; i += 50) {
+      const chunk = missingIds.slice(i, i + 50);
+      const { data } = await youtube.videos.list({ part: ['snippet'], id: chunk });
+      for (const item of data.items || []) {
+        const currentTitle = item.snippet?.title || '';
+        const newTitle = replaceText(currentTitle);
+        const snippetUpdates = {};
+        if (newTitle !== currentTitle) snippetUpdates.title = newTitle;
+        if (replaceInSnippet) {
+          const newDescription = replaceText(item.snippet?.description || '');
+          const newTags = (item.snippet?.tags || []).map((tag) => replaceText(tag));
+          if (newDescription !== (item.snippet?.description || '')) {
+            snippetUpdates.description = newDescription;
+          }
+          if (JSON.stringify(newTags) !== JSON.stringify(item.snippet?.tags || [])) {
+            snippetUpdates.tags = newTags;
+          }
+        }
+        videoPlans.push({
+          filename: item.id,
+          videoId: item.id,
+          oldTitle: currentTitle,
+          newTitle,
+          changed: Object.keys(snippetUpdates).length > 0,
+          snippetUpdates: Object.keys(snippetUpdates).length > 0 ? snippetUpdates : undefined,
         });
       }
     }
@@ -325,14 +445,15 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
   }
 
   // Authenticate
-  const auth = await authenticate({
-    tokenFile: options.tokenFile,
-    clientSecretsFile: options.clientSecretsFile,
-    clientId: options.clientId,
-    clientSecret: options.clientSecret,
-  });
-
-  const youtube = google.youtube({ version: 'v3', auth });
+  if (!youtube) {
+    const auth = await authenticate({
+      tokenFile: options.tokenFile,
+      clientSecretsFile: options.clientSecretsFile,
+      clientId: options.clientId,
+      clientSecret: options.clientSecret,
+    });
+    youtube = google.youtube({ version: 'v3', auth });
+  }
 
   // Update Playlist
   if (playlistPlan && playlistPlan.changed) {
@@ -351,7 +472,11 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
     const v = changedVideos[i];
     onEvent({ type: 'video_update_start', item: v, index: i, total: changedVideos.length });
     try {
-      await updateVideoTitle(youtube, v.videoId, v.newTitle);
+      if (v.snippetUpdates && Object.keys(v.snippetUpdates).length > 0) {
+        await updateVideoSnippet(youtube, v.videoId, v.snippetUpdates);
+      } else {
+        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 });
@@ -362,17 +487,32 @@ export async function batchUpdateMetadata(targetFolder, options = {}) {
   // 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;
+      if (options.replacePattern) {
+        rawMetadata = deepReplaceInObject(
+          rawMetadata,
+          options.replacePattern,
+          options.replaceWith || '',
+          replaceLiteral
+        );
+      } else {
+        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;
+        for (const v of videoPlans) {
+          if (v.changed && rawMetadata.songs?.[v.filename]?.youtube?.snippet) {
+            rawMetadata.songs[v.filename].youtube.snippet.title = v.newTitle;
+            if (v.snippetUpdates?.description) {
+              rawMetadata.songs[v.filename].youtube.snippet.description = v.snippetUpdates.description;
+            }
+            if (v.snippetUpdates?.tags) {
+              rawMetadata.songs[v.filename].youtube.snippet.tags = v.snippetUpdates.tags;
+            }
+          }
         }
       }