veodl 1.8.2 → 1.9.0

package/src/source-discovery.js

@@ -0,0 +1,251 @@
+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;
+
+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 collect = (value, mime = '') => {
+      if (!MEDIA_URL.test(value) && !MEDIA_TYPE.test(mime)) return;
+      try { urls.add(validateUrl(value)); } catch {}
+    };
+    cdp.on(message => {
+      if (message.method === 'Target.attachedToTarget') {
+        const attached = message.params.sessionId;
+        cdp.send('Network.enable', {}, attached).catch(() => {});
+        return;
+      }
+      if (message.method === '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);
+    await abortable(cdp.send('Network.enable', {}, attached.sessionId), signal);
+    await abortable(cdp.send('Page.enable', {}, attached.sessionId), signal);
+    await abortable(cdp.send('Page.navigate', { url: pageUrl }, attached.sessionId), signal);
+    await delay(Math.min(observeMs / 2, 4000), undefined, { signal });
+    await abortable(cdp.send('Runtime.evaluate', { expression: `(() => {
+      for (const video of document.querySelectorAll('video')) video.play().catch(() => {});
+      const buttons = [...document.querySelectorAll('button,[role="button"]')];
+      const play = buttons.find(node => /^(play|watch|abspielen|ansehen|start)(?:\\s+(?:video|movie|film))?$/i.test((node.getAttribute('aria-label') || node.textContent || '').trim()));
+      if (play) play.click();
+    })()`, returnByValue: true }, attached.sessionId).catch(() => {}), signal);
+    await delay(Math.max(1000, observeMs / 2), undefined, { signal });
+    await 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();
+  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 });
+      } catch { /* A request alone is not proof of downloadable media. */ }
+    }
+    signal?.throwIfAborted();
+    Object.defineProperty(sources, 'timedOut', { value: timeout.signal.aborted });
+    return sources;
+  } 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 +1,27 @@
-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, ...safe } = options;
-  return { ...safe, output: path.resolve(options.output) };
-}
+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) };
+}

package/src/uninstall.js

