@materialwebunofficial/antigravity-themes 0.0.0-stage → 1.0.4

package/bin/cli.mjs

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+// antigravity-themes: installs, runs and removes the themes. See README.md.
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, watch as watchFiles, writeFileSync } from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { ROOT, pageScript, REMOVE_SCRIPT, PROBE_SCRIPT, selectScript } from '../lib/bundle.mjs';
+import { readPort, evaluateEverywhere, watch } from '../lib/injector.mjs';
+import { installDir, stateFile, logFile, portFile, appResourcesDir } from '../lib/paths.mjs';
+import { launch, writeAutostart, removeAutostart, hasAutostart, autostartFile } from '../lib/autostart.mjs';
+
+const NAME = 'antigravity-themes';
+const pkg = JSON.parse(readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
+// npx.cmd: PowerShell's default script policy on Windows blocks plain npx (npx.ps1)
+const NPX = `${process.platform === 'win32' ? 'npx.cmd' : 'npx'} -y ${pkg.name}`;
+const [command = 'help', ...args] = process.argv.slice(2);
+const has = (flag) => args.includes(flag);
+const say = (line = '') => console.log(line);
+function fail(message) {
+  console.error(`${NAME}: ${message}`);
+  process.exit(1);
+}
+
+if (typeof WebSocket !== 'function') fail(`Node.js 22 or newer is needed (this is ${process.version}). Get it from https://nodejs.org`);
+
+// ---- Background process ------------------------------------------------------
+// It answers on 127.0.0.1 with a random token, written to run.json: other
+// commands find and stop it through that, never by process id (an id can be
+// reused by an unrelated process after a reboot).
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function readState() {
+  try { return JSON.parse(readFileSync(stateFile(), 'utf8')); } catch { return null; }
+}
+async function running() {
+  const state = readState();
+  if (!state) return null;
+  try {
+    const res = await fetch(`http://127.0.0.1:${state.port}/ping?token=${state.token}`, { signal: AbortSignal.timeout(1000) });
+    if (res.ok) return state;
+  } catch { /* not answering */ }
+  return null;
+}
+
+async function stopBackground() {
+  const state = await running();
+  if (!state) return false;
+  try {
+    await fetch(`http://127.0.0.1:${state.port}/stop?token=${state.token}`, { method: 'POST', signal: AbortSignal.timeout(2000) });
+  } catch { /* it exits while answering */ }
+  for (let i = 0; i < 30 && await running(); i++) await sleep(100);
+  return true;
+}
+
+async function startBackground(cli) {
+  mkdirSync(installDir(), { recursive: true });
+  launch(process.execPath, cli);
+  for (let i = 0; i < 100; i++) {
+    const state = await running();
+    if (state) return state;
+    await sleep(100);
+  }
+  return null;
+}
+
+async function run() {
+  const other = await running();
+  if (other) {
+    say(`Already running (process ${other.pid}).`);
+    return;
+  }
+  const token = randomUUID();
+  const control = http.createServer((req, res) => {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    if (url.searchParams.get('token') !== token) { res.writeHead(403).end(); return; }
+    if (url.pathname === '/ping') { res.end(pkg.version); return; }
+    if (url.pathname === '/stop' && req.method === 'POST') { res.end('stopping'); setTimeout(() => process.exit(0), 50); return; }
+    res.writeHead(404).end();
+  });
+  await new Promise((resolve) => control.listen(0, '127.0.0.1', resolve));
+  mkdirSync(installDir(), { recursive: true });
+  writeFileSync(stateFile(), JSON.stringify({ pid: process.pid, port: control.address().port, token, version: pkg.version }));
+  process.on('exit', () => {
+    if (readState()?.token === token) rmSync(stateFile(), { force: true });
+  });
+  for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => process.exit(0));
+  // Never two processes theming the same windows: when another one has
+  // written run.json since (the last one started wins), or the file is gone
+  // (uninstall), this one ends.
+  setInterval(() => {
+    if (readState()?.token !== token) process.exit(0);
+  }, 2000);
+  // keep the log short: it is only for troubleshooting
+  try { if (statSync(logFile()).size > 512 * 1024) rmSync(logFile()); } catch { /* none yet */ }
+  const log = (line) => {
+    const entry = `${new Date().toISOString()} ${line}`;
+    say(entry);
+    try { appendFileSync(logFile(), `${entry}\n`); } catch { /* uninstalling */ }
+  };
+  process.on('uncaughtException', (err) => {
+    log(err.stack);
+    process.exit(1);
+  });
+  log(`${NAME} ${pkg.version} running from ${ROOT}`);
+  const watcher = watch({ getSource: () => pageScript(ROOT), log });
+  if (has('--dev')) {
+    let timer;
+    for (const dir of ['src', 'themes', 'vendor']) {
+      watchFiles(path.join(ROOT, dir), { recursive: true }, () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => watcher.reload().catch((err) => log(err.message)), 150);
+      });
+    }
+    log('--dev: reloading on changes to src/, themes/ and vendor/');
+  }
+}
+
+// ---- Commands -----------------------------------------------------------------
+const RUNTIME = ['bin', 'lib', 'src', 'themes', 'vendor', 'package.json', 'README.md', 'LICENSE', 'NOTICE'];
+
+const isThemed = (result) => Boolean(result.value && JSON.parse(result.value));
+
+// Waits for the background process to reach the open windows, so that install
+// can report the result itself. Throws when Antigravity is not open.
+async function themedWindows() {
+  let results = [];
+  for (let i = 0; i < 40; i++) {
+    results = await evaluateEverywhere(PROBE_SCRIPT);
+    if (results.length && results.every(isThemed)) break;
+    await sleep(200);
+  }
+  return { themed: results.filter(isThemed).length, total: results.length };
+}
+
+async function installNative() {
+  const { execSync } = await import('node:child_process');
+  const resDir = appResourcesDir();
+  const asarPath = path.join(resDir, 'app.asar');
+  const appDir = path.join(resDir, 'app');
+  if (!existsSync(asarPath) && !existsSync(appDir)) {
+    fail(`Could not find Antigravity resources at ${resDir}. Is Antigravity installed?`);
+  }
+  await stopBackground();
+  removeAutostart();
+
+  if (!existsSync(appDir)) {
+    say('Extracting Antigravity app.asar into resources/app...');
+    execSync(`npx -y @electron/asar extract "${asarPath}" "${appDir}"`, { stdio: 'inherit' });
+  }
+
+  const bundleCode = pageScript(ROOT);
+  const bundleDest = path.join(appDir, 'dist', 'theme-bundle.js');
+  writeFileSync(bundleDest, bundleCode, 'utf8');
+
+  const preloadPath = path.join(appDir, 'dist', 'preload.js');
+  let preloadContent = readFileSync(preloadPath, 'utf8');
+  const marker = '// Antigravity Native Theme Injection (Zero background processes)';
+  if (!preloadContent.includes(marker)) {
+    const patch = `\n\n${marker}\n(function() {\n  try {\n    const electron = require('electron');\n    const path = require('path');\n    const fs = require('fs');\n    const b = path.join(__dirname, 'theme-bundle.js');\n    if (fs.existsSync(b)) {\n      const c = fs.readFileSync(b, 'utf8');\n      if (electron.webFrame) electron.webFrame.executeJavaScript(c);\n    }\n  } catch (e) {}\n})();\n`;
+    appendFileSync(preloadPath, patch, 'utf8');
+  }
+
+  say(`Installed natively into Antigravity (${resDir}).`);
+  say('No background process, no host server, and no startup entry.');
+  say('Done. The themes load permanently whenever Antigravity starts.');
+}
+
+async function install() {
+  if (has('--native')) return installNative();
+  const dir = installDir();
+  const same = path.resolve(dir) === path.resolve(ROOT);
+  const wasRunning = await stopBackground();
+  if (!same) {
+    mkdirSync(dir, { recursive: true });
+    for (const entry of RUNTIME) {
+      const from = path.join(ROOT, entry);
+      if (!existsSync(from)) continue;
+      rmSync(path.join(dir, entry), { recursive: true, force: true });
+      cpSync(from, path.join(dir, entry), { recursive: true });
+    }
+  }
+  const cli = path.join(dir, 'bin', 'cli.mjs');
+  say(`Installed ${NAME} ${pkg.version} in ${dir}`);
+  const permanent = !has('--no-autostart');
+  if (permanent) {
+    say(`Starts at logon: ${writeAutostart(process.execPath, cli)}`);
+  } else {
+    removeAutostart();
+    say('Not started at logon (--no-autostart).');
+  }
+  const state = await startBackground(cli);
+  if (!state) fail(`could not start the background process, see ${logFile()}. On Windows it needs Windows Script Host (wscript.exe), and so does the logon entry.`);
+  say(`${wasRunning ? 'Restarted' : 'Started'} in the background (process ${state.pid}).`);
+  let windows = null;
+  try { windows = await themedWindows(); } catch { /* not open */ }
+  if (!windows?.total) say('Antigravity is not open: the theme appears when it starts.');
+  else if (!windows.themed) fail(`Antigravity is open, but no window got the theme; see ${logFile()}`);
+  else say(`Theme applied to ${windows.themed} of ${windows.total} Antigravity window(s).`);
+  say();
+  say('Choose a theme in Antigravity: the "Theme" menu in the title bar (Matte), or the menu button at the');
+  say('top left, then Theme (Material 3 Expressive). Ctrl+Shift+F12 cycles through the themes.');
+  say(`Remove everything with: ${NPX} uninstall`);
+  say();
+  say(permanent
+    ? 'Done. This is permanent: the themes return at every logon and every Antigravity start. Nothing else to do.'
+    : `Done. Not permanent: after the next logon, run "${NPX} start".`);
+}
+
+async function uninstall() {
+  if (await stopBackground()) say('Stopped the background process.');
+  try {
+    const results = await evaluateEverywhere(REMOVE_SCRIPT);
+    say(`Removed the theme from ${results.filter((r) => !r.error).length} open window(s).`);
+  } catch {
+    say('Antigravity is not running: nothing to remove from its windows.');
+  }
+  const entry = removeAutostart();
+  if (entry) say(`Removed the logon entry: ${entry}`);
+  const dir = installDir();
+  if (path.basename(dir) === NAME && existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true });
+    say(`Deleted ${dir}`);
+  }
+  const appDir = path.join(appResourcesDir(), 'app');
+  if (existsSync(appDir)) {
+    rmSync(appDir, { recursive: true, force: true });
+    say(`Removed native installation at ${appDir}. Restored stock app.asar.`);
+  }
+  say('Done. Antigravity keeps your last theme choice in its own storage; it has no effect without this tool.');
+}
+
+async function on() {
+  const results = await evaluateEverywhere(pageScript(ROOT));
+  const ok = results.filter((r) => !r.error).length;
+  say(`Applied to ${ok} window(s).${await running() ? '' : ' Without the background process it lasts until a window reloads; "install" makes it permanent.'}`);
+}
+
+async function off() {
+  if (await stopBackground()) say('Stopped the background process.');
+  const results = await evaluateEverywhere(REMOVE_SCRIPT);
+  say(`Removed from ${results.filter((r) => !r.error).length} window(s).${hasAutostart() ? ' It comes back at the next logon; "uninstall" removes it for good.' : ''}`);
+}
+
+async function theme() {
+  const index = JSON.parse(readFileSync(path.join(ROOT, 'themes', 'index.json'), 'utf8'));
+  const key = args.find((a) => !a.startsWith('-'));
+  if (!key) {
+    say('Themes:');
+    for (const o of index.options) say(`  ${o.key.padEnd(14)} ${o.name}`);
+    say(`\nSwitch with: ${NPX} theme <key>`);
+    return;
+  }
+  if (!index.options.some((o) => o.key === key)) fail(`no theme "${key}". Run "theme" to list them.`);
+  const results = await evaluateEverywhere(selectScript(key));
+  const ok = results.filter((r) => r.value === 'ok').length;
+  if (!ok) fail('no themed window found. Is the background process running? Try "status".');
+  say(`Switched ${ok} window(s) to ${key}.`);
+}
+
+async function status() {
+  const dir = installDir();
+  let installed = null;
+  try { installed = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8')).version; } catch { /* not installed */ }
+  say(`Installed:   ${installed ? `${installed} in ${dir}` : 'no'}`);
+  say(`At logon:    ${hasAutostart() ? autostartFile() : 'no'}`);
+  const state = await running();
+  say(`Background:  ${state ? `running (process ${state.pid}, version ${state.version})` : 'not running'}`);
+  try {
+    const port = readPort();
+    const results = await evaluateEverywhere(PROBE_SCRIPT, port);
+    say(`Antigravity: running, port ${port}, ${results.length} window(s)`);
+    for (const r of results) {
+      const host = r.value ? JSON.parse(r.value) : null;
+      say(`  ${host ? `themed (${host.theme})` : 'not themed'}  ${r.url}`);
+    }
+  } catch (err) {
+    say(`Antigravity: ${existsSync(portFile()) ? err.message : `not running (no ${portFile()})`}`);
+  }
+  say();
+  if (installed && hasAutostart() && state) {
+    say('OK: installed and permanent.');
+  } else {
+    say(`Not permanent. Fix it with: ${NPX} install`);
+    process.exitCode = 1;
+  }
+}
+
+function help() {
+  say(`${NAME} ${pkg.version}: Matte, Paper, Nordic, and Material 3 Expressive themes for Antigravity Desktop
+
+Usage: ${NPX} <command>
+
+  install [--native]        Install the themes permanently.
+                            With --native: installs directly into Antigravity with ZERO background processes or servers.
+                            Default: copies themes to ${installDir()} and keeps them synced.
+  uninstall                 Remove the themes from Antigravity, the logon entry, and native app directory
+  start                     Start the background process that themes every window (not permanent)
+  stop                      Stop it (open windows keep the theme until they reload)
+  on                        Apply the themes to the open windows once (not permanent)
+  off                       Stop the background process and remove the themes from the open windows
+  theme [key]               List the themes, or switch every window to one
+  status                    Show what is installed and running; exit code 1 if not permanent
+  run [--dev]               Run the background process in this terminal (--dev reloads on file changes)`);
+}
+
+const commands = {
+  install, uninstall, on, off, theme, status, run, help,
+  start: async () => {
+    const state = await running() ?? await startBackground(path.join(ROOT, 'bin', 'cli.mjs'));
+    if (!state) fail(`could not start; see ${logFile()}`);
+    say(`Running in the background (process ${state.pid}).${hasAutostart() ? '' : ' Until the next logon; "install" makes it permanent.'}`);
+  },
+  stop: async () => say(await stopBackground() ? 'Stopped.' : 'Not running.'),
+  '--version': () => say(pkg.version),
+  '-v': () => say(pkg.version),
+  '--help': help,
+  '-h': help,
+};
+const handler = commands[command];
+if (!handler) fail(`unknown command "${command}". Run "help" for the list.`);
+try {
+  await handler();
+} catch (err) {
+  fail(err.message);
+}

package/lib/autostart.mjs

@@ -0,0 +1,90 @@
+// Starts the background process when the user logs in, with no window:
+//   Windows  a .vbs launcher in the Startup folder (no admin rights needed)
+//   macOS    a LaunchAgent (untested)
+//   Linux    an XDG autostart entry (untested)
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ROOT } from './bundle.mjs';
+import { installDir } from './paths.mjs';
+
+const NAME = 'antigravity-themes';
+const PACKAGE = JSON.parse(readFileSync(path.join(ROOT, 'package.json'), 'utf8')).name;
+
+function vbsRun(node, cli) {
+  const q = (s) => s.replace(/"/g, '""');
+  return `CreateObject("WScript.Shell").Run """${q(node)}"" ""${q(cli)}"" run", 0, False`;
+}
+
+// Starts the background process now, with no window. On Windows it goes through
+// the script host, as at logon: a process started directly inherits the output
+// pipes of a shell like PowerShell, and whatever reads those pipes would then
+// wait for the background process to end.
+export function launch(node, cli) {
+  if (process.platform !== 'win32') {
+    spawn(node, [cli, 'run'], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+  const file = path.join(installDir(), 'start.vbs');
+  writeFileSync(file, `${vbsRun(node, cli)}\r\n`);
+  spawn('wscript.exe', ['//B', '//Nologo', file], { stdio: 'ignore', windowsHide: true }).on('error', () => {});
+}
+
+export function autostartFile() {
+  const home = os.homedir();
+  if (process.platform === 'win32') {
+    const roaming = process.env.APPDATA ?? path.join(home, 'AppData', 'Roaming');
+    return path.join(roaming, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', `${NAME}.vbs`);
+  }
+  if (process.platform === 'darwin') return path.join(home, 'Library', 'LaunchAgents', `dev.${NAME}.plist`);
+  return path.join(process.env.XDG_CONFIG_HOME ?? path.join(home, '.config'), 'autostart', `${NAME}.desktop`);
+}
+
+// node and the installed cli.mjs, as absolute paths: the entry keeps working
+// after the npx cache is gone (and stops if Node moves: install again then)
+export function writeAutostart(node, cli) {
+  const file = autostartFile();
+  mkdirSync(path.dirname(file), { recursive: true });
+  if (process.platform === 'win32') {
+    writeFileSync(file, [
+      `' ${NAME}: applies the themes to Antigravity at logon, with no window.`,
+      `' Remove it with: npx ${PACKAGE} uninstall`,
+      vbsRun(node, cli),
+      '',
+    ].join('\r\n'));
+  } else if (process.platform === 'darwin') {
+    const x = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+    writeFileSync(file, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>dev.${NAME}</string>
+  <key>ProgramArguments</key>
+  <array><string>${x(node)}</string><string>${x(cli)}</string><string>run</string></array>
+  <key>RunAtLoad</key><true/>
+</dict>
+</plist>
+`);
+  } else {
+    const q = (s) => `"${s.replace(/(["\\`$])/g, '\\$1')}"`;
+    writeFileSync(file, `[Desktop Entry]
+Type=Application
+Name=${NAME}
+Comment=Applies the themes to Antigravity
+Exec=${q(node)} ${q(cli)} run
+X-GNOME-Autostart-enabled=true
+NoDisplay=true
+`);
+  }
+  return file;
+}
+
+export function removeAutostart() {
+  const file = autostartFile();
+  if (!existsSync(file)) return null;
+  rmSync(file);
+  return file;
+}
+
+export const hasAutostart = () => existsSync(autostartFile());

package/lib/bundle.mjs

@@ -0,0 +1,73 @@
+// Builds the script that runs inside Antigravity: the vendored md3e-web
+// components, the theme modules and the theme host, started with a bundle
+// read from themes/index.json (each theme's CSS, its fonts as base64, and
+// the choices in the Theme menu).
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// The components come first: the indicator modules need them defined.
+const MODULES = [
+  'vendor/md3e/components.js',
+  'src/context-card.js',
+  'src/turn-tokens.js',
+  'src/loading-indicator.js',
+  'src/progress-indicators.js',
+  'src/code-tools.js',
+  'src/theme-host.js',
+];
+
+export function loadBundle(root = ROOT) {
+  const themesDir = path.join(root, 'themes');
+  const index = JSON.parse(readFileSync(path.join(themesDir, 'index.json'), 'utf8'));
+  const themes = {};
+  for (const [id, files] of Object.entries(index.themes)) {
+    themes[id] = [].concat(files).map((file) => readFileSync(path.join(themesDir, file), 'utf8')).join('\n');
+  }
+  const fonts = {};
+  for (const [id, list] of Object.entries(index.fonts ?? {})) {
+    fonts[id] = list.map(({ file, ...descriptors }) => ({
+      ...descriptors,
+      data: readFileSync(path.join(themesDir, file)).toString('base64'),
+    }));
+  }
+  return { default: index.default, themes, fonts, ripple: index.ripple ?? [], options: index.options };
+}
+
+// On a new document the script runs before the parser has created <html>,
+// so it waits for that element; the host then waits for the rest itself.
+export function pageScript(root = ROOT) {
+  const parts = MODULES.map((file) => readFileSync(path.join(root, file), 'utf8'));
+  return `(() => {
+const start = () => {
+${parts.join('\n;')}
+;agyThemeHost(${JSON.stringify(loadBundle(root))});
+};
+if (document.documentElement) start();
+else new MutationObserver((_, observer) => {
+  if (!document.documentElement) return;
+  observer.disconnect();
+  start();
+}).observe(document, { childList: true });
+})();`;
+}
+
+// Undoes everything the page script did in that window
+export const REMOVE_SCRIPT = `(() => {
+  window.__agyThemeHost?.dispose();
+  document.getElementById('agy-theme-css')?.remove();
+  document.documentElement?.removeAttribute('data-agy-theme');
+})();`;
+
+// The theme host's version and theme in a window, or null without one
+export const PROBE_SCRIPT = `JSON.stringify(window.__agyThemeHost ? { version: window.__agyThemeHost.version, theme: window.__agyThemeHost.get() } : null)`;
+
+export const selectScript = (key) => `(() => {
+  const host = window.__agyThemeHost;
+  if (!host) return 'no-host';
+  if (!host.options().some((o) => o.key === ${JSON.stringify(key)})) return 'unknown';
+  host.select(${JSON.stringify(key)});
+  return 'ok';
+})()`;

package/lib/injector.mjs

@@ -0,0 +1,176 @@
+// Talks to a running Antigravity over the Chrome DevTools Protocol on
+// 127.0.0.1: Antigravity opens that port itself on every launch. Nothing is
+// sent anywhere else, and no app file is changed: the theme lives in the
+// open windows, and a script registered for each window's next document
+// brings it back after a reload while the connection lasts.
+import { readFileSync } from 'node:fs';
+import { portFile } from './paths.mjs';
+
+const TARGET_TYPES = new Set(['page', 'webview', 'iframe']);
+
+export function readPort() {
+  const file = portFile();
+  let text;
+  try {
+    text = readFileSync(file, 'utf8');
+  } catch {
+    throw new Error(`${file} was not found. Is Antigravity running?`);
+  }
+  const port = Number(text.split(/\r?\n/)[0]);
+  if (!Number.isInteger(port) || port <= 0) throw new Error(`${file} holds no port.`);
+  return port;
+}
+
+export async function listTargets(port) {
+  let res;
+  try {
+    res = await fetch(`http://127.0.0.1:${port}/json/list`);
+  } catch {
+    throw new Error(`Antigravity does not answer on port ${port}. Is it running?`);
+  }
+  const targets = await res.json();
+  return targets.filter((t) => TARGET_TYPES.has(t.type) && t.webSocketDebuggerUrl && !t.url.startsWith('devtools://'));
+}
+
+export class Session {
+  constructor(target) {
+    this.target = target;
+    this.nextId = 0;
+    this.pending = new Map();
+    this.scriptId = null;
+    this.pageEnabled = false;
+  }
+
+  open() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.target.webSocketDebuggerUrl);
+      this.ws.onopen = () => resolve(this);
+      this.ws.onerror = () => reject(new Error(`cannot connect to ${this.target.url}`));
+      this.ws.onclose = () => {
+        for (const { reject: fail } of this.pending.values()) fail(new Error('connection closed'));
+        this.pending.clear();
+        this.onclose?.();
+      };
+      this.ws.onmessage = (event) => {
+        const msg = JSON.parse(event.data);
+        const call = msg.id && this.pending.get(msg.id);
+        if (!call) return;
+        this.pending.delete(msg.id);
+        if (msg.error) call.reject(new Error(msg.error.message));
+        else call.resolve(msg.result);
+      };
+    });
+  }
+
+  send(method, params = {}) {
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  // Now, and on every new document in this window while connected. Chromium
+  // runs scripts registered for new documents only once the Page domain is
+  // enabled on this connection.
+  async apply(source) {
+    if (!this.pageEnabled) {
+      await this.send('Page.enable');
+      this.pageEnabled = true;
+    }
+    if (this.scriptId) await this.send('Page.removeScriptToEvaluateOnNewDocument', { identifier: this.scriptId });
+    ({ identifier: this.scriptId } = await this.send('Page.addScriptToEvaluateOnNewDocument', { source }));
+    await this.evaluate(source);
+  }
+
+  async evaluate(expression) {
+    const { result, exceptionDetails } = await this.send('Runtime.evaluate', { expression, returnByValue: true });
+    if (exceptionDetails) throw new Error(exceptionDetails.exception?.description ?? exceptionDetails.text);
+    return result?.value;
+  }
+
+  close() {
+    this.ws.close();
+  }
+}
+
+// Runs one script in every open window and closes again
+export async function evaluateEverywhere(script, port = readPort()) {
+  const results = [];
+  for (const target of await listTargets(port)) {
+    const session = new Session(target);
+    try {
+      await session.open();
+      results.push({ url: target.url, value: await session.evaluate(script) });
+    } catch (err) {
+      results.push({ url: target.url, error: err.message });
+    } finally {
+      session.close();
+    }
+  }
+  return results;
+}
+
+// The long-running part: themes every window Antigravity opens, keeps the
+// theme across reloads, follows the port when the app restarts, and waits
+// while it is closed. getSource() is read again when reload() is called.
+export function watch({ getSource, log = () => {} }) {
+  const sessions = new Map();   // target id -> Session
+  let port = null;
+  let source = getSource();
+  let waiting = false;
+
+  function followPort() {
+    const next = readPort();
+    if (next === port) return;
+    for (const session of sessions.values()) session.close();
+    sessions.clear();
+    if (port !== null) log(`Antigravity restarted (port ${next})`);
+    port = next;
+  }
+
+  async function attachNew() {
+    for (const target of await listTargets(port)) {
+      if (sessions.has(target.id)) continue;
+      const session = new Session(target);
+      sessions.set(target.id, session);
+      session.onclose = () => sessions.delete(target.id);
+      try {
+        await session.open();
+        await session.apply(source);
+        log(`themed ${target.type} ${target.url}`);
+      } catch (err) {
+        log(`${target.url}: ${err.message}`);
+        sessions.delete(target.id);
+      }
+    }
+  }
+
+  async function tick() {
+    try {
+      followPort();
+      await attachNew();
+      if (waiting) log(`Antigravity found on port ${port}`);
+      waiting = false;
+    } catch (err) {
+      if (!waiting) log(`waiting for Antigravity (${err.message})`);
+      waiting = true;
+    }
+  }
+
+  const timer = setInterval(tick, 2000);
+  tick();
+  return {
+    async reload() {
+      source = getSource();
+      for (const session of sessions.values()) {
+        try { await session.apply(source); } catch (err) { log(`reload failed for ${session.target.url}: ${err.message}`); }
+      }
+      log(`reloaded into ${sessions.size} window(s)`);
+    },
+    stop() {
+      clearInterval(timer);
+      for (const session of sessions.values()) session.close();
+    },
+  };
+}