veodl 1.8.1

package/src/config-template.js

@@ -0,0 +1,171 @@
+import { translateLegacyConfigComments } from './legacy-config-comments.js';
+
+export const TEMPLATE_MARKER = '// veo: commented configuration template';
+
+const PROFILE_OPTIONS_MARKER = '// veo: profile download options v4';
+export const PROFILE_OPTIONS_GUIDE = String.raw`${PROFILE_OPTIONS_MARKER}
+// Any global option can also be placed inside a profile.
+// Copy the settings you want into "profiles" > "default" or a named profile.
+// Remove the leading // on copied settings; separate entries with commas.
+// Speed without reducing the selected video quality:
+// "quality": "best",
+// "concurrentDownloads": 2,    // Parallel URLs/batch items: 1-4; default 2
+// "adaptiveConcurrency": true, // Reduce parallelism and retry transient errors
+// "concurrentFragments": 8,    // DASH/HLS fragments: 1-16; default 8
+// "playlist": true,            // Enable only for playlist downloads
+// "playlistConcurrency": 2,    // Simultaneous entries: 1-4; default 2
+// "checkSpace": true,          // Estimate free cache/output space first
+// "timings": true,             // Show time spent in each phase
+// "color": true,               // Gray details and colored results; false = plain text
+// Applies to veo's own terminal output, including stats/history/doctor.
+// Each profile can set color independently; NO_COLOR always disables styling.
+// Example inside profiles: "plain": { "color": false }
+// Use: veo stats --profile plain or veo URL --profile plain
+// "folderTemplate": "{channel}/{year}",
+// "filenameTemplate": "{index} - {title}", // Without extension; do not combine with rename
+// "resume": true,
+// "skipExisting": true
+// Lossless container change (the selected codecs must fit the container):
+// "format": "mkv",
+// "compatible": false,        // Opt-in H.264/AAC MP4; converts only when needed
+// "recode": false
+// Compatibility profile to add inside profiles:
+// "kompatibel": { "audio": false, "format": "mp4", "compatible": true, "recode": false }
+// Use: veo URL --profile kompatibel (or simply veo URL --compatible).
+// Optional conversion instead: "format": "webm", "recode": true
+// Conversion can be slower and lose quality; recode is for video only.
+// Sequential downloads: "concurrentDownloads": 1, "concurrentFragments": 1, "playlistConcurrency": 1
+// Example named profile inside the profiles object:
+// "fast": { "quality": "best", "concurrentFragments": 8, "playlistConcurrency": 2, "resume": true }
+// Use with: veo URL --profile fast (add --playlist for a playlist URL).
+// Inspect: veo config show --profile fast | Validate: veo config check
+// Template fields: {title}, {id}, {channel}, {year}, {playlist}, {index}.
+// Missing values use Unknown channel/year, No playlist, unknown ID, index 001.
+`;
+
+export const CONFIG_TEMPLATE = String.raw`${TEMPLATE_MARKER}
+// Save and close the editor. Settings apply the next time you run veo.
+// Comments using // or /* ... */ are supported. Command-line options take priority.
+// To enable an option, remove its leading // and adjust the value.
+// Separate active entries with commas. Do not add a comma after the last entry.
+{
+  // Output directory: use / or double backslashes, for example "D:\\Videos".
+  // Without output, downloads are saved in the current working directory.
+  // "output": "D:/Videos",
+  // Filename without extension. Every * inserts the original video title.
+  // "rename": "movie_*",
+
+  // Maximum video resolution: best, 2160p, 1440p, 1080p, 720p, ...
+  // "quality": "1080p",
+  // Video format: mp4, mkv, webm, mov. Lossless remux; codecs must fit the container.
+  // "format": "mp4",
+  // "recode": false,           // Explicit video conversion; may lose quality
+  // "playlistConcurrency": 2, // Concurrent playlist entries: 1 to 4
+  // "open": false,              // Open the completed file automatically
+  // "resume": true,             // Resume interrupted downloads
+  // "skipExisting": true,       // Skip previously saved downloads
+  // "concurrentFragments": 8,   // Concurrent fragments: 1 to 16; default 8
+
+  // Subtitles and additional information:
+  // "subLangs": "de,en",        // Enable subtitles for these languages
+  // "embedSubs": true,          // Embed subtitles in the video
+  // "embedMetadata": true,      // Embed the title, date and other metadata
+  // "embedThumbnail": true,     // Embed the thumbnail
+
+  // The default profile is used automatically unless you select another profile.
+${PROFILE_OPTIONS_GUIDE}
+  // Select other profiles with --profile NAME or in the interactive wizard.
+  // Example: veo "https://example.com/video.mp4" --profile music
+  "profiles": {
+    "default": {
+      // "color": true, // Set false to disable terminal styling for this profile.
+      // Add everyday defaults here, for example: "quality": "1080p"
+      // Empty means use the global settings above and veo's built-in defaults.
+    },
+    "kompatibel": {
+      "audio": false,
+      "format": "mp4",
+      "compatible": true,
+      "recode": false
+    },
+    "music": {
+      // Audio only. Formats: mp3, m4a, aac, opus, flac, wav.
+      "audio": true,
+      "format": "mp3"
+    },
+    "archive": {
+      "quality": "1080p",
+      "embedMetadata": true,
+      "subLangs": "de,en"
+    }
+  }
+}
+`;
+
+// Remove comments only outside JSON strings. Whitespace replacement preserves
+// token boundaries, so malformed input cannot become valid by joining tokens.
+export function stripConfigComments(text) {
+  text = text.replace(/^\uFEFF/, '');
+  let result = '', quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (quoted) {
+      result += char;
+      if (char === '\\' && i + 1 < text.length) result += text[++i];
+      else if (char === '"') quoted = false;
+    } else if (char === '"') { quoted = true; result += char; }
+    else if (char === '/' && text[i + 1] === '/') {
+      result += '  '; i++;
+      while (i + 1 < text.length && !'\r\n'.includes(text[i + 1])) { result += ' '; i++; }
+    } else if (char === '/' && text[i + 1] === '*') {
+      const commentStart = i;
+      result += '  '; i++;
+      let closed = false;
+      while (++i < text.length) {
+        if (text[i] === '*' && text[i + 1] === '/') { result += '  '; i++; closed = true; break; }
+        result += '\r\n'.includes(text[i]) ? text[i] : ' ';
+      }
+      if (!closed) throw Object.assign(new Error('Unterminated block comment; add */ to close it.'), { position: commentStart });
+    } else result += char;
+  }
+  return result;
+}
+
+export function withConfigTemplate(text) {
+  text = translateLegacyConfigComments(text);
+  text = addDefaultProfile(text);
+  if (!text.replace(/^\uFEFF/, '').trim()) return CONFIG_TEMPLATE;
+  if (text.replace(/^\uFEFF/, '').startsWith(TEMPLATE_MARKER)) {
+    // Upgrade the commented reference in older configs without changing settings.
+    if (!text.includes(PROFILE_OPTIONS_MARKER)) return text.replace(TEMPLATE_MARKER, `${TEMPLATE_MARKER}\n${PROFILE_OPTIONS_GUIDE}`);
+    return text;
+  }
+  // Keep existing settings and formatting byte-for-byte after a commented guide.
+  return `${TEMPLATE_MARKER}\n// Reference: copy any examples you need into your existing configuration below.\n${CONFIG_TEMPLATE.split('\n').slice(1).map(line => `// ${line}`).join('\n')}\n// Your existing settings:\n${text.replace(/^\uFEFF/, '')}`;
+}
+
+function addDefaultProfile(text) {
+  // Insert only the missing profile, preserving user comments and formatting.
+  let clean, config;
+  try { clean = stripConfigComments(text); config = JSON.parse(clean); } catch { return text; }
+  if (!config || Array.isArray(config) || typeof config !== 'object') return text;
+  if (config.profiles && Object.hasOwn(config.profiles, 'default')) return text;
+  if (config.profiles !== undefined && (!config.profiles || Array.isArray(config.profiles) || typeof config.profiles !== 'object')) return text;
+  text = text.replace(/^\uFEFF/, '');
+  // Track depth to find the top-level profiles object, never a profile named profiles.
+  let depth = 0;
+  const tokens = /"(?:\\.|[^"\\])*"|[{}]/g;
+  for (const token of clean.matchAll(tokens)) {
+    if (token[0] === '{') depth++;
+    else if (token[0] === '}') depth--;
+    else if (depth === 1 && token[0] === '"profiles"') {
+      const after = token.index + token[0].length;
+      const match = /^\s*:\s*\{/.exec(clean.slice(after));
+      if (!match) continue;
+      const index = after + match[0].length;
+      return text.slice(0, index) + '\n    // Used automatically when no other profile is selected.\n    "default": {}' + (Object.keys(config.profiles).length ? ',' : '') + '\n' + text.slice(index);
+    }
+  }
+  const index = clean.indexOf('{') + 1;
+  return text.slice(0, index) + '\n  // Used automatically when no other profile is selected.\n  "profiles": { "default": {} }' + (Object.keys(config).length ? ',' : '') + '\n' + text.slice(index);
+}