@@ -0,0 +1,222 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { rm } from 'node:fs/promises';
+import { commandOutput } from './output.js';
+import { cacheBase } from './paths.js';
+import { configFile as resolveConfigFile } from './config.js';
+import { cleanText, readableError } from './utils.js';
+import { removeAlias, validateAliasName, listAliases } from './alias.js';
+
+const PACKAGE = 'veodl';
+
+export const UNINSTALL_HELP = `veo uninstall - remove veo completely or one command alias
+
+Usage:
+  veo uninstall [-p|--prefix <name>] [--json]
+                               Remove one alias (e.g. veo uninstall -p veodl)
+  veo uninstall [--yes] [--keep-cache] [--keep-config] [--keep-aliases] [--json]
+                               Remove everything: aliases, package, cache, config
+  veo uninstall --help         Show this help
+
+With -p/--prefix, only that alias is deleted; veo itself stays installed.
+Without -p, veo prints what would be removed. Add --yes to delete everything:
+custom wrappers created with veo alias add, the ${PACKAGE} package itself
+(commands veo, veodl) with npm, veo's cache directory (downloads, jobs,
+backend tools, history, statistics) and the config file. Use --keep-cache,
+--keep-config or --keep-aliases to preserve one part. The config file is
+deleted by default; its path is shown before and after.
+`;
+
+export function npmUninstallCommand({ platform = process.platform } = {}) {
+  const args = ['uninstall', '-g', PACKAGE];
+  if (platform === 'win32') {
+    return {
+      command: 'cmd.exe',
+      args: ['/d', '/s', '/c', `npm ${args.join(' ')}`],
+      shell: false,
+      windowsVerbatimArguments: true,
+    };
+  }
+  return { command: 'npm', args, shell: false };
+}
+
+export function runNpmUninstall({ spawnImpl = spawn, platform = process.platform, signal, timeoutMs = 600_000 } = {}) {
+  const { command, args, ...spawnOptions } = npmUninstallCommand({ platform });
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(command, args, { ...spawnOptions, stdio: 'inherit', windowsHide: true, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs) });
+    child.once('error', reject);
+    child.once('close', resolve);
+  });
+}
+
+function parseUninstallArgs(args) {
+  let prefix;
+  let yes = false;
+  let keepCache = false;
+  let keepConfig = false;
+  let keepAliases = false;
+  let json = false;
+  let binDir;
+  const rest = [];
+  for (let index = 0; index < args.length; index++) {
+    const token = args[index];
+    if (token === '-p' || token === '--prefix') {
+      prefix = args[++index];
+      if (!prefix) throw new Error('--prefix requires an alias name. Use: veo uninstall -p veodl');
+    } else if (token.startsWith('-p=')) {
+      prefix = token.slice(3) || undefined;
+      if (!prefix) throw new Error('--prefix requires an alias name. Use: veo uninstall -p veodl');
+    } else if (token.startsWith('--prefix=')) {
+      prefix = token.slice(9) || undefined;
+      if (!prefix) throw new Error('--prefix requires an alias name. Use: veo uninstall -p veodl');
+    } else if (token === '--yes') yes = true;
+    else if (token === '--purge') {
+      // Deprecated: full cleanup is now the default. Kept so older commands keep working.
+    } else if (token === '--keep-cache') keepCache = true;
+    else if (token === '--keep-config') keepConfig = true;
+    else if (token === '--keep-aliases') keepAliases = true;
+    else if (token === '--json') json = true;
+    else if (token === '--bin-dir') {
+      binDir = args[++index];
+      if (!binDir) throw new Error('--bin-dir requires a directory.');
+    } else if (token.startsWith('--bin-dir=')) {
+      binDir = token.slice(10) || undefined;
+      if (!binDir) throw new Error('--bin-dir requires a directory.');
+    } else rest.push(token);
+  }
+  return { prefix, yes, keepCache, keepConfig, keepAliases, json, binDir, rest };
+}
+
+export async function uninstallMain(args = [], {
+  stdout = process.stdout,
+  stderr = process.stderr,
+  platform = process.platform,
+  env = process.env,
+  spawnImpl = spawn,
+  rmImpl = rm,
+  cacheRoot,
+  configFile,
+  listImpl = listAliases,
+  removeImpl = removeAlias,
+} = {}) {
+  [args, stdout, stderr] = commandOutput(args, stdout, stderr);
+  const { prefix, yes, keepCache, keepConfig, keepAliases, json, binDir, rest } = parseUninstallArgs(args);
+  if (rest.includes('-h') || rest.includes('--help')) {
+    stdout.write(UNINSTALL_HELP);
+    return 0;
+  }
+  if (rest.length) throw new Error(`Unknown option for veo uninstall: ${rest.join(' ')}. Use: veo uninstall --help`);
+
+  if (prefix) {
+    if (keepCache || keepConfig || keepAliases) throw new Error('--keep-* cannot be combined with --prefix. Remove one alias or uninstall veo itself.');
+    const valid = validateAliasName(prefix);
+    const removed = await removeImpl(valid, { binDir, platform, env });
+    if (json) {
+      stdout.write(`${JSON.stringify({ status: 'removed', ...removed })}\n`);
+      return 0;
+    }
+    stdout.write(`Alias removed: ${removed.name} (${removed.removed.length} file(s) in ${removed.binDir})\n`);
+    if (removed.builtin) stdout.write('Note: veo update recreates the shipped veodl name.\n');
+    return 0;
+  }
+
+  const cache = cacheRoot || cacheBase({ platform, env });
+  const config = configFile || resolveConfigFile({ platform, env });
+  const manual = `npm uninstall -g ${PACKAGE}`;
+
+  // Custom wrappers first so the plan names them; npm removes veo/veodl itself.
+  let customAliases = [];
+  let aliasDir = binDir ? path.resolve(binDir) : null;
+  try {
+    const listed = await listImpl({ binDir: binDir || undefined, platform, env });
+    aliasDir = listed.binDir;
+    customAliases = listed.aliases.filter(entry => entry.present && entry.managed && !entry.builtin).map(entry => entry.name);
+  } catch {
+    // No bin directory (e.g. running from source without a global install):
+    // npm uninstall still works, alias cleanup is reported as skipped.
+  }
+
+  if (!yes) {
+    if (json) {
+      stdout.write(`${JSON.stringify({ status: 'planned', package: PACKAGE, manual, aliases: customAliases, binDir: aliasDir, cache, config })}\n`);
+      return 0;
+    }
+    stdout.write(`This removes everything: the ${PACKAGE} package with npm (commands veo, veodl).\n`);
+    if (!keepAliases) {
+      stdout.write(customAliases.length
+        ? `Custom wrappers to delete: ${customAliases.join(', ')} (${aliasDir})\n`
+        : `Custom wrappers: none found${aliasDir ? ` (${aliasDir})` : ''}.\n`);
+    }
+    if (!keepCache) stdout.write(`Cache to delete: ${cache}\n`);
+    if (!keepConfig) stdout.write(`Config to delete: ${config}\n`);
+    if (keepCache || keepConfig || keepAliases) {
+      const kept = [
+        keepAliases && 'aliases',
+        keepCache && 'cache',
+        keepConfig && 'config',
+      ].filter(Boolean).join(', ');
+      stdout.write(`Kept: ${kept}.\n`);
+    }
+    const keepFlags = `${keepAliases ? ' --keep-aliases' : ''}${keepCache ? ' --keep-cache' : ''}${keepConfig ? ' --keep-config' : ''}`;
+    stdout.write(`Run with --yes to proceed: veo uninstall --yes${keepFlags}\n`);
+    stdout.write(`Manual command: ${manual}\n`);
+    return 0;
+  }
+
+  let code;
+  try {
+    stdout.write(`Uninstalling ${PACKAGE} with npm…\n`);
+    code = await runNpmUninstall({ spawnImpl, platform, signal: AbortSignal.timeout(600_000) });
+  } catch (error) {
+    const reason = error.code === 'ENOENT' ? 'npm was not found. Install Node.js/npm, or uninstall manually.' : `Could not run npm: ${readableError(error)}`;
+    stderr.write(`veo: ${reason}\nManual command: ${manual}\n`);
+    return 1;
+  }
+  if (code !== 0) {
+    stderr.write(`veo: npm exited with code ${code}. Uninstall manually with: ${manual}\n`);
+    return 1;
+  }
+
+  const removedAliases = [];
+  if (!keepAliases) {
+    for (const name of customAliases) {
+      try {
+        await removeImpl(name, { binDir: aliasDir, platform, env });
+        removedAliases.push(name);
+      } catch (error) {
+        stderr.write(`veo: removed the package but could not delete alias ${name}: ${readableError(error)}\n`);
+        return 1;
+      }
+    }
+  }
+  let cacheDeleted = false;
+  if (!keepCache) {
+    try {
+      await rmImpl(cache, { recursive: true, force: true });
+      cacheDeleted = true;
+    } catch (error) {
+      stderr.write(`veo: removed the package but could not delete the cache ${cache}: ${readableError(error)}\n`);
+      return 1;
+    }
+  }
+  let configDeleted = false;
+  if (!keepConfig) {
+    try {
+      await rmImpl(config, { force: true });
+      configDeleted = true;
+    } catch (error) {
+      stderr.write(`veo: removed the package but could not delete the config ${config}: ${readableError(error)}\n`);
+      return 1;
+    }
+  }
+  if (json) {
+    stdout.write(`${JSON.stringify({ status: 'uninstalled', package: PACKAGE, aliases: removedAliases, binDir: aliasDir, cacheDeleted, cache, configDeleted, config })}\n`);
+    return 0;
+  }
+  stdout.write(`veo uninstalled (${PACKAGE}).`);
+  if (!keepAliases) stdout.write(removedAliases.length ? ` Aliases deleted: ${removedAliases.join(', ')}.` : ' No custom wrappers found.');
+  stdout.write(cacheDeleted ? ` Cache deleted: ${cache}.` : ` Cache kept: ${cache}.`);
+  stdout.write(configDeleted ? ` Config deleted: ${config}.` : ` Config kept: ${config}.`);
+  stdout.write('\n');
+  return 0;
+}

