veodl 1.12.0 → 2.0.0

package/src/runs.js

@@ -1,346 +0,0 @@
-import { commandOutput } from './output.js';
-import { randomInt, randomUUID } from 'node:crypto';
-import { lstat, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { cacheBase } from './paths.js';
-import { writeJson } from './state.js';
-import { runArchiveFile } from './run-archive.js';
-import { cleanText, localStamp } from './utils.js';
-
-/**
- * Every veo run registers itself under the per-user cache's `runs` directory
- * while it works, so another terminal can list it (`veo runs`), inspect it
- * (`veo runs <id>`) or cancel it (`veo stop <id>`) without guessing at PIDs.
- * Records hold an id, times, URLs, paths and settings — never credentials or
- * cookie settings, and the record itself is always removed when the run ends.
- */
-export const RUN_ID = /^[0-9a-z]{6}$/;
-export const STOP_TIMEOUT_MS = 15000;
-const RECORD = /^[a-f0-9-]{36}\.json$/;
-const ID_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
-const ITEM_STATUSES = new Set(['pending', 'running', 'saved', 'skipped', 'failed', 'cancelled']);
-const SHOWN_ITEMS = 10;
-const OUTPUT_WIDTH = 42;
-
-export const RUNS_HELP = `veo runs [id] [--json]
-
-List active veo runs with their 6-character id, process id, start time and progress.
-With an id, show one run in detail: URLs, media settings, output directory, job file
-and the state of every item. A run appears while it works and disappears when it
-finishes. Records of crashed runs are kept but marked stale.
-Use --json for machine-readable run metadata and per-item progress.
-Use veo stop <id> to stop one run.
-`;
-
-export const STOP_HELP = `veo stop [id]
-
-Ask one run, or every run when no id is given, to stop, and wait until it exits.
-A stopped run keeps its partial data and its retry job, so the printed
-veo --retry-failed command still works; veo flush removes those later.
-Stale records of crashed runs are removed. Exit status is 1 when a run does not
-stop in time.
-`;
-
-export function runsDirectory(root = cacheBase()) {
-  return path.join(path.resolve(root), 'runs');
-}
-
-/**
- * A run record is only trusted when it names a plausible process. Older veo
- * versions wrote nothing but a pid, so a missing version is still accepted.
- */
-function validRecord(run) {
-  if (!run || typeof run !== 'object' || Array.isArray(run)) return false;
-  return (run.version === undefined || run.version === 1) && Number.isInteger(run.pid) && run.pid > 0;
-}
-
-const exists = file => lstat(file).then(() => true, error => { if (error.code === 'ENOENT') return false; throw error; });
-const text = value => typeof value === 'string' ? cleanText(value) : '';
-const newRunId = () => Array.from({ length: 6 }, () => ID_ALPHABET[randomInt(ID_ALPHABET.length)]).join('');
-
-export function alive(pid) {
-  try { process.kill(pid, 0); return true; }
-  catch (error) { return error.code !== 'ESRCH'; }
-}
-
-async function runFiles(root) {
-  const directory = runsDirectory(root);
-  const info = await lstat(directory).catch(error => { if (error.code === 'ENOENT') return null; throw error; });
-  if (!info) return [];
-  if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Invalid active run directory: ${directory}`);
-  return (await readdir(directory, { withFileTypes: true }))
-    .filter(entry => entry.isFile() && RECORD.test(entry.name)).map(entry => path.join(directory, entry.name));
-}
-
-// Cache files are machine-written: a missing, truncated or foreign file must
-// never take a veo command down, so unreadable JSON simply counts as unknown.
-async function readRecordFile(file) {
-  try { return JSON.parse(await readFile(file, 'utf8')); } catch { return null; }
-}
-
-async function readRecords(root) {
-  const records = [];
-  for (const file of await runFiles(root)) {
-    // Damaged or foreign files are ignored, never fatal: a single stray file
-    // must not block every later veo run. Downloads of a run that could not be
-    // recognized stay protected by the staging lock that run holds.
-    const run = await readRecordFile(file);
-    if (!validRecord(run)) continue;
-    records.push({ ...run, id: RUN_ID.test(run.id || '') ? run.id : null, file });
-  }
-  return records;
-}
-
-/** Every registered run, live ones first and then the most recently started. */
-export async function listRuns(root = cacheBase()) {
-  const runs = await readRecords(root);
-  for (const run of runs) run.alive = alive(run.pid);
-  return runs.sort((a, b) => Number(b.alive) - Number(a.alive) || String(b.startedAt || '').localeCompare(String(a.startedAt || '')));
-}
-
-/**
- * Register this process as a run and poll for a stop request. The returned
- * handle exposes the run's id, its resolved settings for `veo runs <id>`, and
- * the cleanup that removes the record when the run ends.
- */
-export async function registerRun(cancel, root = cacheBase()) {
-  const directory = runsDirectory(root);
-  await mkdir(directory, { recursive: true });
-  const gate = path.join(path.resolve(root), '.flush');
-  if (await exists(gate)) throw new Error('veo flush is in progress. Try again after cleanup finishes.');
-  const taken = new Set((await readRecords(root)).map(run => run.id).filter(Boolean));
-  let id = null;
-  for (let attempt = 0; attempt < 20 && !id; attempt++) {
-    const candidate = newRunId();
-    if (!taken.has(candidate) && !await exists(runArchiveFile(candidate, root))) id = candidate;
-  }
-  if (!id) throw new Error('Could not allocate a free run id. Remove stale run records with veo stop or veo flush.');
-  const file = path.join(directory, `${randomUUID()}.json`);
-  const request = `${file}.cancel`;
-  const record = { version: 1, id, pid: process.pid, startedAt: new Date().toISOString(),
-    urls: [], output: null, media: null, quality: null, format: null, profile: null, playlist: false, job: null };
-  await writeJson(file, record);
-  // A flush that started while this run registered must still win.
-  if (await exists(gate)) {
-    await rm(file, { force: true });
-    throw new Error('veo flush is in progress. Try again after cleanup finishes.');
-  }
-  let cancelling = false;
-  const timer = setInterval(() => {
-    if (cancelling) return;
-    exists(request).then(found => {
-      if (found && !cancelling) {
-        cancelling = true;
-        cancel();
-      }
-    }).catch(() => {});
-  }, 200);
-  timer.unref();
-  return {
-    id,
-    file,
-    /** Merge what this run resolved, so other terminals can inspect it. */
-    async describe(details = {}) {
-      Object.assign(record, {
-        urls: (Array.isArray(details.urls) ? details.urls : []).filter(url => typeof url === 'string').slice(0, 200).map(cleanText),
-        output: text(details.output) || null,
-        media: details.audio ? 'audio' : 'video',
-        quality: details.audio ? null : text(details.quality) || null,
-        format: text(details.format) || null,
-        profile: text(details.profile) || null,
-        playlist: Boolean(details.playlist),
-        job: text(details.job) || null,
-      });
-      await writeJson(file, record);
-    },
-    async unregister() {
-      cancelling = true;
-      clearInterval(timer);
-      await rm(file, { force: true });
-      await rm(request, { force: true });
-    },
-  };
-}
-
-/** Per-item progress of a run, read from the job file it writes as it works. */
-async function readProgress(jobFile) {
-  if (!jobFile) return null;
-  const job = await readRecordFile(jobFile);
-  if (job?.version !== 1 || !Array.isArray(job.items)) return null;
-  const items = job.items.map(item => ({
-    url: text(item?.url),
-    status: ITEM_STATUSES.has(item?.status) ? item.status : 'pending',
-    files: (Array.isArray(item?.files) ? item.files : []).map(text).filter(Boolean),
-    error: text(item?.error) || null,
-  }));
-  const counts = { total: items.length, pending: 0, running: 0, saved: 0, skipped: 0, failed: 0, cancelled: 0 };
-  for (const item of items) counts[item.status]++;
-  return { items, counts };
-}
-
-async function describeRuns(root) {
-  const runs = await listRuns(root);
-  return Promise.all(runs.map(async run => ({ ...run, progress: await readProgress(run.job) })));
-}
-
-export function summarizeProgress(progress) {
-  const counts = progress?.counts;
-  if (!counts?.total) return 'starting';
-  const parts = [];
-  const done = counts.saved + counts.skipped;
-  if (done) parts.push(`${done}/${counts.total} done`);
-  if (counts.running) parts.push(`${counts.running} running`);
-  if (counts.failed) parts.push(`${counts.failed} failed`);
-  if (counts.cancelled) parts.push(`${counts.cancelled} cancelled`);
-  if (counts.pending) parts.push(parts.length ? `${counts.pending} pending` : `${counts.total} pending`);
-  return parts.join(', ');
-}
-
-function shortDuration(ms) {
-  if (!Number.isFinite(ms) || ms < 0) return '0s';
-  const seconds = Math.floor(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-  return `${Math.floor(seconds / 3600)}h ${Math.floor(seconds % 3600 / 60)}m`;
-}
-
-const shorten = (value, width = OUTPUT_WIDTH) => value.length <= width ? value : `…${value.slice(-(width - 1))}`;
-const label = run => run.id || `PID ${run.pid}`;
-// Records of older versions have no start time, so no uptime can be shown.
-const uptime = run => Number.isFinite(Date.parse(run.startedAt)) ? shortDuration(Date.now() - Date.parse(run.startedAt)) : null;
-
-function describeMedia(run) {
-  const detail = run.media === 'audio' ? run.format : run.quality;
-  return `${run.media || 'not resolved yet'}${detail ? `, ${detail}` : ''}${run.playlist ? ', playlist' : ''}`;
-}
-
-export function formatRuns(runs) {
-  if (!runs.length) return 'veo runs\n\nNo veo runs are active. Start a download to see it here.\n';
-  const rows = runs.map(run => {
-    const running = uptime(run);
-    return [run.id || '-', String(run.pid), run.alive ? `running${running ? ` ${running}` : ''}` : 'stale',
-      localStamp(run.startedAt), summarizeProgress(run.progress), run.output ? shorten(text(run.output)) : '-'];
-  });
-  const header = ['ID', 'PID', 'STATE', 'STARTED', 'ITEMS', 'OUTPUT'];
-  const widths = header.map((title, index) => Math.max(title.length, ...rows.map(row => row[index].length)));
-  const line = cells => cells.map((cell, index) => cell.padEnd(widths[index])).join('  ').trimEnd();
-  return `${['veo runs', '', line(header), ...rows.map(line), '', 'Details: veo runs <id>    Stop: veo stop [id]'].join('\n')}\n`;
-}
-
-export function formatRunDetails(run) {
-  const lines = [`veo runs ${run.id || '-'}`, ''];
-  const running = uptime(run);
-  lines.push(`State:   ${run.alive ? `running (PID ${run.pid})` : `stale (PID ${run.pid} is gone)`}`);
-  lines.push(`Started: ${localStamp(run.startedAt)}${run.alive && running ? ` (${running} ago)` : ''}`);
-  lines.push(`Media:   ${describeMedia(run)}`);
-  lines.push(`Profile: ${text(run.profile) || 'global (no profile)'}`);
-  lines.push(`Output:  ${text(run.output) || 'not resolved yet'}`);
-  lines.push(`Job:     ${text(run.job) || 'not created yet'}`);
-  const urls = (Array.isArray(run.urls) ? run.urls : []).map(text).filter(Boolean);
-  lines.push(`URLs:    ${urls.length ? `${urls.length}` : 'not resolved yet'}`);
-  urls.slice(0, SHOWN_ITEMS).forEach((url, index) => lines.push(`  ${index + 1}. ${url}`));
-  if (urls.length > SHOWN_ITEMS) lines.push(`  … and ${urls.length - SHOWN_ITEMS} more`);
-  const items = run.progress?.items || [];
-  if (items.length) {
-    lines.push(`Items:   ${summarizeProgress(run.progress)}`);
-    items.slice(0, SHOWN_ITEMS).forEach((item, index) => {
-      const files = item.files.length ? `  ${item.files[0]}${item.files.length > 1 ? ` (+${item.files.length - 1} file(s))` : ''}` : '';
-      lines.push(`  ${String(index + 1).padStart(2)}. ${item.status}${item.status === 'saved' ? files : `  ${item.url}`}`);
-      if (item.error) lines.push(`      ${item.error}`);
-    });
-    if (items.length > SHOWN_ITEMS) lines.push(`  … and ${items.length - SHOWN_ITEMS} more item(s)`);
-  }
-  lines.push('');
-  lines.push(run.alive && run.id ? `Stop:    veo stop ${run.id}` : 'Cleanup: veo stop  (removes stale records)');
-  return `${lines.join('\n')}\n`;
-}
-
-function normalizeId(value) {
-  const id = cleanText(value).toLowerCase();
-  if (!RUN_ID.test(id)) throw new Error(`Invalid run id "${cleanText(value)}". Run ids have 6 characters and are listed by veo runs.`);
-  return id;
-}
-
-export async function runsMain(args = [], { stdout = process.stdout, root = cacheBase() } = {}) {
-  [args, stdout] = commandOutput(args, stdout);
-  if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
-    stdout.write(RUNS_HELP);
-    return 0;
-  }
-  const json = args.includes('--json');
-  args = args.filter(arg => arg !== '--json');
-  if (args.length > 1) throw new Error('Usage: veo runs [id] [--json]');
-  const runs = await describeRuns(root);
-  if (!args.length) {
-    if (json) stdout.write(`${JSON.stringify({ count: runs.length, runs: runs.map(publicRun) })}\n`);
-    else stdout.write(formatRuns(runs));
-    return 0;
-  }
-  const id = normalizeId(args[0]);
-  const run = runs.find(item => item.id === id);
-  if (!run) throw new Error(`No veo run with id ${id} is active. List runs with veo runs.`);
-  if (json) stdout.write(`${JSON.stringify(publicRun(run))}\n`);
-  else stdout.write(formatRunDetails(run));
-  return 0;
-}
-
-function publicRun(run) {
-  return { id: run.id, pid: run.pid, state: run.alive ? 'running' : 'stale', startedAt: run.startedAt || null,
-    urls: Array.isArray(run.urls) ? run.urls : [], output: run.output || null, media: run.media || null,
-    quality: run.quality || null, format: run.format || null, profile: run.profile || null,
-    playlist: Boolean(run.playlist), job: run.job || null,
-    progress: run.progress || null };
-}
-
-/**
- * A run answers a stop request by cleaning up its own record, so a run counts as
- * gone as soon as its record disappears — a live-looking process is not enough
- * (the pid may already belong to something else).
- */
-export async function waitForExit(runs, timeoutMs) {
-  const pending = async () => {
-    for (const run of runs) if (alive(run.pid) && await exists(run.file)) return true;
-    return false;
-  };
-  const deadline = Date.now() + timeoutMs;
-  while (await pending()) {
-    if (Date.now() >= deadline) return false;
-    await delay(100);
-  }
-  return true;
-}
-
-export async function stopMain(args = [], { stdout = process.stdout, root = cacheBase(), timeoutMs = STOP_TIMEOUT_MS } = {}) {
-  [args, stdout] = commandOutput(args, stdout);
-  if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
-    stdout.write(STOP_HELP);
-    return 0;
-  }
-  if (args.length > 1) throw new Error('Usage: veo stop [id]');
-  let targets = await listRuns(root);
-  if (args.length) {
-    const id = normalizeId(args[0]);
-    targets = targets.filter(run => run.id === id);
-    if (!targets.length) throw new Error(`No veo run with id ${id} is active. List runs with veo runs.`);
-  }
-  const stale = targets.filter(run => !run.alive);
-  const live = targets.filter(run => run.alive);
-  for (const run of live) await writeFile(`${run.file}.cancel`, 'stop');
-  if (live.length) await waitForExit(live, timeoutMs);
-  const remaining = [];
-  for (const run of live) if (await exists(run.file) && alive(run.pid)) remaining.push(run);
-  const stopped = live.filter(run => !remaining.includes(run));
-  for (const run of [...stale, ...stopped]) {
-    await rm(run.file, { force: true });
-    await rm(`${run.file}.cancel`, { force: true });
-  }
-  const lines = ['veo stop', ''];
-  if (stopped.length) lines.push(`Stopped: ${stopped.map(label).join(', ')}`);
-  if (stale.length) lines.push(`Removed ${stale.length} stale record(s): ${stale.map(label).join(', ')}`);
-  if (remaining.length) lines.push(`Still running: ${remaining.map(label).join(', ')}`);
-  if (!stopped.length && !stale.length && !remaining.length) lines.push('No veo runs were active.');
-  if (stopped.length) lines.push('', 'Partial data and retry jobs are kept; veo flush removes them.');
-  stdout.write(`${lines.join('\n')}\n`);
-  return remaining.length ? 1 : 0;
-}

package/src/source-discovery.js

@@ -1,303 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-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 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;
-  if (signal.aborted) {
-    Promise.resolve(promise).catch(() => {});
-    throw signal.reason;
-  }
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(signal.reason);
-    signal.addEventListener('abort', onAbort, { once: true });
-    Promise.resolve(promise).then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
-  });
-}
-
-export function parseSourceTimeout(value) {
-  const match = /^(\d+)(ms|s|m)?$/i.exec(String(value || '').trim());
-  if (!match) throw new Error('--timeout expects seconds, e.g. 30, 30s or 2m.');
-  const milliseconds = Number(match[1]) * ({ ms: 1, s: 1000, m: 60000 }[match[2]?.toLowerCase() || 's']);
-  if (!Number.isSafeInteger(milliseconds) || milliseconds < 5000 || milliseconds > 600000) {
-    throw new Error('--timeout must be between 5 seconds and 10 minutes.');
-  }
-  return milliseconds;
-}
-
-export function shouldOfferSourceDiscovery(error) {
-  if (error?.name === 'AbortError') return false;
-  return !/(?:HTTP (?:Error )?(?:401|403|404|429|5\d\d)|\b(?:DRM|live stream|rate limit|timed out|timeout|connection refused|login required|sign in|private video|geo.?block)\b|This URL is a collection)/i
-    .test(String(error?.message || error));
-}
-
-export function browserCandidates() {
-  const custom = process.env.VEO_BROWSER_PATH;
-  if (custom) return [custom];
-  if (process.platform === 'win32') {
-    const roots = [process.env.PROGRAMFILES, process.env['PROGRAMFILES(X86)'], process.env.LOCALAPPDATA].filter(Boolean);
-    return roots.flatMap(root => [
-      path.join(root, 'Google', 'Chrome', 'Application', 'chrome.exe'),
-      path.join(root, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
-      path.join(root, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
-    ]);
-  }
-  if (process.platform === 'darwin') return [
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-    '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
-  ];
-  return ['chromium', 'chromium-browser', 'google-chrome', 'microsoft-edge', 'brave-browser'];
-}
-
-export function mediaUrlsFromText(body) {
-  if (typeof body !== 'string' || body.length > 524288) return [];
-  const normalized = body.replaceAll('\\/', '/').replaceAll('\\u0026', '&').replaceAll('&amp;', '&');
-  const urls = normalized.match(/https?:\/\/[^\s"'<>\\]+/gi) || [];
-  return [...new Set(urls.map(value => value.replace(/[),;]+$/, '')).filter(value => MEDIA_URL.test(value)).map(value => {
-    try { return validateUrl(value); } catch { return null; }
-  }).filter(Boolean))];
-}
-
-export function summarizeSource(metadata, url, index, pageUrl) {
-  const formats = (metadata.formats || []).filter(format => !format.has_drm);
-  const heights = [...new Set(formats.map(format => format.height).filter(Number.isFinite))].sort((a, b) => b - a);
-  const bytes = metadata.filesize || metadata.filesize_approx || null;
-  const bitrate = Number.isFinite(metadata.tbr) ? metadata.tbr : Math.max(0, ...formats.map(format => format.tbr).filter(Number.isFinite));
-  return {
-    index, title: cleanText(metadata.title || metadata.id || 'Video'),
-    source: new URL(url).hostname, type: /\.m3u8(?:[?#]|$)/i.test(url) ? 'HLS' : /\.mpd(?:[?#]|$)/i.test(url) ? 'DASH' : 'Video',
-    quality: heights.length ? heights.map(height => `${height}p`) : [],
-    estimatedMiB: bytes ? Math.round(bytes / 1048576 * 10) / 10 : null,
-    bitrateMbps: bitrate > 0 ? Math.round(bitrate / 100) / 10 : null,
-    pageUrl,
-  };
-}
-
-function createCdp(socket) {
-  let nextId = 0;
-  const pending = new Map();
-  const listeners = new Set();
-  socket.addEventListener('message', event => {
-    let message;
-    try { message = JSON.parse(event.data); } catch { return; }
-    if (message.id) {
-      const entry = pending.get(message.id);
-      if (!entry) return;
-      pending.delete(message.id);
-      if (message.error) entry.reject(new Error(message.error.message));
-      else entry.resolve(message.result || {});
-    } else for (const listener of listeners) listener(message);
-  });
-  socket.addEventListener('close', () => {
-    for (const entry of pending.values()) entry.reject(new Error('Browser connection closed.'));
-    pending.clear();
-  });
-  return {
-    on(listener) { listeners.add(listener); return () => listeners.delete(listener); },
-    send(method, params = {}, sessionId) {
-      const id = ++nextId;
-      const promise = new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
-      socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
-      return promise;
-    },
-  };
-}
-
-async function findDebuggerPort(directory, child, signal) {
-  for (let attempt = 0; attempt < 80; attempt++) {
-    signal?.throwIfAborted();
-    if (child.exitCode !== null) throw new Error('The browser exited before source discovery started.');
-    const text = await readFile(path.join(directory, 'DevToolsActivePort'), 'utf8').catch(() => null);
-    if (text) return Number(text.split(/\r?\n/)[0]);
-    await delay(100, undefined, { signal });
-  }
-  throw new Error('The browser did not start its debugging connection.');
-}
-
-/** Observe media requests in a temporary browser profile; no browser cookies are copied. */
-export async function captureBrowserMedia(pageUrl, { signal, browserPaths = browserCandidates(), observeMs = 8000, deepScan = false } = {}) {
-  const directory = await mkdtemp(path.join(tmpdir(), 'veo-discover-'));
-  let child, socket;
-  const urls = new Set();
-  try {
-    let started = false;
-    for (const executable of browserPaths) {
-      try {
-        child = spawn(executable, ['--headless=new', '--remote-debugging-port=0', `--user-data-dir=${directory}`,
-          '--no-first-run', '--no-default-browser-check', '--autoplay-policy=no-user-gesture-required', 'about:blank'],
-        { stdio: 'ignore', windowsHide: true });
-        await new Promise((resolve, reject) => {
-          child.once('spawn', resolve);
-          child.once('error', reject);
-        });
-        started = true;
-        break;
-      } catch { child = null; }
-    }
-    if (!started) throw new Error('No Chromium-based browser found. Set VEO_BROWSER_PATH to Chrome, Edge or Chromium.');
-    const port = await findDebuggerPort(directory, child, signal);
-    const endpoint = await fetch(`http://127.0.0.1:${port}/json/version`, { signal }).then(response => response.json());
-    socket = new WebSocket(endpoint.webSocketDebuggerUrl);
-    await abortable(new Promise((resolve, reject) => {
-      socket.addEventListener('open', resolve, { once: true });
-      socket.addEventListener('error', reject, { once: true });
-    }), signal);
-    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;
-        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;
-        collect(response.url, response.mimeType);
-        if (/(?:json|javascript|text\/plain)/i.test(response.mimeType || '')) {
-          responses.set(`${message.sessionId || ''}:${message.params.requestId}`, { sessionId: message.sessionId, requestId: message.params.requestId });
-        }
-      }
-      if (message.method === 'Network.loadingFinished') {
-        const key = `${message.sessionId || ''}:${message.params.requestId}`;
-        const response = responses.get(key);
-        if (!response || message.params.encodedDataLength > 524288) return;
-        responses.delete(key);
-        if (!deepScan && bodyReads.length >= 100) return;
-        bodyReads.push(cdp.send('Network.getResponseBody', { requestId: response.requestId }, response.sessionId)
-          .then(result => { if (!result.base64Encoded) for (const url of mediaUrlsFromText(result.body)) urls.add(url); })
-          .catch(() => {}));
-      }
-    });
-    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);
-    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);
-    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)));
-      if (!deepScan && urls.size > 0) break;
-      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) {
-    if (signal?.aborted && ['AbortError', 'TimeoutError'].includes(error?.name)) return [...urls];
-    throw error;
-  } finally {
-    socket?.close();
-    child?.kill();
-    await rm(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch(() => {});
-  }
-}
-
-/** Verify candidates with yt-dlp before offering them to the user. */
-export async function discoverSources(pageUrl, { signal, capture = captureBrowserMedia, inspect, limit = 30,
-  deepScan = false, timeoutMs = deepScan ? 120000 : 45000 } = {}) {
-  signal?.throwIfAborted();
-  const timeout = new AbortController();
-  const timer = setTimeout(() => timeout.abort(new DOMException('Source scan timed out.', 'TimeoutError')), timeoutMs);
-  const scanSignal = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
-  const sources = [];
-  const seen = new Set();
-  const formatReferences = new Map();
-  const mediaKey = value => {
-    try { const address = new URL(value); return `${address.origin}${address.pathname}`; }
-    catch { return null; }
-  };
-  try {
-    const observeMs = deepScan ? Math.min(30000, Math.floor(timeoutMs * 0.6)) : Math.min(8000, Math.floor(timeoutMs * 0.5));
-    let urls;
-    try { urls = await capture(pageUrl, { signal: scanSignal, observeMs, deepScan }); }
-    catch (error) { if (!timeout.signal.aborted) throw error; urls = []; }
-    signal?.throwIfAborted();
-    for (const url of deepScan ? urls : urls.slice(0, limit)) {
-      if (timeout.signal.aborted) break;
-      signal?.throwIfAborted();
-      try {
-        const metadata = await abortable(inspect(url, pageUrl, { signal: scanSignal }), scanSignal);
-        if (metadata.has_drm || metadata.is_live || metadata.formats?.length && metadata.formats.every(format => format.has_drm)
-          || !metadata.formats?.length && !metadata.url) continue;
-        const address = new URL(url);
-        const key = `${address.origin}${address.pathname}:${metadata.id || ''}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        sources.push({ ...summarizeSource(metadata, url, sources.length + 1, pageUrl), url });
-        formatReferences.set(url, new Set((metadata.formats || []).map(format => mediaKey(format.url)).filter(Boolean)));
-      } catch { /* A request alone is not proof of downloadable media. */ }
-    }
-    signal?.throwIfAborted();
-    // A master playlist and its variant streams describe the same video.
-    const distinct = sources.filter(source => !sources.some(other => other !== source
-      && formatReferences.get(other.url)?.has(mediaKey(source.url))));
-    distinct.forEach((source, index) => { source.index = index + 1; });
-    Object.defineProperty(distinct, 'timedOut', { value: timeout.signal.aborted });
-    return distinct;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export function formatSource(source) {
-  const size = source.estimatedMiB === null ? 'Size unknown' : `about ${source.estimatedMiB} MiB`;
-  const bitrate = source.bitrateMbps === null ? '' : ` | ${source.bitrateMbps} Mbit/s`;
-  return `${source.index}. ${source.title} | ${source.source} | ${source.type} | ${source.quality.join(', ') || 'Quality unknown'} | ${size}${bitrate}`;
-}

package/src/state.js

@@ -1,27 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-
-export function digest(value) {
-  return createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 24);
-}
-
-export async function readJson(file, fallback) {
-  try { return JSON.parse(await readFile(file, 'utf8')); }
-  catch (error) { if (error.code === 'ENOENT') return fallback; throw error; }
-}
-
-export async function writeJson(file, value) {
-  await mkdir(path.dirname(file), { recursive: true });
-  const temporary = `${file}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
-    await rename(temporary, file);
-  } finally { await rm(temporary, { force: true }); }
-}
-
-// Do not persist browser sessions or cookie paths in retry jobs.
-export function publicOptions(options) {
-  const { cookies, cookiesFromBrowser, profile, urls, url, retryFailed, batchFile, mediaUrl, ...safe } = options;
-  return { ...safe, output: path.resolve(options.output) };
-}