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

package/src/cli/remove-watermark.js

@@ -0,0 +1,252 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  removeWatermark,
+  isWatermarkSupportedMedia,
+  defaultCleanOutputPath,
+  defaultCleanOutDir,
+} from '../actions/remove-watermark.js';
+import {
+  DEFAULT_WATERMARK_PROVIDER,
+  listWatermarkProviders,
+} from '../providers/watermark/index.js';
+
+/**
+ * Batch / single-file watermark removal without metadata.json.
+ *
+ * @param {string} input - File or directory path
+ * @param {object} [options]
+ * @param {string} [options.output] - Explicit output file (file input only)
+ * @param {string} [options.outDir] - Output directory (directory input, or optional for file)
+ * @param {string} [options.provider]
+ * @param {boolean} [options.overwrite=false]
+ * @param {boolean} [options.json=false]
+ * @param {number} [options.videoBitrateMbps]
+ * @param {boolean} [options.dryRun=false]
+ * @param {(event: object) => void} [options.onEvent]
+ * @returns {Promise<{
+ *   input: string,
+ *   mode: 'file' | 'directory',
+ *   provider: string,
+ *   dryRun: boolean,
+ *   processed: Array<object>,
+ *   skipped: Array<object>,
+ *   failed: Array<object>
+ * }>}
+ */
+export async function batchRemoveWatermark(input, options = {}) {
+  const {
+    output,
+    outDir,
+    provider = DEFAULT_WATERMARK_PROVIDER,
+    overwrite = false,
+    json = false,
+    videoBitrateMbps,
+    dryRun = false,
+    onEvent,
+  } = options;
+
+  const resolvedInput = path.resolve(input || '.');
+  if (!fs.existsSync(resolvedInput)) {
+    throw new Error(`Input path not found: ${resolvedInput}`);
+  }
+
+  const stat = fs.statSync(resolvedInput);
+  const actionOpts = { provider, overwrite, json, videoBitrateMbps };
+
+  if (stat.isFile()) {
+    return removeSingleFile(resolvedInput, { output, outDir, dryRun, actionOpts, onEvent });
+  }
+
+  if (stat.isDirectory()) {
+    return removeDirectory(resolvedInput, { outDir, dryRun, actionOpts, onEvent });
+  }
+
+  throw new Error(`Unsupported input path type: ${resolvedInput}`);
+}
+
+/**
+ * @param {string} inputPath
+ * @param {object} ctx
+ */
+async function removeSingleFile(inputPath, ctx) {
+  const { output, outDir, dryRun, actionOpts, onEvent } = ctx;
+  let outputPath = output ? path.resolve(output) : null;
+  if (!outputPath && outDir) {
+    outputPath = path.join(path.resolve(outDir), path.basename(inputPath));
+  }
+  if (!outputPath) {
+    outputPath = defaultCleanOutputPath(inputPath);
+  }
+
+  const processed = [];
+  const skipped = [];
+  const failed = [];
+
+  if (onEvent) {
+    onEvent({
+      type: 'watermark_plan',
+      mode: 'file',
+      input: inputPath,
+      total: 1,
+      provider: actionOpts.provider,
+      dryRun,
+    });
+  }
+
+  try {
+    if (onEvent) {
+      onEvent({ type: 'entry_start', index: 0, total: 1, filename: path.basename(inputPath), inputPath });
+    }
+
+    if (!isWatermarkSupportedMedia(inputPath)) {
+      const skip = { filename: path.basename(inputPath), inputPath, reason: 'Unsupported media extension' };
+      skipped.push(skip);
+      if (onEvent) onEvent({ type: 'entry_skipped', ...skip });
+    } else if (fs.existsSync(outputPath) && !actionOpts.overwrite && !dryRun) {
+      const skip = {
+        filename: path.basename(inputPath),
+        inputPath,
+        outputPath,
+        reason: 'Output file already exists (use --overwrite / --force)',
+      };
+      skipped.push(skip);
+      if (onEvent) onEvent({ type: 'entry_skipped', ...skip });
+    } else {
+      const res = await removeWatermark({
+        inputPath,
+        outputPath,
+        action: actionOpts,
+        dryRun,
+        onStderr: (chunk) => {
+          if (onEvent) onEvent({ type: 'provider_stderr', chunk });
+        },
+      });
+      const item = {
+        filename: path.basename(inputPath),
+        inputPath,
+        outputPath,
+        command: res.command,
+        provider: res.provider,
+        dryRun: res.dryRun,
+      };
+      processed.push(item);
+      if (onEvent) onEvent({ type: 'entry_complete', ...item });
+    }
+  } catch (err) {
+    const fail = { filename: path.basename(inputPath), inputPath, error: err };
+    failed.push(fail);
+    if (onEvent) onEvent({ type: 'entry_failed', filename: fail.filename, inputPath, error: err });
+  }
+
+  return {
+    input: inputPath,
+    mode: 'file',
+    provider: actionOpts.provider,
+    dryRun,
+    processed,
+    skipped,
+    failed,
+  };
+}
+
+/**
+ * @param {string} inputDir
+ * @param {object} ctx
+ */
+async function removeDirectory(inputDir, ctx) {
+  const { outDir, dryRun, actionOpts, onEvent } = ctx;
+  const resolvedOutDir = outDir ? path.resolve(outDir) : defaultCleanOutDir(inputDir);
+
+  const entries = fs.readdirSync(inputDir)
+    .map((name) => path.join(inputDir, name))
+    .filter((p) => fs.statSync(p).isFile() && isWatermarkSupportedMedia(p))
+    .sort((a, b) => a.localeCompare(b));
+
+  if (onEvent) {
+    onEvent({
+      type: 'watermark_plan',
+      mode: 'directory',
+      input: inputDir,
+      outDir: resolvedOutDir,
+      total: entries.length,
+      provider: actionOpts.provider,
+      dryRun,
+    });
+  }
+
+  // Directory batch: prefer provider --out-dir when not dry-run for a single spawn when overwrite/json only.
+  // We still process file-by-file so skip/exists and progress events stay consistent with apply-actions.
+  const processed = [];
+  const skipped = [];
+  const failed = [];
+
+  for (let i = 0; i < entries.length; i++) {
+    const inputPath = entries[i];
+    const outputPath = path.join(resolvedOutDir, path.basename(inputPath));
+
+    if (onEvent) {
+      onEvent({
+        type: 'entry_start',
+        index: i,
+        total: entries.length,
+        filename: path.basename(inputPath),
+        inputPath,
+      });
+    }
+
+    try {
+      if (fs.existsSync(outputPath) && !actionOpts.overwrite && !dryRun) {
+        const skip = {
+          filename: path.basename(inputPath),
+          inputPath,
+          outputPath,
+          reason: 'Output file already exists (use --overwrite / --force)',
+        };
+        skipped.push(skip);
+        if (onEvent) onEvent({ type: 'entry_skipped', ...skip });
+        continue;
+      }
+
+      const res = await removeWatermark({
+        inputPath,
+        outputPath,
+        action: actionOpts,
+        dryRun,
+        onStderr: (chunk) => {
+          if (onEvent) onEvent({ type: 'provider_stderr', chunk });
+        },
+      });
+      const item = {
+        filename: path.basename(inputPath),
+        inputPath,
+        outputPath,
+        command: res.command,
+        provider: res.provider,
+        dryRun: res.dryRun,
+      };
+      processed.push(item);
+      if (onEvent) onEvent({ type: 'entry_complete', ...item });
+    } catch (err) {
+      const fail = { filename: path.basename(inputPath), inputPath, error: err };
+      failed.push(fail);
+      if (onEvent) onEvent({ type: 'entry_failed', filename: fail.filename, inputPath, error: err });
+    }
+  }
+
+  return {
+    input: inputDir,
+    mode: 'directory',
+    provider: actionOpts.provider,
+    outDir: resolvedOutDir,
+    dryRun,
+    processed,
+    skipped,
+    failed,
+  };
+}
+
+export {
+  listWatermarkProviders,
+  DEFAULT_WATERMARK_PROVIDER,
+};

