Skip to content

Looksmaxxing for motion graphics. An agent skill that turns AI slop videos into films that look made by a motion designer.

8.2 KB
Raw Blame
// _cdp.mjs - shared zero-dependency Chrome DevTools Protocol helper (used by brand.mjs and render.mjs).
// Not a CLI. Exports: findChrome, launchChrome, CDP, parseArgs, die.
//
//   const br = await launchChrome({ args: [...extra flags] });
//   const page = await br.newPage({ width: 1920, height: 1080, scale: 1 });
//   await page.goto(url);  await page.eval('document.title');  await page.shot({format:'png'});
//   await br.close();
import { spawn } from 'node:child_process';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';

export function die(msg, code = 1) { console.error(`error: ${msg}`); process.exit(code); }

// Leading '//' comment block of a script, used as --help text.
export function helpFrom(metaUrl) {
  const out = [];
  for (const l of fs.readFileSync(new URL(metaUrl), 'utf8').split('\n')) {
    if (l.startsWith('#!')) continue;
    if (l.startsWith('//')) out.push(l.replace(/^\/\/ ?/, '')); else break;
  }
  return out.join('\n');
}

export function findChrome() {
  const c = [process.env.CHROME_PATH,
    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
    '/Applications/Chromium.app/Contents/MacOS/Chromium',
    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
    '/usr/bin/google-chrome', '/usr/bin/chromium', '/usr/bin/chromium-browser'];
  const p = c.find((x) => x && fs.existsSync(x));
  if (!p) die('Google Chrome not found (set CHROME_PATH)');
  return p;
}

// Minimal argv parser: flags = {name: 'string'|'bool'}; returns {pos:[], opt:{}}
export function parseArgs(argv, flags) {
  const pos = [], opt = {};
  for (let i = 0; i < argv.length; i++) {
    const a = argv[i];
    if (a.startsWith('--')) {
      const [k, inline] = a.slice(2).split(/=(.*)/s);
      if (!(k in flags)) die(`unknown option --${k} (try --help)`);
      if (flags[k] === 'bool') opt[k] = true;
      else {
        const v = inline !== undefined ? inline : argv[++i];
        if (v === undefined) die(`--${k} needs a value`);
        opt[k] = v;
      }
    } else pos.push(a);
  }
  return { pos, opt };
}

export class CDP {
  constructor(ws) {
    this.ws = ws; this.id = 0; this.pending = new Map(); this.handlers = [];
    ws.addEventListener('message', (e) => {
      const m = JSON.parse(typeof e.data === 'string' ? e.data : Buffer.from(e.data).toString());
      if (m.id !== undefined) {
        const p = this.pending.get(m.id);
        if (!p) return;
        this.pending.delete(m.id); clearTimeout(p.timer);
        if (m.error) p.rej(new Error(`${p.method}: ${m.error.message}`)); else p.res(m.result || {});
      } else for (const h of [...this.handlers]) if (h.method === m.method && (!h.sid || h.sid === m.sessionId)) h.fn(m.params || {}, m);
    });
    ws.addEventListener('close', () => {
      for (const p of this.pending.values()) { clearTimeout(p.timer); p.rej(new Error(`${p.method}: connection closed`)); }
      this.pending.clear(); this.closed = true;
    });
  }
  static async connect(url) {
    const ws = new WebSocket(url);
    await new Promise((res, rej) => {
      ws.addEventListener('open', res, { once: true });
      ws.addEventListener('error', () => rej(new Error('cannot connect to ' + url)), { once: true });
    });
    return new CDP(ws);
  }
  send(method, params = {}, sessionId, timeout = 60000) {
    return new Promise((res, rej) => {
      if (this.closed) return rej(new Error(`${method}: connection closed`));
      const id = ++this.id;
      const timer = setTimeout(() => { this.pending.delete(id); rej(new Error(`${method}: timeout after ${timeout}ms`)); }, timeout);
      this.pending.set(id, { res, rej, method, timer });
      this.ws.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
    });
  }
  on(method, fn, sid) { const h = { method, fn, sid }; this.handlers.push(h); return () => { this.handlers = this.handlers.filter((x) => x !== h); }; }
}

