veodl 1.8.1

package/src/config-diagnostics.js

@@ -0,0 +1,144 @@
+import { CONFIG_KEYS, parseConfigText, effectiveConfig, applyProfile } from './config.js';
+import { stripConfigComments } from './config-template.js';
+import { QUALITIES, AUDIO_FORMATS, VIDEO_FORMATS } from './utils.js';
+
+// Parse only after JSON.parse succeeds. Keep paths and source spans, including
+// escaped property names and repeated settings in different profiles.
+export function configSource(text) {
+  const clean = stripConfigComments(text);
+  const data = JSON.parse(clean), nodes = new Map();
+  const tokens = [...clean.matchAll(/"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null|[{}\[\]:,]/g)];
+  let index = 0;
+  const bom = text.startsWith('\uFEFF') ? 1 : 0;
+  const visit = (path, keyToken) => {
+    const first = tokens[index++];
+    if (first[0] === '{') {
+      while (tokens[index][0] !== '}') {
+        const key = tokens[index++]; index++; // colon
+        visit([...path, JSON.parse(key[0])], key);
+        if (tokens[index][0] === ',') index++;
+      }
+      index++;
+    } else if (first[0] === '[') {
+      let item = 0;
+      while (tokens[index][0] !== ']') {
+        visit([...path, item++]);
+        if (tokens[index][0] === ',') index++;
+      }
+      index++;
+    }
+    const last = tokens[index - 1];
+    nodes.set(JSON.stringify(path), { path, start: first.index + bom, end: last.index + last[0].length + bom,
+      keyStart: keyToken?.index + bom, keyEnd: keyToken ? keyToken.index + keyToken[0].length + bom : undefined });
+  };
+  visit([]);
+  return { data, nodes };
+}
+
+function distance(a, b) {
+  let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 0; i < a.length; i++) {
+    const next = [i + 1];
+    for (let j = 0; j < b.length; j++) next.push(Math.min(next[j] + 1, row[j + 1] + 1, row[j] + (a[i] !== b[j])));
+    row = next;
+  }
+  return row[b.length];
+}
+
+const keys = Object.keys(CONFIG_KEYS);
+function suggestion(key, choices) {
+  const ranked = choices.map(value => [value, distance(key.toLowerCase(), value.toLowerCase())]).sort((a, b) => a[1] - b[1]);
+  return ranked[0]?.[1] <= 2 ? ranked[0][0] : null;
+}
+
+function located(text, node, message, property = false, choices = []) {
+  const start = (property ? node?.keyStart : node?.start) ?? 0;
+  const end = (property ? node?.keyEnd : node?.end) ?? start + 1;
+  return { message, start, end, line: text.slice(0, start).split('\n').length,
+    column: start - text.lastIndexOf('\n', start - 1), choices };
+}
+
+function valueChoices(key, config = {}) {
+  if (CONFIG_KEYS[key] === 'boolean') return [true, false];
+  if (key === 'quality') return QUALITIES;
+  if (key === 'format') return config.audio ? AUDIO_FORMATS : VIDEO_FORMATS;
+  if (['concurrentDownloads', 'playlistConcurrency'].includes(key)) return [1, 2, 3, 4];
+  if (key === 'concurrentFragments') return Array.from({ length: 16 }, (_, i) => i + 1);
+  return [];
+}
+
+export async function semanticIssue(text) {
+  const { data, nodes } = configSource(text);
+  const node = path => nodes.get(JSON.stringify(path));
+  const object = value => value && typeof value === 'object' && !Array.isArray(value);
+  if (!object(data)) return located(text, node([]), 'The config must contain a JSON object.');
+  const check = (settings, path) => {
+    for (const [key, value] of Object.entries(settings)) {
+      if (!path.length && ['$schema', 'profiles'].includes(key)) continue;
+      const target = node([...path, key]);
+      if (!Object.hasOwn(CONFIG_KEYS, key)) {
+        const proposed = suggestion(key, path.length ? keys : [...keys, 'profiles', '$schema']);
+        return located(text, target, `Unknown setting "${key}".${proposed ? ` Did you mean "${proposed}"?` : ''}`, true, proposed ? [proposed] : []);
+      }
+      if (typeof value !== CONFIG_KEYS[key]) {
+        const choices = valueChoices(key, settings);
+        return located(text, target, `"${key}" must be a ${CONFIG_KEYS[key]}.${choices.length ? ` Choose: ${choices.join(', ')}.` : ''}`, false, choices);
+      }
+    }
+    return null;
+  };
+  let issue = check(data, []);
+  if (issue) return issue;
+  if (Object.hasOwn(data, 'profiles')) {
+    if (!object(data.profiles)) return located(text, node(['profiles']), 'Profiles must be an object.');
+    for (const [name, profile] of Object.entries(data.profiles)) {
+      if (!object(profile)) return located(text, node(['profiles', name]), `Profile "${name}" must be an object.`);
+      issue = check(profile, ['profiles', name]); if (issue) return issue;
+    }
+  }
+  const { config } = parseConfigText(text);
+  for (const profile of [undefined, ...Object.keys(config.profiles || {})]) {
+    try { await effectiveConfig(config, profile); }
+    catch (error) {
+      const message = error.message;
+      let key = /Invalid quality/.test(message) ? 'quality' : /Invalid (?:audio|video) format/.test(message) ? 'format' :
+        /output directory/.test(message) ? 'output' : /custom filename/.test(message) ? 'rename' :
+          /--([a-z-]+)/.exec(message)?.[1]?.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const name = profile ?? (config.profiles?.default ? 'default' : undefined);
+      const selected = applyProfile(config, profile);
+      // Template errors do not name the CLI option. Locate the failing template.
+      if (!key) {
+        const { validateTemplate } = await import('./naming.js');
+        for (const candidate of ['filenameTemplate', 'folderTemplate']) {
+          if (selected[candidate] !== undefined) {
+            try { validateTemplate(selected[candidate], { folders: candidate === 'folderTemplate' }); }
+            catch { key = candidate; break; }
+          }
+        }
+      }
+      const target = name !== undefined && Object.hasOwn(config.profiles[name], key) ? node(['profiles', name, key]) : node([key]);
+      const value = ['quality', 'format'].includes(key) ? `"${key}": unsupported value ${JSON.stringify(selected[key])}. ` : '';
+      return located(text, target || node([]), `${name === undefined ? '' : `Profile "${name}": `}${value}${message}`, false, valueChoices(key, selected));
+    }
+  }
+  return null;
+}
+
+export function editorCompletions(text, cursor) {
+  try {
+    const { data, nodes } = configSource(text);
+    for (const item of nodes.values()) {
+      const path = item.path;
+      if (!(path.length === 1 || (path.length === 3 && path[0] === 'profiles'))) continue;
+      const key = path.at(-1), property = cursor >= item.keyStart && cursor <= item.keyEnd;
+      if (!property && !(cursor >= item.start && cursor <= item.end)) continue;
+      const profile = path.length === 3 ? path[1] : undefined;
+      const choices = property ? (path.length === 1 ? [...keys, 'profiles', '$schema'] : keys) : valueChoices(key, applyProfile(data, profile));
+      if (!choices.length) return null;
+      const proposed = property ? suggestion(key, choices) : null;
+      return { start: property ? item.keyStart : item.start, end: property ? item.keyEnd : item.end,
+        choices: proposed ? [proposed, ...choices.filter(value => value !== proposed)] : choices };
+    }
+  } catch { /* Syntax must be valid before offering safe token replacements. */ }
+  return null;
+}

package/src/config-editor.js

@@ -0,0 +1,281 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { emitKeypressEvents } from 'node:readline';
+import { PassThrough } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+import { parseConfigText } from './config.js';
+import { semanticIssue, editorCompletions } from './config-diagnostics.js';
+import { configClipboard } from './config-clipboard.js';
+
+const safe = text => text.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');
+
+export async function validateEditorText(text) {
+  try {
+    // Run source-aware checks even when the normal loader rejects a setting.
+    return await semanticIssue(text);
+  } catch (error) {
+    try { parseConfigText(text); } catch (configError) { error = configError; }
+    const location = /line (\d+), column (\d+)/.exec(error.message);
+    return { message: error.message.replace(/^The veo config file is not valid JSON: .*?\(line \d+, column \d+\)\. /, ''), line: location ? Number(location[1]) : null,
+      column: location ? Number(location[2]) : null };
+  }
+}
+
+// A small text buffer shared by the keyboard handler and focused editing tests.
+export class EditorBuffer {
+  constructor(text) { this.text = text; this.cursor = 0; this.anchor = null; }
+  get selection() {
+    return this.anchor === null ? [this.cursor, this.cursor] : [Math.min(this.anchor, this.cursor), Math.max(this.anchor, this.cursor)];
+  }
+  deleteSelection() {
+    const [start, end] = this.selection;
+    this.anchor = null;
+    if (start === end) return false;
+    this.text = this.text.slice(0, start) + this.text.slice(end); this.cursor = start;
+    return true;
+  }
+  point(row, col, extend = false) {
+    if (extend && this.anchor === null) this.anchor = this.cursor;
+    if (!extend) this.anchor = null;
+    const lines = this.text.split('\n');
+    row = Math.max(0, Math.min(lines.length - 1, row));
+    this.cursor = lines.slice(0, row).reduce((sum, line) => sum + line.length + 1, 0) + Math.max(0, Math.min(lines[row].length, col));
+  }
+  insert(text) {
+    this.deleteSelection();
+    this.text = this.text.slice(0, this.cursor) + text + this.text.slice(this.cursor);
+    this.cursor += text.length;
+  }
+  get position() {
+    const before = this.text.slice(0, this.cursor);
+    return { row: before.split('\n').length - 1, col: this.cursor - before.lastIndexOf('\n') - 1 };
+  }
+  move(rows) {
+    const lines = this.text.split('\n'), { row, col } = this.position;
+    const next = Math.max(0, Math.min(lines.length - 1, row + rows));
+    this.cursor = lines.slice(0, next).reduce((sum, line) => sum + line.length + 1, 0) + Math.min(col, lines[next].length);
+  }
+  key(name) {
+    if (['backspace', 'delete'].includes(name) && this.deleteSelection()) return;
+    if (['left', 'right', 'up', 'down', 'home', 'end'].includes(name)) this.anchor = null;
+    if (name === 'left') this.cursor = Math.max(0, this.cursor - 1);
+    if (name === 'right') this.cursor = Math.min(this.text.length, this.cursor + 1);
+    if (name === 'up') this.move(-1);
+    if (name === 'down') this.move(1);
+    if (name === 'home') this.cursor -= this.position.col;
+    if (name === 'end') this.cursor = this.text.indexOf('\n', this.cursor) < 0 ? this.text.length : this.text.indexOf('\n', this.cursor);
+    if (name === 'backspace' && this.cursor) {
+      this.text = this.text.slice(0, this.cursor - 1) + this.text.slice(this.cursor); this.cursor--;
+    }
+    if (name === 'delete') this.text = this.text.slice(0, this.cursor) + this.text.slice(this.cursor + 1);
+    if (name === 'return') this.insert('\n');
+    if (name === 'tab') this.insert('  ');
+  }
+}
+
+export function colorLine(line, enabled = true) {
+  const clean = safe(line);
+  if (!enabled) return clean;
+  return clean.replace(/("(?:\\.|[^"\\])*"\s*:?)|(\/\/.*$)|\b(true|false|null|-?\d+(?:\.\d+)?)\b/g,
+    (token, string, comment) => `\x1b[${comment ? 90 : string ? (token.endsWith(':') ? 36 : 32) : 33}m${token}\x1b[0m`);
+}
+
+export async function editConfig(file, { input = process.stdin, output = process.stdout, color = !Object.hasOwn(process.env, 'NO_COLOR'), clipboard = configClipboard } = {}) {
+  if (!input.isTTY || !output.isTTY || !input.setRawMode) throw new Error('The config editor requires an interactive terminal. Set EDITOR to use an external editor.');
+  const original = await readFile(file, 'utf8');
+  const newline = original.includes('\r\n') ? '\r\n' : '\n';
+  const buffer = new EditorBuffer(original.replace(/\r\n/g, '\n'));
+  let saved = buffer.text, disk = original, issue = await validateEditorText(buffer.text);
+  let top = 0, left = 0, followCursor = true, question = false, busy = false, closed = false, timer;
+  let status = '', revision = 0;
+  let viewport, dragging = false, completion = null;
+  const wasRaw = input.isRaw, wasPaused = input.isPaused();
+  const render = () => {
+    if (closed) return;
+    const width = Math.max(1, (output.columns || 80) - 1), height = Math.max(1, (output.rows || 24) - 6);
+    const lines = buffer.text.split('\n'), { row, col } = buffer.position;
+    const gutter = Math.min(width - 1, String(lines.length).length + 2), available = Math.max(1, width - gutter);
+    if (followCursor) {
+      top = Math.max(0, Math.min(top, row));
+      if (row >= top + height) top = row - height + 1;
+    }
+    top = Math.max(0, Math.min(top, Math.max(0, lines.length - height)));
+    left = Math.max(0, Math.min(left, col)); if (col >= left + available) left = col - available + 1;
+    viewport = { height, gutter, width };
+    const [selectionStart, selectionEnd] = buffer.selection;
+    let offset = lines.slice(0, top).reduce((sum, line) => sum + line.length + 1, 0);
+    const screen = [safe(`veo config | ${file}${buffer.text !== saved ? ' *' : ''}`).slice(0, width)];
+    for (let index = top; index < top + height; index++) {
+      const line = lines[index];
+      const prefix = line === undefined ? '' : `${index + 1 === issue?.line ? '!' : ' '}${String(index + 1).padStart(Math.max(0, gutter - 2))} `;
+      const content = (line || '').slice(left, left + available);
+      const start = Math.max(0, selectionStart - offset - left), end = Math.min(content.length, selectionEnd - offset - left);
+      if (end > start) {
+        screen.push(prefix + colorLine(content.slice(0, start), color) + '\x1b[7m' + safe(content.slice(start, end)) + '\x1b[0m' + colorLine(content.slice(end), color));
+      } else if (issue?.start !== undefined && color) {
+        const from = Math.max(0, issue.start - offset - left), to = Math.min(content.length, issue.end - offset - left);
+        screen.push(to > from ? prefix + colorLine(content.slice(0, from), color) + '\x1b[41;97m' + safe(content.slice(from, to)) + '\x1b[0m' + colorLine(content.slice(to), color) : prefix + colorLine(content, color));
+      } else screen.push(index + 1 === issue?.line && color ? `\x1b[41;97m${prefix}${safe(content)}\x1b[0m` : prefix + colorLine(content, color));
+      offset += (line || '').length + 1;
+    }
+    screen.push(safe(question ? 'Discard unsaved changes? Y = discard, N / Esc = keep editing' : 'Ctrl+S Save | Ctrl+C Copy | Ctrl+V Paste | Esc Exit | F2 Options | Wheel Scroll').slice(0, width));
+    const diagnosis = issue ? `${issue.line ? `Line ${issue.line}, column ${issue.column}: ` : ''}${issue.message}` : '';
+    const detail = safe(completion ? `Options (${completion.index + 1}/${completion.choices.length}): ${JSON.stringify(completion.choices[completion.index])} | Up/Down choose, Enter apply, Esc cancel` :
+      status ? `${status}${diagnosis ? ` | ${diagnosis}` : ''}` : diagnosis || 'Config OK');
+    for (let row = 0; row < 3; row++) screen.push(detail.slice(row * width, (row + 1) * width));
+    screen.push(`Ln ${row + 1}, Col ${col + 1}`.slice(0, width));
+    const cursorVisible = row >= top && row < top + height;
+    output.write('\x1b[?25l\x1b[H' + screen.map(line => line + '\x1b[K').join('\r\n') +
+      (cursorVisible ? `\x1b[${row - top + 2};${gutter + col - left + 1}H\x1b[?25h` : ''));
+  };
+  await new Promise((resolve, reject) => {
+    const keyboard = new PassThrough();
+    const decoder = new StringDecoder('utf8');
+    let pending = '', mouseTimer;
+    const mouse = (button, x, y, release) => {
+      if (busy || closed || question) return;
+      if (button & 64) {
+        if (!release) {
+          followCursor = false;
+          top += (button & 1) ? 3 : -3;
+          render();
+        }
+        return;
+      }
+      completion = null;
+      if ((button & 3) !== 0) return;
+      const inside = y >= 2 && y <= viewport.height + 1 && x >= 1 && x <= viewport.width;
+      if (!inside && !dragging) return;
+      if (!(button & 32) && !release) {
+        followCursor = true;
+        buffer.point(top + y - 2, left + x - viewport.gutter - 1);
+        buffer.anchor = buffer.cursor; dragging = true;
+      } else if (dragging) {
+        buffer.point(top + Math.max(0, Math.min(viewport.height - 1, y - 2)), left + x - viewport.gutter - 1, true);
+      }
+      if (release) dragging = false;
+      render();
+    };
+    // Filter SGR mouse reports before readline so their digits never enter the file.
+    const onData = chunk => {
+      clearTimeout(mouseTimer);
+      pending += typeof chunk === 'string' ? chunk : decoder.write(chunk);
+      while (pending) {
+        const match = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(pending);
+        if (match) {
+          pending = pending.slice(match[0].length);
+          mouse(Number(match[1]), Number(match[2]), Number(match[3]), match[4] === 'm');
+        } else if (/^\x1b(?:\[(?:<[\d;]*)?)?$/.test(pending)) {
+          mouseTimer = setTimeout(() => { if (!pending.startsWith('\x1b[<')) keyboard.write(pending); pending = ''; }, 100);
+          break;
+        } else {
+          const character = String.fromCodePoint(pending.codePointAt(0));
+          keyboard.write(character); pending = pending.slice(character.length);
+        }
+      }
+    };
+    const finish = error => {
+      if (closed) return;
+      closed = true; clearTimeout(timer); clearTimeout(mouseTimer);
+      input.off('data', onData); keyboard.off('keypress', onKey); keyboard.destroy();
+      input.off('keypress', onKey); input.off('end', onEnd); input.off('error', onError); output.off('resize', render);
+      input.setRawMode(Boolean(wasRaw)); if (wasPaused) input.pause();
+      output.write('\x1b[?1002l\x1b[?1006l\x1b[0m\x1b[?25h\x1b[?1049l');
+      error ? reject(error) : resolve();
+    };
+    const onEnd = () => finish();
+    const onError = error => finish(error);
+    const onKey = async (text, key = {}) => {
+      if (busy || closed) return;
+      try {
+        if (question) {
+          if (text?.toLowerCase() === 'y') return finish();
+          if (text?.toLowerCase() === 'n' || key.name === 'escape') question = false;
+          render(); return;
+        }
+        if (completion) {
+          if (key.name === 'escape') completion = null;
+          else if (['up', 'down', 'tab'].includes(key.name)) completion.index = (completion.index + (key.name === 'up' ? -1 : 1) + completion.choices.length) % completion.choices.length;
+          else if (key.name === 'return') {
+            buffer.anchor = completion.start; buffer.cursor = completion.end;
+            buffer.insert(JSON.stringify(completion.choices[completion.index]));
+            completion = null; status = ''; revision++; clearTimeout(timer);
+            busy = true; issue = await validateEditorText(buffer.text); busy = false;
+          }
+          render(); return;
+        }
+        if (key.name === 'f2' || (key.ctrl && key.name === 'space')) {
+          const options = editorCompletions(buffer.text, buffer.cursor);
+          completion = options ? { ...options, index: 0 } : null;
+          status = options ? '' : 'No options here. Place the cursor on a property or value in valid JSON.';
+          render(); return;
+        }
+        if (key.ctrl && key.name === 'c') {
+          const [start, end] = buffer.selection;
+          if (start === end) status = 'Select text first, then press Ctrl+C.';
+          else {
+            busy = true;
+            try { await clipboard.copy(buffer.text.slice(start, end)); status = 'Copied to clipboard.'; }
+            catch (error) { status = `Copy failed: ${error.message}`; }
+            finally { busy = false; }
+          }
+          render(); return;
+        }
+        if (key.ctrl && key.name === 'v') {
+          busy = true;
+          try {
+            const pasted = (await clipboard.paste()).replace(/\r\n?|\n/g, '\n').replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '');
+            if (pasted) {
+              buffer.insert(pasted); followCursor = true;
+              status = ''; issue = await validateEditorText(buffer.text);
+              revision++; clearTimeout(timer);
+            } else status = 'Clipboard has no text.';
+          } catch (error) { status = `Paste failed: ${error.message}`; }
+          finally { busy = false; }
+          render(); return;
+        }
+        if (key.ctrl && ['up', 'down'].includes(key.name)) {
+          followCursor = false; top += key.name === 'up' ? -3 : 3; render(); return;
+        }
+        if (key.name === 'escape' || (key.ctrl && key.name === 'q')) {
+          if (buffer.text === saved) return finish();
+          question = true; render(); return;
+        }
+        if (key.ctrl && key.name === 's') {
+          followCursor = true;
+          revision++; clearTimeout(timer); buffer.anchor = null;
+          busy = true;
+          issue = await validateEditorText(buffer.text);
+          if (issue) {
+            if (issue.line) buffer.cursor = buffer.text.split('\n').slice(0, issue.line - 1).reduce((sum, line) => sum + line.length + 1, 0) + issue.column - 1;
+          } else {
+            try {
+              if (await readFile(file, 'utf8') !== disk) throw new Error('File changed outside the editor. Exit and reopen before saving.');
+              const next = buffer.text.replace(/\n/g, newline);
+              await writeFile(file, next, 'utf8'); disk = next; saved = buffer.text; status = 'Saved';
+            } catch (error) { status = `Save failed: ${error.message}`; }
+          }
+          busy = false; render(); return;
+        }
+        if (key.ctrl || key.meta) return;
+        followCursor = true;
+        const before = buffer.text;
+        if (key.name === 'pageup' || key.name === 'pagedown') buffer.move((key.name === 'pageup' ? -1 : 1) * Math.max(1, (output.rows || 24) - 4));
+        else if (['left', 'right', 'up', 'down', 'home', 'end', 'backspace', 'delete', 'return', 'tab'].includes(key.name)) buffer.key(key.name);
+        else if (text && !/[\x00-\x1f\x7f-\x9f]/.test(text)) buffer.insert(text);
+        if (before !== buffer.text) {
+          status = ''; issue = null; const current = ++revision; clearTimeout(timer);
+          timer = setTimeout(async () => {
+            const result = await validateEditorText(buffer.text);
+            if (!closed && current === revision) { issue = result; render(); }
+          }, 150);
+        }
+        render();
+      } catch (error) { finish(error); }
+    };
+    emitKeypressEvents(keyboard); keyboard.on('keypress', onKey);
+    input.on('data', onData);
+    input.on('keypress', onKey); input.on('end', onEnd); input.on('error', onError); output.on('resize', render);
+    input.setRawMode(true); input.resume();
+    output.write('\x1b[?1049h\x1b[?1006h\x1b[?1002h'); render();
+  });
+}

