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

package/src/cli/preview-journey.js

@@ -38,11 +38,12 @@ export async function previewJourney(songKey, options = {}) {
   const journeyConfig = {
     enabled: true,
     mode: 'before-current',
-    position: 'left',
-    displayDuration: 5,
+    position: 'right',
+    displayDuration: 4,
     sidebarDisplayDuration: undefined,
-    sidebarLabel: 'title',
+    sidebarLabel: 'stage',
     theme: 'dark',
+    style: 'badge',
     maxCenterChars: 60,
     maxVisibleRows: 8,
     ...(rawMetadata.journey || {}),
@@ -71,7 +72,7 @@ export async function previewJourney(songKey, options = {}) {
     currentSongKey: songKey,
     rawMetadata,
     mode: journeyConfig.mode,
-    maxVisibleRows: journeyConfig.maxVisibleRows,
+    maxVisibleRows: journeyConfig.style === 'panel' ? journeyConfig.maxVisibleRows : null,
     sidebarLabel: journeyConfig.sidebarLabel,
   });
 
@@ -86,6 +87,10 @@ export async function previewJourney(songKey, options = {}) {
     showSidebar: journeyConfig.enabled !== false,
     theme: journeyConfig.theme,
     position: journeyConfig.position,
+    style: journeyConfig.style,
+    stage: songData.journeyStage || songData.albumRole,
+    step: typeof songData.trackNumber === 'number' ? songData.trackNumber : (songData.playlistPosition !== undefined ? songData.playlistPosition + 1 : undefined),
+    totalSteps: rawMetadata.album?.trackCount || rawMetadata.album?.arc?.length || (tracks[0]?.totalTracks) || 11,
   });
 
   const pngBuffer = renderSvgToPng(svgContent, width, height);

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,12 +580,22 @@ 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;
   mode?: 'before-current' | 'all';
-  position?: 'left';
+  position?: 'left' | 'right';
+  style?: 'badge' | 'panel';
+  badgeText?: string;
   displayDuration?: number | 'full';
   sidebarDisplayDuration?: number | 'full';
   sidebarLabel?: 'title' | 'stage' | 'both';
@@ -614,7 +704,12 @@ export function generateJourneySvg(params: {
   centerText?: string;
   showSidebar?: boolean;
   theme?: 'dark' | 'light';
-  position?: 'left';
+  position?: 'left' | 'right';
+  style?: 'badge' | 'panel';
+  stage?: string;
+  step?: number;
+  totalSteps?: number;
+  badgeText?: string;
 }): string;
 
 export function renderSvgToPng(svgContent: string, width?: number, height?: number): Buffer;
@@ -630,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';