package/src/config.js

@@ -0,0 +1,213 @@
+import { commandOutput } from './output.js';
+import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { configBase } from './paths.js';
+import { configSyntaxError } from './config-errors.js';
+import { CONFIG_TEMPLATE, stripConfigComments, withConfigTemplate } from './config-template.js';
+
+/**
+ * Keys accepted in the config file, with the CLI flag they act as a default for.
+ * Everything here is a default only: an explicit command-line flag always wins.
+ */
+export const CONFIG_KEYS = Object.freeze({
+  concurrentDownloads: 'number',
+  adaptiveConcurrency: 'boolean',
+  filenameTemplate: 'string',
+  folderTemplate: 'string',
+  checkSpace: 'boolean',
+  timings: 'boolean',
+  color: 'boolean',
+  output: 'string',
+  quality: 'string',
+  format: 'string',
+  compatible: 'boolean',
+  recode: 'boolean',
+  playlistConcurrency: 'number',
+  rename: 'string',
+  audio: 'boolean',
+  open: 'boolean',
+  resume: 'boolean',
+  closestQuality: 'boolean',
+  cookies: 'string',
+  cookiesFromBrowser: 'string',
+  playlist: 'boolean',
+  concurrentFragments: 'number',
+  subs: 'boolean',
+  subLangs: 'string',
+  embedSubs: 'boolean',
+  embedMetadata: 'boolean',
+  embedThumbnail: 'boolean',
+  sponsorblockRemove: 'string',
+  section: 'string',
+  json: 'boolean',
+  skipExisting: 'boolean',
+  playlistItems: 'string',
+});
+
+export function configFile({ env = process.env } = {}) {
+  const override = env.VEO_CONFIG;
+  if (typeof override === 'string' && override.trim()) {
+    if (override.includes('\0')) throw new Error('VEO_CONFIG must be a filesystem path.');
+    return path.resolve(override.trim());
+  }
+  return path.join(configBase({ env }), 'config.json');
+}
+
+function typeOf(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'array';
+  return typeof value;
+}
+
+/**
+ * Read optional user defaults. A missing file is not an error; a malformed one
+ * is reported loudly, because silently ignoring a typo would be worse.
+ */
+export async function loadConfig({ env = process.env, file } = {}) {
+  const target = file || configFile({ env });
+  let text;
+  try {
+    text = await readFile(target, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return { file: target, exists: false, config: {}, warnings: [] };
+    throw new Error(`Cannot read the veo config file ${target}: ${error.message}`);
+  }
+  return parseConfigText(text, target);
+}
+
+export function parseConfigText(text, target = 'config') {
+  let data;
+  let clean = text.replace(/^\uFEFF/, '');
+  try {
+    clean = stripConfigComments(text);
+    data = JSON.parse(clean);
+  } catch (error) {
+    throw configSyntaxError(clean, target, error);
+  }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error(`The veo config file must contain a JSON object: ${target}`);
+  }
+  const warnings = [];
+  const config = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (key === '$schema') continue;
+    if (key === 'profiles') {
+      if (!value || typeOf(value) !== 'object') throw new Error('Config profiles must be an object.');
+      config.profiles = Object.create(null);
+      for (const [name, profile] of Object.entries(value)) {
+        if (!profile || typeOf(profile) !== 'object') throw new Error(`Profile "${name}" must be an object.`);
+        const checked = {};
+        for (const [setting, item] of Object.entries(profile)) {
+          if (!Object.hasOwn(CONFIG_KEYS, setting)) throw new Error(`Unknown setting "${setting}" in profile "${name}".`);
+          if (typeOf(item) !== CONFIG_KEYS[setting]) throw new Error(`Profile "${name}": "${setting}" must be a ${CONFIG_KEYS[setting]}.`);
+          checked[setting] = item;
+        }
+        config.profiles[name] = checked;
+      }
+      continue;
+    }
+    const expected = CONFIG_KEYS[key];
+    if (!expected) {
+      warnings.push(`Unknown config key "${key}" in ${target} was ignored.`);
+      continue;
+    }
+    if (typeOf(value) !== expected) {
+      throw new Error(`Config key "${key}" must be a ${expected}, not a ${typeOf(value)} (${target}).`);
+    }
+    config[key] = value;
+  }
+  return { file: target, exists: true, config, warnings };
+}
+
+export function applyProfile(config, name) {
+  const { profiles, ...defaults } = config;
+  if (!name) {
+    if (!profiles || !Object.hasOwn(profiles, 'default')) return defaults;
+    name = 'default';
+  }
+  if (!profiles || !Object.hasOwn(profiles, name)) throw new Error(`Unknown profile "${name}". Available: ${Object.keys(profiles || {}).join(', ') || 'none'}. Use veo config edit.`);
+  return { ...defaults, ...profiles[name] };
+}
+
+export async function prepareConfigEdit(file) {
+  await mkdir(path.dirname(file), { recursive: true });
+  try { await writeFile(file, CONFIG_TEMPLATE, { flag: 'wx', mode: 0o600 }); }
+  catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    const original = await readFile(file, 'utf8');
+    const annotated = withConfigTemplate(original);
+    if (annotated !== original) await writeFile(file, annotated, 'utf8');
+  }
+}
+
+export async function configMain(args) {
+  const editorColor = !args.includes('--no-color') && !Object.hasOwn(process.env, 'NO_COLOR');
+  let stdout;
+  [args, stdout] = commandOutput(args, process.stdout);
+  if (args[0] === 'show') stdout = process.stdout;
+  const file = configFile();
+  if (args[0] === 'reset') {
+    if (args.length !== 1) throw new Error('Usage: veo config reset');
+    return (await import('./config-reset.js')).resetConfig(file, { output: stdout });
+  }
+  if (['check', 'show'].includes(args[0])) {
+    const { parseArgs } = await import('node:util');
+    const { values, positionals } = parseArgs({ args: args.slice(1), allowPositionals: true, options: { profile: { type: 'string' } } });
+    if (positionals.length) throw new Error('Usage: veo config check|show [--profile NAME]');
+    const loaded = await loadConfig({ file });
+    if (loaded.warnings.length) throw new Error(loaded.warnings.join('\n'));
+    if (args[0] === 'show') {
+      const effective = await effectiveConfig(loaded.config, values.profile);
+      stdout.write(`${JSON.stringify(effective, null, 2)}\n`);
+    } else {
+      const names = values.profile ? [values.profile] : [undefined, ...Object.keys(loaded.config.profiles || {})];
+      for (const name of names) {
+        try { await effectiveConfig(loaded.config, name); }
+        catch (error) { throw new Error(`Profile ${name || 'default/global'}: ${error.message}`); }
+      }
+      stdout.write(`Config OK: ${file} (${names.length} effective configurations checked).\n`);
+    }
+    return 0;
+  }
+  let editorMode;
+  if (args[0] === 'edit') {
+    if (args.length > 2 || (args[1] && !['--external', '--terminal'].includes(args[1]))) throw new Error('Usage: veo config edit [--external|--terminal]');
+    editorMode = args[1]?.slice(2) || process.env.VEO_CONFIG_EDITOR || 'auto';
+    if (!['auto', 'external', 'terminal'].includes(editorMode)) throw new Error('VEO_CONFIG_EDITOR must be auto, external or terminal.');
+  } else if (args.length !== 1 || !['path', 'profiles'].includes(args[0])) throw new Error('Usage: veo config edit|path|profiles|check|show|reset');
+  if (args[0] === 'path') { stdout.write(`${file}\n`); return 0; }
+  if (args[0] === 'profiles') {
+    const loaded = await loadConfig();
+    stdout.write(`${Object.keys(loaded.config.profiles || {}).join('\n') || 'No profiles configured. Use veo config edit.'}\n`);
+    return 0;
+  }
+  await prepareConfigEdit(file);
+  if (editorMode === 'terminal' || (editorMode === 'auto' && !process.env.VISUAL && !process.env.EDITOR && process.stdin.isTTY && process.stdout.isTTY)) {
+    const { editConfig } = await import('./config-editor.js');
+    await editConfig(file, { color: editorColor });
+    return 0;
+  }
+  // Treat the editor as an executable path, never as shell code.
+  const editor = process.env.VISUAL || process.env.EDITOR || (process.platform === 'win32' ? 'notepad.exe' : 'vi');
+  await new Promise((resolve, reject) => {
+    const child = spawn(editor, [file], { shell: false, stdio: 'inherit', windowsHide: true });
+    child.on('error', () => reject(new Error(`Could not launch editor. Set EDITOR to an executable path or edit ${file}.`)));
+    child.on('close', code => code === 0 ? resolve() : reject(new Error(`Editor exited with ${code}. Config: ${file}`)));
+  });
+  await loadConfig();
+  return 0;
+}
+
+export async function effectiveConfig(config, profile) {
+  const { parseCli } = await import('./cli.js');
+  const selected = applyProfile(config, profile);
+  // Inspection is offline and never prints credential file paths or browser profiles.
+  const { cookies, cookiesFromBrowser, ...safe } = selected;
+  const parsed = parseCli(['https://example.invalid/config-check'], { config: safe });
+  const result = Object.fromEntries(Object.keys(CONFIG_KEYS).filter(key => parsed[key] !== undefined).map(key => [key, parsed[key]]));
+  result.output = path.resolve(result.output);
+  if (cookies !== undefined) result.cookies = '[configured]';
+  if (cookiesFromBrowser !== undefined) result.cookiesFromBrowser = '[configured]';
+  return result;
+}