package/src/config-errors.js

@@ -0,0 +1,64 @@
+// Diagnose syntax without echoing config values (which can include private paths).
+export function configSyntaxError(text, file, original) {
+  let index = 0;
+  const fail = reason => { throw { reason, position: index }; };
+  const space = () => { while (/\s/.test(text[index] || '') && index < text.length) index++; };
+  function string() {
+    index++;
+    while (index < text.length) {
+      const char = text[index++];
+      if (char === '"') return;
+      if (char.charCodeAt(0) < 32) { index--; fail('Unescaped line break or control character inside a string.'); }
+      if (char === '\\') {
+        const escape = text[index];
+        if (escape === 'u') {
+          index++;
+          for (let count = 0; count < 4; count++, index++) {
+            if (!/[0-9a-f]/i.test(text[index] || '')) fail('Invalid Unicode escape; use four hexadecimal digits after \\u.');
+          }
+        } else if (escape && '"\\/bfnrt'.includes(escape)) index++;
+        else fail('Invalid escape sequence. For Windows paths, use forward slashes (G:/Videos) or double backslashes (G:\\\\Videos).');
+      }
+    }
+    fail('Unterminated string; add a closing double quote.');
+  }
+  function value() {
+    space();
+    const char = text[index];
+    if (char === '`') fail('Markdown code fences are not valid JSON. Remove the lines containing ```json and ```.');
+    if (char === '"') return string();
+    if (char === '{' || char === '[') {
+      const object = char === '{', close = object ? '}' : ']';
+      index++; space();
+      if (text[index] === close) { index++; return; }
+      while (true) {
+        space();
+        if (text[index] === '`') fail('Markdown code fences are not valid JSON. Remove the lines containing ```json and ```.');
+        if (object) {
+          if (text[index] !== '"') fail('Expected a property name in double quotes. Check for a trailing comma or a missing closing brace.');
+          string(); space();
+          if (text[index++] !== ':') { index--; fail('Expected a colon (:) after the property name.'); }
+        }
+        value(); space();
+        if (text[index] === close) { index++; return; }
+        if (text[index] !== ',') fail(`Expected a comma (,) or closing ${close}.`);
+        index++; space();
+        if (text[index] === close) fail('Trailing commas are not allowed. Remove the comma before the closing bracket or brace.');
+      }
+    }
+    const literal = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(index));
+    if (!literal) fail('Expected a JSON value: object, array, string, number, true, false or null.');
+    index += literal[0].length;
+  }
+  let issue;
+  if (Number.isInteger(original?.position)) issue = { position: original.position, reason: original.message };
+  else {
+    try { value(); space(); if (index !== text.length) fail('Unexpected content after the JSON value. Remove extra text or Markdown code fences.'); }
+    catch (error) { issue = error; }
+  }
+  const position = Math.min(issue?.position ?? index, text.length);
+  const preceding = text.slice(0, position);
+  const line = preceding.split('\n').length;
+  const column = position - preceding.lastIndexOf('\n');
+  return new Error(`The veo config file is not valid JSON: ${file} (line ${line}, column ${column}). ${issue?.reason || 'Invalid JSON syntax.'}`);
+}

