Wiki Light Mode

@@ -0,0 +1,391 @@+#!/usr/bin/env node+// wiki-light-shot — render an Adom Wiki page in synthesized LIGHT MODE and+// screenshot it (top viewport + full page), optionally injecting the shots+// into adom-shotlog so the human actually sees them.+//+// The wiki ships dark-only (color-scheme: dark, no light palette). This tool+// logs a headless Chrome in via a single-use `adom-wiki auth login` magic link+// (so private pages work), applies an invert+hue-rotate overlay with raster+// media re-inverted (hero/screenshots keep true colors), verifies at the pixel+// level that the result is genuinely light, and saves/injects the shots.+//+// Contract: OK:/WARN:/ERROR: + Hint: lines. Exit 0 = shots saved, 1 = failure.++import { execFileSync, spawnSync } from 'node:child_process';+import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';+import { createRequire } from 'node:module';+import { homedir } from 'node:os';+import { dirname, join, resolve } from 'node:path';+import { fileURLToPath } from 'node:url';+import zlib from 'node:zlib';++const PKG_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '..');+const WIKI_HOST = 'wiki.adom.inc';+const NAV_TIMEOUT_MS = 45000;+const SETTLE_MS = 2500;++// ---------- output helpers ----------+const jsonMode = process.argv.includes('--json');+const lines = [];+function say(line) { if (jsonMode) lines.push(line); else console.log(line); }+const ok = (m) => say(`OK: ${m}`);+const warn = (m) => say(`WARN: ${m}`);+const hint = (m) => say(`Hint: ${m}`);+function die(msg, ...hints) {+  if (jsonMode) {+    console.log(JSON.stringify({ status: 'error', error: msg, hints, log: lines }, null, 2));+  } else {+    console.error(`ERROR: ${msg}`);+    for (const h of hints) console.error(`Hint: ${h}`);+  }+  process.exit(1);+}++// ---------- args ----------+function usage() {+  say('wiki-light-shot — screenshot an Adom Wiki page in synthesized light mode');+  say('');+  say('Usage: wiki-light-shot <owner/slug | https://wiki.adom.inc/...> [options]');+  say('');+  say('Options:');+  say('  --out DIR        output directory (default: ./wiki-light-shots)');+  say('  --channel NAME   shotlog channel (default: the page slug)');+  say('  --no-inject      save PNGs only, skip adom-shotlog');+  say('  --no-auth        skip login (public pages only; private pages 404)');+  say('  --keep-dark      capture as-is without the light-mode overlay');+  say('  --viewport WxH   viewport size (default 1920x1200)');+  say('  --full-max PX    cap full-page capture height (default 8000)');+  say('  --json           machine-readable { status, data, hints[] } envelope');+  process.exit(process.argv.length <= 2 ? 1 : 0);+}++const VALUE_FLAGS = new Set(['--out', '--channel', '--viewport', '--full-max']);+const BOOL_FLAGS = new Set(['--no-inject', '--no-auth', '--keep-dark', '--json', '--help', '-h']);+const flags = {};+const positionals = [];+const rawArgs = process.argv.slice(2);+for (let i = 0; i < rawArgs.length; i++) {+  const a = rawArgs[i];+  if (VALUE_FLAGS.has(a)) {+    const v = rawArgs[++i];+    if (v === undefined || v.startsWith('--')) die(`${a} needs a value`);+    flags[a] = v;+  } else if (BOOL_FLAGS.has(a)) flags[a] = true;+  else if (a.startsWith('--')) die(`unknown flag ${a}`, 'run with --help for usage');+  else positionals.push(a);+}+if (rawArgs.length === 0 || flags['--help'] || flags['-h']) usage();++const flagVal = (name, dflt) => flags[name] ?? dflt;+const hasFlag = (name) => !!flags[name];++if (positionals.length !== 1) {+  die(positionals.length === 0 ? 'no page reference given' : `expected one page reference, got: ${positionals.join(', ')}`,+    'pass owner/slug (e.g. adom/puma-bridge) or a full wiki.adom.inc URL');+}+const ref = positionals[0];++const outDir = resolve(flagVal('--out', './wiki-light-shots'));+const noInject = hasFlag('--no-inject');+const noAuth = hasFlag('--no-auth');+const keepDark = hasFlag('--keep-dark');+const vpRaw = flagVal('--viewport', '1920x1200');+const vpMatch = /^(\d{3,4})x(\d{3,4})$/.exec(vpRaw);+if (!vpMatch) die(`bad --viewport '${vpRaw}'`, 'use WxH, e.g. 1920x1200');+const viewport = { width: +vpMatch[1], height: +vpMatch[2] };+const fullMax = Math.max(viewport.height, parseInt(flagVal('--full-max', '8000'), 10) || 8000);++// ---------- resolve + validate the target URL (never leak the session elsewhere) ----------+let pageUrl, slug;+if (/^https?:\/\//i.test(ref)) {+  let u;+  try { u = new URL(ref); } catch { die(`'${ref}' is not a valid URL`); }+  if (u.hostname !== WIKI_HOST) {+    die(`refusing to open ${u.hostname} — this tool logs the browser in as YOU and only navigates ${WIKI_HOST}`,+      'pass an owner/slug or a https://wiki.adom.inc/... URL');+  }+  pageUrl = u.href;+  slug = u.pathname.split('/').filter(Boolean).slice(0, 2).join('-') || 'wiki-page';+} else {+  const m = /^([A-Za-z0-9][\w.-]*)\/([A-Za-z0-9][\w.-]*)$/.exec(ref);+  if (!m) die(`'${ref}' is neither owner/slug nor a wiki URL`, 'examples: adom/puma-bridge, https://wiki.adom.inc/adom/core');+  pageUrl = `https://${WIKI_HOST}/${m[1]}/${m[2]}`;+  slug = m[2];+}+const channel = flagVal('--channel', slug);++// ---------- find Chrome ----------+function findChrome() {+  const envPath = process.env.WIKI_LIGHT_CHROME;+  if (envPath) {+    if (existsSync(envPath)) return envPath;+    die(`WIKI_LIGHT_CHROME points at '${envPath}' which does not exist`, 'unset it or fix the path');+  }+  for (const flavor of ['chrome', 'chrome-headless-shell']) {+    const base = join(homedir(), '.cache', 'puppeteer', flavor);+    if (!existsSync(base)) continue;+    const versions = readdirSync(base).filter((d) => d.startsWith('linux-'))+      .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));+    for (const v of versions) {+      for (const sub of [`chrome-linux64/chrome`, `chrome-headless-shell-linux64/chrome-headless-shell`]) {+        const p = join(base, v, sub);+        if (existsSync(p)) return p;+      }+    }+  }+  for (const name of ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser']) {+    const r = spawnSync('which', [name], { encoding: 'utf8' });+    if (r.status === 0 && r.stdout.trim()) return r.stdout.trim();+  }+  return null;+}++// ---------- puppeteer-core, self-healing ----------+async function loadPuppeteer() {+  const req = createRequire(join(PKG_DIR, 'package.json'));+  try { return req('puppeteer-core'); } catch {}+  try { return (await import('puppeteer-core')).default; } catch {}+  warn('puppeteer-core not found — installing it into the skill package (one-time)');+  // --no-save is load-bearing: this package.json's "dependencies" holds WIKI+  // deps (owner/slug refs) — letting npm write into it would corrupt them.+  const r = spawnSync('npm', ['install', 'puppeteer-core@^22', '--no-save', '--no-package-lock', '--no-audit', '--no-fund', '--silent'],+    { cwd: PKG_DIR, encoding: 'utf8', timeout: 180000 });+  if (r.status !== 0) {+    die('could not install puppeteer-core', `run manually: cd ${PKG_DIR} && npm i puppeteer-core@^22`,+      r.stderr ? `npm said: ${String(r.stderr).trim().slice(0, 300)}` : 'is npm on PATH?');+  }+  try { return req('puppeteer-core'); }+  catch (e) { die(`puppeteer-core installed but still not loadable: ${e.message}`); }+}++// ---------- auth ----------+function mintLoginUrl() {+  try {+    const out = execFileSync('adom-wiki', ['auth', 'login', '--json'], { encoding: 'utf8', timeout: 20000 });+    const parsed = JSON.parse(out);+    const url = parsed?.data?.logged_in_url;+    if (url && new URL(url).hostname === WIKI_HOST) return url;+    warn('adom-wiki auth login returned no usable link — continuing anonymously');+  } catch (e) {+    warn(`could not mint a wiki login link (${String(e.message).split('\n')[0]}) — continuing anonymously`);+    hint("private pages will 404 without auth; check `adom-wiki auth token` / `adom-wiki whoami`");+  }+  return null;+}++// ---------- tiny PNG luminance check (proof the shot is really light) ----------+// Supports what Chrome emits: 8-bit RGB/RGBA, non-interlaced.+function pngMeanLuminance(buf) {+  try {+    if (buf.readUInt32BE(0) !== 0x89504e47) return null;+    let pos = 8, width = 0, height = 0, colorType = -1, bitDepth = 0, interlace = 0;+    const idat = [];+    while (pos < buf.length) {+      const len = buf.readUInt32BE(pos);+      const type = buf.toString('ascii', pos + 4, pos + 8);+      const data = buf.subarray(pos + 8, pos + 8 + len);+      if (type === 'IHDR') {+        width = data.readUInt32BE(0); height = data.readUInt32BE(4);+        bitDepth = data[8]; colorType = data[9]; interlace = data[12];+      } else if (type === 'IDAT') idat.push(data);+      else if (type === 'IEND') break;+      pos += 12 + len;+    }+    if (bitDepth !== 8 || interlace !== 0 || (colorType !== 2 && colorType !== 6)) return null;+    const bpp = colorType === 6 ? 4 : 3;+    const raw = zlib.inflateSync(Buffer.concat(idat));+    const stride = width * bpp;+    let sum = 0, n = 0;+    const prev = Buffer.alloc(stride);+    const cur = Buffer.alloc(stride);+    const rowStep = Math.max(1, Math.floor(height / 240));   // sample ~240 rows+    const pxStep = Math.max(1, Math.floor(width / 320)) * bpp;+    for (let y = 0; y < height; y++) {+      const filter = raw[y * (stride + 1)];+      raw.copy(cur, 0, y * (stride + 1) + 1, (y + 1) * (stride + 1));+      for (let i = 0; i < stride; i++) {+        const a = i >= bpp ? cur[i - bpp] : 0, b = prev[i], c = i >= bpp ? prev[i - bpp] : 0;+        let v = cur[i];+        if (filter === 1) v = (v + a) & 255;+        else if (filter === 2) v = (v + b) & 255;+        else if (filter === 3) v = (v + ((a + b) >> 1)) & 255;+        else if (filter === 4) {+          const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);+          v = (v + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c)) & 255;+        }+        cur[i] = v;+      }+      if (y % rowStep === 0) {+        for (let i = 0; i + 2 < stride; i += pxStep) {+          sum += 0.2126 * cur[i] + 0.7152 * cur[i + 1] + 0.0722 * cur[i + 2];+          n++;+        }+      }+      cur.copy(prev);+    }+    return n ? sum / n : null;+  } catch { return null; }+}++// ---------- shotlog ----------+function shotlogAvailable() {+  const r = spawnSync('adom-shotlog', ['health'], { encoding: 'utf8', timeout: 8000 });+  return r.status === 0;+}+function inject(file, desc) {+  const r = spawnSync('adom-shotlog',+    ['inject', '-c', channel, '-d', desc, '-s', 'headless-chrome', '--thread', 'wiki light mode', file],+    { encoding: 'utf8', timeout: 30000 });+  const out = (r.stdout || '') + (r.stderr || '');+  if (r.status !== 0) { warn(`shotlog inject failed for ${file}: ${out.trim().slice(0, 200)}`); return false; }+  const seen = out.split('\n').find((l) => l.includes('viewer(s)'));+  if (seen) say(seen.trim());+  return true;+}++// ---------- main ----------+const chromePath = findChrome();+if (!chromePath) {+  die('no Chrome found', 'set WIKI_LIGHT_CHROME=/path/to/chrome, or install one: npx @puppeteer/browsers install chrome@stable');+}+const puppeteer = await loadPuppeteer();+mkdirSync(outDir, { recursive: true });++let browser;+const cleanup = async () => { try { await browser?.close(); } catch {} };+process.on('SIGINT', async () => { await cleanup(); process.exit(1); });+process.on('SIGTERM', async () => { await cleanup(); process.exit(1); });++try {+  browser = await puppeteer.launch({+    executablePath: chromePath,+    headless: 'new',+    args: ['--no-sandbox', '--disable-dev-shm-usage', '--hide-scrollbars'],+  });+} catch (e) {+  die(`Chrome failed to launch (${chromePath}): ${String(e.message).split('\n')[0]}`,+    'try a different binary via WIKI_LIGHT_CHROME');+}++try {+  const page = await browser.newPage();+  await page.setViewport({ ...viewport, deviceScaleFactor: 1 });+  await page.emulateMediaFeatures([{ name: 'prefers-color-scheme', value: 'light' }]);++  // Belt-and-braces: block requests to any non-wiki host except same-page assets.+  await page.setRequestInterception(true);+  page.on('request', (r) => {+    try {+      const h = new URL(r.url()).hostname;+      if (h === WIKI_HOST || h.endsWith('.r2.cloudflarestorage.com') || r.url().startsWith('data:')) r.continue();+      else r.abort('blockedbyclient');+    } catch { r.abort('blockedbyclient'); }+  });++  // Log in (single-use link, fresh every run). One retry with a fresh link.+  let authed = false;+  if (!noAuth) {+    for (let attempt = 0; attempt < 2 && !authed; attempt++) {+      const loginUrl = mintLoginUrl();+      if (!loginUrl) break;+      try {+        const r = await page.goto(loginUrl, { waitUntil: 'networkidle2', timeout: NAV_TIMEOUT_MS });+        // The session cookie is HttpOnly, so a clean 2xx/3xx landing is the signal.+        authed = !!r && r.status() < 400;+        if (!authed) warn(`login link landed with HTTP ${r?.status?.()} (link expired? links are single-use, 60s)`);+      } catch (e) {+        warn(`login navigation failed (attempt ${attempt + 1}): ${String(e.message).split('\n')[0]}`);+      }+    }+    if (authed) ok('logged in via single-use adom-wiki magic link');+    else warn('proceeding anonymously — private pages will 404');+  }++  // Navigate to the page, one retry (the session cookie survives retries).+  let resp = null;+  for (let attempt = 0; attempt < 2; attempt++) {+    try {+      resp = await page.goto(pageUrl, { waitUntil: 'networkidle2', timeout: NAV_TIMEOUT_MS });+      break;+    } catch (e) {+      if (attempt === 1) die(`could not load ${pageUrl}: ${String(e.message).split('\n')[0]}`,+        'is wiki.adom.inc reachable from this container?');+      warn('page load timed out, retrying once');+    }+  }+  const status = resp?.status?.() ?? 0;+  if (status === 404) {+    await cleanup();+    die(`the wiki returned 404 for ${pageUrl}`,+      authed ? 'the page does not exist (check the slug with `adom-wiki page stats <owner>/<slug>`) or your account lacks access'+             : 'the page may be private — retry without --no-auth so the tool can log in');+  }+  if (status >= 400) { await cleanup(); die(`the wiki returned HTTP ${status} for ${pageUrl}`); }+  await new Promise((r) => setTimeout(r, SETTLE_MS));++  // Synthesized light mode: invert the page, re-invert raster media so the+  // hero and screenshots keep their true colors.+  if (!keepDark) {+    await page.addStyleTag({ content: `+      html { filter: invert(1) hue-rotate(180deg) !important; color-scheme: light !important; background: #ffffff !important; }+      img, video, iframe, canvas, [style*="background-image"] { filter: invert(1) hue-rotate(180deg) !important; }+    ` });+    await new Promise((r) => setTimeout(r, 600));+  }++  const meta = await page.evaluate(() => ({+    title: document.title,+    scrollHeight: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight || 0),+  }));++  const mode = keepDark ? 'dark' : 'light';+  const topFile = join(outDir, `${slug}-${mode}-top.png`);+  const fullFile = join(outDir, `${slug}-${mode}-full.png`);+  await page.screenshot({ path: topFile });++  const fullH = Math.min(meta.scrollHeight, fullMax);+  if (meta.scrollHeight > fullMax) {+    warn(`page is ${meta.scrollHeight}px tall — full capture clipped to ${fullMax}px (raise with --full-max)`);+  }+  await page.screenshot({ path: fullFile, clip: { x: 0, y: 0, width: viewport.width, height: fullH } });+  await cleanup();++  // Pixel-level proof: is the shot actually light?+  const lum = pngMeanLuminance(readFileSync(topFile));+  if (!keepDark) {+    if (lum === null) warn('could not verify luminance (unexpected PNG format) — eyeball the shot');+    else if (lum < 100) warn(`the capture still reads DARK (mean luminance ${lum.toFixed(0)}/255) — the wiki markup may have changed; inspect ${topFile}`);+    else ok(`light mode verified: mean luminance ${lum.toFixed(0)}/255`);+  } else if (lum !== null) {+    ok(`captured as-is (mean luminance ${lum.toFixed(0)}/255)`);+  }++  ok(`saved ${topFile} (${viewport.width}x${viewport.height}) and ${fullFile} (${viewport.width}x${fullH})`);++  // Show the human, via shotlog.+  let injected = false;+  if (!noInject) {+    if (shotlogAvailable()) {+      const label = keepDark ? 'as-is (dark)' : 'in light mode (wiki is dark-only; light synthesized via CSS invert)';+      injected = inject(topFile, `wiki ${ref} ${label} - top of page`);+      injected = inject(fullFile, `wiki ${ref} ${label} - full page`) || injected;+      if (injected) ok(`injected into shotlog channel '${channel}' — the human sees it in the shotlog viewer`);+    } else {+      warn('adom-shotlog is not available — shots saved to disk only');+      hint('install it (`adom-wiki pkg install adom/adom-shotlog`) so the human can actually SEE the shots; you cannot show images in a text thread');+    }+  }++  if (jsonMode) {+    console.log(JSON.stringify({+      status: 'ok',+      data: { page: pageUrl, title: meta.title, mode, top: topFile, full: fullFile,+              meanLuminance: lum, channel: injected ? channel : null, authed },+      hints: [], log: lines,+    }, null, 2));+  }+  process.exit(0);+} catch (e) {+  await cleanup();+  die(`capture failed: ${String(e.stack || e.message).split('\n').slice(0, 3).join(' | ')}`);+}