veodl 1.9.0 → 1.9.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to veo. This project follows [Semantic Versioning](https://semver.org/).
 
+## 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

@@ -307,9 +307,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.
@@ -328,7 +329,9 @@ download fails because a login is required, the error message points at these fl
   Scripts must pass `--source <n>`; they 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.

package/docs/AGENT_GUIDE.md

@@ -14,7 +14,8 @@ 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,
+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.9.1",
   "description": "A clean, simple video downloader powered by yt-dlp.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -9,7 +9,8 @@ import { openFile } from './open-file.js';
 import { maybeUpdateNotice, updateMain, UPDATE_HELP, defaultRegistry, packageVersion } from './updater.js';
 import { applyProfile, configMain, loadConfig } from './config.js';
 import { validateItems, describeEstimate } from './playlist.js';
-import { parseSourceTimeout } from './source-discovery.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';
 
@@ -201,7 +202,7 @@ export function optionDefaults(config = {}) {
   };
 }
 
-export function cliOptions(config = {}) {
+export function cliOptions(config = {}) {
   const defaults = optionDefaults(config);
   const options = {};
   for (const [name, extra] of Object.entries(STRING_OPTIONS)) {
@@ -213,7 +214,41 @@ 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;
+}
 
 export function parseCli(args, { config = {} } = {}) {
   if (args[0] === 'help') args = ['--help', ...args.slice(1)];
@@ -221,9 +256,14 @@ export function parseCli(args, { config = {} } = {}) {
     if (args.length !== 1) throw new Error('Usage: veo version');
     return { version: true };
   }
-  const preliminary = parseArgs({ args, allowPositionals: true, strict: true, allowNegative: true, options: cliOptions() });
-  config = applyProfile(config, preliminary.values.profile);
-  const { values, positionals, tokens } = parseArgs({ args, tokens: true, allowNegative: true, allowPositionals: true, strict: true, options: cliOptions(config) });
+  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;
   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.
@@ -307,8 +347,10 @@ export function parseCli(args, { config = {} } = {}) {
   return options;
 }
 
-export async function main(args = process.argv.slice(2), { config } = {}) {
-  if (args[0] === 'help') args = ['--help', ...args.slice(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 {

package/src/option-suggestions.js

@@ -0,0 +1,43 @@
+// Match misspelled flags without silently accepting them. Ignore punctuation
+// differences first, then allow a small number of insertions or transpositions.
+function editDistance(left, right) {
+  const rows = Array.from({ length: left.length + 1 }, () => Array(right.length + 1).fill(0));
+  for (let i = 0; i <= left.length; i++) rows[i][0] = i;
+  for (let j = 0; j <= right.length; j++) rows[0][j] = j;
+  for (let i = 1; i <= left.length; i++) {
+    for (let j = 1; j <= right.length; j++) {
+      rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1,
+        rows[i - 1][j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1));
+      if (i > 1 && j > 1 && left[i - 1] === right[j - 2] && left[i - 2] === right[j - 1]) {
+        rows[i][j] = Math.min(rows[i][j], rows[i - 2][j - 2] + 1);
+      }
+    }
+  }
+  return rows[left.length][right.length];
+}
+
+export function suggestOption(unknown, options) {
+  const normalized = value => value.toLowerCase().replace(/-/g, '');
+  const target = normalized(unknown);
+  const prefix = unknown.startsWith('--') ? '--' : unknown.startsWith('-') ? '-' : null;
+  const candidates = [...new Set(options)].filter(option => prefix ? option.startsWith(prefix) : !option.startsWith('-'));
+  const ranked = candidates.map(option => ({ option, distance: editDistance(target, normalized(option)) }))
+    .sort((a, b) => a.distance - b.distance || a.option.length - b.option.length);
+  const best = ranked[0];
+  return best && best.distance <= Math.min(3, Math.max(1, Math.floor(target.length / 3))) ? best.option : null;
+}
+
+export function optionSpellings(schema) {
+  return Object.entries(schema).flatMap(([name, details]) => [
+    `--${name}`, ...(details.short ? [`-${details.short}`] : []),
+    ...(details.type === 'boolean' ? [`--no-${name}`] : []),
+  ]);
+}
+
+export function explainUnknownOption(error, schema) {
+  if (error?.code !== 'ERR_PARSE_ARGS_UNKNOWN_OPTION') return error;
+  const unknown = /Unknown option '([^']+)'/.exec(error.message)?.[1];
+  if (!unknown) return error;
+  const suggestion = suggestOption(unknown, optionSpellings(schema));
+  return new Error(`Unknown option "${unknown}".${suggestion ? ` Did you mean "${suggestion}"?` : ' Run veo --help to see available options.'}`, { cause: error });
+}

package/src/source-discovery.js

@@ -5,8 +5,44 @@ import path from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { cleanText, validateUrl } from './utils.js';
 
-const MEDIA_URL = /\.(?:m3u8|mpd|mp4|webm|mov)(?:[?#]|$)/i;
-const MEDIA_TYPE = /(?:mpegurl|dash\+xml|video\/(?:mp4|webm|quicktime))/i;
+const MEDIA_URL = /\.(?:m3u8|mpd|mp4|webm|mov)(?:[?#]|$)/i;
+const MEDIA_TYPE = /(?:mpegurl|dash\+xml|video\/(?:mp4|webm|quicktime))/i;
+const PLAY_CONTROL = String.raw`(() => {
+  const visited = new WeakSet();
+  const state = globalThis[Symbol.for('veo.playControls')] ||= { visited, clicks: 0 };
+  const labelMatches = node => {
+    const label = [node.getAttribute('aria-label'), node.getAttribute('title'), node.getAttribute('data-testid'),
+      node.getAttribute('value'), node.textContent].find(value => value && value.trim())?.trim() || '';
+    return /^(?:play|watch|start|replay|abspielen|ansehen|wiedergabe)(?:\s+(?:video|movie|film|now))?$/i.test(label)
+      || /(?:^|[-_\s])(?:big[-_])?play(?:[-_\s]|$)/i.test(node.className?.baseVal || node.className || '');
+  };
+  const documents = [document];
+  for (let index = 0; index < documents.length && index < 16; index++) {
+    for (const frame of documents[index].querySelectorAll('iframe')) {
+      try { if (frame.contentDocument && !documents.includes(frame.contentDocument)) documents.push(frame.contentDocument); } catch {}
+    }
+  }
+  for (const doc of documents) {
+    const controls = doc.querySelectorAll('button,[role="button"],[aria-label],[title],[data-testid],input[type="button"],input[type="image"],[class*="play"],[class*="Play"]');
+    for (const node of controls) {
+      if (state.clicks >= 8) return false;
+      if (state.visited.has(node) || node.disabled || node.getAttribute('aria-disabled') === 'true' || !labelMatches(node)) continue;
+      const style = doc.defaultView.getComputedStyle(node);
+      if (style.display === 'none' || style.visibility === 'hidden' || style.pointerEvents === 'none' || !node.getClientRects().length) continue;
+      state.visited.add(node);
+      state.clicks++;
+      node.click();
+      return true;
+    }
+    for (const video of doc.querySelectorAll('video')) {
+      if (state.visited.has(video) || !video.paused) continue;
+      state.visited.add(video);
+      video.play().catch(() => {});
+      return true;
+    }
+  }
+  return false;
+})()`;
 
 function abortable(promise, signal) {
   if (!signal) return promise;
@@ -149,19 +185,22 @@ export async function captureBrowserMedia(pageUrl, { signal, browserPaths = brow
       socket.addEventListener('open', resolve, { once: true });
       socket.addEventListener('error', reject, { once: true });
     }), signal);
-    const cdp = createCdp(socket);
-    const responses = new Map();
-    const bodyReads = [];
+    const cdp = createCdp(socket);
+    const responses = new Map();
+    const bodyReads = [];
+    const sessions = new Set();
     const collect = (value, mime = '') => {
       if (!MEDIA_URL.test(value) && !MEDIA_TYPE.test(mime)) return;
       try { urls.add(validateUrl(value)); } catch {}
     };
     cdp.on(message => {
-      if (message.method === 'Target.attachedToTarget') {
-        const attached = message.params.sessionId;
-        cdp.send('Network.enable', {}, attached).catch(() => {});
-        return;
-      }
+      if (message.method === 'Target.attachedToTarget') {
+        const attached = message.params.sessionId;
+        sessions.add(attached);
+        cdp.send('Network.enable', {}, attached).catch(() => {});
+        return;
+      }
+      if (message.method === 'Target.detachedFromTarget') sessions.delete(message.params.sessionId);
       if (message.method === 'Network.requestWillBeSent') collect(message.params.request?.url);
       if (message.method === 'Network.responseReceived') {
         const response = message.params.response;
@@ -182,19 +221,21 @@ export async function captureBrowserMedia(pageUrl, { signal, browserPaths = brow
       }
     });
     await abortable(cdp.send('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: false, flatten: true }), signal);
-    const target = await abortable(cdp.send('Target.createTarget', { url: 'about:blank' }), signal);
-    const attached = await abortable(cdp.send('Target.attachToTarget', { targetId: target.targetId, flatten: true }), signal);
+    const target = await abortable(cdp.send('Target.createTarget', { url: 'about:blank' }), signal);
+    const attached = await abortable(cdp.send('Target.attachToTarget', { targetId: target.targetId, flatten: true }), signal);
+    sessions.add(attached.sessionId);
     await abortable(cdp.send('Network.enable', {}, attached.sessionId), signal);
     await abortable(cdp.send('Page.enable', {}, attached.sessionId), signal);
-    await abortable(cdp.send('Page.navigate', { url: pageUrl }, attached.sessionId), signal);
-    await delay(Math.min(observeMs / 2, 4000), undefined, { signal });
-    await abortable(cdp.send('Runtime.evaluate', { expression: `(() => {
-      for (const video of document.querySelectorAll('video')) video.play().catch(() => {});
-      const buttons = [...document.querySelectorAll('button,[role="button"]')];
-      const play = buttons.find(node => /^(play|watch|abspielen|ansehen|start)(?:\\s+(?:video|movie|film))?$/i.test((node.getAttribute('aria-label') || node.textContent || '').trim()));
-      if (play) play.click();
-    })()`, returnByValue: true }, attached.sessionId).catch(() => {}), signal);
-    await delay(Math.max(1000, observeMs / 2), undefined, { signal });
+    await abortable(cdp.send('Page.navigate', { url: pageUrl }, attached.sessionId), signal);
+    const observeUntil = Date.now() + observeMs;
+    while (Date.now() < observeUntil) {
+      signal?.throwIfAborted();
+      await Promise.allSettled([...sessions].map(sessionId => abortable(cdp.send('Runtime.evaluate', {
+        expression: PLAY_CONTROL, returnByValue: true,
+      }, sessionId), signal)));
+      const remaining = observeUntil - Date.now();
+      if (remaining > 0) await delay(Math.min(300, remaining), undefined, { signal });
+    }
     await Promise.race([Promise.allSettled(bodyReads), delay(1000, undefined, { signal }).catch(() => {})]);
     return [...urls];
   } catch (error) {