veodl 1.9.1 → 1.10.1

package/src/backend.js

@@ -291,11 +291,19 @@ async function downloadBackend({ asset, release, expected, directory, signal, st
   }
 }
 
-async function acquire(asset, directory, signal, status) {
+async function acquire(asset, directory, signal, status, statusDone = () => {}) {
   const destination = path.join(directory, `yt-dlp${exeSuffix()}`);
   const expected = HASHES[asset];
   status('Checking yt-dlp…');
-  if (await matches(destination, expected, signal)) {
+  let cached;
+  try {
+    cached = await matches(destination, expected, signal);
+    statusDone('Checking yt-dlp…', 'done');
+  } catch (error) {
+    if (!signal?.aborted && error?.name !== 'AbortError') statusDone('Checking yt-dlp…', 'failed');
+    throw error;
+  }
+  if (cached) {
     if (process.platform !== 'win32') await chmod(destination, 0o755);
     return destination;
   }
@@ -330,7 +338,6 @@ async function managedMediaTools({ signal, status, directory }) {
   } catch (cause) {
     return `the bundled static media tools are unusable (${cause.message})`;
   }
-  status('Preparing ffmpeg and ffprobe…');
   const suffix = exeSuffix();
   await stage(ffmpeg, path.join(directory, `ffmpeg${suffix}`), signal);
   await stage(ffprobe, path.join(directory, `ffprobe${suffix}`), signal);
@@ -343,38 +350,58 @@ async function managedMediaTools({ signal, status, directory }) {
  * then a system installation (which is what Windows on ARM needs, because
  * ffmpeg-static and ffprobe-static ship no arm64 Windows binaries).
  */
-export async function resolveMediaTools({ signal, status = () => {}, directory, offline = false,
+export async function resolveMediaTools({ signal, status = () => {}, statusDone = () => {}, directory, offline = false,
   find = findOnPath, managed = managedMediaTools, install = installMediaTools } = {}) {
-  const suffix = exeSuffix();
-  const override = envPath('VEO_FFMPEG_PATH');
-  if (override) {
-    await executable(path.join(override, `ffmpeg${suffix}`), 'VEO_FFMPEG_PATH ffmpeg');
-    await executable(path.join(override, `ffprobe${suffix}`), 'VEO_FFMPEG_PATH ffprobe');
-    status('Using VEO_FFMPEG_PATH override.');
-    return override;
-  }
-  const problem = await managed({ signal, status, directory });
-  if (!problem) return directory;
-  // A previous run may already have staged a working pair into the cache.
-  if (await isExecutable(path.join(directory, `ffmpeg${suffix}`))
-    && await isExecutable(path.join(directory, `ffprobe${suffix}`))) return directory;
-  const ffmpeg = await find(['ffmpeg']);
-  const ffprobe = await find(['ffprobe']);
-  if (!ffmpeg || !ffprobe) {
-    if (!offline) return install({ signal, status, directory, find, stage });
-    const missing = [!ffmpeg && 'ffmpeg', !ffprobe && 'ffprobe'].filter(Boolean).join(' and ');
-    throw new Error(`Cannot load media tools: ${problem}, and no ${missing} was found on PATH. `
-      + 'Run veo doctor fix without --offline to install them automatically, or set VEO_FFMPEG_PATH to a directory containing both binaries.');
-  }
-  // Same directory: yt-dlp can use it in place instead of duplicating ~150 MB.
-  if (path.dirname(ffmpeg) === path.dirname(ffprobe)) {
-    status(`Using the system ffmpeg in ${path.dirname(ffmpeg)}.`);
-    return path.dirname(ffmpeg);
+  const preparing = 'Preparing ffmpeg and ffprobe…';
+  let currentStatus;
+  const report = message => { currentStatus = message; status(message); };
+  const finish = outcome => {
+    if (currentStatus !== preparing) report(preparing);
+    statusDone(preparing, outcome);
+  };
+  report(preparing);
+  try {
+    const suffix = exeSuffix();
+    const override = envPath('VEO_FFMPEG_PATH');
+    if (override) {
+      await executable(path.join(override, `ffmpeg${suffix}`), 'VEO_FFMPEG_PATH ffmpeg');
+      await executable(path.join(override, `ffprobe${suffix}`), 'VEO_FFMPEG_PATH ffprobe');
+      finish('done');
+      report('Using VEO_FFMPEG_PATH override.');
+      return override;
+    }
+    const problem = await managed({ signal, status: report, directory });
+    if (!problem) { finish('done'); return directory; }
+    // A previous run may already have staged a working pair into the cache.
+    if (await isExecutable(path.join(directory, `ffmpeg${suffix}`))
+      && await isExecutable(path.join(directory, `ffprobe${suffix}`))) { finish('done'); return directory; }
+    const ffmpeg = await find(['ffmpeg']);
+    const ffprobe = await find(['ffprobe']);
+    if (!ffmpeg || !ffprobe) {
+      if (!offline) {
+        const location = await install({ signal, status: report, directory, find, stage });
+        finish('done');
+        return location;
+      }
+      const missing = [!ffmpeg && 'ffmpeg', !ffprobe && 'ffprobe'].filter(Boolean).join(' and ');
+      throw new Error(`Cannot load media tools: ${problem}, and no ${missing} was found on PATH. `
+        + 'Run veo doctor fix without --offline to install them automatically, or set VEO_FFMPEG_PATH to a directory containing both binaries.');
+    }
+    // Same directory: yt-dlp can use it in place instead of duplicating ~150 MB.
+    if (path.dirname(ffmpeg) === path.dirname(ffprobe)) {
+      finish('done');
+      report(`Using the system ffmpeg in ${path.dirname(ffmpeg)}.`);
+      return path.dirname(ffmpeg);
+    }
+    report('Copying system ffmpeg and ffprobe into the backend cache…');
+    await stage(ffmpeg, path.join(directory, `ffmpeg${suffix}`), signal);
+    await stage(ffprobe, path.join(directory, `ffprobe${suffix}`), signal);
+    finish('done');
+    return directory;
+  } catch (error) {
+    if (!signal?.aborted && error?.name !== 'AbortError') finish('failed');
+    throw error;
   }
-  status('Copying system ffmpeg and ffprobe into the backend cache…');
-  await stage(ffmpeg, path.join(directory, `ffmpeg${suffix}`), signal);
-  await stage(ffprobe, path.join(directory, `ffprobe${suffix}`), signal);
-  return directory;
 }
 
 /**
@@ -457,12 +484,13 @@ export async function inspectBackend({ signal, platform = process.platform, arch
  * cannot serve the current platform (notably Windows on ARM).
  * onStatus receives plain strings. Throws on cancellation or acquisition failure.
  */
-export async function resolveBackend({ signal, onStatus, offline = false, platform = process.platform, find = findOnPath,
+export async function resolveBackend({ signal, onStatus, onStatusDone, offline = false, platform = process.platform, find = findOnPath,
   setupTermux = installTermuxTools, hasEjs = hasTermuxEjs, run = runSetup } = {}) {
   if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal.');
   if (onStatus !== undefined && typeof onStatus !== 'function') throw new TypeError('onStatus must be a function.');
   signal?.throwIfAborted();
   const status = onStatus || (() => {});
+  const statusDone = onStatusDone || (() => {});
   const ytOverride = envPath('VEO_YT_DLP_PATH');
   if (platform === 'android') {
     const mediaOverride = envPath('VEO_FFMPEG_PATH');
@@ -508,13 +536,13 @@ export async function resolveBackend({ signal, onStatus, offline = false, platfo
   const installed = ytDlp ? null : await activeOverride(asset, { signal });
   const directory = cacheDirectory();
   await mkdir(directory, { recursive: true, mode: 0o700 });
-  const ffmpegLocation = await resolveMediaTools({ signal, status, directory, offline });
+  const ffmpegLocation = await resolveMediaTools({ signal, status, statusDone, directory, offline });
   if (ytDlp) status('Using VEO_YT_DLP_PATH override.');
   else if (installed) status(`Using the installed yt-dlp ${installed.release}.`);
   if (offline && !ytDlp && !installed && !await matches(path.join(directory, `yt-dlp${exeSuffix()}`), HASHES[asset], signal)) {
     throw new Error('yt-dlp is missing or damaged. Run veo doctor fix without --offline to download it.');
   }
-  const backend = ytDlp || installed?.path || await acquire(asset, directory, signal, status);
+  const backend = ytDlp || installed?.path || await acquire(asset, directory, signal, status, statusDone);
   signal?.throwIfAborted();
   return { ytDlp: backend, ffmpegLocation };
 }

package/src/cli.js

@@ -1,4 +1,5 @@
 import { outputOptions, outputStream, withOutputSettings } from './output.js';
+import { validateFragments, confirmExperimentalFragments } from './experimental-fragments.js';
 import { validateTemplate } from './naming.js';
 import { parseArgs } from 'node:util';
 import path from 'node:path';
@@ -7,10 +8,10 @@ import { createInterface } from 'node:readline/promises';
 import { createReporter } from './progress.js';
 import { openFile } from './open-file.js';
 import { maybeUpdateNotice, updateMain, UPDATE_HELP, defaultRegistry, packageVersion } from './updater.js';
-import { applyProfile, configMain, loadConfig } from './config.js';
+import { applyProfile, configMain, loadConfig, profileMain, selectedProfileName } from './config.js';
 import { validateItems, describeEstimate } from './playlist.js';
-import { parseSourceTimeout } from './source-discovery.js';
-import { explainUnknownOption, optionSpellings, suggestOption } from './option-suggestions.js';
+import { parseSourceTimeout } from './source-discovery.js';
+import { explainUnknownOption, optionSpellings, suggestOption } from './option-suggestions.js';
 import { retryOptions, runJob, jobFilePath } from './jobs.js';
 import { QUALITIES, VIDEO_FORMATS, AUDIO_FORMATS, validateUrl, readableError, cleanText, validateCookieFile, validateBrowserSpec, cookieFileWarning } from './utils.js';
 
@@ -43,7 +44,9 @@ Options:
   --playlist-concurrency <n>  Simultaneous playlist downloads (1-4; default: 2)
   --playlist               Download every entry of a playlist or channel URL
   -N, --concurrent-fragments <n>
-                           Download this many fragments in parallel (1-16; default: 8)
+                           Parallel fragments (1-64; default: 8); 17-64 are experimental
+  --experimental-fragments  Explicitly accept experimental values above 16
+                           Otherwise requires terminal confirmation before download
   --subs                   Download subtitles (default languages: en)
   --sub-langs <langs>      Subtitle languages, e.g. "de,en" (implies --subs)
   --embed-subs             Embed subtitles into the video file
@@ -56,9 +59,11 @@ Options:
   --cookies-from-browser <browser[:profile]>
                            Read cookies from an installed browser
   --resume                 Keep partial data and continue an interrupted download
+  --list-qualities         Show available video resolutions and exit
+  --list-qualitys          Alias for --list-qualities
   --list-formats           Show the available formats and exit
   --list-sources           Find video sources loaded by a web page and exit
-  --auto-list-sources      Search automatically after no downloadable video is found
+  --auto-list-sources      Search after no video is found (default: on)
   --source <n>             Select source number from that page (also for scripts)
   --deep-scan              Check every media candidate found during source search
   --timeout <duration>     Source search deadline, e.g. 30, 30s or 2m (5s-10m)
@@ -66,7 +71,7 @@ Options:
   --json                   Print one JSON object per URL instead of prose
   --profile <name>         Apply a named config profile
   --batch-file <file>      Read URLs from a file (one per line; # comments)
-  --retry-failed <file>    Retry failed/unfinished items from a saved job
+  --retry-failed <id|file> Retry failed/unfinished items by run ID or job file
   --playlist-items <list>  Select playlist entries, e.g. 1,3-5 (implies --playlist)
   --skip-existing         Skip matching downloads still present on disk
   --no-<boolean-option>   Disable a stored boolean default, e.g. --no-open
@@ -89,7 +94,8 @@ Commands:
   veo alias list|add|remove  Manage extra command names (wrappers calling veo)
   veo uninstall [-p <name>]  Remove one alias, or everything with --yes
   veo version              Show the installed version
-  veo config edit|path|profiles|check|show|reset  Manage defaults and named profiles
+  veo config edit|path|profiles|guide|check|show|reset  Manage defaults and named profiles
+  veo profile [list|reset|name]  Show, list or change the default profile
   veo config edit [--external|--terminal]      Choose the configuration editor
 
 Run veo without arguments in a terminal for interactive setup.
@@ -133,6 +139,7 @@ const STRING_OPTIONS = {
 };
 
 const BOOLEAN_OPTIONS = {
+  'experimental-fragments': {},
   compatible: {},
   recode: {},
   'adaptive-concurrency': {},
@@ -148,6 +155,8 @@ const BOOLEAN_OPTIONS = {
   'embed-metadata': {},
   'embed-thumbnail': {},
   'closest-quality': {},
+  'list-qualities': {},
+  'list-qualitys': {},
   'list-formats': {},
   'list-sources': {},
   'auto-list-sources': {},
@@ -179,6 +188,7 @@ export function optionDefaults(config = {}) {
     cookies: config.cookies,
     'cookies-from-browser': config.cookiesFromBrowser,
     'concurrent-fragments': String(config.concurrentFragments ?? 8),
+    'experimental-fragments': config.experimentalFragments ?? false,
     'sub-langs': config.subLangs,
     'sponsorblock-remove': config.sponsorblockRemove,
     section: config.section,
@@ -198,11 +208,11 @@ export function optionDefaults(config = {}) {
     timeout: config.timeout,
     'deep-scan': config.deepScan ?? false,
     'list-sources': config.listSources ?? false,
-    'auto-list-sources': config.autoListSources ?? false,
+    'auto-list-sources': config.autoListSources ?? true,
   };
 }
 
-export function cliOptions(config = {}) {
+export function cliOptions(config = {}) {
   const defaults = optionDefaults(config);
   const options = {};
   for (const [name, extra] of Object.entries(STRING_OPTIONS)) {
@@ -214,41 +224,42 @@ export function cliOptions(config = {}) {
     if (defaults[name] !== undefined) options[name].default = defaults[name];
   }
   return options;
-}
-
-const COMMAND_FLAGS = {
-  stats: ['--json'], history: ['--json', '--limit', '--failed'],
-  runs: ['--json'], stop: [], flush: ['--stats'],
-  inspect: ['--json', '--check-audio', '--search'],
-  doctor: ['--offline', '--output', '-o'],
-  update: ['--check'], up: ['--check'], upgrade: ['--check'], check: ['--check'],
-  backend: ['--check', '--keep-files'],
-  alias: ['--json', '--force', '--bin-dir'],
-  uninstall: ['--prefix', '-p', '--yes', '--keep-cache', '--keep-config', '--keep-aliases', '--json', '--bin-dir'],
-  config: ['--profile', '--external', '--terminal'],
-};
-const COMMAND_NAMES = [...Object.keys(COMMAND_FLAGS), 'retry', 'help', 'version'];
-
-function mistypedCommandOption(args) {
-  const command = args[0];
-  if (command && !command.startsWith('-') && !COMMAND_NAMES.includes(command)) {
-    const suggestion = suggestOption(command, COMMAND_NAMES);
-    if (suggestion) return `Unknown command "${command}". Did you mean "${suggestion}"?`;
-  }
-  const options = Object.hasOwn(COMMAND_FLAGS, command)
-    ? [...COMMAND_FLAGS[command], '--help', '-h', '--no-color', '--color', '--profile']
-    : command === 'retry' ? [...optionSpellings(cliOptions()), '--last'] : null;
-  if (!options) return null; // Download flags are checked by parseCli itself.
-  const start = ['config', 'backend', 'alias'].includes(command) && args[1] && !args[1].startsWith('-') ? 2 : 1;
-  for (const arg of args.slice(start)) {
-    if (arg === '--') break;
-    const name = arg.split('=')[0];
-    if (!name.startsWith('-') || options.includes(name)) continue;
-    const suggestion = suggestOption(name, options);
-    if (suggestion) return `Unknown option "${name}". Did you mean "${suggestion}"?`;
-  }
-  return null;
-}
+}
+
+const COMMAND_FLAGS = {
+  stats: ['--json'], history: ['--json', '--limit', '--failed'],
+  runs: ['--json'], stop: [], flush: ['--stats'],
+  inspect: ['--json', '--check-audio', '--search'],
+  doctor: ['--offline', '--output', '-o'],
+  update: ['--check'], up: ['--check'], upgrade: ['--check'], check: ['--check'],
+  backend: ['--check', '--keep-files'],
+  alias: ['--json', '--force', '--bin-dir'],
+  uninstall: ['--prefix', '-p', '--yes', '--keep-cache', '--keep-config', '--keep-aliases', '--json', '--bin-dir'],
+  config: ['--profile', '--external', '--terminal'],
+  profile: [],
+};
+const COMMAND_NAMES = [...Object.keys(COMMAND_FLAGS), 'retry', 'help', 'version'];
+
+function mistypedCommandOption(args) {
+  const command = args[0];
+  if (command && !command.startsWith('-') && !COMMAND_NAMES.includes(command)) {
+    const suggestion = suggestOption(command, COMMAND_NAMES);
+    if (suggestion) return `Unknown command "${command}". Did you mean "${suggestion}"?`;
+  }
+  const options = Object.hasOwn(COMMAND_FLAGS, command)
+    ? [...COMMAND_FLAGS[command], '--help', '-h', '--no-color', '--color', '--profile']
+    : command === 'retry' ? [...optionSpellings(cliOptions()), '--last'] : null;
+  if (!options) return null; // Download flags are checked by parseCli itself.
+  const start = ['config', 'backend', 'alias'].includes(command) && args[1] && !args[1].startsWith('-') ? 2 : 1;
+  for (const arg of args.slice(start)) {
+    if (arg === '--') break;
+    const name = arg.split('=')[0];
+    if (!name.startsWith('-') || options.includes(name)) continue;
+    const suggestion = suggestOption(name, options);
+    if (suggestion) return `Unknown option "${name}". Did you mean "${suggestion}"?`;
+  }
+  return null;
+}
 
 export function parseCli(args, { config = {} } = {}) {
   if (args[0] === 'help') args = ['--help', ...args.slice(1)];
@@ -256,14 +267,15 @@ export function parseCli(args, { config = {} } = {}) {
     if (args.length !== 1) throw new Error('Usage: veo version');
     return { version: true };
   }
-  let preliminary;
-  try { preliminary = parseArgs({ args, allowPositionals: true, strict: true, allowNegative: true, options: cliOptions() }); }
-  catch (error) { throw explainUnknownOption(error, cliOptions()); }
-  config = applyProfile(config, preliminary.values.profile);
-  let parsed;
-  try { parsed = parseArgs({ args, tokens: true, allowNegative: true, allowPositionals: true, strict: true, options: cliOptions(config) }); }
-  catch (error) { throw explainUnknownOption(error, cliOptions(config)); }
-  const { values, positionals, tokens } = parsed;
+  let preliminary;
+  try { preliminary = parseArgs({ args, allowPositionals: true, strict: true, allowNegative: true, options: cliOptions() }); }
+  catch (error) { throw explainUnknownOption(error, cliOptions()); }
+  const profileName = selectedProfileName(config, preliminary.values.profile);
+  config = applyProfile(config, preliminary.values.profile);
+  let parsed;
+  try { parsed = parseArgs({ args, tokens: true, allowNegative: true, allowPositionals: true, strict: true, options: cliOptions(config) }); }
+  catch (error) { throw explainUnknownOption(error, cliOptions(config)); }
+  const { values, positionals, tokens } = parsed;
   if (values.help || values.version) return values;
   // A stored default conflicting with a flag typed right now is a user error;
   // a stored default merely ignored by another flag is not.
@@ -290,6 +302,13 @@ export function parseCli(args, { config = {} } = {}) {
   if (values.audio && values.quality !== 'best' && typed.quality) throw new Error('--quality is for video; omit it when using --audio.');
   if (values.audio && values['closest-quality'] && typed.closest) throw new Error('--closest-quality is for video; omit it when using --audio.');
   if (values['closest-quality'] && values.quality === 'best' && typed.closest) throw new Error('--closest-quality requires a numeric --quality such as 1080p.');
+  values['list-qualities'] = Boolean(values['list-qualities'] || values['list-qualitys']);
+  delete values['list-qualitys'];
+  if (values['list-qualities']) {
+    if (positionals.length !== 1 || values['batch-file'] || values['retry-failed']) throw new Error('--list-qualities accepts exactly one URL.');
+    if (values['list-formats'] || values['list-sources']) throw new Error('--list-qualities cannot be combined with other listing actions.');
+    if (values.audio || values.playlist) throw new Error('--list-qualities requires a single video without --audio or --playlist.');
+  }
   if (values['list-formats'] && (values.audio || values.format)) throw new Error('--list-formats cannot be combined with --audio or --format.');
   if (values['list-formats'] && positionals.length > 1) throw new Error('--list-formats accepts exactly one URL.');
   if (values.source && (!/^[1-9]\d*$/.test(values.source) || !Number.isSafeInteger(Number(values.source)))) throw new Error('--source requires a positive source number.');
@@ -307,7 +326,7 @@ export function parseCli(args, { config = {} } = {}) {
   if ((values.source || values['list-sources']) && values.playlist) throw new Error('--source and --list-sources cannot be combined with --playlist.');
   if (values['concurrent-fragments'] !== undefined) {
     const fragments = Number(values['concurrent-fragments']);
-    if (!Number.isInteger(fragments) || fragments < 1 || fragments > 16) throw new Error('--concurrent-fragments must be a whole number between 1 and 16.');
+    validateFragments(fragments);
   }
   const concurrency = Number(values['playlist-concurrency']);
   if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 4) throw new Error('--playlist-concurrency must be a whole number between 1 and 4.');
@@ -344,13 +363,14 @@ export function parseCli(args, { config = {} } = {}) {
     options.subLangs = undefined;
     options.embedSubs = false;
   }
+  options.profile = profileName;
   return options;
 }
 
-export async function main(args = process.argv.slice(2), { config } = {}) {
-  if (args[0] === 'help') args = ['--help', ...args.slice(1)];
-  const mistyped = mistypedCommandOption(args);
-  if (mistyped) { process.stderr.write(`veo: ${mistyped}\n`); return 1; }
+export async function main(args = process.argv.slice(2), { config } = {}) {
+  if (args[0] === 'help') args = ['--help', ...args.slice(1)];
+  const mistyped = mistypedCommandOption(args);
+  if (mistyped) { process.stderr.write(`veo: ${mistyped}\n`); return 1; }
   let color = !args.includes('--no-color') && !args.includes('--json');
   let display;
   try {
@@ -427,6 +447,10 @@ async function runMain(args, { config }) {
       args = ['--retry-failed', await latestFailedJob(), ...args.slice(2)];
     } catch (error) { stderr.write(`veo: ${readableError(error)}\n`); return 1; }
   }
+  if (args[0] === 'profile') {
+    try { return await profileMain(args.slice(1)); }
+    catch (error) { stderr.write(`veo: ${readableError(error)}\n`); return 1; }
+  }
   const { cleanupDownloadCache } = await import('./download-cache.js');
   await cleanupDownloadCache().catch(error => stderr.write(`veo: Could not clean expired local downloads: ${readableError(error)}\n`));
   // update/upgrade/up/check subcommands are handled before URL validation.
@@ -507,7 +531,14 @@ async function runMain(args, { config }) {
       retryItems = await retryOptions(options.retryFailed);
       // Revalidate stored options and apply only flags explicitly supplied now.
       const retryArgs = args.filter((arg, index) => arg !== '--retry-failed' && args[index - 1] !== '--retry-failed' && !arg.startsWith('--retry-failed='));
-      retryItems = retryItems.map(item => parseCli([item.url, ...retryArgs], { config: { ...item, profiles: loaded.config?.profiles } }));
+      const overrideProfile = retryArgs.some(arg => arg === '--profile' || arg.startsWith('--profile='));
+      retryItems = retryItems.map(item => {
+        const resumed = parseCli([item.url, ...retryArgs], { config: overrideProfile
+          ? { ...item, profiles: loaded.config?.profiles }
+          : item });
+        if (!overrideProfile) resumed.profile = item.profile;
+        return resumed;
+      });
       options = { ...retryItems[0], urls: retryItems.map(item => item.url) };
     }
     if (options.batchFile) {
@@ -518,20 +549,26 @@ async function runMain(args, { config }) {
       if (options.rename && options.urls.length > 1 && !options.rename.includes('*')) throw new Error('--rename only applies to a single URL unless the name contains * for the original title.');
       if (options.listFormats && options.urls.length > 1) throw new Error('--list-formats accepts exactly one URL.');
     }
+    await confirmExperimentalFragments(retryItems || [options], { signal: controller.signal });
     // The job file is created before the first download, so another terminal can
     // follow this run's per-item progress with `veo runs <id>`.
-    const jobFile = options.listFormats || options.listSources || options.dryRun ? null : jobFilePath();
+    const jobFile = options.listQualities || options.listFormats || options.listSources || options.dryRun ? null : jobFilePath();
     await run?.describe({ urls: options.urls, output: options.output ? path.resolve(options.output) : null,
-      audio: options.audio, quality: options.quality, format: options.format, playlist: options.playlist, job: jobFile });
+      audio: options.audio, quality: options.quality, format: options.format, profile: options.profile || null,
+      playlist: options.playlist, job: jobFile });
     reporter.configure?.({ color: options.color && !options.json });
     reporter.start(options.rename);
+    if (!options.dryRun && !options.listQualities && !options.listFormats && !options.listSources) reporter.profile(options.profile);
+    const preparedBackends = new Map();
+    const reuseBackend = request => preparedBackends.has(request.url) ? async () => preparedBackends.get(request.url) : undefined;
     const cookieWarning = cookieFileWarning(options.cookies);
     if (cookieWarning) stderr.write(`veo: ${cookieWarning}\n`);
 
     // For a single page, fall back to media requests observed while its player loads.
     // Explicit --source always rediscovers: signed media URLs can expire between runs.
     if (!retryItems && options.urls.length === 1 && (!options.playlist || options.listSources)) {
-      const discovery = await resolvePageSource(options, { signal: controller.signal, stderr });
+      const discovery = await resolvePageSource(options, { signal: controller.signal, stderr, reporter,
+        onBackend: backend => preparedBackends.set(options.url, backend) });
       if (options.listSources) {
         if (options.json) stdout.write(`${JSON.stringify({ url: options.url, status: 'sources', timedOut: Boolean(discovery.sources.timedOut), sources: discovery.sources.map(({ url, pageUrl, ...safe }) => safe) })}\n`);
         else for (const source of discovery.sources) stdout.write(`${discovery.formatSource(source)}\n`);
@@ -554,20 +591,31 @@ async function runMain(args, { config }) {
     }
     if (retryItems) for (const item of retryItems) {
       if (!item.source) continue;
-      const discovery = await resolvePageSource(item, { signal: controller.signal, stderr });
+      const discovery = await resolvePageSource(item, { signal: controller.signal, stderr, reporter,
+        onBackend: backend => preparedBackends.set(item.url, backend) });
       item.mediaUrl = discovery.mediaUrl;
     }
 
+    if (options.listQualities) {
+      const { listQualities } = await import('./downloader.js');
+      const result = await listQualities(options, { signal: controller.signal, reporter, backendResolver: reuseBackend(options) });
+      if (options.json) stdout.write(JSON.stringify(result) + '\n');
+      else {
+        stdout.write('Available qualities: ' + (result.qualities.join(', ') || 'resolution unknown') + '\n');
+        if (result.qualities.length) stdout.write('Choose with --quality ' + result.qualities[0] + '\n');
+      }
+      return 0;
+    }
     if (options.listFormats) {
       const { listFormats } = await import('./downloader.js');
-      stdout.write(await listFormats(options, { signal: controller.signal, reporter }));
+      stdout.write(await listFormats(options, { signal: controller.signal, reporter, backendResolver: reuseBackend(options) }));
       return 0;
     }
     if (options.dryRun) {
       const { planDownload } = await import('./downloader.js');
       for (const request of retryItems || options.urls.map(url => ({ ...options, url }))) {
         const { url } = request;
-        const plan = await planDownload(request, { signal: controller.signal, reporter });
+        const plan = await planDownload(request, { signal: controller.signal, reporter, backendResolver: reuseBackend(request) });
         if (options.json) stdout.write(`${JSON.stringify({ url, status: 'planned', ...plan })}\n`);
         else {
           stdout.write(`URL: ${url}\n`);
@@ -581,13 +629,17 @@ async function runMain(args, { config }) {
     const { download } = await import('./downloader.js');
     const { createStatsRecorder } = await import('./stats.js');
     const { createHistoryRecorder } = await import('./history.js');
-    const result = await runJob(options, { download, reporter, signal: controller.signal, openFile, items: retryItems, jobFile: jobFile || undefined, runId: run?.id, recordStats: createStatsRecorder(), recordHistory: createHistoryRecorder() });
+    if (!options.json && process.stdout.isTTY) reporter.enableInline();
+    const result = await runJob(options, { download: (request, dependencies) => download(request, { ...dependencies, backendResolver: reuseBackend(request) }),
+      reporter, stdout: reporter.output(stdout), stderr: reporter.output(stderr), signal: controller.signal, openFile, items: retryItems, jobFile: jobFile || undefined, runId: run?.id, recordStats: createStatsRecorder(), recordHistory: createHistoryRecorder() });
     return result;
   } catch (error) {
     reporter.fail(controller.signal.aborted);
+    reporter.dispose();
     stderr.write(`veo: ${readableError(error)}\n`);
     return controller.signal.aborted || error.name === 'AbortError' ? 130 : 1;
   } finally {
+    reporter.dispose();
     await run?.unregister();
     process.removeListener('SIGINT', cancel);
     process.removeListener('SIGTERM', cancel);
@@ -600,11 +652,12 @@ async function askSourceQuestion(prompt, signal) {
   finally { rl.close(); }
 }
 
-export async function resolvePageSource(options, { signal, stderr, inspect, discover, ask = askSourceQuestion,
+export async function resolvePageSource(options, { signal, stderr, reporter, onBackend, inspect, discover, ask = askSourceQuestion,
   backendResolver, interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY && !options.json) }) {
   const { fetchMetadata, prepareBackend, runBackend } = await import('./downloader.js');
   const { discoverSources, formatSource, shouldOfferSourceDiscovery } = await import('./source-discovery.js');
-  const backend = inspect ? null : await (backendResolver || prepareBackend)(options, { signal });
+  const backend = inspect ? null : await (backendResolver || prepareBackend)(options, { signal, reporter });
+  if (backend) onBackend?.(backend);
   const inspectMedia = (request, requestSignal = signal) => inspect ? inspect(request, requestSignal) : fetchMetadata(request, { signal: requestSignal, backend, runner: runBackend });
   let originalError;
   if (!options.source && !options.listSources) {
@@ -617,11 +670,8 @@ export async function resolvePageSource(options, { signal, stderr, inspect, disc
     }
     catch (error) { originalError = error; }
     if (!shouldOfferSourceDiscovery(originalError)) throw originalError;
-    if (!interactive && !options.autoListSources) throw new Error(`${originalError.message} Use --list-sources to search this page, then --source <number> to select one.`);
-    if (interactive && !options.autoListSources) {
-      const answer = (await ask('No downloadable video found. Search this page for other sources? (y/N): ', signal)).trim().toLowerCase();
-      if (!['y', 'yes'].includes(answer)) throw originalError;
-    }
+    if (options.autoListSources === false) throw new Error(`${originalError.message} Use --list-sources to search this page, then --source <number> to select one.`);
+    stderr.write('veo: No direct video found; searching the page for a playable source…\n');
   }
   let sources;
   try {
@@ -642,9 +692,11 @@ export async function resolvePageSource(options, { signal, stderr, inspect, disc
   }
   let index = Number(options.source);
   if (!index) {
-    if (!interactive && options.autoListSources) return { sources, formatSource, needsSelection: true };
+    if (sources.length === 1) index = 1;
+    else if (!interactive) return { sources, formatSource, needsSelection: true };
+  }
+  if (!index) {
     for (const source of sources) stderr.write(`${formatSource(source)}\n`);
-    if (!interactive) throw new Error('Select a source with --source <number>.');
     const answer = await ask('Source number (Enter to cancel): ', signal);
     if (!/^[1-9]\d*$/.test(answer.trim())) throw new Error('No source selected.');
     index = Number(answer.trim());

package/src/config-diagnostics.js

@@ -1,4 +1,4 @@
-import { CONFIG_KEYS, parseConfigText, effectiveConfig, applyProfile } from './config.js';
+import { CONFIG_KEYS, RESERVED_PROFILE_NAMES, parseConfigText, effectiveConfig, applyProfile } from './config.js';
 import { stripConfigComments } from './config-template.js';
 import { QUALITIES, AUDIO_FORMATS, VIDEO_FORMATS } from './utils.js';
 
@@ -64,7 +64,7 @@ function valueChoices(key, config = {}) {
   if (key === 'format') return config.audio ? AUDIO_FORMATS : VIDEO_FORMATS;
   if (key === 'timeout') return ['30s', '45s', '1m', '2m', '5m'];
   if (['concurrentDownloads', 'playlistConcurrency'].includes(key)) return [1, 2, 3, 4];
-  if (key === 'concurrentFragments') return Array.from({ length: 16 }, (_, i) => i + 1);
+  if (key === 'concurrentFragments') return Array.from({ length: 64 }, (_, i) => i + 1);
   return [];
 }
 
@@ -75,7 +75,7 @@ export async function semanticIssue(text) {
   if (!object(data)) return located(text, node([]), 'The config must contain a JSON object.');
   const check = (settings, path) => {
     for (const [key, value] of Object.entries(settings)) {
-      if (!path.length && ['$schema', 'profiles'].includes(key)) continue;
+      if (!path.length && ['$schema', 'profiles', 'activeProfile'].includes(key)) continue;
       const target = node([...path, key]);
       if (!Object.hasOwn(CONFIG_KEYS, key)) {
         const proposed = suggestion(key, path.length ? keys : [...keys, 'profiles', '$schema']);
@@ -93,10 +93,19 @@ export async function semanticIssue(text) {
   if (Object.hasOwn(data, 'profiles')) {
     if (!object(data.profiles)) return located(text, node(['profiles']), 'Profiles must be an object.');
     for (const [name, profile] of Object.entries(data.profiles)) {
+      if (RESERVED_PROFILE_NAMES.includes(name)) {
+        return located(text, node(['profiles', name]), `Profile name "${name}" is reserved for veo profile ${name}. Rename this profile.`, true);
+      }
       if (!object(profile)) return located(text, node(['profiles', name]), `Profile "${name}" must be an object.`);
       issue = check(profile, ['profiles', name]); if (issue) return issue;
     }
   }
+  if (Object.hasOwn(data, 'activeProfile')) {
+    if (typeof data.activeProfile !== 'string' || !data.activeProfile) return located(text, node(['activeProfile']), '"activeProfile" must be a non-empty profile name.');
+    if (!object(data.profiles) || !Object.hasOwn(data.profiles, data.activeProfile)) {
+      return located(text, node(['activeProfile']), `Unknown active profile "${data.activeProfile}". Choose: ${Object.keys(data.profiles || {}).join(', ') || 'none'}.`, false, Object.keys(data.profiles || {}));
+    }
+  }
   const { config } = parseConfigText(text);
   for (const profile of [undefined, ...Object.keys(config.profiles || {})]) {
     try { await effectiveConfig(config, profile); }
@@ -105,7 +114,7 @@ export async function semanticIssue(text) {
       let key = /Invalid quality/.test(message) ? 'quality' : /Invalid (?:audio|video) format/.test(message) ? 'format' :
         /output directory/.test(message) ? 'output' : /custom filename/.test(message) ? 'rename' :
           /--([a-z-]+)/.exec(message)?.[1]?.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-      const name = profile ?? (config.profiles?.default ? 'default' : undefined);
+      const name = profile ?? config.activeProfile ?? (config.profiles?.default ? 'default' : undefined);
       const selected = applyProfile(config, profile);
       // Template errors do not name the CLI option. Locate the failing template.
       if (!key) {
@@ -134,7 +143,8 @@ export function editorCompletions(text, cursor) {
       const key = path.at(-1), property = cursor >= item.keyStart && cursor <= item.keyEnd;
       if (!property && !(cursor >= item.start && cursor <= item.end)) continue;
       const profile = path.length === 3 ? path[1] : undefined;
-      const choices = property ? (path.length === 1 ? [...keys, 'profiles', '$schema'] : keys) : valueChoices(key, applyProfile(data, profile));
+      const choices = property ? (path.length === 1 ? [...keys, 'profiles', 'activeProfile', '$schema'] : keys) :
+        key === 'activeProfile' ? Object.keys(data.profiles || {}) : valueChoices(key, applyProfile(data, profile));
       if (!choices.length) return null;
       const proposed = property ? suggestion(key, choices) : null;
       return { start: property ? item.keyStart : item.start, end: property ? item.keyEnd : item.end,