@juspay/neurolink 9.95.3 → 10.0.1

package/dist/cli/commands/telemetry.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-/* eslint-disable no-console, curly */
 /**
  * NeuroLink CLI Telemetry Commands
  *
@@ -16,6 +15,7 @@ import { logger } from "../../lib/utils/logger.js";
 import { NeuroLink } from "../../lib/neurolink.js";
 import { flushOpenTelemetry } from "../../lib/services/server/ai/observability/instrumentation.js";
 import { formatRow, formatCost } from "../utils/formatters.js";
+import { redactUrlCredentials } from "../../lib/utils/logSanitize.js";
 /**
  * Available exporter names
  */
@@ -87,54 +87,58 @@ export class TelemetryCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const status = neurolink.getTelemetryStatus();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Status retrieved");
+                    }
                     if (args.format === "json") {
-                        console.log(JSON.stringify(status, null, 2));
+                        logger.always(JSON.stringify(status, (_key, value) => typeof value === "string" &&
+                            (_key === "baseUrl" || _key === "endpoint")
+                            ? redactUrlCredentials(value)
+                            : value, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Telemetry Status ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Telemetry Status ==="));
+                        logger.always("");
                         // Telemetry enabled status
                         const enabledIcon = status.enabled
                             ? chalk.green("ENABLED")
                             : chalk.red("DISABLED");
-                        console.log(formatRow("Telemetry:", enabledIcon));
+                        logger.always(formatRow("Telemetry:", enabledIcon));
                         // OpenTelemetry status
                         if (status.openTelemetry) {
-                            console.log("");
-                            console.log(chalk.bold("OpenTelemetry:"));
+                            logger.always("");
+                            logger.always(chalk.bold("OpenTelemetry:"));
                             const otelStatus = status.openTelemetry.enabled
                                 ? chalk.green("Active")
                                 : chalk.gray("Inactive");
-                            console.log(formatRow("  Status:", otelStatus));
+                            logger.always(formatRow("  Status:", otelStatus));
                             if (status.openTelemetry.endpoint) {
-                                console.log(formatRow("  Endpoint:", status.openTelemetry.endpoint));
+                                logger.always(formatRow("  Endpoint:", redactUrlCredentials(status.openTelemetry.endpoint)));
                             }
                             if (status.openTelemetry.serviceName) {
-                                console.log(formatRow("  Service:", status.openTelemetry.serviceName));
+                                logger.always(formatRow("  Service:", status.openTelemetry.serviceName));
                             }
                         }
                         // Langfuse status
                         if (status.langfuse) {
-                            console.log("");
-                            console.log(chalk.bold("Langfuse:"));
+                            logger.always("");
+                            logger.always(chalk.bold("Langfuse:"));
                             const lfStatus = status.langfuse.enabled
                                 ? chalk.green("Active")
                                 : chalk.gray("Inactive");
-                            console.log(formatRow("  Status:", lfStatus));
+                            logger.always(formatRow("  Status:", lfStatus));
                             if (status.langfuse.baseUrl) {
-                                console.log(formatRow("  URL:", status.langfuse.baseUrl));
+                                logger.always(formatRow("  URL:", redactUrlCredentials(status.langfuse.baseUrl)));
                             }
                             if (status.langfuse.environment) {
-                                console.log(formatRow("  Environment:", status.langfuse.environment));
+                                logger.always(formatRow("  Environment:", status.langfuse.environment));
                             }
                         }
                         // Exporters health summary
                         if (status.exporters && status.exporters.length > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Exporter Health:"));
+                            logger.always("");
+                            logger.always(chalk.bold("Exporter Health:"));
                             for (const exporter of status.exporters) {
                                 const healthIcon = exporter.healthy
                                     ? chalk.green("[OK]")
@@ -142,24 +146,25 @@ export class TelemetryCommandFactory {
                                 const pendingInfo = exporter.pendingSpans
                                     ? chalk.gray(` (${exporter.pendingSpans} pending)`)
                                     : "";
-                                console.log(`  ${healthIcon} ${exporter.name}${pendingInfo}`);
+                                logger.always(`  ${healthIcon} ${exporter.name}${pendingInfo}`);
                                 if (exporter.errors && exporter.errors.length > 0) {
                                     for (const error of exporter.errors.slice(0, 2)) {
-                                        console.log(chalk.red(`      Error: ${error}`));
+                                        logger.always(chalk.red(`      Error: ${error}`));
                                     }
                                 }
                             }
                         }
                         else {
-                            console.log("");
-                            console.log(chalk.gray("No exporters configured."));
+                            logger.always("");
+                            logger.always(chalk.gray("No exporters configured."));
                         }
-                        console.log("");
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to get status");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -213,33 +218,36 @@ export class TelemetryCommandFactory {
                         config = JSON.parse(args.config);
                     }
                     catch {
-                        if (spinner)
+                        if (spinner) {
                             spinner.fail("Invalid JSON configuration");
-                        console.log(chalk.red("Error: Configuration must be valid JSON"));
-                        console.log("");
-                        console.log("Example:");
-                        console.log(chalk.gray(`  neurolink telemetry configure --exporter langfuse --config '{"publicKey":"pk-...", "secretKey":"sk-..."}'`));
+                        }
+                        logger.always(chalk.red("Error: Configuration must be valid JSON"));
+                        logger.always("");
+                        logger.always("Example:");
+                        logger.always(chalk.gray(`  neurolink telemetry configure --exporter langfuse --config '{"publicKey":"pk-...", "secretKey":"sk-..."}'`));
                         process.exit(1);
                     }
                     // Validate required fields based on exporter type
                     const validationResult = validateExporterConfig(args.exporter, config);
                     if (!validationResult.valid) {
-                        if (spinner)
+                        if (spinner) {
                             spinner.fail("Configuration validation failed");
-                        console.log(chalk.red(`Error: ${validationResult.error}`));
-                        console.log("");
-                        console.log(chalk.yellow(`Required fields for ${args.exporter}:`));
+                        }
+                        logger.always(chalk.red(`Error: ${validationResult.error}`));
+                        logger.always("");
+                        logger.always(chalk.yellow(`Required fields for ${args.exporter}:`));
                         for (const field of validationResult.requiredFields ?? []) {
-                            console.log(chalk.gray(`  - ${field}`));
+                            logger.always(chalk.gray(`  - ${field}`));
                         }
                         process.exit(1);
                     }
                     // Currently, exporter configuration is done via environment variables
                     // or SDK initialization. This command provides guidance on how to configure.
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed(`${args.exporter} configuration validated`);
+                    }
                     if (args.format === "json") {
-                        console.log(JSON.stringify({
+                        logger.always(JSON.stringify({
                             exporter: args.exporter,
                             config: config,
                             valid: true,
@@ -247,32 +255,33 @@ export class TelemetryCommandFactory {
                         }, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan(`=== ${args.exporter} Configuration ===`));
-                        console.log("");
-                        console.log(chalk.green("Configuration validated successfully!"));
-                        console.log("");
-                        console.log(chalk.bold("To apply this configuration:"));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan(`=== ${args.exporter} Configuration ===`));
+                        logger.always("");
+                        logger.always(chalk.green("Configuration validated successfully!"));
+                        logger.always("");
+                        logger.always(chalk.bold("To apply this configuration:"));
+                        logger.always("");
                         // Show environment variable instructions
                         const envVars = getExporterEnvVars(args.exporter);
-                        console.log(chalk.yellow("Option 1: Set environment variables"));
+                        logger.always(chalk.yellow("Option 1: Set environment variables"));
                         for (const [key, description] of Object.entries(envVars)) {
-                            console.log(chalk.gray(`  export ${key}="<${description}>"`));
+                            logger.always(chalk.gray(`  export ${key}="<${description}>"`));
                         }
-                        console.log("");
-                        console.log(chalk.yellow("Option 2: SDK initialization"));
-                        console.log(chalk.gray(`  const neurolink = new NeuroLink({`));
-                        console.log(chalk.gray(`    observability: {`));
-                        console.log(chalk.gray(`      ${args.exporter}: ${JSON.stringify(config, null, 6).split("\n").join("\n      ")}`));
-                        console.log(chalk.gray(`    }`));
-                        console.log(chalk.gray(`  });`));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.yellow("Option 2: SDK initialization"));
+                        logger.always(chalk.gray(`  const neurolink = new NeuroLink({`));
+                        logger.always(chalk.gray(`    observability: {`));
+                        logger.always(chalk.gray(`      ${args.exporter}: ${JSON.stringify(config, null, 6).split("\n").join("\n      ")}`));
+                        logger.always(chalk.gray(`    }`));
+                        logger.always(chalk.gray(`  });`));
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to configure exporter");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -308,20 +317,21 @@ export class TelemetryCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const status = neurolink.getTelemetryStatus();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Exporters listed");
+                    }
                     const configuredExporters = status.exporters ?? [];
                     const configuredNames = new Set(configuredExporters.map((e) => e.name.toLowerCase()));
                     if (args.format === "json") {
-                        console.log(JSON.stringify({
+                        logger.always(JSON.stringify({
                             available: AVAILABLE_EXPORTERS,
                             configured: configuredExporters,
                         }, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Available Exporters ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Available Exporters ==="));
+                        logger.always("");
                         for (const exporter of AVAILABLE_EXPORTERS) {
                             const isConfigured = configuredNames.has(exporter);
                             const configuredExporter = configuredExporters.find((e) => e.name.toLowerCase() === exporter);
@@ -331,27 +341,28 @@ export class TelemetryCommandFactory {
                                     : chalk.yellow("[CONFIGURED]")
                                 : chalk.gray("[AVAILABLE]");
                             const description = getExporterDescription(exporter);
-                            console.log(`${statusIcon} ${chalk.bold(exporter)}`);
-                            console.log(chalk.gray(`    ${description}`));
+                            logger.always(`${statusIcon} ${chalk.bold(exporter)}`);
+                            logger.always(chalk.gray(`    ${description}`));
                             if (isConfigured && configuredExporter) {
                                 if (configuredExporter.pendingSpans) {
-                                    console.log(chalk.gray(`    Pending spans: ${configuredExporter.pendingSpans}`));
+                                    logger.always(chalk.gray(`    Pending spans: ${configuredExporter.pendingSpans}`));
                                 }
                                 if (configuredExporter.lastExportTime) {
                                     const lastExport = new Date(configuredExporter.lastExportTime);
-                                    console.log(chalk.gray(`    Last export: ${lastExport.toISOString()}`));
+                                    logger.always(chalk.gray(`    Last export: ${lastExport.toISOString()}`));
                                 }
                             }
-                            console.log("");
+                            logger.always("");
                         }
-                        console.log(chalk.bold("Configuration Help:"));
-                        console.log(chalk.gray("  Use 'neurolink telemetry configure --exporter <name> --config <json>' to configure an exporter"));
-                        console.log("");
+                        logger.always(chalk.bold("Configuration Help:"));
+                        logger.always(chalk.gray("  Use 'neurolink telemetry configure --exporter <name> --config <json>' to configure an exporter"));
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to list exporters");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -397,21 +408,27 @@ export class TelemetryCommandFactory {
                     // Count pending spans before flush
                     const pendingBefore = statusBefore.exporters?.reduce((sum, e) => sum + (e.pendingSpans ?? 0), 0) ?? 0;
                     // Create a timeout promise
+                    let flushTimer;
                     const timeoutPromise = new Promise((_, reject) => {
-                        setTimeout(() => reject(new Error("Flush operation timed out")), args.timeout ?? 30000);
+                        flushTimer = setTimeout(() => reject(new Error("Flush operation timed out")), args.timeout ?? 30000);
                     });
                     // Flush OpenTelemetry spans
                     const flushPromise = flushOpenTelemetry();
                     // Race between flush and timeout
                     await Promise.race([flushPromise, timeoutPromise]);
+                    // Cancel the timeout timer to avoid unhandled rejection
+                    if (flushTimer !== undefined) {
+                        clearTimeout(flushTimer);
+                    }
                     // Get status after flush
                     const statusAfter = neurolink.getTelemetryStatus();
                     const pendingAfter = statusAfter.exporters?.reduce((sum, e) => sum + (e.pendingSpans ?? 0), 0) ?? 0;
                     const flushedCount = Math.max(0, pendingBefore - pendingAfter);
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Flush completed");
+                    }
                     if (args.format === "json") {
-                        console.log(JSON.stringify({
+                        logger.always(JSON.stringify({
                             success: true,
                             pendingBefore,
                             pendingAfter,
@@ -419,18 +436,19 @@ export class TelemetryCommandFactory {
                         }, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Flush Complete ==="));
-                        console.log("");
-                        console.log(formatRow("Spans before:", pendingBefore.toString()));
-                        console.log(formatRow("Spans after:", pendingAfter.toString()));
-                        console.log(formatRow("Flushed:", chalk.green(flushedCount.toString())));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Flush Complete ==="));
+                        logger.always("");
+                        logger.always(formatRow("Spans before:", pendingBefore.toString()));
+                        logger.always(formatRow("Spans after:", pendingAfter.toString()));
+                        logger.always(formatRow("Flushed:", chalk.green(flushedCount.toString())));
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to flush spans");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }
@@ -485,10 +503,11 @@ export class TelemetryCommandFactory {
                 try {
                     const neurolink = new NeuroLink();
                     const metrics = neurolink.getMetrics();
-                    if (spinner)
+                    if (spinner) {
                         spinner.succeed("Statistics retrieved");
+                    }
                     if (args.format === "json") {
-                        console.log(JSON.stringify({
+                        logger.always(JSON.stringify({
                             tokens: {
                                 input: metrics.tokens.totalInputTokens,
                                 output: metrics.tokens.totalOutputTokens,
@@ -511,82 +530,83 @@ export class TelemetryCommandFactory {
                         }, null, 2));
                     }
                     else {
-                        console.log("");
-                        console.log(chalk.bold.cyan("=== Token & Cost Statistics ==="));
-                        console.log("");
+                        logger.always("");
+                        logger.always(chalk.bold.cyan("=== Token & Cost Statistics ==="));
+                        logger.always("");
                         // Token usage
-                        console.log(chalk.bold("Token Usage:"));
-                        console.log(formatRow("  Input tokens:", metrics.tokens.totalInputTokens.toLocaleString()));
-                        console.log(formatRow("  Output tokens:", metrics.tokens.totalOutputTokens.toLocaleString()));
-                        console.log(formatRow("  Total tokens:", metrics.tokens.totalTokens.toLocaleString()));
+                        logger.always(chalk.bold("Token Usage:"));
+                        logger.always(formatRow("  Input tokens:", metrics.tokens.totalInputTokens.toLocaleString()));
+                        logger.always(formatRow("  Output tokens:", metrics.tokens.totalOutputTokens.toLocaleString()));
+                        logger.always(formatRow("  Total tokens:", metrics.tokens.totalTokens.toLocaleString()));
                         if (args.detailed) {
                             if (metrics.tokens.cacheReadTokens > 0) {
-                                console.log(formatRow("  Cache read:", metrics.tokens.cacheReadTokens.toLocaleString()));
+                                logger.always(formatRow("  Cache read:", metrics.tokens.cacheReadTokens.toLocaleString()));
                             }
                             if (metrics.tokens.reasoningTokens > 0) {
-                                console.log(formatRow("  Reasoning:", metrics.tokens.reasoningTokens.toLocaleString()));
+                                logger.always(formatRow("  Reasoning:", metrics.tokens.reasoningTokens.toLocaleString()));
                             }
                         }
                         // Cost summary
-                        console.log("");
-                        console.log(chalk.bold("Cost Summary:"));
-                        console.log(formatRow("  Total cost:", formatCost(metrics.totalCost ?? 0)));
+                        logger.always("");
+                        logger.always(chalk.bold("Cost Summary:"));
+                        logger.always(formatRow("  Total cost:", formatCost(metrics.totalCost ?? 0)));
                         // Cost by provider
                         if (args.byProvider !== false &&
                             metrics.costByProvider &&
                             metrics.costByProvider.length > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Cost by Provider:"));
+                            logger.always("");
+                            logger.always(chalk.bold("Cost by Provider:"));
                             const sortedProviders = [...metrics.costByProvider].sort((a, b) => b.totalCost - a.totalCost);
                             for (const provider of sortedProviders) {
-                                console.log(`  ${chalk.cyan(provider.provider.padEnd(15))} ${formatCost(provider.totalCost)}`);
-                                console.log(chalk.gray(`    ${provider.requestCount} requests, avg ${formatCost(provider.avgCostPerRequest)}/req`));
+                                logger.always(`  ${chalk.cyan(provider.provider.padEnd(15))} ${formatCost(provider.totalCost)}`);
+                                logger.always(chalk.gray(`    ${provider.requestCount} requests, avg ${formatCost(provider.avgCostPerRequest)}/req`));
                             }
                         }
                         // Cost by model
                         if (args.byModel !== false &&
                             metrics.costByModel &&
                             metrics.costByModel.length > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Cost by Model:"));
+                            logger.always("");
+                            logger.always(chalk.bold("Cost by Model:"));
                             const sortedModels = [...metrics.costByModel].sort((a, b) => b.totalCost - a.totalCost);
                             for (const model of sortedModels) {
-                                console.log(`  ${chalk.cyan(model.model)}`);
-                                console.log(`    Cost: ${formatCost(model.totalCost)}`);
-                                console.log(chalk.gray(`    ${model.requestCount} requests, avg ${formatCost(model.avgCostPerRequest)}/req`));
+                                logger.always(`  ${chalk.cyan(model.model)}`);
+                                logger.always(`    Cost: ${formatCost(model.totalCost)}`);
+                                logger.always(chalk.gray(`    ${model.requestCount} requests, avg ${formatCost(model.avgCostPerRequest)}/req`));
                                 if (args.detailed) {
-                                    console.log(chalk.gray(`    ${model.inputTokens.toLocaleString()} input, ${model.outputTokens.toLocaleString()} output tokens`));
+                                    logger.always(chalk.gray(`    ${model.inputTokens.toLocaleString()} input, ${model.outputTokens.toLocaleString()} output tokens`));
                                 }
                             }
                         }
                         // Request statistics
-                        console.log("");
-                        console.log(chalk.bold("Request Statistics:"));
-                        console.log(formatRow("  Total requests:", metrics.totalSpans.toLocaleString()));
-                        console.log(formatRow("  Successful:", metrics.successfulSpans.toLocaleString()));
-                        console.log(formatRow("  Failed:", metrics.failedSpans.toLocaleString()));
-                        console.log(formatRow("  Success rate:", `${(metrics.successRate * 100).toFixed(2)}%`));
+                        logger.always("");
+                        logger.always(chalk.bold("Request Statistics:"));
+                        logger.always(formatRow("  Total requests:", metrics.totalSpans.toLocaleString()));
+                        logger.always(formatRow("  Successful:", metrics.successfulSpans.toLocaleString()));
+                        logger.always(formatRow("  Failed:", metrics.failedSpans.toLocaleString()));
+                        logger.always(formatRow("  Success rate:", `${(metrics.successRate * 100).toFixed(2)}%`));
                         // Latency (if detailed)
                         if (args.detailed && metrics.latency.count > 0) {
-                            console.log("");
-                            console.log(chalk.bold("Latency (ms):"));
-                            console.log(formatRow("  P50:", metrics.latency.p50.toFixed(2)));
-                            console.log(formatRow("  P95:", metrics.latency.p95.toFixed(2)));
-                            console.log(formatRow("  P99:", metrics.latency.p99.toFixed(2)));
+                            logger.always("");
+                            logger.always(chalk.bold("Latency (ms):"));
+                            logger.always(formatRow("  P50:", metrics.latency.p50.toFixed(2)));
+                            logger.always(formatRow("  P95:", metrics.latency.p95.toFixed(2)));
+                            logger.always(formatRow("  P99:", metrics.latency.p99.toFixed(2)));
                         }
                         // Tracking duration
                         if (metrics.trackingDurationMs) {
                             const durationSec = metrics.trackingDurationMs / 1000;
                             const throughput = metrics.totalSpans > 0 ? metrics.totalSpans / durationSec : 0;
-                            console.log("");
-                            console.log(chalk.gray(`Tracking: ${durationSec.toFixed(1)}s (${throughput.toFixed(2)} req/s)`));
+                            logger.always("");
+                            logger.always(chalk.gray(`Tracking: ${durationSec.toFixed(1)}s (${throughput.toFixed(2)} req/s)`));
                         }
-                        console.log("");
+                        logger.always("");
                     }
                 }
                 catch (error) {
-                    if (spinner)
+                    if (spinner) {
                         spinner.fail("Failed to get statistics");
+                    }
                     logger.error("Error:", error instanceof Error ? error.message : String(error));
                     process.exit(1);
                 }

package/dist/cli/factories/commandFactory.d.ts

@@ -192,6 +192,13 @@ export declare class CLICommandFactory {
      * objects independently.
      */
     private static buildCsvOptionsFromArgv;
+    /**
+     * Build video processor options from CLI argv. Shared by executeGenerate,
+     * executeStream and executeBatch, which previously built byte-for-byte
+     * identical `videoOptions` objects independently (mirrors
+     * {@link buildCsvOptionsFromArgv}).
+     */
+    private static buildVideoOptionsFromArgv;
     /**
      * Build output configuration for generate request
      */

package/dist/cli/factories/commandFactory.js

@@ -2438,6 +2438,20 @@ export class CLICommandFactory {
             parseTimeoutMs: argv.csvParseTimeoutMs,
         };
     }
+    /**
+     * Build video processor options from CLI argv. Shared by executeGenerate,
+     * executeStream and executeBatch, which previously built byte-for-byte
+     * identical `videoOptions` objects independently (mirrors
+     * {@link buildCsvOptionsFromArgv}).
+     */
+    static buildVideoOptionsFromArgv(argv) {
+        return {
+            frames: argv.videoFrames,
+            quality: argv.videoQuality,
+            format: argv.videoFormat,
+            transcribeAudio: argv.transcribeAudio,
+        };
+    }
     /**
      * Build output configuration for generate request
      */
@@ -2677,12 +2691,7 @@ export class CLICommandFactory {
                     password: CLICommandFactory.resolvePdfPassword(argv),
                 },
                 csvOptions: CLICommandFactory.buildCsvOptionsFromArgv(argv),
-                videoOptions: {
-                    frames: argv.videoFrames,
-                    quality: argv.videoQuality,
-                    format: argv.videoFormat,
-                    transcribeAudio: argv.transcribeAudio,
-                },
+                videoOptions: CLICommandFactory.buildVideoOptionsFromArgv(argv),
                 output: outputConfig,
                 provider: enhancedOptions.provider,
                 model: enhancedOptions.model,
@@ -2932,12 +2941,7 @@ export class CLICommandFactory {
                 password: CLICommandFactory.resolvePdfPassword(argv),
             },
             csvOptions: CLICommandFactory.buildCsvOptionsFromArgv(argv),
-            videoOptions: {
-                frames: argv.videoFrames,
-                quality: argv.videoQuality,
-                format: argv.videoFormat,
-                transcribeAudio: argv.transcribeAudio,
-            },
+            videoOptions: CLICommandFactory.buildVideoOptionsFromArgv(argv),
             provider: enhancedOptions.provider,
             model: enhancedOptions.model,
             temperature: enhancedOptions.temperature,
@@ -3411,6 +3415,7 @@ export class CLICommandFactory {
             // see createBatchCommand — so `argv.file` can never be set here; no
             // exclusion needed to protect the (differently-named) positional.
             validateCliInputFiles(argv);
+            validateCsvMaxRows(argv);
             const batchImages = CLICommandFactory.processCliImages(argv.image);
             const batchCsvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
             const batchPdfFiles = CLICommandFactory.processCliPDFFiles(argv.pdf);
@@ -3469,6 +3474,12 @@ export class CLICommandFactory {
                 logger.alwaysStderr(chalk.yellow("⚠️  Multimodal files (--image/--csv/--pdf/--video) are attached to ALL prompts in this batch."));
                 spinner?.start();
             }
+            // Resolve the PDF password once for the whole batch. resolvePdfPassword
+            // emits a "visible in shell history" stderr warning when the flag is set;
+            // it must fire once per run (like generate/stream), not once per prompt.
+            const batchPdfPassword = batchPdfFiles?.length
+                ? CLICommandFactory.resolvePdfPassword(argv)
+                : undefined;
             for (let i = 0; i < prompts.length; i++) {
                 if (spinner) {
                     spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
@@ -3518,18 +3529,15 @@ export class CLICommandFactory {
                         // unlike generate/stream, so an empty options object here is
                         // pure noise on every prompt of every batch run.
                         ...(batchCsvFiles?.length && {
-                            csvOptions: {
-                                maxRows: argv.csvMaxRows,
-                                formatStyle: argv.csvFormat,
+                            csvOptions: CLICommandFactory.buildCsvOptionsFromArgv(argv),
+                        }),
+                        ...(batchPdfFiles?.length && {
+                            pdfOptions: {
+                                password: batchPdfPassword,
                             },
                         }),
                         ...(batchVideoFiles?.length && {
-                            videoOptions: {
-                                frames: argv.videoFrames,
-                                quality: argv.videoQuality,
-                                format: argv.videoFormat,
-                                transcribeAudio: argv.transcribeAudio,
-                            },
+                            videoOptions: CLICommandFactory.buildVideoOptionsFromArgv(argv),
                         }),
                         provider: enhancedOptions.provider,
                         model: enhancedOptions.model,

package/dist/cli/utils/inputValidation.d.ts

@@ -21,6 +21,7 @@ export declare const CLI_SOFT_LIMITS_MB: {
     readonly IMAGE_MAX_MB: 10;
     readonly CSV_MAX_MB: 50;
     readonly PDF_MAX_MB: 100;
+    readonly PDF_SOFT_MAX_MB: 50;
     readonly VIDEO_MAX_MB: 500;
 };
 /**

package/dist/cli/utils/inputValidation.js

@@ -27,6 +27,11 @@ export const CLI_SOFT_LIMITS_MB = {
     IMAGE_MAX_MB: 10,
     CSV_MAX_MB: 50,
     PDF_MAX_MB: 100,
+    // Distinct from PDF_MAX_MB above (which mirrors the processor's true
+    // 100MB hard cap in lib/processors/config/sizeLimits.ts and is kept here
+    // for backward compatibility). Docs promise a 50MB *warning* threshold
+    // specifically for --pdf — wire warnAtMB to this value, not the hard cap.
+    PDF_SOFT_MAX_MB: 50,
     VIDEO_MAX_MB: 500,
 };
 // `file://` is intentionally excluded here: it addresses a local path, so it
@@ -165,7 +170,7 @@ export function validateCliInputFiles(argv) {
         {
             option: "--pdf",
             value: argv.pdf,
-            warnAtMB: CLI_SOFT_LIMITS_MB.PDF_MAX_MB,
+            warnAtMB: CLI_SOFT_LIMITS_MB.PDF_SOFT_MAX_MB,
         },
         {
             option: "--video",