veodl 1.9.0 → 1.10.0

package/src/config.js

@@ -4,13 +4,13 @@ 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';
+import { CONFIG_TEMPLATE, CONFIG_GUIDE, stripConfigComments } 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({
+export const CONFIG_KEYS = Object.freeze({
   concurrentDownloads: 'number',
   adaptiveConcurrency: 'boolean',
   filenameTemplate: 'string',
@@ -47,7 +47,9 @@ export const CONFIG_KEYS = Object.freeze({
   timeout: 'string',
   listSources: 'boolean',
   autoListSources: 'boolean',
-});
+});
+
+export const RESERVED_PROFILE_NAMES = Object.freeze(['list', 'reset']);
 
 export function configFile({ env = process.env, platform = process.platform } = {}) {
   const override = env.VEO_CONFIG;
@@ -94,13 +96,19 @@ export function parseConfigText(text, target = 'config') {
   }
   const warnings = [];
   const config = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (key === '$schema') continue;
+  for (const [key, value] of Object.entries(data)) {
+    if (key === '$schema') continue;
+    if (key === 'activeProfile') {
+      if (typeOf(value) !== 'string' || !value) throw new Error(`Config key "activeProfile" must be a non-empty string (${target}).`);
+      config.activeProfile = value;
+      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.`);
+      config.profiles = Object.create(null);
+      for (const [name, profile] of Object.entries(value)) {
+        if (RESERVED_PROFILE_NAMES.includes(name)) throw new Error(`Profile name "${name}" is reserved for veo profile ${name}. Rename it in ${target}.`);
+        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}".`);
@@ -119,20 +127,95 @@ export function parseConfigText(text, target = 'config') {
     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] };
-}
+    config[key] = value;
+  }
+  if (config.activeProfile && !Object.hasOwn(config.profiles || {}, config.activeProfile)) {
+    throw new Error(`Unknown active profile "${config.activeProfile}" in ${target}. Available: ${Object.keys(config.profiles || {}).join(', ') || 'none'}.`);
+  }
+  return { file: target, exists: true, config, warnings };
+}
+
+export function selectedProfileName(config, name) {
+  return name || config.activeProfile || (Object.hasOwn(config.profiles || {}, 'default') ? 'default' : undefined);
+}
+
+export function applyProfile(config, name) {
+  const { profiles, activeProfile, ...defaults } = config;
+  name = selectedProfileName(config, name);
+  if (!name) return defaults;
+  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 profileMain(args, { file = configFile(), output = process.stdout } = {}) {
+  if (args.length > 1 || args[0]?.startsWith('-')) throw new Error('Usage: veo profile [list|reset|NAME]');
+  const loaded = await loadConfig({ file });
+  if (!args.length) {
+    output.write(`Active profile: ${selectedProfileName(loaded.config) || 'global (no profile)'}\n`);
+    output.write(`Available: ${Object.keys(loaded.config.profiles || {}).join(', ') || 'none'}\n`);
+    return 0;
+  }
+  if (args[0] === 'list' && args.length === 1) {
+    const names = Object.keys(loaded.config.profiles || {});
+    if (!names.length) output.write('No profiles configured. Use veo config edit.\n');
+    else {
+      const active = selectedProfileName(loaded.config);
+      output.write(`Profiles:\n${active ? '' : '* global (no profile)\n'}${names.map(name => `${name === active ? '* ' : '  '}${name}${name === active ? ' (active)' : ''}`).join('\n')}\n`);
+    }
+    return 0;
+  }
+  const reset = args[0] === 'reset' && args.length === 1;
+  const name = args[0];
+  if (!reset) {
+    applyProfile(loaded.config, name);
+    await effectiveConfig(loaded.config, name);
+  }
+  if (!loaded.exists) {
+    output.write('Active profile: global (no profile)\n');
+    return 0;
+  }
+  const original = await readFile(file, 'utf8');
+  // Token locations come from the comment-aware parser, preserving hand-written notes.
+  const { configSource } = await import('./config-diagnostics.js');
+  const { nodes } = configSource(original);
+  const property = nodes.get(JSON.stringify(['activeProfile']));
+  let updated;
+  if (reset) {
+    if (!property) updated = original;
+    else {
+      const clean = (original.startsWith('\uFEFF') ? ' ' : '') + stripConfigComments(original);
+      let start = property.keyStart, end = property.end;
+      while (/\s/.test(clean[end] || '')) end++;
+      if (clean[end] === ',') end++;
+      else {
+        let before = start - 1;
+        while (before >= 0 && /\s/.test(clean[before])) before--;
+        if (clean[before] === ',') start = before;
+        end = property.end;
+      }
+      updated = original.slice(0, start) + original.slice(end);
+    }
+  } else if (property) updated = original.slice(0, property.start) + JSON.stringify(name) + original.slice(property.end);
+  else {
+    const root = nodes.get('[]');
+    const clean = (original.startsWith('\uFEFF') ? ' ' : '') + stripConfigComments(original);
+    const first = root.start + 1 + clean.slice(root.start + 1, root.end - 1).search(/\S/);
+    const empty = first === root.start;
+    const newline = original.includes('\r\n') ? '\r\n' : '\n';
+    const position = empty ? root.end - 1 : first;
+    const indent = empty ? '  ' : /^[ \t]*$/.test(original.slice(original.lastIndexOf('\n', position - 1) + 1, position))
+      ? original.slice(original.lastIndexOf('\n', position - 1) + 1, position) : '';
+    updated = original.slice(0, position) + (empty ? `${newline}${indent}` : '') +
+      `"activeProfile": ${JSON.stringify(name)}${empty ? `${newline}` : `,${newline}${indent}`}` + original.slice(position);
+  }
+  parseConfigText(updated, file);
+  if (updated !== original) {
+    if (await readFile(file, 'utf8') !== original) throw new Error('Config changed while switching profiles. Try again.');
+    await writeFile(file, updated, 'utf8');
+  }
+  output.write(`Active profile: ${reset ? selectedProfileName(parseConfigText(updated, file).config) || 'global (no profile)' : name}\n`);
+  return 0;
+}
 
 export async function prepareConfigEdit(file) {
   await mkdir(path.dirname(file), { recursive: true });
@@ -140,8 +223,7 @@ export async function prepareConfigEdit(file) {
   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');
+    if (!original.replace(/^\uFEFF/, '').trim()) await writeFile(file, CONFIG_TEMPLATE, 'utf8');
   }
 }
 
@@ -149,7 +231,7 @@ 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;
+  if (args[0] === 'show' || args[0] === 'guide') stdout = process.stdout;
   const file = configFile();
   if (args[0] === 'reset') {
     if (args.length !== 1) throw new Error('Usage: veo config reset');
@@ -179,8 +261,9 @@ export async function configMain(args) {
     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; }
+  } else if (args.length !== 1 || !['path', 'profiles', 'guide'].includes(args[0])) throw new Error('Usage: veo config edit|path|profiles|guide|check|show|reset');
+  if (args[0] === 'path') { stdout.write(`${file}\n`); return 0; }
+  if (args[0] === 'guide') { stdout.write(CONFIG_GUIDE); 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`);

package/src/downloader.js

@@ -1,5 +1,5 @@
 import { ensureCompatibility } from './compatibility.js';
-import { adaptiveRun, reducedLimit, phaseTimer, formatTimings } from './execution.js';
+import { adaptiveRun, reducedLimit, phaseTimer } from './execution.js';
 import { mediaDestination, prepareDestination } from './naming.js';
 import { estimateMediaBytes, reserveSpace } from './disk-space.js';
 import { spawn } from 'node:child_process';
@@ -288,20 +288,26 @@ export async function fetchMetadata(options, { signal, backend, runner, reporter
   const args = [...common, '--dump-single-json', '--skip-download'];
   if (options.playlist && !options._entryIndex) args.push('--flat-playlist');
   args.push('--', options.mediaUrl || options.url);
-  let metadata = JSON.parse(await runner(backend.ytDlp, args, { signal }));
-  if (options._entryIndex && metadata.entries) metadata = metadata.entries.find(Boolean);
-  if (!metadata) throw new Error('The selected playlist entry is unavailable.');
-  if (!options.playlist && (metadata._type === 'playlist' || metadata.entries)) {
-    throw new Error('This URL is a collection. Add --playlist to download every entry.');
-  }
-  if (metadata.is_live) throw new Error('Live streams are not supported. Please use a finished video.');
-  if (metadata.has_drm) throw new Error('This content is DRM-protected.');
-  return metadata;
-}
-
-export async function prepareBackend(options, { signal, backendResolver = resolveBackend, reporter } = {}) {
-  return backendResolver({ signal, onStatus: message => reporter?.status(message) });
-}
+  try {
+    let metadata = JSON.parse(await runner(backend.ytDlp, args, { signal }));
+    if (options._entryIndex && metadata.entries) metadata = metadata.entries.find(Boolean);
+    if (!metadata) throw new Error('The selected playlist entry is unavailable.');
+    if (!options.playlist && (metadata._type === 'playlist' || metadata.entries)) {
+      throw new Error('This URL is a collection. Add --playlist to download every entry.');
+    }
+    if (metadata.is_live) throw new Error('Live streams are not supported. Please use a finished video.');
+    if (metadata.has_drm) throw new Error('This content is DRM-protected.');
+    reporter?.finishStatus?.('Reading video…', 'done');
+    return metadata;
+  } catch (error) {
+    if (!signal?.aborted && error?.name !== 'AbortError') reporter?.finishStatus?.('Reading video…', 'failed');
+    throw error;
+  }
+}
+
+export async function prepareBackend(options, { signal, backendResolver = resolveBackend, reporter } = {}) {
+  return backendResolver({ signal, onStatus: message => reporter?.status(message), onStatusDone: (message, outcome) => reporter?.finishStatus?.(message, outcome) });
+}
 
 /** The extension the finished file will most likely have, for previews. */
 export function predictedExtension(options) {
@@ -411,10 +417,10 @@ async function downloadCollection(options, metadata, dependencies) {
  */
 export async function download(options, { signal, reporter, backendResolver = resolveBackend, runner = runBackend, onEntry, localRoot = downloadCacheRoot(), skipCacheCleanup = false, adaptiveState = { divisor: 1 }, wait, diskChecker = reserveSpace, now, compatibilityRunner = runBackend } = {}) {
   const timer = phaseTimer(now);
-  const timingResult = () => {
-    if (options.timings === false) return {};
-    const timings = timer.result(); reporter?.status(formatTimings(timings)); return { timings };
-  };
+  const timingResult = () => {
+    if (options.timings === false) return {};
+    return { timings: timer.result() };
+  };
   let directory = path.resolve(options.output);
   localRoot = path.resolve(localRoot);
   if (!skipCacheCleanup) await cleanupDownloadCache(localRoot);
@@ -548,8 +554,9 @@ export async function download(options, { signal, reporter, backendResolver = re
     }
     await writeJson(historyFile, { version: 1, source: sourceKey(metadata, options.url), settings: downloadSettings(options), files });
     return { url: options.url, title: metadata.title || metadata.id || 'video', files, status: 'saved', saved: 1, skipped: 0, ...timingResult() };
-  } catch (error) {
-    // A kept staging directory is the whole point of --resume, and cancellation
+  } catch (error) {
+    if (!signal?.aborted) reporter?.failStep?.();
+    // A kept staging directory is the whole point of --resume, and cancellation
     // is the most common reason to want one.
     keepPartial = Boolean(options.resume || manifest?.ready?.length || unconfirmedOutput);
     if (manifest && unconfirmedOutput) manifest.unconfirmedOutput = true;

package/src/interactive.js

@@ -1,7 +1,7 @@
 import { outputStream, formatOutput } from './output.js';
 import { createInterface } from 'node:readline/promises';
 import { availableHeights, cleanText, validateUrl } from './utils.js';
-import { applyProfile } from './config.js';
+import { applyProfile, selectedProfileName } from './config.js';
 import { fetchMetadata, prepareBackend, runBackend } from './downloader.js';
 import { describeEstimate, selectedEntries, sizeEstimate, validateItems } from './playlist.js';
 
@@ -25,9 +25,9 @@ export async function interactiveArgs(config, { signal, input = process.stdin, o
     const profiles = Object.keys(config.profiles || {});
     let defaults = applyProfile(config);
     if (profiles.length) {
-      const hasDefault = profiles.includes('default');
-      const choices = hasDefault ? profiles : [...profiles, 'none'];
-      const fallback = hasDefault ? 'default' : 'none';
+      const selected = selectedProfileName(config);
+      const choices = selected ? profiles : [...profiles, 'none'];
+      const fallback = selected || 'none';
       const profile = await choose(`Profile (${choices.join(', ')}) [${fallback}]: `, choices, fallback);
       if (profile !== 'none') { args.push('--profile', profile); defaults = applyProfile(config, profile); }
     }
@@ -53,24 +53,24 @@ export async function interactiveArgs(config, { signal, input = process.stdin, o
     } catch (originalError) {
       const { discoverSources, formatSource, parseSourceTimeout, shouldOfferSourceDiscovery } = await import('./source-discovery.js');
       if (!shouldOfferSourceDiscovery(originalError)) throw originalError;
-      if (!defaults.autoListSources) {
-        const answer = (await question('No downloadable video found. Search this page for other sources? (y/N): ')).trim().toLowerCase();
-        if (!['y', 'yes'].includes(answer)) throw originalError;
-      }
+      if (defaults.autoListSources === false) throw originalError;
       const inspectSource = (mediaUrl, _page, { signal: scanSignal = signal } = {}) => inspect
         ? inspect({ ...inspectionOptions, playlist: false, mediaUrl }, scanSignal)
         : fetchMetadata({ ...inspectionOptions, playlist: false, mediaUrl }, { signal: scanSignal, backend, runner: runBackend });
-      const sources = await (discover || discoverSources)(url, { signal, inspect: inspectSource,
-        deepScan: defaults.deepScan, timeoutMs: defaults.timeout ? parseSourceTimeout(defaults.timeout) : undefined }).catch(() => []);
-      if (!sources.length) throw originalError;
-      for (const source of sources) output.write(`${formatSource(source)}\n`);
-      let selection;
-      while (!selection) {
-        const answer = (await question('Source number: ')).trim();
-        const index = Number(answer);
-        if (/^[1-9]\d*$/.test(answer) && sources[index - 1]) selection = sources[index - 1];
-        else output.write(`Choose a number from 1 to ${sources.length}.\n`);
-      }
+      const sources = await (discover || discoverSources)(url, { signal, inspect: inspectSource,
+        deepScan: defaults.deepScan, timeoutMs: defaults.timeout ? parseSourceTimeout(defaults.timeout) : undefined }).catch(() => []);
+      if (!sources.length) throw originalError;
+      let selection = sources[0];
+      if (sources.length > 1) {
+        for (const source of sources) output.write(`${formatSource(source)}\n`);
+        selection = null;
+        while (!selection) {
+          const answer = (await question('Source number: ')).trim();
+          const index = Number(answer);
+          if (/^[1-9]\d*$/.test(answer) && sources[index - 1]) selection = sources[index - 1];
+          else output.write(`Choose a number from 1 to ${sources.length}.\n`);
+        }
+      } else output.write(`Found video source: ${formatSource(selection)}\n`);
       args.push('--source', String(selection.index));
       metadata = await inspectSource(selection.url);
     }

package/src/jobs.js

@@ -1,4 +1,4 @@
-import { runPool, serialQueue, reducedLimit } from './execution.js';
+import { runPool, serialQueue, reducedLimit, formatTimings } from './execution.js';
 import { styleText } from './progress.js';
 import path from 'node:path';
 import { lstat, readdir } from 'node:fs/promises';
@@ -126,14 +126,14 @@ export async function runJob(options, { download, reporter, signal, openFile, st
           skipped += result.skipped ?? 0;
           failed += result.failures?.length ?? (item.status === 'failed' ? 1 : 0);
         }
-        if (options.json) stdout.write(`${JSON.stringify({ ...result, status: item.status, ...(runId ? { runId } : {}) })}\n`);
+        if (options.json) stdout.write(`${JSON.stringify({ ...result, status: item.status, profile: request.profile || null, ...(runId ? { runId } : {}) })}\n`);
         await publish(result.files);
       } catch (error) {
         item.status = signal?.aborted ? 'cancelled' : 'failed';
         item.error = readableError(error);
         if (!signal?.aborted) failed++;
         item.files = item.entries.flatMap(entry => entry.files || []);
-        if (options.json) stdout.write(`${JSON.stringify({ url: request.url, status: item.status, error: item.error, files: item.files, ...(runId ? { runId } : {}) })}\n`);
+        if (options.json) stdout.write(`${JSON.stringify({ url: request.url, status: item.status, profile: request.profile || null, error: item.error, files: item.files, ...(runId ? { runId } : {}) })}\n`);
         else stderr.write(styleText(stderr, `veo: ${cleanText(request.url)}: ${item.error}`, 'error', options.color !== false) + '\n');
       }
       if (recordStats) {
@@ -165,7 +165,16 @@ export async function runJob(options, { download, reporter, signal, openFile, st
     stderr.write(`Run ID: ${runId}\n`);
   }
   const unfinished = job.items.some(item => !['saved', 'skipped'].includes(item.status));
-  stderr.write(styleText(stderr, `Summary: ${saved} saved, ${skipped} skipped, ${failed} failed${signal?.aborted ? ', cancelled' : ''}.`, unfinished ? 'error' : 'success', options.color !== false && !options.json) + '\n');
+  const downloadCount = job.items.reduce((count, item) => count + Math.max(1, item.entries?.length || 0), 0);
+  if (downloadCount > 1) stderr.write(styleText(stderr, `Summary: ${saved} saved, ${skipped} skipped, ${failed} failed${signal?.aborted ? ', cancelled' : ''}.`, unfinished ? 'error' : 'success', options.color !== false && !options.json) + '\n');
+  if (options.timings !== false) {
+    const totals = {};
+    for (const item of job.items) for (const timings of [item.timings, ...(item.entryTimings || []).map(entry => entry.timings)]) {
+      if (!timings) continue;
+      for (const [phase, ms] of Object.entries(timings)) totals[phase] = (totals[phase] || 0) + ms;
+    }
+    if (Object.keys(totals).length) stderr.write(styleText(stderr, formatTimings(totals), 'muted', options.color !== false && !options.json) + '\n');
+  }
   if (unfinished) stderr.write(`Retry failed/unfinished downloads: veo --retry-failed "${file}"\n`);
   if (unfinished) reporter.fail(Boolean(signal?.aborted)); else reporter.complete();
   return signal?.aborted ? 130 : unfinished ? 1 : 0;

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/progress.js

@@ -5,7 +5,7 @@ const PROCESSING_LABELS = { Merger: 'Merging audio/video', VideoRemuxer: 'Changi
 
 export function styleText(stream, text, role = 'muted', enabled = true, env = process.env) {
   if (!enabled || !stream.isTTY || Object.hasOwn(env, 'NO_COLOR') || env.TERM === 'dumb') return text;
-  const codes = { muted: 90, title: 1, success: 32, error: 31 };
+  const codes = { muted: 90, title: 1, profile: 97, success: 32, error: 31 };
   return '\x1b[' + (codes[role] || 90) + 'm' + text + '\x1b[0m';
 }
 
@@ -56,10 +56,10 @@ export function formatProgress(data, { columns = Infinity, prefix = '' } = {}) {
   return fit(variants.at(-1), columns);
 }
 
-export function createReporter(stream = process.stderr, { setTitle = createTerminalTitle(stream) } = {}) {
+export function createReporter(stream = process.stderr, { setTitle = createTerminalTitle(stream), env = process.env } = {}) {
   let color = true;
-  const muted = text => styleText(stream, text, 'muted', color);
-  const heading = text => styleText(stream, text, 'title', color);
+  const muted = text => styleText(stream, text, 'muted', color, env);
+  const heading = text => styleText(stream, text, 'title', color, env);
   let active = false;
   let lastLog = 0;
   let name = '';
@@ -68,27 +68,64 @@ export function createReporter(stream = process.stderr, { setTitle = createTermi
   let position = '';
   let hasItem = false;
   let streamName = '';
+  let animation;
+  let animationLabel = '';
+  let animationOwner;
+  let animationFrame = 0;
+  const stopAnimation = () => { if (animation) clearInterval(animation); animation = undefined; };
+  const display = value => fit(value, stream.isTTY ? Math.max(1, (stream.columns || 80) - 1) : Infinity);
+  const animate = (label, owner) => {
+    clear();
+    if (!stream.isTTY) { stream.write(muted(label + '…') + '\n'); return; }
+    animationLabel = label;
+    animationOwner = owner;
+    animationFrame = 0;
+    const tick = () => { stream.write(`\r\x1b[2K${muted(display(animationLabel + '.'.repeat(animationFrame % 3 + 1)))}`); active = true; animationFrame++; };
+    tick();
+    animation = setInterval(tick, 350);
+    animation.unref?.();
+  };
+  const processingResult = (label, status) => {
+    clear();
+    const failed = status === 'failed' || status === 'error';
+    const suffix = failed ? 'failed' : 'done';
+    const width = stream.isTTY ? Math.max(1, (stream.columns || 80) - 1) : Infinity;
+    const result = `${fit(label, Math.max(0, width - suffix.length - 2))}: `;
+    stream.write(muted(result) + styleText(stream, suffix, failed ? 'error' : 'success', color, env) + '\n');
+  };
+  const finishStatus = (message, owner, prefix = '', outcome) => {
+    const label = prefix + cleanText(message);
+    if (!animation || animationOwner !== owner || animationLabel !== label.slice(0, -1)) return;
+    if (outcome) { processingResult(label.slice(0, -1), outcome); return; }
+    clear();
+    stream.write(muted(display(label)) + '\n');
+  };
   const line = (data, prefix) => formatProgress(data, { prefix, columns: stream.isTTY ? Math.max(1, (stream.columns || 80) - 1) : Infinity });
   const draw = (data, prefix) => { stream.write(`\r\x1b[2K${line(data, prefix)}`); active = true; };
   const updateTitle = () => setTitle(`veo | ${phase}${name ? ` | ${name}` : ''}`);
   function clear() {
+    stopAnimation();
     if (active && stream.isTTY) stream.write('\r\x1b[2K');
     active = false;
+    animationLabel = '';
+    animationOwner = undefined;
   }
   const scoped = (index, total, title, parent = '') => {
     let childName = cleanText(title), lastProgress = 0;
+    const owner = Symbol('scoped reporter');
     const prefix = parent + '[' + index + '/' + total + '] ';
     const log = (message, quiet = true) => {
-      clear();
-      const line = prefix + childName + ': ' + cleanText(message);
-      stream.write((quiet ? muted(line) : line) + '\n');
       phase = cleanText(message); name = childName;
+      const line = prefix + childName + ': ' + phase;
+      if (phase.endsWith('…')) animate(line.slice(0, -1), owner);
+      else { clear(); stream.write((quiet ? muted(line) : line) + '\n'); }
       if (started) updateTitle();
     };
     return {
       scoped: (index, total, title) => scoped(index, total, title, prefix),
       name(value) { childName = cleanText(value); },
       status: log,
+      finishStatus(message, outcome) { finishStatus(message, owner, prefix + childName + ': ', outcome); },
       progress(data) {
         if (stream.isTTY) {
           draw(data, prefix + childName + ': ' + (data.stream || 'Media'));
@@ -97,8 +134,15 @@ export function createReporter(stream = process.stderr, { setTitle = createTermi
           lastProgress = Date.now();
         }
       },
-      processing(data) { log((PROCESSING_LABELS[data.postprocessor] || 'Processing media') + (data.status === 'finished' ? ': done' : '…')); },
+      processing(data) {
+        const label = prefix + childName + ': ' + (PROCESSING_LABELS[data.postprocessor] || 'Processing media');
+        if (['finished', 'failed', 'error'].includes(data.status)) processingResult(label, data.status);
+        else animate(label, owner);
+        phase = `${PROCESSING_LABELS[data.postprocessor] || 'Processing media'}${data.status === 'finished' ? ': done' : '…'}`;
+        name = childName; if (started) updateTitle();
+      },
       finish() {},
+      failStep() { if (animation && animationOwner === owner) processingResult(animationLabel, 'failed'); },
     };
   };
   return {
@@ -112,9 +156,10 @@ export function createReporter(stream = process.stderr, { setTitle = createTermi
     processing(data) {
       const processor = cleanText(data.postprocessor || 'Processing');
       const label = PROCESSING_LABELS[processor] || 'Processing media';
-      clear(); phase = `${label}${data.status === 'finished' ? ': done' : '…'}`;
+      phase = `${label}${data.status === 'finished' ? ': done' : '…'}`;
       if (started) updateTitle();
-      stream.write(muted(`${position}${phase}`) + '\n');
+      if (['finished', 'failed', 'error'].includes(data.status)) processingResult(`${position}${label}`, data.status);
+      else animate(`${position}${label}`);
     },
     start(title = '') { started = true; name = cleanText(title); phase = 'Starting…'; updateTitle(); },
     name(title) {
@@ -123,11 +168,22 @@ export function createReporter(stream = process.stderr, { setTitle = createTermi
       name = next; if (started) updateTitle();
     },
     status(message) {
-      clear();
       phase = cleanText(message);
       if (started) updateTitle();
-      stream.write(muted(phase) + '\n');
+      if (phase.endsWith('…')) animate(phase.slice(0, -1));
+      else { clear(); stream.write(muted(phase) + '\n'); }
+    },
+    profile(value) {
+      const selected = value ? cleanText(value) : 'global (no profile)';
+      phase = `Profile: ${selected}`;
+      if (started) updateTitle();
+      clear();
+      stream.write(value && value !== 'default'
+        ? muted('Profile: ') + styleText(stream, selected, 'profile', color, env) + '\n'
+        : muted(phase) + '\n');
     },
+    finishStatus(message, outcome) { finishStatus(message, undefined, '', outcome); },
+    failStep() { if (animation && animationOwner === undefined) processingResult(animationLabel, 'failed'); },
     complete() { clear(); phase = 'Done'; if (started) updateTitle(); },
     fail(cancelled = false) { clear(); phase = cancelled ? 'Cancelled' : 'Failed'; if (started) updateTitle(); },
     progress(data) {

package/src/runs.js

@@ -119,7 +119,7 @@ export async function registerRun(cancel, root = cacheBase()) {
   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, playlist: false, job: null };
+    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)) {
@@ -146,8 +146,9 @@ export async function registerRun(cancel, root = cacheBase()) {
         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,
+        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,
       });
@@ -232,7 +233,8 @@ export function formatRunDetails(run) {
   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(`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);
@@ -286,7 +288,8 @@ export async function runsMain(args = [], { stdout = process.stdout, root = cach
 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, playlist: Boolean(run.playlist), job: run.job || 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 };
 }