@pilio/gemini-watermark-remover 1.0.37 → 1.0.39

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [

package/src/cli/gwrCli.js

@@ -2,7 +2,7 @@ import { runRemoveCommand } from './gwrRemoveCommand.js';
 
 export async function main(argv, io) {
   if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-    io.stdout.write('Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json] [--video-page <url-or-file>]\n');
+    io.stdout.write('Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json] [--video-page <url-or-file>] [--video-timeout-ms <ms>] [--video-bitrate-mbps <Mbps>]\n');
     return 0;
   }
 

package/src/cli/gwrRemoveCommand.js

@@ -10,9 +10,9 @@ import {
 } from '../sdk/node.js';
 
 const REMOVE_USAGE =
-  'Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json] [--video-page <url-or-file>]';
+  'Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json] [--video-page <url-or-file>] [--video-timeout-ms <ms>] [--video-bitrate-mbps <Mbps>]';
 
-export async function runRemoveCommand(argv, io) {
+export async function runRemoveCommand(argv, io, dependencies = {}) {
   if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
     io.stdout.write(`${REMOVE_USAGE}\n`);
     return 0;
@@ -24,7 +24,12 @@ export async function runRemoveCommand(argv, io) {
     return 2;
   }
 
-  const commandOptions = { ...options, imageCodecPromise: null };
+  const commandOptions = {
+    ...options,
+    imageCodecPromise: null,
+    onVideoProgress: createVideoProgressReporter(io.stderr),
+    removeVideoFile: dependencies.removeVideoWatermarkFromFile || removeVideoWatermarkFromFile
+  };
   const inputStats = await stat(commandOptions.input).catch(() => null);
   if (!inputStats) {
     io.stderr.write(`Input not found: ${commandOptions.input}\n`);
@@ -66,6 +71,7 @@ function parseRemoveArgs(argv) {
     videoPage: null,
     videoDenoiseBackend: null,
     videoTimeoutMs: null,
+    videoBitrateMbps: null,
     allowLowConfidence: false
   };
 
@@ -142,6 +148,14 @@ function parseRemoveArgs(argv) {
       continue;
     }
 
+    if (token === '--video-bitrate-mbps') {
+      const parsed = parseOptionValue(argv, index, '--video-bitrate-mbps');
+      if (!parsed.ok) return parsed;
+      options.videoBitrateMbps = Number(parsed.value);
+      index = parsed.index;
+      continue;
+    }
+
     if (token === '--overwrite') {
       options.overwrite = true;
       continue;
@@ -180,6 +194,10 @@ function parseRemoveArgs(argv) {
     return { ok: false, error: '--video-timeout-ms must be a positive number.' };
   }
 
+  if (options.videoBitrateMbps !== null && (!Number.isFinite(options.videoBitrateMbps) || options.videoBitrateMbps <= 0)) {
+    return { ok: false, error: '--video-bitrate-mbps must be a positive number.' };
+  }
+
   return options;
 }
 
@@ -204,6 +222,30 @@ function parseOptionValue(argv, optionIndex, optionName) {
   return { ok: true, value: nextToken, index: optionIndex + 1 };
 }
 
+function createVideoProgressReporter(stderr) {
+  let lastPercent = -1;
+  let lastPhase = null;
+
+  return (progress = {}) => {
+    const percent = Number.isFinite(progress.progress)
+      ? Math.max(0, Math.min(100, Math.round(progress.progress * 100)))
+      : null;
+    const phaseChanged = progress.phase && progress.phase !== lastPhase;
+    const percentChanged = percent !== null && (percent === 100 || percent >= lastPercent + 5);
+    if (!phaseChanged && !percentChanged) return;
+
+    const frameLabel = Number.isFinite(progress.processedFrames)
+      ? ` ${progress.processedFrames}${Number.isFinite(progress.frameEstimate) ? `/${progress.frameEstimate}` : ''} frames`
+      : '';
+    const inferenceLabel = Number.isFinite(progress.aiDenoiseFrames) || Number.isFinite(progress.aiReuseFrames)
+      ? ` (AI ${progress.aiDenoiseFrames || 0}, reused ${progress.aiReuseFrames || 0})`
+      : '';
+    stderr.write(`[video] ${percent ?? '?'}%${frameLabel}${inferenceLabel}\n`);
+    if (percent !== null) lastPercent = percent;
+    lastPhase = progress.phase || lastPhase;
+  };
+}
+
 async function resolveCodecOptions(options) {
   if (!options.decoder && !options.encoder) {
     return createSharpCodec();
@@ -337,7 +379,7 @@ async function processOneFile(inputPath, outputPath, options) {
 
   await mkdir(path.dirname(outputPath), { recursive: true });
   if (isVideoPath(inputPath) || isVideoPath(outputPath)) {
-    const result = await removeVideoWatermarkFromFile(inputPath, {
+    const result = await options.removeVideoFile(inputPath, {
       outputPath,
       mimeType: inferVideoMimeTypeFromPath(outputPath || inputPath),
       pagePath: options.videoPage || undefined,
@@ -345,6 +387,10 @@ async function processOneFile(inputPath, outputPath, options) {
       timeoutMs: Number.isFinite(options.videoTimeoutMs) && options.videoTimeoutMs > 0
         ? options.videoTimeoutMs
         : undefined,
+      videoBitrate: Number.isFinite(options.videoBitrateMbps) && options.videoBitrateMbps > 0
+        ? options.videoBitrateMbps * 1_000_000
+        : undefined,
+      onProgress: options.onVideoProgress,
       allowLowConfidence: options.allowLowConfidence
     });
 
@@ -383,3 +429,5 @@ async function getImageCodec(options) {
   }
   return options.imageCodecPromise;
 }
+
+export { parseRemoveArgs };

package/src/sdk/node.d.ts

@@ -4,6 +4,7 @@ export type {
     VideoBufferRemovalResult,
     VideoFileRemovalOptions,
     VideoFileRemovalResult,
+    VideoProcessingProgress,
     VideoRemovalMeta
 } from './video.js';
 

package/src/sdk/video.d.ts

@@ -1,11 +1,24 @@
-export interface VideoRemovalMeta {
+export interface VideoRemovalMeta {
     status?: string;
     denoiseBackend?: string;
     actualDenoiseBackend?: string;
     actualControls?: Record<string, unknown>;
     pagePath?: string;
     [key: string]: unknown;
-}
+}
+
+export interface VideoProcessingProgress {
+    tone: string;
+    status: string;
+    progressText: string;
+    progress: number | null;
+    phase: string | null;
+    processedFrames: number | null;
+    frameEstimate: number | null;
+    aiDenoiseFrames: number | null;
+    aiReuseFrames: number | null;
+    elapsedMs: number;
+}
 
 export interface VideoFileProcessorContext {
     outputPath?: string | null;
@@ -19,9 +32,10 @@ export interface VideoFileProcessorContext {
     residualCleanupStrength?: number;
     videoBitrate?: number;
     adaptiveAlpha?: boolean;
-    alphaGain?: number;
-    alphaProfile?: string;
-}
+    alphaGain?: number;
+    alphaProfile?: string;
+    onProgress?: (progress: VideoProcessingProgress) => void;
+}
 
 export interface VideoBufferProcessorContext extends Omit<VideoFileProcessorContext, 'filePath'> {
     filePath?: string;
@@ -43,9 +57,10 @@ export interface VideoFileRemovalOptions {
     residualCleanupStrength?: number;
     videoBitrate?: number;
     adaptiveAlpha?: boolean;
-    alphaGain?: number;
-    alphaProfile?: string;
-    processVideoFile?: (
+    alphaGain?: number;
+    alphaProfile?: string;
+    onProgress?: (progress: VideoProcessingProgress) => void;
+    processVideoFile?: (
         inputPath: string,
         context: VideoFileProcessorContext
     ) => Promise<VideoProcessorResult> | VideoProcessorResult;

package/src/sdk/video.js

@@ -2,10 +2,14 @@ import path from 'node:path';
 import { createReadStream } from 'node:fs';
 import { createServer } from 'node:http';
 import { access, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-
-const DEFAULT_VIDEO_DENOISE_BACKEND = 'allenk-fdncnn-browser-spike';
-const DEFAULT_VIDEO_TIMEOUT_MS = 6 * 60 * 1000;
+import { fileURLToPath } from 'node:url';
+import {
+    DEFAULT_VIDEO_TIMEOUT_MS,
+    configureVideoPageTimeouts,
+    waitForVideoProcessing
+} from './videoProgress.js';
+
+const DEFAULT_VIDEO_DENOISE_BACKEND = 'allenk-fdncnn-browser-spike';
 
 function normalizeBufferLike(value) {
     if (Buffer.isBuffer(value)) return value;
@@ -200,10 +204,11 @@ async function processVideoWithPreviewPage(inputPath, options = {}) {
         edgeDenoiseStrength,
         residualCleanupStrength,
         videoBitrate,
-        adaptiveAlpha = false,
-        alphaGain,
-        alphaProfile
-    } = options;
+        adaptiveAlpha = false,
+        alphaGain,
+        alphaProfile,
+        onProgress
+    } = options;
 
     if (!isHttpUrl(pagePath)) {
         await assertReadableFile(pagePath, 'Video preview page');
@@ -215,8 +220,8 @@ async function processVideoWithPreviewPage(inputPath, options = {}) {
     const browser = await chromium.launch({ headless: true });
     try {
         return await withLocalVideoPreviewPage(pagePath, async (pageUrl) => {
-            const page = await browser.newPage();
-            page.setDefaultTimeout(timeoutMs);
+            const page = await browser.newPage();
+            configureVideoPageTimeouts(page);
             await page.goto(pageUrl);
             await page.locator('#fileInput').setInputFiles(inputPath);
             await page.evaluate((value) => {
@@ -266,13 +271,10 @@ async function processVideoWithPreviewPage(inputPath, options = {}) {
             }
 
             await page.locator('#processBtn').click();
-            await page.waitForFunction(() => {
-                const status = document.getElementById('status');
-                return status?.dataset?.tone === 'success' || status?.dataset?.tone === 'error';
-            }, null, { timeout: timeoutMs });
-
-            const status = await page.locator('#status').textContent();
-            const tone = await page.locator('#status').getAttribute('data-tone');
+            const { status, tone } = await waitForVideoProcessing(page, {
+                timeoutMs,
+                onProgress
+            });
             if (tone !== 'success') {
                 throw new Error(status || 'Video export failed');
             }

package/src/sdk/videoProgress.js

@@ -0,0 +1,108 @@
+const DEFAULT_VIDEO_TIMEOUT_MS = 6 * 60 * 1000;
+const DEFAULT_VIDEO_PROGRESS_POLL_INTERVAL_MS = 1000;
+const DEFAULT_VIDEO_PAGE_SETUP_TIMEOUT_MS = 30_000;
+
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function readVideoProgressSnapshot(page) {
+    return page.evaluate(() => {
+        const status = document.getElementById('status');
+        const progressBar = document.getElementById('progressBar');
+        const progressText = document.getElementById('progressText');
+        const rawProgress = Number.parseFloat(progressBar?.style?.width || '');
+        const runtimeProgress = globalThis.__gwrVideoCliProgress;
+
+        return {
+            tone: status?.dataset?.tone || '',
+            status: status?.textContent || '',
+            progressText: progressText?.textContent || '',
+            progress: Number.isFinite(runtimeProgress?.progress)
+                ? Math.max(0, Math.min(1, runtimeProgress.progress))
+                : Number.isFinite(rawProgress)
+                    ? Math.max(0, Math.min(1, rawProgress / 100))
+                    : null,
+            phase: runtimeProgress?.phase || null,
+            processedFrames: Number.isFinite(runtimeProgress?.processedFrames)
+                ? runtimeProgress.processedFrames
+                : null,
+            frameEstimate: Number.isFinite(runtimeProgress?.frameEstimate)
+                ? runtimeProgress.frameEstimate
+                : null,
+            aiDenoiseFrames: Number.isFinite(runtimeProgress?.aiDenoiseFrames)
+                ? runtimeProgress.aiDenoiseFrames
+                : null,
+            aiReuseFrames: Number.isFinite(runtimeProgress?.aiReuseFrames)
+                ? runtimeProgress.aiReuseFrames
+                : null
+        };
+    });
+}
+
+function describeProgress(snapshot) {
+    return [snapshot?.progressText, snapshot?.status]
+        .map((value) => String(value || '').trim())
+        .filter(Boolean)
+        .filter((value, index, values) => values.indexOf(value) === index)
+        .join(' - ');
+}
+
+function configureVideoPageTimeouts(page) {
+    page.setDefaultTimeout(DEFAULT_VIDEO_PAGE_SETUP_TIMEOUT_MS);
+    page.setDefaultNavigationTimeout(DEFAULT_VIDEO_PAGE_SETUP_TIMEOUT_MS);
+}
+
+async function waitForVideoProcessing(page, options = {}) {
+    const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+        ? options.timeoutMs
+        : DEFAULT_VIDEO_TIMEOUT_MS;
+    const pollIntervalMs = Number.isFinite(options.pollIntervalMs) && options.pollIntervalMs >= 0
+        ? options.pollIntervalMs
+        : DEFAULT_VIDEO_PROGRESS_POLL_INTERVAL_MS;
+    const now = typeof options.now === 'function' ? options.now : Date.now;
+    const sleep = typeof options.sleep === 'function' ? options.sleep : delay;
+    const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
+    const startedAt = now();
+    let lastActivityAt = startedAt;
+    let lastSnapshotKey = null;
+
+    while (true) {
+        const snapshot = await readVideoProgressSnapshot(page);
+        const elapsedMs = Math.max(0, now() - startedAt);
+        const result = { ...snapshot, elapsedMs };
+        const snapshotKey = JSON.stringify(snapshot);
+        if (snapshotKey !== lastSnapshotKey) {
+            lastActivityAt = now();
+            lastSnapshotKey = snapshotKey;
+            onProgress(result);
+        }
+
+        if (snapshot.tone === 'success' || snapshot.tone === 'error') {
+            return result;
+        }
+
+        const inactiveMs = Math.max(0, now() - lastActivityAt);
+        if (inactiveMs >= timeoutMs) {
+            const detail = describeProgress(snapshot);
+            const timeoutLabel = timeoutMs < 1000
+                ? `${Math.round(timeoutMs)} ms`
+                : `${Math.round(timeoutMs / 1000)} seconds`;
+            throw new Error(
+                `Video processing made no progress for ${timeoutLabel}${detail ? ` at ${detail}` : ''}. ` +
+                'Increase --video-timeout-ms for unusually long files.'
+            );
+        }
+
+        await sleep(Math.min(pollIntervalMs, Math.max(0, timeoutMs - inactiveMs)));
+    }
+}
+
+export {
+    DEFAULT_VIDEO_PAGE_SETUP_TIMEOUT_MS,
+    DEFAULT_VIDEO_PROGRESS_POLL_INTERVAL_MS,
+    DEFAULT_VIDEO_TIMEOUT_MS,
+    configureVideoPageTimeouts,
+    describeProgress,
+    waitForVideoProcessing
+};