package/src/updater.js

@@ -17,6 +17,7 @@ export const UPDATE_HELP = `veo update - keep veo current
 Usage:
   veo update               Install the latest version with npm
   veo update --check       Only check whether a newer version exists
+  veo up                   Short alias for veo update (also: veo up --check)
   veo upgrade              Alias for veo update
   veo check update         Alias for veo update --check
 
@@ -95,7 +96,7 @@ export async function maybeUpdateNotice({
   try {
     latest = await fetchLatestVersion({ fetchImpl, registry, timeoutMs });
     if (compareVersions(latest, currentVersion) > 0) {
-      message = `Update available: veo ${latest} (you have ${currentVersion}). Run: veo update`;
+      message = `Update available: veo ${latest} (you have ${currentVersion}). Run: veo up`;
     }
   } catch {
     latest = null; // Unreachable registry still consumes the throttle interval.
@@ -158,7 +159,7 @@ export async function packageVersion() {
 }
 
 /**
- * Implements `veo update [--check]`, `veo upgrade`, and `veo check update`.
+ * Implements `veo update [--check]`, `veo up`, `veo upgrade`, and `veo check update`.
  * Returns the process exit code. Deps are injectable for tests.
  */
 export async function updateMain(args, {
@@ -174,6 +175,7 @@ export async function updateMain(args, {
   activeBackend,
 } = {}) {
   [args, stdout, stderr] = commandOutput(args, stdout, stderr);
+  if (args[0] === 'up') args = ['update', ...args.slice(1)];
   current = current ?? await packageVersion();
   const isCheckCommand = args[0] === 'check';
   const rest = isCheckCommand ? args.slice(2) : args.slice(1);
@@ -194,7 +196,7 @@ export async function updateMain(args, {
   }
   const newer = compareVersions(latest, current) > 0;
   if (checkOnly) {
-    stdout.write(newer ? `Update available: veo ${latest} (you have ${current}). Run: veo update\n` : `${currentText} is up to date.\n`);
+    stdout.write(newer ? `Update available: veo ${latest} (you have ${current}). Run: veo up\n` : `${currentText} is up to date.\n`);
     return 0;
   }
   if (newer) {