veodl 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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
+
+- Added typo and spelling suggestions for misspelled CLI options and subcommands (e.g. `--deepscan` suggests `--deep-scan`, `veo histroy` suggests `veo history`).
+
+### Fixed
+
+- Improved browser-based player source discovery to continuously detect delayed play controls and overlays inside frames.
+
 ## 1.9.0
 
 ### 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
 
@@ -307,9 +309,10 @@ download fails because a login is required, the error message points at these fl
 
 ### Inspection and scripting
 
-- `veo <page-url> --list-sources` opens the page in a temporary headless Chrome,
-  Edge or Chromium profile, presses a clearly labeled Play button when present,
-  and checks media requests loaded by the player. Use `--json` for numbered source
+- `veo <page-url> --list-sources` opens the page in a temporary headless Chrome,
+  Edge or Chromium profile, repeatedly checks for visible Play controls (including
+  controls added later or inside frames), and watches media requests after interaction.
+  Use `--json` for numbered source
   metadata. Each result includes its title, host, HLS/DASH/direct type, known
   resolutions, estimated MiB size and Mbit/s bitrate when the source provides them. Signed media
   URLs are not printed. Set `VEO_BROWSER_PATH` if the browser is not found.
@@ -321,14 +324,17 @@ 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.
+  profile without copying browser cookies, and cannot unlock DRM content.
+  Misspelled flags and commands show a nearby valid spelling, for example
+  `--deepscan` suggests `--deep-scan`.
 - `--list-formats` prints the backend's own format table for one URL and exits.
 - `--dry-run` prints the title, the resolved quality and the destination path that would be
   used — without creating the output directory or downloading anything.
@@ -388,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
@@ -400,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
 {
@@ -417,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
@@ -432,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
@@ -461,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
 
@@ -499,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,11 +10,14 @@ 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
-browser and observes media requests after Play. It needs Chrome, Edge or Chromium,
+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
 unknown, and DRM-protected media is excluded. Source numbers are tied to the
 page's current discovery run and may change later.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veodl",
-  "version": "1.9.0",
+  "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 };
 }