veodl 1.9.1 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to veo. This project follows [Semantic Versioning](https://semver.org/).
 
+## 1.10.0
+
+### Added
+
+- **Persistent Profile Management**: Added `veo profile [NAME|list|reset]` commands to view the active configuration profile, inspect available profiles, switch defaults, or reset back to default without manual configuration edits.
+- **On-demand Config Guide**: Added `veo config guide` to display full configuration guidance, supported options, and templates in the terminal without opening the interactive editor.
+- **Interactive Config Editor enhancements**:
+  - Full Undo (`Ctrl+Z`) and Redo (`Ctrl+Y`) history support when modifying settings.
+  - Select All (`Ctrl+A`) shortcut to easily highlight and overwrite lines or entire sections.
+  - Interactive F3 guide management prompt (`A` to add/refresh, `R` to strip documentation lines).
+  - Mouse edge drag auto-scrolling when dragging selections past viewport bounds.
+- **Automatic Browser Source Discovery**: Enabled automatic source discovery fallback by default when direct extraction fails, automatically selecting and proceeding if a single verified media stream is found.
+
+### Changed
+
+- Streamlined source discovery observation polling to immediately proceed once candidate streams are detected.
+- Enhanced progress output styling and ANSI handling across terminal status reporting.
+
 ## 1.9.1
 
 ### Added

package/README.md

@@ -193,9 +193,11 @@ example through `veo config edit`. Enable it with `veo URL --profile kompatibel`
   reserved by concurrent downloads in the same process. Unknown sizes are reported as
   unknown; conversion sizes and other processes' disk usage cannot be predicted exactly.
   Use `--no-check-space` to disable this conservative check.
-- `--timings` shows elapsed time for setup, metadata, download/backend, processing,
-  saving and retry waits. Download/backend includes the backend's own startup and
-  extraction overhead; these are elapsed timings, not a diagnosis of network speed.
+- `--timings` shows phase times at the end of the run. Single downloads show
+  timing without a summary; multiple downloads show timing below the summary.
+  The phases cover setup, metadata, download/backend, processing, saving and retry waits.
+  Download/backend includes the backend's own startup and extraction overhead;
+  these are summed per-download times, not a diagnosis of network speed.
   JSON results include `timings` in milliseconds, or `entryTimings` for playlists.
   Use `--no-timings` to hide/omit them.
 - Terminal details are gray, titles bold, saves green and errors red. The same styling
@@ -230,7 +232,7 @@ veo config show --profile fast
 Config checks validate every effective profile (or the selected one), including unknown
 settings, ranges and conflicting options. Show prints merged built-in, global and profile
 settings as JSON, with credential paths/browser profiles redacted. Neither command contacts
-video sites. All new options are also documented as commented examples in `veo config edit`.
+video sites. All new options are also documented in `veo config guide`.
 
 ### Files, names and resume
 
@@ -322,11 +324,12 @@ download fails because a login is required, the error message points at these fl
   is reached, verified sources found so far are shown with a timeout notice.
   A deep scan covers observed requests; it cannot discover sources that the
   page never loads. The timeout does not stop a subsequent download.
-- `veo <page-url> --source 2 --dry-run --json` previews source 2;
-  `veo <page-url> --source 2 --json` downloads it. For an unsupported single page
-  URL in a terminal, veo asks whether to search for sources. Answer `y` to see
-  the numbered list and choose one; `n` or Enter keeps the original failure.
-  Scripts must pass `--source <n>`; they never receive an interactive prompt.
+- For an unsupported single page URL, veo searches for media automatically and
+  uses the only verified source when there is one. If several sources are found,
+  the terminal asks which one to use; scripts receive a numbered source list and
+  a nonzero exit. `veo <page-url> --source 2 --dry-run --json` previews a chosen
+  source, and `veo <page-url> --source 2 --json` downloads it. Scripts never
+  receive an interactive prompt.
   Retry jobs retain the page URL and selected number and discover a fresh media
   URL, because player links may expire. Browser discovery uses a temporary
   profile without copying browser cookies, and cannot unlock DRM content.
@@ -391,10 +394,11 @@ silently ignoring a typo would be worse.
 Source discovery defaults are `deepScan` (boolean), `timeout` (string such as
 `"30s"` or `"2m"`), `listSources` (boolean) and `autoListSources` (boolean).
 `listSources: true` makes a single URL list sources and exit; use
-`--no-list-sources` to download for one invocation. `autoListSources: true`
-starts a source search when ordinary extraction finds no downloadable video,
-without the yes/no question. It still requires a source number before a
-download; scripts receive the source list and a nonzero exit. `deepScan` and
+`--no-list-sources` to download for one invocation. `autoListSources` defaults
+to `true` and searches when ordinary extraction finds no downloadable video.
+Set it to `false` or pass `--no-auto-list-sources` to disable that fallback.
+A single verified source is selected automatically; multiple sources require
+a choice. `deepScan` and
 `timeout` apply to either kind of source search.
 
 Additional defaults are `skipExisting` and `playlistItems`. Boolean defaults can be disabled
@@ -403,11 +407,16 @@ disables stored subtitle languages and subtitle embedding for that invocation.
 
 ### Named profiles
 
-If no profile is selected, `profiles.default` is applied automatically. You can also select
-it explicitly with `--profile default`. Other named profiles use global defaults rather
-than inheriting `default`. The wizard preselects `default` when it exists.
-`veo config edit` adds an empty `default` profile to existing configurations if missing,
-preserving existing settings. An empty profile does not change download behavior.
+If no profile is selected, `profiles.default` is applied automatically. `veo profile music`
+selects another named profile for future commands and stores it as `activeProfile` in the
+config; `veo profile` shows the current choice, and `veo profile list` marks it in
+the list. `veo profile reset` removes the stored choice and returns to `default`.
+You can also use `veo profile default` to select it explicitly.
+The names `list` and `reset` are reserved for these commands and cannot be used as profile names.
+`--profile NAME` overrides this choice for one command. Named profiles use global defaults
+rather than inheriting `default`. The wizard preselects the active profile.
+New configurations include an empty `default` profile and the example profiles. Existing configurations are
+left unchanged when opened. An empty profile does not change download behavior.
 
 ```json
 {
@@ -420,13 +429,15 @@ preserving existing settings. An empty profile does not change download behavior
 }
 ```
 
-`veo <url> --profile music` merges global defaults, then the selected profile, then explicit
-CLI flags. `veo config profiles` lists profile names; `veo config path` prints the file path.
-`veo config edit` fills new or empty files with a commented template explaining common
-options and example profiles. When the template changes in a new veo version,
-`veo config edit` refreshes its marked reference guide in existing files. Active settings
-and comments outside the marked guide remain intact; put personal notes below the guide.
-New options are visible without resetting the config.
+`veo <url> --profile music` merges global defaults, then the selected profile, then explicit
+CLI flags. `veo config profiles` lists profile names; `veo config path` prints the file path.
+The download status shows `Profile: NAME` (or `global (no profile)` when none is configured).
+`veo config edit` creates a small, valid configuration for new or empty files. Opening an
+existing configuration does not add or update comments. The current option guide is kept in
+the program; `veo config guide` prints it without changing the file. In the built-in editor,
+F3 offers **A** to add or update the guide at the top and **R** to remove a previously
+generated guide. Ctrl+S saves that choice. This can also clean up the long duplicate block
+inserted by older versions. Personal settings and notes below a generated block are preserved.
 In an interactive terminal, it opens the built-in editor
 unless `VISUAL` or `EDITOR` is configured (an executable path, without shell arguments).
 The editor provides syntax colors, line numbers and live validation. Syntax errors mark
@@ -435,11 +446,13 @@ spelling suggestions, expected types and allowed values in the status area. Vali
 the same rules as the CLI, including profile overrides and audio/video formats.
 Press F2 on a property or value to open suggestions, use Up/Down to choose, Enter to apply
 or Esc to cancel. Suggestions require valid JSON syntax; free-text values and custom numeric
-resolutions such as `900p` remain supported. Ctrl+S validates and saves;
-Esc or Ctrl+Q exits, asking before discarding changes. Use arrows, Home/End and PageUp/PageDown
+resolutions such as `900p` remain supported. Ctrl+S validates and saves;
+Ctrl+Z undoes edits, Ctrl+Y redoes them, and Ctrl+A selects the whole file.
+Esc or Ctrl+Q exits, asking before discarding changes. Use arrows, Home/End and PageUp/PageDown
 to navigate. Invalid configurations cannot be saved. `--no-color` disables syntax colors.
 In terminals supporting SGR mouse reporting, left-click positions the cursor and dragging
-selects text, including across lines. Backspace/Delete removes the selection; typing replaces
+selects text, including across lines. Holding the pointer at the top or bottom while dragging
+scrolls the file and extends the selection. Backspace/Delete removes the selection; typing replaces
 it. The mouse wheel scrolls without changing the editing position; Ctrl+Up/Down also scrolls.
 Ctrl+C copies selected text to the system clipboard, and Ctrl+V pastes clipboard text at the
 cursor or replaces the selection. Ctrl+Q or Esc exits the editor. The editor disables mouse
@@ -464,9 +477,8 @@ $env:VEO_CONFIG_EDITOR = 'external'
 
 Non-interactive sessions use the external editor unless `--terminal` is explicitly selected,
 in which case an interactive-terminal error is reported. The wizard also offers configured profiles.
-Generated templates and app messages are in English. Previously generated German template
-comments are translated the next time you run `veo config edit`; existing profile names,
-paths and custom comments are preserved.
+Generated guides and app messages are in English. Existing comments, profile names and
+settings are preserved when opening the editor.
 
 ### Terminal output
 
@@ -502,9 +514,14 @@ paths and custom comments are preserved.
 ```bash
 veo version           # installed version (also: veo --version or veo -v)
 veo                   # interactive download wizard (terminal only)
-veo config edit       # create/open config, including example profiles
+veo config edit       # create/open config; F3 offers the optional guide
+veo config guide      # print the current option guide
 veo config reset      # confirm with y; back up config and restore the current template
-veo config profiles   # list available profiles
+veo config profiles   # list available profiles
+veo profile            # show the currently selected profile
+veo profile list       # list all profiles and mark the active one
+veo profile music      # use music as the default for future commands
+veo profile reset      # return to default (or global settings if absent)
 veo config path       # show the config file location
 veo doctor            # diagnose the local setup; exit 1 if a check fails
 veo doctor fix        # restore missing or damaged managed tools

package/docs/AGENT_GUIDE.md

@@ -10,10 +10,12 @@ veo "https://example.com/video" --json --output ./downloads
 veo inspect "./downloads/video.mp4" --check-audio --json
 ```
 
-For a page with an embedded player that the normal extractor cannot identify,
-run `veo "<page-url>" --list-sources --json` and choose an `index` from the
-returned `sources`. Then use `veo "<page-url>" --source <index> --dry-run --json`
-before the download. Source discovery opens a temporary headless Chromium-based
+For a page with an embedded player that the normal extractor cannot identify,
+`veo "<page-url>" --dry-run --json` searches for playable media automatically.
+It uses a single verified source without a second command. If several sources
+are found, run `veo "<page-url>" --list-sources --json` and choose an `index`,
+then use `veo "<page-url>" --source <index> --dry-run --json` before downloading.
+Source discovery opens a temporary headless Chromium-based
 browser, repeatedly checks for Play controls, and observes media requests after
 interaction. It needs Chrome, Edge or Chromium,
 or `VEO_BROWSER_PATH`. A found source is verified by the backend; size may be

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veodl",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "A clean, simple video downloader powered by yt-dlp.",
   "type": "module",
   "bin": {

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

@@ -7,7 +7,7 @@ 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';
@@ -58,7 +58,7 @@ Options:
   --resume                 Keep partial data and continue an interrupted download
   --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)
@@ -89,7 +89,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.
@@ -198,7 +199,7 @@ 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,
   };
 }
 