package/src/index.d.ts

@@ -193,6 +193,78 @@ export const QUOTA_PER_SWAP: number;
 export const DEFAULT_SWAP_STATE_FILENAME: string;
 export const SWAP_STATUSES: string[];
 
+// ─── Access / Privacy ────────────────────────────────────────────────────────
+
+export type PrivacyStatus = 'private' | 'unlisted' | 'public';
+
+export const QUOTA_PER_PRIVACY_UPDATE: number;
+
+export function normalizePrivacyStatus(value: unknown): PrivacyStatus;
+export function getVideosPrivacy(youtube: youtube_v3.Youtube, videoIds: string[]): Promise<Map<string, PrivacyStatus>>;
+export function getPlaylistPrivacy(youtube: youtube_v3.Youtube, playlistId: string): Promise<PrivacyStatus>;
+export function setVideoPrivacy(youtube: youtube_v3.Youtube, videoId: string, privacyStatus: PrivacyStatus): Promise<void>;
+export function setPlaylistPrivacy(youtube: youtube_v3.Youtube, playlistId: string, privacyStatus: PrivacyStatus): Promise<void>;
+
+export interface AccessVideoPlan {
+  videoId: string;
+  title?: string;
+  position?: number;
+  currentPrivacy: PrivacyStatus | null;
+  targetPrivacy: PrivacyStatus;
+  changed: boolean;
+}
+
+export interface SetPlaylistAccessOptions {
+  youtube?: youtube_v3.Youtube;
+  playlistId: string;
+  privacyStatus: PrivacyStatus;
+  videoIds?: string[];
+  videoSource?: 'playlist' | 'history';
+  albumDir?: string;
+  overviewHistoryPath?: string;
+  overviewKeys?: string[];
+  updateMetadata?: boolean;
+  metadataFile?: string;
+  dryRun?: boolean;
+  onEvent?: (event: { type: string; [key: string]: any }) => void;
+}
+
+export interface SetPlaylistAccessResult {
+  dryRun: boolean;
+  playlistId: string;
+  privacyStatus: PrivacyStatus;
+  videoSource: 'playlist' | 'history';
+  playlist: {
+    playlistId: string;
+    currentPrivacy: PrivacyStatus | null;
+    targetPrivacy: PrivacyStatus;
+    changed: boolean;
+  };
+  videos: AccessVideoPlan[];
+  changedCount: number;
+  estimatedQuota: number;
+  updated: {
+    playlist: boolean;
+    videos: Array<{ videoId: string; privacyStatus: PrivacyStatus }>;
+  };
+}
+
+export function setPlaylistAccess(options: SetPlaylistAccessOptions): Promise<SetPlaylistAccessResult>;
+
+export interface SetVideosAccessOptions {
+  youtube?: youtube_v3.Youtube;
+  videoIds: string[];
+  privacyStatus: PrivacyStatus;
+  dryRun?: boolean;
+}
+
+export function setVideosAccess(options: SetVideosAccessOptions): Promise<{
+  dryRun: boolean;
+  videos: AccessVideoPlan[];
+  changedCount?: number;
+  updated?: string[];
+}>;
+
 // ─── Metadata & Title Updates ──────────────────────────────────────────────
 
 export interface BatchUpdateMetadataOptions {
@@ -200,6 +272,11 @@ export interface BatchUpdateMetadataOptions {
   titlePrefix?: string;
   playlistPostfix?: string;
   playlistTitle?: string;
+  replacePattern?: string;
+  replaceWith?: string;
+  replaceLiteral?: boolean;
+  replaceInSnippet?: boolean;
+  includePlaylistId?: string;
   metadataFile?: string;
   updateLocalMetadata?: boolean;
   syncMetadata?: boolean;
@@ -260,6 +337,9 @@ export function updatePlaylistTitle(
   newTitle: string
 ): Promise<{ playlistId: string; title: string; data: any }>;
 
+export function applyTextReplace(text: string, pattern: string, replacement?: string, literal?: boolean): string;
+export function deepReplaceInObject(value: unknown, pattern: string, replacement?: string, literal?: boolean): unknown;
+
 export function batchUpdateMetadata(
   targetFolder?: string,
   options?: BatchUpdateMetadataOptions
@@ -500,7 +580,15 @@ export interface JourneyOverlayAction {
   showSidebar?: boolean;
 }
 
-export type VideoAction = ShortenAction | ReplaceBackgroundAction | JourneyOverlayAction | { type: string; [key: string]: any };
+export interface RemoveWatermarkAction {
+  type: 'remove-watermark';
+  provider?: string;
+  overwrite?: boolean;
+  json?: boolean;
+  videoBitrateMbps?: number;
+}
+
+export type VideoAction = ShortenAction | ReplaceBackgroundAction | JourneyOverlayAction | RemoveWatermarkAction | { type: string; [key: string]: any };
 
 export interface JourneyConfig {
   enabled?: boolean;
@@ -637,6 +725,64 @@ export function applyJourneyOverlay(params: {
   onWarn?: (msg: string) => void;
 }): Promise<{ outputPath: string; duration?: number; dryRun?: boolean; command?: string }>;
 
+export function isWatermarkSupportedMedia(filePath: string): boolean;
+export function defaultCleanOutputPath(inputPath: string): string;
+export function defaultCleanOutDir(inputDir: string): string;
+
+export function removeWatermark(params: {
+  inputPath: string;
+  outputPath: string;
+  action?: Partial<RemoveWatermarkAction>;
+  dryRun?: boolean;
+  onWarn?: (msg: string) => void;
+  onStderr?: (chunk: string) => void;
+}): Promise<{ outputPath: string; dryRun?: boolean; command: string; provider: string }>;
+
+export function listWatermarkProviders(): Array<{ id: string; license: string; packageName: string }>;
+export function getWatermarkProvider(providerId?: string): {
+  id: string;
+  license: string;
+  packageName: string;
+  remove: (options: object) => Promise<any>;
+};
+export function removeWatermarkWithProvider(options: {
+  inputPath: string;
+  outputPath?: string;
+  outDir?: string;
+  provider?: string;
+  overwrite?: boolean;
+  json?: boolean;
+  videoBitrateMbps?: number;
+  dryRun?: boolean;
+  onStderr?: (chunk: string) => void;
+}): Promise<{ outputPath?: string; outDir?: string; dryRun?: boolean; command: string; exitCode?: number; stdout?: string }>;
+
+export const DEFAULT_WATERMARK_PROVIDER: string;
+export const PERMISSIVE_LICENSES: readonly string[];
+
+export function batchRemoveWatermark(
+  input?: string,
+  options?: {
+    output?: string;
+    outDir?: string;
+    provider?: string;
+    overwrite?: boolean;
+    json?: boolean;
+    videoBitrateMbps?: number;
+    dryRun?: boolean;
+    onEvent?: (event: { type: string; [key: string]: any }) => void;
+  }
+): Promise<{
+  input: string;
+  mode: 'file' | 'directory';
+  provider: string;
+  dryRun: boolean;
+  outDir?: string;
+  processed: Array<object>;
+  skipped: Array<object>;
+  failed: Array<object>;
+}>;
+
 export function runActionsPipeline(
   entry: PlannedEntry | { songKey?: string; filename: string; sourcePath: string; targetPath?: string },
   actions?: VideoAction[],

package/src/index.js

@@ -32,6 +32,8 @@ export {
   updatePlaylistSnippet,
   updatePlaylistTitle,
   batchUpdateMetadata,
+  applyTextReplace,
+  deepReplaceInObject,
   QUOTA_PER_VIDEO_UPDATE,
   QUOTA_PER_PLAYLIST_UPDATE,
   QUOTA_PER_LIST,
@@ -81,6 +83,10 @@ export {
   generateJourneySvg,
   renderSvgToPng,
   resolveJourneyTracks,
+  removeWatermark,
+  isWatermarkSupportedMedia,
+  defaultCleanOutputPath,
+  defaultCleanOutDir,
   runActionsPipeline,
 } from './actions/index.js';
 export {
@@ -97,5 +103,41 @@ export {
 export {
   previewJourney,
 } from './cli/preview-journey.js';
+export {
+  batchRemoveWatermark,
+} from './cli/remove-watermark.js';
+export {
+  getWatermarkProvider,
+  listWatermarkProviders,
+  removeWatermarkWithProvider,
+  DEFAULT_WATERMARK_PROVIDER,
+  PERMISSIVE_LICENSES,
+} from './providers/watermark/index.js';
+export {
+  detectOutdatedUploads,
+} from './playlist/detect-outdated.js';
+export {
+  listPlaylistItems,
+  reorderPlaylist,
+  playlistOrderMatches,
+} from './playlist/reorder.js';
+export {
+  resolveDesiredPlaylistOrder,
+} from './playlist/order.js';
+export {
+  syncPlaylist,
+} from './playlist/sync.js';
+export {
+  normalizePrivacyStatus,
+  getVideosPrivacy,
+  getPlaylistPrivacy,
+  setVideoPrivacy,
+  setPlaylistPrivacy,
+  QUOTA_PER_PRIVACY_UPDATE,
+} from './access/privacy.js';
+export {
+  setPlaylistAccess,
+  setVideosAccess,
+} from './access/set-access.js';
 
 

package/src/playlist/detect-outdated.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Find local MP4 files that changed after their last YouTube upload timestamp.
+ *
+ * @param {string} targetDir
+ * @param {import('../state.js').UploadState} state
+ * @param {object} [options]
+ * @param {number} [options.toleranceMs=1000] - Ignore sub-second clock skew
+ * @param {string[]} [options.onlyFilenames] - Restrict to these basenames
+ * @returns {Array<{ filename: string, filePath: string, videoId: string, uploadedAt: string, modifiedAt: string }>}
+ */
+export function detectOutdatedUploads(targetDir, state, options = {}) {
+  const toleranceMs = options.toleranceMs ?? 1000;
+  const only = options.onlyFilenames
+    ? new Set(options.onlyFilenames.map((f) => path.basename(f)))
+    : null;
+
+  const outdated = [];
+  const uploads = state.data.uploads || {};
+
+  for (const [filename, record] of Object.entries(uploads)) {
+    if (only && !only.has(filename)) continue;
+    if (!record?.videoId || !record?.uploadedAt) continue;
+
+    const filePath = path.join(targetDir, filename);
+    if (!fs.existsSync(filePath)) continue;
+
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size === 0) continue;
+
+    const modifiedMs = stat.mtimeMs;
+    const uploadedMs = new Date(record.uploadedAt).getTime();
+    if (Number.isNaN(uploadedMs)) continue;
+
+    if (modifiedMs > uploadedMs + toleranceMs) {
+      outdated.push({
+        filename,
+        filePath,
+        videoId: record.videoId,
+        uploadedAt: record.uploadedAt,
+        modifiedAt: new Date(modifiedMs).toISOString(),
+      });
+    }
+  }
+
+  outdated.sort((a, b) => a.filename.localeCompare(b.filename));
+  return outdated;
+}

package/src/playlist/order.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadMetadata } from '../metadata.js';
+
+/**
+ * Resolve desired playlist video IDs from upload histories + metadata song order.
+ *
+ * @param {object} options
+ * @param {string} options.albumDir
+ * @param {import('../state.js').UploadState} options.albumState
+ * @param {string} [options.overviewHistoryPath]
+ * @param {string[]} [options.overviewKeys]
+ * @param {string[]} [options.songKeys]
+ * @returns {string[]}
+ */
+export function resolveDesiredPlaylistOrder(options = {}) {
+  const {
+    albumDir,
+    albumState,
+    overviewHistoryPath,
+    overviewKeys = [],
+    songKeys,
+  } = options;
+
+  const ids = [];
+
+  if (overviewHistoryPath && overviewKeys.length > 0) {
+    const abs = path.resolve(overviewHistoryPath);
+    if (!fs.existsSync(abs)) {
+      throw new Error(`Overview upload history not found: ${abs}`);
+    }
+    const overviewHistory = JSON.parse(fs.readFileSync(abs, 'utf-8'));
+    for (const key of overviewKeys) {
+      const rec = overviewHistory.uploads?.[key];
+      if (!rec?.videoId) {
+        throw new Error(`Overview upload history missing videoId for ${key}`);
+      }
+      ids.push(rec.videoId);
+    }
+  }
+
+  let orderedSongs = songKeys;
+  if (!orderedSongs || orderedSongs.length === 0) {
+    const metadata = loadMetadata(albumDir);
+    orderedSongs = metadata.videos.map((v) => v.filename);
+  }
+
+  for (const filename of orderedSongs) {
+    const rec = albumState.getUpload(filename);
+    if (!rec?.videoId) {
+      throw new Error(`Album upload history missing videoId for ${filename}`);
+    }
+    ids.push(rec.videoId);
+  }
+
+  return ids;
+}

package/src/playlist/reorder.js

@@ -0,0 +1,90 @@
+/**
+ * List all playlist items with snippet data.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} playlistId
+ * @returns {Promise<Array<{ id: string, videoId: string, position: number, title: string }>>}
+ */
+export async function listPlaylistItems(youtube, playlistId) {
+  const items = [];
+  let pageToken;
+  do {
+    const { data } = await youtube.playlistItems.list({
+      part: ['snippet'],
+      playlistId,
+      maxResults: 50,
+      pageToken,
+    });
+    for (const item of data.items || []) {
+      items.push({
+        id: item.id,
+        videoId: item.snippet?.resourceId?.videoId,
+        position: item.snippet?.position ?? 0,
+        title: item.snippet?.title || '',
+      });
+    }
+    pageToken = data.nextPageToken;
+  } while (pageToken);
+
+  items.sort((a, b) => a.position - b.position);
+  return items;
+}
+
+/**
+ * Reorder a playlist to match an explicit video ID sequence.
+ * Updates positions from end to start to avoid index drift.
+ *
+ * @param {import('googleapis').youtube_v3.Youtube} youtube
+ * @param {string} playlistId
+ * @param {string[]} desiredVideoIds
+ * @returns {Promise<{ changed: number, finalOrder: string[] }>}
+ */
+export async function reorderPlaylist(youtube, playlistId, desiredVideoIds) {
+  if (!desiredVideoIds.length) {
+    throw new Error('desiredVideoIds must not be empty');
+  }
+
+  const items = await listPlaylistItems(youtube, playlistId);
+  const byVideo = new Map(items.map((item) => [item.videoId, item]));
+
+  for (const videoId of desiredVideoIds) {
+    if (!byVideo.has(videoId)) {
+      throw new Error(`Video ${videoId} is not in playlist ${playlistId}`);
+    }
+  }
+
+  let changed = 0;
+  for (let pos = desiredVideoIds.length - 1; pos >= 0; pos -= 1) {
+    const videoId = desiredVideoIds[pos];
+    const item = byVideo.get(videoId);
+    if (item.position === pos) continue;
+
+    await youtube.playlistItems.update({
+      part: ['snippet'],
+      requestBody: {
+        id: item.id,
+        snippet: {
+          playlistId,
+          resourceId: { kind: 'youtube#video', videoId },
+          position: pos,
+        },
+      },
+    });
+    item.position = pos;
+    changed += 1;
+  }
+
+  return { changed, finalOrder: desiredVideoIds };
+}
+
+/**
+ * Compare current playlist order to desired video IDs.
+ *
+ * @param {string[]} currentVideoIds
+ * @param {string[]} desiredVideoIds
+ * @returns {boolean}
+ */
+export function playlistOrderMatches(currentVideoIds, desiredVideoIds) {
+  if (currentVideoIds.length !== desiredVideoIds.length) return false;
+  return currentVideoIds.every((id, i) => id === desiredVideoIds[i]);
+}