package/src/disk-space.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { stat, statfs } from 'node:fs/promises';
+
+const reservations = new Map();
+export function estimateMediaBytes(metadata, options = {}) {
+  const size = format => {
+    const direct = format.filesize || format.filesize_approx;
+    if (Number.isFinite(direct) && direct > 0) return direct;
+    return Number.isFinite(format.tbr) && metadata.duration > 0 ? format.tbr * 1000 / 8 * metadata.duration : 0;
+  };
+  if (size(metadata)) return Math.ceil(size(metadata));
+  const target = options.quality && options.quality !== 'best' ? parseInt(options.quality, 10) : Infinity;
+  const formats = (metadata.formats || []).filter(format => !format.has_drm && (options.closestQuality || !format.height || format.height <= target));
+  const video = formats.filter(format => format.vcodec !== 'none');
+  const audio = formats.filter(format => format.vcodec === 'none' && format.acodec !== 'none');
+  const bestVideo = Math.max(0, ...video.map(size));
+  const bestAudio = Math.max(0, ...audio.map(size));
+  if (options.audio) return bestAudio ? Math.ceil(bestAudio) : null;
+  if (!bestVideo) return null;
+  // Separate video needs an audio estimate too; otherwise the total is unknown.
+  if (video.some(format => format.acodec === 'none') && !bestAudio) return null;
+  return Math.ceil(bestVideo + bestAudio);
+}
+
+async function volume(directory) {
+  let current = path.resolve(directory);
+  while (true) {
+    try {
+      const info = await stat(current);
+      if (info.isDirectory()) {
+        const fs = await statfs(current);
+        return { key: String(info.dev), free: fs.bavail * fs.bsize };
+      }
+    } catch (error) { if (!['ENOENT', 'ENOTDIR'].includes(error.code)) throw error; }
+    const parent = path.dirname(current);
+    if (parent === current) throw new Error('No existing parent directory.');
+    current = parent;
+  }
+}
+
+export async function reserveSpace({ cache, destination, bytes, cached = false, reporter, inspect = volume } = {}) {
+  let cacheVolume, outputVolume;
+  try { [cacheVolume, outputVolume] = await Promise.all([inspect(cache), inspect(destination)]); }
+  catch { reporter?.status('Free-space check unavailable on this filesystem; continuing.'); return () => {}; }
+  if (!Number.isFinite(bytes) || bytes <= 0) {
+    reporter?.status(`Size unknown; free space: cache ${(cacheVolume.free / 1073741824).toFixed(1)} GiB, destination ${(outputVolume.free / 1073741824).toFixed(1)} GiB.`);
+    return () => {};
+  }
+  // Allow space for temporary merge output and destination copy. Conservative even
+  // when the filesystem can hard-link; conversion sizes remain estimates.
+  const needs = new Map();
+  for (const [volume, amount] of [[cacheVolume, cached ? 0 : bytes * 2], [outputVolume, bytes]]) {
+    const entry = needs.get(volume.key) || { free: volume.free, bytes: 0 };
+    entry.free = Math.min(entry.free, volume.free); entry.bytes += amount;
+    needs.set(volume.key, entry);
+  }
+  for (const [key, need] of needs) {
+    const available = need.free - (reservations.get(key) || 0);
+    if (available < need.bytes) throw new Error(`Not enough disk space: approximately ${(need.bytes / 1048576).toFixed(1)} MiB needed including temporary files; ${(Math.max(0, available) / 1048576).toFixed(1)} MiB available after active downloads.`);
+  }
+  for (const [key, need] of needs) reservations.set(key, (reservations.get(key) || 0) + need.bytes);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    for (const [key, need] of needs) { const remaining = (reservations.get(key) || 0) - need.bytes; if (remaining > 0) reservations.set(key, remaining); else reservations.delete(key); }
+  };
+}