@@ -226,6 +227,7 @@ const COMMAND_FLAGS = {
   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'];
 
@@ -259,6 +261,7 @@ export function parseCli(args, { config = {} } = {}) {
   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) }); }
@@ -340,12 +343,13 @@ export function parseCli(args, { config = {} } = {}) {
   if (options.rename && options.filenameTemplate) throw new Error('--rename and --filename-template cannot be combined.');
   const disableSubs = values.subs === false && tokens.some(token => token.name === 'subs');
   if (options.subLangs && !disableSubs) options.subs = true;
-  if (disableSubs) {
-    options.subLangs = undefined;
-    options.embedSubs = false;
-  }
-  return options;
-}
+  if (disableSubs) {
+    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)];
@@ -417,7 +421,7 @@ async function runMain(args, { config }) {
     try { return await (await import('./runs.js')).stopMain(args.slice(1)); }
     catch (error) { stderr.write(`veo: ${readableError(error)}\n`); return 1; }
   }
-  if (args[0] === 'retry') {
+  if (args[0] === 'retry') {
     if (args[1] !== '--last') {
       stderr.write('veo: Usage: veo retry --last [download options]\n');
       return 1;
@@ -426,8 +430,12 @@ async function runMain(args, { config }) {
       const { latestFailedJob } = await import('./jobs.js');
       args = ['--retry-failed', await latestFailedJob(), ...args.slice(2)];
     } catch (error) { stderr.write(`veo: ${readableError(error)}\n`); return 1; }
-  }
-  const { cleanupDownloadCache } = await import('./download-cache.js');
+  }
+  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.
   if (['update', 'up', 'upgrade', 'check'].includes(args[0])) {
@@ -438,10 +446,10 @@ async function runMain(args, { config }) {
     }
     return updateMain(args, { registry: defaultRegistry() });
   }
-  if (args[0] === 'config') {
-    try { return await configMain(args.slice(1)); }
-    catch (error) { stderr.write(`veo: ${readableError(error)}\n`); return 1; }
-  }
+  if (args[0] === 'config') {
+    try { return await configMain(args.slice(1)); }
+    catch (error) { stderr.write(`veo: ${readableError(error)}\n`); return 1; }
+  }
   if (args[0] === 'doctor') {
     try {
       const { doctorMain } = await import('./doctor.js');
@@ -507,7 +515,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) {
@@ -521,17 +536,22 @@ async function runMain(args, { config }) {
     // 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();
-    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 });
-    reporter.configure?.({ color: options.color && !options.json });
-    reporter.start(options.rename);
-    const cookieWarning = cookieFileWarning(options.cookies);
+    await run?.describe({ urls: options.urls, output: options.output ? path.resolve(options.output) : null,
+      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.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 +574,21 @@ 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.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,7 +602,8 @@ 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() });
+    const result = await runJob(options, { download: (request, dependencies) => download(request, { ...dependencies, backendResolver: reuseBackend(request) }),
+      reporter, 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);
@@ -600,11 +622,12 @@ async function askSourceQuestion(prompt, signal) {
   finally { rl.close(); }
 }
 
-export async function resolvePageSource(options, { signal, stderr, inspect, discover, ask = askSourceQuestion,
-  backendResolver, interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY && !options.json) }) {
+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) {
@@ -615,13 +638,10 @@ export async function resolvePageSource(options, { signal, stderr, inspect, disc
       }
       return {};
     }
-    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;
-    }
+    catch (error) { originalError = error; }
+    if (!shouldOfferSourceDiscovery(originalError)) 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 {
@@ -636,16 +656,18 @@ export async function resolvePageSource(options, { signal, stderr, inspect, disc
   }
   if (options.listSources) return { sources, formatSource };
   if (sources.timedOut) stderr.write(`veo: Source search timed out after ${options.timeout || (options.deepScan ? '120s' : '45s')}; showing verified sources found so far.\n`);
-  if (!sources.length) {
-    if (originalError) throw originalError;
-    throw new Error('No downloadable video sources were found on this page.');
-  }
-  let index = Number(options.source);
-  if (!index) {
-    if (!interactive && options.autoListSources) return { sources, formatSource, needsSelection: true };
-    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 (!sources.length) {
+    if (originalError) throw originalError;
+    throw new Error('No downloadable video sources were found on this page.');
+  }
+  let index = Number(options.source);
+  if (!index) {
+    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`);
+    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());
   }