export async function launchChrome({ args = [], width = 1920, height = 1080, headless = true } = {}) {
  const exe = findChrome();
  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'md-chrome-'));
  const flags = [
    headless ? '--headless=new' : '', '--remote-debugging-port=0', `--user-data-dir=${dir}`,
    `--window-size=${width},${height}`, '--no-first-run', '--no-default-browser-check', '--disable-extensions',
    '--disable-sync', '--hide-scrollbars', '--mute-audio', '--force-color-profile=srgb', '--disable-dev-shm-usage',
    '--autoplay-policy=no-user-gesture-required', '--disable-renderer-backgrounding', '--disable-background-timer-throttling',
    '--disable-backgrounding-occluded-windows', '--disable-features=Translate,MediaRouter,OptimizationHints',
    '--enable-unsafe-swiftshader', '--ignore-gpu-blocklist', '--disable-popup-blocking', ...args, 'about:blank',
  ].filter(Boolean);
  const proc = spawn(exe, flags, { stdio: ['ignore', 'ignore', 'pipe'] });
  let dead = false, errTail = '';
  proc.on('exit', () => { dead = true; });
  const wsUrl = await new Promise((res, rej) => {
    const t = setTimeout(() => rej(new Error('Chrome did not report a DevTools URL in 25s\n' + errTail.slice(-600))), 25000);
    proc.stderr.on('data', (d) => {
      errTail += d; const m = /DevTools listening on (ws:\/\/\S+)/.exec(errTail);
      if (m) { clearTimeout(t); res(m[1]); }
    });
    proc.on('exit', (c) => { clearTimeout(t); rej(new Error(`Chrome exited early (code ${c})\n${errTail.slice(-600)}`)); });
  });
  const cdp = await CDP.connect(wsUrl);
  let closed = false;
  const close = async () => {
    if (closed) return; closed = true;
    try { await cdp.send('Browser.close', {}, undefined, 3000); } catch {}
    try { cdp.ws.close(); } catch {}
    if (!dead) { proc.kill('SIGTERM'); await new Promise((r) => { proc.once('exit', r); setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} r(); }, 2000); }); }
    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
  };
  process.on('exit', () => { try { proc.kill('SIGKILL'); } catch {} try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
  for (const s of ['SIGINT', 'SIGTERM']) process.on(s, () => { close().finally(() => process.exit(130)); });
  const version = (await cdp.send('Browser.getVersion')).product;

  async function newPage({ width: w = width, height: h = height, scale = 1 } = {}) {
    const { targetId } = await cdp.send('Target.createTarget', { url: 'about:blank' });
    const { sessionId } = await cdp.send('Target.attachToTarget', { targetId, flatten: true });
    const send = (m, p, t) => cdp.send(m, p, sessionId, t);
    const page = {
      sessionId, targetId, send, cdp,
      on: (ev, fn) => cdp.on(ev, fn, sessionId),
      async setViewport(vw, vh, s = 1) {
        await send('Emulation.setDeviceMetricsOverride', { width: vw, height: vh, deviceScaleFactor: s, mobile: false });
      },
      async eval(expression, { timeout = 60000 } = {}) {
        const r = await send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true }, timeout);
        if (r.exceptionDetails) {
          const d = r.exceptionDetails;
          throw new Error('page eval: ' + (d.exception?.description || d.text || 'exception').split('\n')[0]);
        }
        return r.result.value;
      },
      async goto(url, { timeout = 30000 } = {}) {
        const loaded = new Promise((res) => { const off = page.on('Page.loadEventFired', () => { off(); res(true); }); setTimeout(() => { off(); res(false); }, timeout); });
        const r = await send('Page.navigate', { url });
        if (r.errorText) throw new Error(`navigation failed: ${r.errorText} (${url})`);
        return loaded; // false = load event timed out (page may still be usable)
      },
      async shot({ format = 'png', quality = 90, clip, beyond = false } = {}) {
        const r = await send('Page.captureScreenshot', { format, ...(format === 'jpeg' ? { quality } : {}), ...(clip ? { clip } : {}), captureBeyondViewport: beyond }, 60000);
        return Buffer.from(r.data, 'base64');
      },
      close: () => cdp.send('Target.closeTarget', { targetId }).catch(() => {}),
    };
    await send('Page.enable'); await send('Runtime.enable');
    await page.setViewport(w, h, scale);
    await send('Page.bringToFront').catch(() => {});
    return page;
  }
  return { cdp, proc, version, newPage, close, exe };
}