package/src/config-reset.js

@@ -0,0 +1,39 @@
+import { mkdir, readFile, writeFile, rename, rm } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { CONFIG_TEMPLATE } from './config-template.js';
+
+export async function resetConfig(file, { input = process.stdin, output = process.stdout, confirm } = {}) {
+  file = path.resolve(file);
+  output.write(`Reset configuration and all profiles: ${file}\n`);
+  output.write('The existing file will be backed up. Downloads, history and statistics are preserved.\n');
+  if (!confirm && !input.isTTY) throw new Error('Config reset requires an interactive terminal for confirmation.');
+  let answer;
+  if (confirm) answer = await confirm('Reset configuration? [y/N] ');
+  else {
+    const rl = createInterface({ input, output: process.stdout });
+    try { answer = await rl.question('Reset configuration? [y/N] '); }
+    finally { rl.close(); }
+  }
+  if (!/^y(?:es)?$/i.test(String(answer).trim())) {
+    output.write('Config reset cancelled.\n');
+    return 0;
+  }
+  let original;
+  try { original = await readFile(file); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  await mkdir(path.dirname(file), { recursive: true });
+  if (original !== undefined) {
+    const backup = `${file}.${new Date().toISOString().replace(/[:.]/g, '-')}.${randomUUID()}.bak`;
+    await writeFile(backup, original, { flag: 'wx', mode: 0o600 });
+    output.write(`Backup: ${backup}\n`);
+  }
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, CONFIG_TEMPLATE, { flag: 'wx', mode: 0o600 });
+    await rename(temporary, file);
+  } finally { await rm(temporary, { force: true }); }
+  output.write(`Config reset: ${file}\n`);
+  return 0;
+}