@opul/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1391 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { writeFile, access } from "fs/promises";
+import { join } from "path";
+
+// src/ui.ts
+var isTTY = process.stderr.isTTY;
+var c = (code, s) => isTTY ? `\x1B[${code}m${s}\x1B[0m` : s;
+var ink = {
+  bold: (s) => c("1", s),
+  dim: (s) => c("2", s),
+  green: (s) => c("32", s),
+  red: (s) => c("31", s),
+  yellow: (s) => c("33", s)
+};
+function fmtDuration(ms) {
+  const total = Math.round(ms / 1e3);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+function fmtSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(0)} KB`;
+  return `${(kb / 1024).toFixed(1)} MB`;
+}
+var Progress = class {
+  start = Date.now();
+  timer = null;
+  line = "";
+  constructor() {
+    if (isTTY) this.timer = setInterval(() => this.paint(), 250);
+  }
+  update(index, total, name) {
+    const done = index + 1;
+    const dots = "\u25CF".repeat(done) + "\u25CB".repeat(Math.max(0, total - done));
+    const label = name.length > 24 ? name.slice(0, 23) + "\u2026" : name;
+    this.line = `${ink.dim(`step ${done}/${total}`)}  ${label.padEnd(24)} ${dots}`;
+    this.paint();
+  }
+  message(text) {
+    this.line = ink.dim(text);
+    this.paint();
+  }
+  paint() {
+    if (!isTTY) return;
+    const elapsed = fmtDuration(Date.now() - this.start);
+    process.stderr.write(`\r\x1B[2K${this.line}  ${ink.dim(elapsed)}`);
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    if (isTTY) process.stderr.write("\r\x1B[2K");
+  }
+};
+
+// src/commands/init.ts
+var STUB = {
+  $schema: "https://opul.dev/schema/steps.v1.json",
+  name: "My app",
+  url: "https://myapp.com",
+  viewport: { width: 1440, height: 900 },
+  cursor: { color: "#C8F24E" },
+  startUrl: "http://localhost:3000",
+  steps: [
+    { action: "goto", url: "http://localhost:3000/login" },
+    { action: "wait", selector: "[data-demo='email']", timeoutMs: 15e3 },
+    { action: "type", selector: "[data-demo='email']", text: "demo@myapp.test" },
+    { action: "type", selector: "[data-demo='password']", text: "hunter2hunter2" },
+    { action: "click", selector: "[data-demo='submit']", name: "Sign in" },
+    { action: "wait", selector: "[data-demo='dashboard']" },
+    { action: "pause", ms: 900 },
+    { action: "click", selector: "[data-demo='billing']", name: "Open billing" },
+    { action: "pause", ms: 1400 }
+  ]
+};
+async function initCommand(opts) {
+  const path = join(process.cwd(), opts.out);
+  try {
+    await access(path);
+    console.log(ink.yellow(`${opts.out} already exists \u2014 leaving it untouched.`));
+    return;
+  } catch {
+  }
+  await writeFile(path, JSON.stringify(STUB, null, 2) + "\n");
+  console.log(`${ink.green("\u2713")} wrote ${ink.bold(opts.out)}
+`);
+  console.log(ink.bold("Add demo hooks to your app so selectors stay stable:"));
+  console.log(`  ${ink.dim("\u2022")} prefer ${ink.bold("[data-demo='\u2026']")} over brittle CSS/text selectors`);
+  console.log(`  ${ink.dim("\u2022")} hide Intercom / chat bubbles during the demo`);
+  console.log(`  ${ink.dim("\u2022")} sign in with a demo account, not real data`);
+  console.log(`  ${ink.dim("\u2022")} freeze dates/clocks if the UI shows them
+`);
+  console.log(`Then record:  ${ink.bold("npx opul demo --url http://localhost:3000")}`);
+}
+
+// src/commands/doctor.ts
+import { spawnSync } from "child_process";
+
+// ../recorder/dist/record.js
+import { mkdir, writeFile as writeFile4, rm } from "fs/promises";
+import { join as join4 } from "path";
+import puppeteer from "puppeteer-core";
+
+// ../recorder/dist/chrome.js
+import { existsSync } from "fs";
+import { platform } from "os";
+var CANDIDATES = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium"
+  ],
+  linux: [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser"
+  ],
+  win32: [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+  ]
+};
+var ChromeNotFoundError = class extends Error {
+};
+function resolveChromePath(explicit) {
+  const fromEnv = process.env.PUPPETEER_EXECUTABLE_PATH;
+  const ordered = [explicit, fromEnv].filter(Boolean);
+  for (const p of ordered) {
+    if (existsSync(p))
+      return p;
+  }
+  for (const p of CANDIDATES[platform()] ?? []) {
+    if (existsSync(p))
+      return p;
+  }
+  throw new ChromeNotFoundError("Google Chrome not found. Install Chrome, or set PUPPETEER_EXECUTABLE_PATH to its path.");
+}
+function launchArgs() {
+  const args = [
+    "--hide-scrollbars",
+    "--disable-infobars",
+    "--disable-notifications",
+    "--disable-extensions",
+    "--force-color-profile=srgb",
+    "--disable-features=Translate,MediaRouter",
+    "--no-first-run",
+    "--no-default-browser-check"
+  ];
+  if (platform() === "darwin") {
+    args.push("--use-angle=metal", "--enable-gpu");
+  }
+  return args;
+}
+
+// ../recorder/dist/screencast.js
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var Screencast = class {
+  page;
+  framesDir;
+  viewport;
+  client = null;
+  frames = [];
+  seq = 0;
+  writes = [];
+  started = false;
+  baseTs = 0;
+  lastTs = 0;
+  // capture-relative CDP time of the last frame
+  lastWall = 0;
+  // Date.now() when that frame arrived
+  constructor(page, framesDir, viewport) {
+    this.page = page;
+    this.framesDir = framesDir;
+    this.viewport = viewport;
+  }
+  async start() {
+    const client = await this.page.createCDPSession();
+    this.client = client;
+    client.on("Page.screencastFrame", (evt) => {
+      const idx = this.seq++;
+      const file2 = String(idx).padStart(6, "0") + ".jpg";
+      const ts = evt.metadata?.timestamp ?? 0;
+      if (this.frames.length === 0)
+        this.baseTs = ts;
+      const rel = ts - this.baseTs;
+      this.lastTs = rel;
+      this.lastWall = Date.now();
+      this.frames.push({ file: file2, timestamp: rel });
+      const buf = Buffer.from(evt.data, "base64");
+      this.writes.push(writeFile2(join2(this.framesDir, file2), buf));
+      client.send("Page.screencastFrameAck", { sessionId: evt.sessionId }).catch(() => {
+      });
+    });
+    await client.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: 92,
+      everyNthFrame: 1,
+      maxWidth: this.viewport.width,
+      maxHeight: this.viewport.height
+    });
+    this.started = true;
+  }
+  /**
+   * capture-relative seconds now. Projects the CDP clock forward using wall
+   * time so static holds (no new paint) still advance — otherwise a final
+   * pause would look zero-length to marker/poster logic.
+   */
+  now() {
+    if (this.lastWall === 0)
+      return 0;
+    return this.lastTs + (Date.now() - this.lastWall) / 1e3;
+  }
+  async stop() {
+    if (!this.started || !this.client)
+      return this.frames;
+    await this.client.send("Page.stopScreencast").catch(() => {
+    });
+    await Promise.all(this.writes);
+    await this.client.detach().catch(() => {
+    });
+    this.started = false;
+    return this.frames;
+  }
+  getFrames() {
+    return this.frames;
+  }
+};
+
+// ../recorder/dist/overlay.js
+function overlayInitSource() {
+  return function opulInstall(config) {
+    const w = window;
+    if (w.__opulInstalled)
+      return;
+    w.__opulInstalled = true;
+    const POS_KEY = "__opul_cursor_pos";
+    const INK2 = "#0E0E0E";
+    const PAPER = "#F4F4F2";
+    function ensureFont() {
+      if (document.getElementById("__opul_font"))
+        return;
+      const l = document.createElement("link");
+      l.id = "__opul_font";
+      l.rel = "stylesheet";
+      l.href = "https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600&display=swap";
+      (document.head || document.documentElement).appendChild(l);
+    }
+    let root;
+    let cursor;
+    let lower;
+    let pos = { x: window.innerWidth / 2, y: window.innerHeight / 2 };
+    try {
+      const saved = sessionStorage.getItem(POS_KEY);
+      if (saved)
+        pos = JSON.parse(saved);
+    } catch (e) {
+    }
+    function savePos() {
+      try {
+        sessionStorage.setItem(POS_KEY, JSON.stringify(pos));
+      } catch (e) {
+      }
+    }
+    function build() {
+      ensureFont();
+      root = document.createElement("div");
+      root.id = "__opul_root";
+      root.style.cssText = "position:fixed;inset:0;z-index:2147483647;pointer-events:none;font-family:'Plus Jakarta Sans',system-ui,sans-serif;";
+      cursor = document.createElement("div");
+      cursor.style.cssText = "position:absolute;top:0;left:0;width:26px;height:26px;transform:translate(" + pos.x + "px," + pos.y + "px);will-change:transform;transition:none;";
+      cursor.innerHTML = '<svg width="26" height="26" viewBox="0 0 26 26" style="display:block;filter:drop-shadow(0 2px 3px rgba(14,14,14,.35))"><path d="M3 2 L3 21 L8.5 15.8 L12 23 L15 21.6 L11.6 14.6 L19 14.4 Z" fill="' + config.color + '" stroke="' + INK2 + '" stroke-width="1.2" stroke-linejoin="round"/></svg>';
+      lower = document.createElement("div");
+      lower.style.cssText = "position:absolute;left:24px;bottom:24px;max-width:60%;background:" + INK2 + ";color:" + PAPER + ";font-size:16px;font-weight:600;line-height:1.2;letter-spacing:-0.025em;padding:8px 12px;border-radius:6px;opacity:0;transition:opacity 150ms ease;white-space:nowrap;";
+      root.appendChild(lower);
+      root.appendChild(cursor);
+      (document.body || document.documentElement).appendChild(root);
+    }
+    function ready() {
+      return new Promise((res) => {
+        if (document.body) {
+          build();
+          res();
+        } else {
+          document.addEventListener("DOMContentLoaded", () => {
+            build();
+            res();
+          });
+        }
+      });
+    }
+    const easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+    function move2(x, y, dur) {
+      return new Promise((res) => {
+        const sx = pos.x;
+        const sy = pos.y;
+        const dx = x - sx;
+        const dy = y - sy;
+        const start = performance.now();
+        function frame(now) {
+          const t = Math.min(1, (now - start) / dur);
+          const e = easeOutCubic(t);
+          pos.x = sx + dx * e;
+          pos.y = sy + dy * e;
+          cursor.style.transform = "translate(" + pos.x + "px," + pos.y + "px)";
+          if (t < 1)
+            requestAnimationFrame(frame);
+          else {
+            savePos();
+            res();
+          }
+        }
+        requestAnimationFrame(frame);
+      });
+    }
+    function click() {
+      return new Promise((res) => {
+        cursor.animate([
+          { transform: "translate(" + pos.x + "px," + pos.y + "px) scale(1)" },
+          {
+            transform: "translate(" + pos.x + "px," + pos.y + "px) scale(0.82)"
+          },
+          { transform: "translate(" + pos.x + "px," + pos.y + "px) scale(1)" }
+        ], { duration: 110, easing: "ease-out" });
+        const r = document.createElement("div");
+        r.style.cssText = "position:absolute;left:" + (pos.x + 4) + "px;top:" + (pos.y + 4) + "px;width:14px;height:14px;margin:-7px 0 0 -7px;border-radius:50%;border:2px solid " + config.color + ";opacity:0.9;";
+        root.appendChild(r);
+        r.animate([
+          { transform: "scale(0.4)", opacity: 0.9 },
+          { transform: "scale(2.6)", opacity: 0 }
+        ], { duration: 400, easing: "ease-out" }).onfinish = () => r.remove();
+        setTimeout(res, 120);
+      });
+    }
+    function showLower(text) {
+      return new Promise((res) => {
+        lower.textContent = text;
+        void lower.offsetWidth;
+        lower.style.opacity = "1";
+        setTimeout(res, 150);
+      });
+    }
+    function hideLower2() {
+      return new Promise((res) => {
+        lower.style.opacity = "0";
+        setTimeout(res, 150);
+      });
+    }
+    function endCard(o) {
+      return new Promise((res) => {
+        if (cursor)
+          cursor.style.display = "none";
+        if (lower)
+          lower.style.display = "none";
+        const card = document.createElement("div");
+        card.style.cssText = "position:fixed;inset:0;z-index:2147483646;background:" + INK2 + ";display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;opacity:0;transition:opacity 200ms ease;font-family:'Plus Jakarta Sans',system-ui,sans-serif;";
+        const name = document.createElement("div");
+        name.textContent = o.name;
+        name.style.cssText = "color:" + PAPER + ";font-size:24px;font-weight:600;letter-spacing:-0.025em;";
+        card.appendChild(name);
+        if (o.url) {
+          const url = document.createElement("div");
+          url.textContent = o.url;
+          url.style.cssText = "color:" + PAPER + ";font-size:16px;font-weight:400;letter-spacing:-0.015em;opacity:0.85;";
+          card.appendChild(url);
+        }
+        if (o.watermark) {
+          const wm = document.createElement("div");
+          wm.textContent = "Recorded with Opul";
+          wm.style.cssText = "color:" + PAPER + ";font-size:13px;font-weight:500;opacity:0.55;margin-top:8px;";
+          card.appendChild(wm);
+        }
+        document.documentElement.appendChild(card);
+        void card.offsetWidth;
+        card.style.opacity = "1";
+        setTimeout(res, o.holdMs);
+      });
+    }
+    w.__opul = { ready, move: move2, click, showLower, hideLower: hideLower2, endCard, pos: () => pos };
+  };
+}
+
+// ../recorder/dist/runner.js
+var MOVE_MS = 240;
+var PRE_CLICK_MS = 250;
+var SETTLE_MS = 520;
+var CHAR_MS = 55;
+var StepFailure = class extends Error {
+  stepIndex;
+  selector;
+  constructor(message, stepIndex, selector) {
+    super(message);
+    this.stepIndex = stepIndex;
+    this.selector = selector;
+  }
+};
+async function installOverlay(page, color) {
+  const source = overlayInitSource();
+  await page.evaluateOnNewDocument(source, { color });
+  await page.evaluate(source, { color }).catch(() => {
+  });
+  await ensureReady(page);
+}
+async function ensureReady(page) {
+  await page.evaluate(async () => {
+    const o = window.__opul;
+    if (o && o.ready)
+      await o.ready();
+  });
+}
+async function runSteps(ctx) {
+  const { page, cast, steps, onProgress } = ctx;
+  const markers = [];
+  const total = steps.steps.length;
+  for (let i = 0; i < steps.steps.length; i++) {
+    const step = steps.steps[i];
+    onProgress?.({
+      phase: "step",
+      stepIndex: i,
+      stepTotal: total,
+      stepName: step.name ?? step.action
+    });
+    const startAt = cast.now();
+    try {
+      await runStep(page, cast, step);
+    } catch (err) {
+      throw new StepFailure(`step ${i} (${step.action}) failed: ${err.message}`, i, step.selector);
+    }
+    const endAt = cast.now();
+    markers.push({
+      kind: step.action === "pause" ? "hold" : "step",
+      index: i,
+      startAt,
+      endAt,
+      name: step.name
+    });
+  }
+  return markers;
+}
+async function centerOf(page, selector, timeoutMs) {
+  const el = await page.waitForSelector(selector, {
+    visible: true,
+    timeout: timeoutMs
+  });
+  if (!el)
+    throw new Error(`selector not found: ${selector}`);
+  await el.evaluate((n) => n.scrollIntoView({ block: "center", behavior: "smooth" }));
+  await sleep(260);
+  const rect = await el.evaluate((n) => {
+    const r = n.getBoundingClientRect();
+    return { x: r.x, y: r.y, w: r.width, h: r.height };
+  });
+  if (rect.w === 0 && rect.h === 0)
+    throw new Error(`selector not visible: ${selector}`);
+  return { x: rect.x + rect.w / 2, y: rect.y + rect.h / 2 };
+}
+async function runStep(page, cast, step) {
+  const timeout = step.timeoutMs ?? 15e3;
+  switch (step.action) {
+    case "goto": {
+      await page.goto(step.url, { waitUntil: "networkidle2", timeout });
+      await ensureReady(page);
+      return;
+    }
+    case "wait": {
+      await page.waitForSelector(step.selector, {
+        visible: true,
+        timeout
+      });
+      return;
+    }
+    case "pause": {
+      await sleep(step.ms ?? 800);
+      return;
+    }
+    case "scroll": {
+      const by = step.by ?? Math.round(0.8 * await viewportH(page));
+      await page.evaluate((d) => window.scrollBy({ top: d, behavior: "smooth" }), by);
+      await sleep(700);
+      return;
+    }
+    case "hover": {
+      const c2 = await centerOf(page, step.selector, timeout);
+      if (step.name)
+        await moveOverlay(page, c2.x, c2.y, MOVE_MS, step.name);
+      else
+        await move(page, c2.x, c2.y, MOVE_MS);
+      await page.mouse.move(c2.x, c2.y);
+      await sleep(PRE_CLICK_MS);
+      return;
+    }
+    case "click": {
+      const c2 = await centerOf(page, step.selector, timeout);
+      await moveOverlay(page, c2.x, c2.y, MOVE_MS, step.name);
+      await sleep(PRE_CLICK_MS);
+      await overlayClick(page);
+      await page.mouse.click(c2.x, c2.y);
+      await sleep(SETTLE_MS);
+      if (step.name)
+        await hideLower(page);
+      return;
+    }
+    case "type": {
+      const c2 = await centerOf(page, step.selector, timeout);
+      await moveOverlay(page, c2.x, c2.y, MOVE_MS, step.name);
+      await sleep(PRE_CLICK_MS);
+      await overlayClick(page);
+      await page.mouse.click(c2.x, c2.y);
+      await sleep(120);
+      await page.keyboard.type(step.text, {
+        delay: step.charDelayMs ?? CHAR_MS
+      });
+      await sleep(SETTLE_MS);
+      if (step.name)
+        await hideLower(page);
+      return;
+    }
+  }
+}
+async function move(page, x, y, dur) {
+  await page.evaluate(async (a) => {
+    const o = window.__opul;
+    if (o)
+      await o.move(a.x, a.y, a.dur);
+  }, { x, y, dur });
+}
+async function moveOverlay(page, x, y, dur, name) {
+  await page.evaluate(async (a) => {
+    const o = window.__opul;
+    if (!o)
+      return;
+    if (a.name)
+      await o.showLower(a.name);
+    await o.move(a.x, a.y, a.dur);
+  }, { x, y, dur, name: name ?? "" });
+}
+async function overlayClick(page) {
+  await page.evaluate(async () => {
+    const o = window.__opul;
+    if (o)
+      await o.click();
+  });
+}
+async function hideLower(page) {
+  await page.evaluate(async () => {
+    const o = window.__opul;
+    if (o)
+      await o.hideLower();
+  });
+}
+async function viewportH(page) {
+  return page.evaluate(() => window.innerHeight);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ../recorder/dist/encode.js
+import { spawn } from "child_process";
+import { writeFile as writeFile3, stat } from "fs/promises";
+import { join as join3 } from "path";
+var INK = "0x0E0E0E";
+var MIN_D = 1 / 120;
+var MAX_D = 2;
+var FfmpegError = class extends Error {
+};
+var even = (n) => 2 * Math.round(n / 2);
+function targetDims(sourceH) {
+  const h = even(sourceH);
+  const w = even(h * 16 / 9);
+  return { w, h };
+}
+function buildConcatText(frames) {
+  const lines = ["ffconcat version 1.0"];
+  for (let i = 0; i < frames.length; i++) {
+    const f = frames[i];
+    lines.push(`file '${f.file}'`);
+    const next = frames[i + 1];
+    const raw = next ? next.timestamp - f.timestamp : MAX_D;
+    const d = Math.min(MAX_D, Math.max(MIN_D, raw));
+    lines.push(`duration ${d.toFixed(4)}`);
+  }
+  const last = frames[frames.length - 1];
+  if (last)
+    lines.push(`file '${last.file}'`);
+  return lines.join("\n") + "\n";
+}
+function concatDurationMs(frames) {
+  let s = 0;
+  for (let i = 0; i < frames.length; i++) {
+    const f = frames[i];
+    const next = frames[i + 1];
+    const raw = next ? next.timestamp - f.timestamp : MAX_D;
+    s += Math.min(MAX_D, Math.max(MIN_D, raw));
+  }
+  return s * 1e3;
+}
+async function encode(opts) {
+  const { w, h } = targetDims(opts.sourceH);
+  const concatPath = join3(opts.framesDir, "concat.txt");
+  await writeFile3(concatPath, buildConcatText(opts.frames));
+  const vf = [
+    "fps=60",
+    `scale=${w}:${h}:force_original_aspect_ratio=decrease`,
+    `pad=${w}:${h}:-1:-1:color=${INK}`,
+    "unsharp=3:3:0.3",
+    "format=yuv420p"
+  ].join(",");
+  await run("ffmpeg", [
+    "-y",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    concatPath,
+    "-vf",
+    vf,
+    "-r",
+    "60",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "medium",
+    "-crf",
+    "21",
+    "-pix_fmt",
+    "yuv420p",
+    "-movflags",
+    "+faststart",
+    "-an",
+    opts.outPath
+  ]);
+  const { size } = await stat(opts.outPath);
+  return { byteSize: size, width: w, height: h };
+}
+function posterFrame(frames, markers) {
+  if (frames.length === 0)
+    throw new Error("no frames");
+  const holds = markers.filter((m) => m.kind === "hold");
+  let best = null;
+  for (const m of holds) {
+    if (!best || m.endAt - m.startAt >= best.endAt - best.startAt)
+      best = m;
+  }
+  if (!best) {
+    const steps = markers.filter((m) => m.kind !== "endcard");
+    best = steps[steps.length - 1] ?? null;
+  }
+  const t = best ? (best.startAt + best.endAt) / 2 : frames[frames.length - 1].timestamp * 0.6;
+  let chosen = frames[0];
+  for (const f of frames) {
+    if (f.timestamp <= t)
+      chosen = f;
+    else
+      break;
+  }
+  return chosen;
+}
+async function writePoster(opts) {
+  const { w, h } = targetDims(opts.sourceH);
+  const vf = [
+    `scale=${w}:${h}:force_original_aspect_ratio=decrease`,
+    `pad=${w}:${h}:-1:-1:color=${INK}`
+  ].join(",");
+  await run("ffmpeg", [
+    "-y",
+    "-i",
+    join3(opts.framesDir, opts.frame.file),
+    "-vf",
+    vf,
+    "-q:v",
+    "3",
+    opts.outPath
+  ]);
+}
+function run(cmd, args) {
+  return new Promise((resolve4, reject) => {
+    const p = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let err = "";
+    p.stderr.on("data", (d) => err += d.toString());
+    p.on("error", (e) => reject(new FfmpegError(e.message.includes("ENOENT") ? "ffmpeg not found on PATH. Install it: brew install ffmpeg" : e.message)));
+    p.on("close", (code) => {
+      if (code === 0)
+        resolve4();
+      else
+        reject(new FfmpegError(`ffmpeg exited ${code}
+${err.slice(-1500)}`));
+    });
+  });
+}
+
+// ../recorder/dist/record.js
+var END_CARD_MS = 2e3;
+var INITIAL_HOLD_MS = 600;
+async function record(opts) {
+  const { steps, outDir } = opts;
+  const framesDir = join4(outDir, "frames");
+  const videoPath = join4(outDir, "demo.mp4");
+  const posterPath = join4(outDir, "poster.jpg");
+  const vp = steps.viewport ?? { width: 1440, height: 900 };
+  const sourceH = opts.height ?? vp.height;
+  const cursorColor = steps.cursor?.color ?? "#C8F24E";
+  await mkdir(framesDir, { recursive: true });
+  opts.onProgress?.({ phase: "launch", message: "Launching Chrome" });
+  const chromePath = resolveChromePath(opts.chromePath);
+  const browser = await puppeteer.launch({
+    executablePath: chromePath,
+    headless: opts.headed ? false : true,
+    args: launchArgs(),
+    defaultViewport: { width: vp.width, height: vp.height, deviceScaleFactor: 1 },
+    userDataDir: opts.userDataDir
+  });
+  let page = null;
+  let screencast = null;
+  try {
+    page = await browser.newPage();
+    if (opts.headed)
+      await sleep2(3e3);
+    await installOverlay(page, cursorColor);
+    const first = steps.steps[0];
+    if (!first || first.action !== "goto") {
+      const startUrl = steps.startUrl ?? steps.url;
+      if (startUrl) {
+        await page.goto(startUrl, { waitUntil: "networkidle2" });
+        await page.evaluate(async () => {
+          const o = window.__opul;
+          if (o && o.ready)
+            await o.ready();
+        });
+      }
+    }
+    screencast = new Screencast(page, framesDir, vp);
+    await screencast.start();
+    opts.onProgress?.({ phase: "capture", message: "Capturing" });
+    await sleep2(INITIAL_HOLD_MS);
+    let markers = [];
+    try {
+      markers = await runSteps({
+        page,
+        cast: screencast,
+        steps,
+        onProgress: opts.onProgress
+      });
+    } catch (err) {
+      if (err instanceof StepFailure) {
+        await page.screenshot({ path: join4(outDir, "failed.png") }).catch(() => {
+        });
+      }
+      throw err;
+    }
+    const endStart = screencast.now();
+    await page.evaluate(async (o) => {
+      const api = window.__opul;
+      if (api)
+        await api.endCard(o);
+    }, {
+      name: steps.name,
+      url: steps.url ?? "",
+      watermark: opts.watermark ?? false,
+      holdMs: END_CARD_MS
+    });
+    markers.push({
+      kind: "endcard",
+      index: steps.steps.length,
+      startAt: endStart,
+      endAt: screencast.now()
+    });
+    const frames = await screencast.stop();
+    if (frames.length === 0) {
+      throw new Error("no frames captured \u2014 the page may never have painted");
+    }
+    const meta = {
+      width: vp.width,
+      height: sourceH,
+      startedAt: 0,
+      frames,
+      markers
+    };
+    await writeFile4(join4(outDir, "meta.json"), JSON.stringify(meta, null, 2));
+    opts.onProgress?.({ phase: "encode", message: "Encoding 60fps" });
+    const enc = await encode({ framesDir, frames, sourceH, outPath: videoPath });
+    opts.onProgress?.({ phase: "poster", message: "Poster" });
+    const pf = posterFrame(frames, markers);
+    await writePoster({ framesDir, frame: pf, sourceH, outPath: posterPath });
+    await rm(framesDir, { recursive: true, force: true });
+    const durationMs = concatDurationMs(frames);
+    opts.onProgress?.({ phase: "done" });
+    return {
+      videoPath,
+      posterPath,
+      durationMs,
+      byteSize: enc.byteSize,
+      width: enc.width,
+      height: enc.height
+    };
+  } finally {
+    await browser.close().catch(() => {
+    });
+  }
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ../recorder/dist/codegen.js
+import { writeFile as writeFile5 } from "fs/promises";
+import { createInterface } from "readline";
+import puppeteer2 from "puppeteer-core";
+async function recordSteps(opts) {
+  const vp = opts.viewport ?? { width: 1440, height: 900 };
+  const chromePath = resolveChromePath(opts.chromePath);
+  const browser = await puppeteer2.launch({
+    executablePath: chromePath,
+    headless: false,
+    args: launchArgs(),
+    defaultViewport: { width: vp.width, height: vp.height, deviceScaleFactor: 1 }
+  });
+  const steps = [];
+  const page = (await browser.pages())[0] ?? await browser.newPage();
+  await page.exposeFunction("__opulEmit", (payload) => {
+    let ev;
+    try {
+      ev = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    const last = steps[steps.length - 1];
+    if (ev.action === "type" && last && last.action === "click" && last.selector === ev.selector) {
+      steps.pop();
+    }
+    if (ev.action === "click") {
+      steps.push({
+        action: "click",
+        selector: ev.selector,
+        name: ev.name || void 0
+      });
+    } else if (ev.action === "type") {
+      steps.push({ action: "type", selector: ev.selector, text: ev.text ?? "" });
+    }
+  });
+  await page.evaluateOnNewDocument(captureSource());
+  await page.goto(opts.url, { waitUntil: "domcontentloaded" });
+  await page.evaluate(captureSource()).catch(() => {
+  });
+  console.error("\n\x1B[1m\u25CF recording\x1B[0m  click and type through your app.\n  press \x1B[1mEnter\x1B[0m here (or close the window) to save.\n");
+  await waitForFinish(browser);
+  await browser.close().catch(() => {
+  });
+  const host = safeHost(opts.url);
+  const file2 = {
+    $schema: "https://opul.dev/schema/steps.v1.json",
+    name: opts.name ?? host,
+    url: opts.url,
+    startUrl: opts.url,
+    viewport: vp,
+    steps
+  };
+  await writeFile5(opts.outPath, JSON.stringify(file2, null, 2) + "\n");
+  return file2;
+}
+function waitForFinish(browser) {
+  return new Promise((resolve4) => {
+    let done = false;
+    const finish = () => {
+      if (done)
+        return;
+      done = true;
+      rl.close();
+      resolve4();
+    };
+    const rl = createInterface({ input: process.stdin });
+    rl.once("line", finish);
+    browser.once("disconnected", finish);
+  });
+}
+function safeHost(url) {
+  try {
+    return new URL(url).host || "My app";
+  } catch {
+    return "My app";
+  }
+}
+function captureSource() {
+  return function install() {
+    const w = window;
+    if (w.__opulCap || !w.__opulEmit)
+      return;
+    w.__opulCap = true;
+    const sel = (el) => {
+      if (!el || el.nodeType !== 1)
+        return null;
+      const dd = el.closest("[data-demo]");
+      if (dd)
+        return `[data-demo='${dd.getAttribute("data-demo")}']`;
+      if (el.id && document.querySelectorAll(`#${CSS.escape(el.id)}`).length === 1)
+        return `#${CSS.escape(el.id)}`;
+      const parts = [];
+      let node = el;
+      while (node && node.nodeType === 1 && parts.length < 4) {
+        if (node.id) {
+          parts.unshift(`#${CSS.escape(node.id)}`);
+          break;
+        }
+        let part = node.tagName.toLowerCase();
+        const parent = node.parentElement;
+        if (parent) {
+          const same = Array.from(parent.children).filter((c2) => c2.tagName === node.tagName);
+          if (same.length > 1)
+            part += `:nth-of-type(${same.indexOf(node) + 1})`;
+        }
+        parts.unshift(part);
+        node = node.parentElement;
+      }
+      return parts.join(" > ");
+    };
+    const label = (el) => (el.textContent || "").trim().replace(/\s+/g, " ").slice(0, 40);
+    document.addEventListener("click", (e) => {
+      const raw = e.target;
+      const t = raw.closest("a,button,[data-demo],[role='button'],[onclick]") || raw;
+      const s = sel(t);
+      if (s)
+        w.__opulEmit(JSON.stringify({ action: "click", selector: s, name: label(t) }));
+    }, true);
+    document.addEventListener("change", (e) => {
+      const t = e.target;
+      if (t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA") && t.value) {
+        const s = sel(t);
+        if (s)
+          w.__opulEmit(JSON.stringify({ action: "type", selector: s, text: t.value }));
+      }
+    }, true);
+  };
+}
+
+// ../recorder/dist/schema.js
+var ACTIONS = [
+  "goto",
+  "wait",
+  "click",
+  "type",
+  "hover",
+  "scroll",
+  "pause"
+];
+var StepsValidationError = class extends Error {
+};
+function parseSteps(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new StepsValidationError("steps file must be a JSON object");
+  }
+  const obj = raw;
+  if (typeof obj.name !== "string" || obj.name.trim() === "") {
+    throw new StepsValidationError('"name" is required (product/demo name)');
+  }
+  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+    throw new StepsValidationError('"steps" must be a non-empty array');
+  }
+  const steps = obj.steps.map((s, i) => validateStep(s, i));
+  const vp = obj.viewport;
+  const viewport = vp && typeof vp.width === "number" && typeof vp.height === "number" ? { width: vp.width, height: vp.height } : { width: 1440, height: 900 };
+  return {
+    $schema: typeof obj.$schema === "string" ? obj.$schema : void 0,
+    name: obj.name,
+    url: typeof obj.url === "string" ? obj.url : void 0,
+    startUrl: typeof obj.startUrl === "string" ? obj.startUrl : void 0,
+    viewport,
+    cursor: obj.cursor && typeof obj.cursor.color === "string" ? { color: obj.cursor.color } : void 0,
+    steps
+  };
+}
+function validateStep(s, i) {
+  if (typeof s !== "object" || s === null) {
+    throw new StepsValidationError(`step ${i} must be an object`);
+  }
+  const step = s;
+  const action = step.action;
+  if (typeof action !== "string" || !ACTIONS.includes(action)) {
+    throw new StepsValidationError(`step ${i}: action must be one of ${ACTIONS.join(", ")}`);
+  }
+  const a = action;
+  const need = (field) => {
+    if (step[field] == null || step[field] === "") {
+      throw new StepsValidationError(`step ${i} (${a}): "${field}" is required`);
+    }
+  };
+  if (a === "goto")
+    need("url");
+  if (a === "click" || a === "hover" || a === "wait")
+    need("selector");
+  if (a === "type") {
+    need("selector");
+    need("text");
+  }
+  if (a === "pause" && typeof step.ms !== "number") {
+    throw new StepsValidationError(`step ${i} (pause): "ms" number is required`);
+  }
+  return {
+    action: a,
+    selector: typeof step.selector === "string" ? step.selector : void 0,
+    url: typeof step.url === "string" ? step.url : void 0,
+    text: typeof step.text === "string" ? step.text : void 0,
+    ms: typeof step.ms === "number" ? step.ms : void 0,
+    timeoutMs: typeof step.timeoutMs === "number" ? step.timeoutMs : 15e3,
+    name: typeof step.name === "string" ? step.name : void 0,
+    by: typeof step.by === "number" ? step.by : void 0,
+    charDelayMs: typeof step.charDelayMs === "number" ? step.charDelayMs : void 0
+  };
+}
+
+// src/commands/doctor.ts
+async function doctorCommand() {
+  let ok = true;
+  try {
+    const p = resolveChromePath();
+    console.log(`${ink.green("\u2713")} Chrome   ${ink.dim(p)}`);
+  } catch {
+    ok = false;
+    console.log(
+      `${ink.red("\u2717")} Chrome   not found \u2014 install Google Chrome, or set ${ink.bold("PUPPETEER_EXECUTABLE_PATH")}`
+    );
+  }
+  const ff = spawnSync("ffmpeg", ["-version"], { encoding: "utf8" });
+  if (ff.status === 0) {
+    const v = (ff.stdout || "").split("\n")[0] ?? "";
+    console.log(`${ink.green("\u2713")} ffmpeg   ${ink.dim(v)}`);
+  } else {
+    ok = false;
+    console.log(
+      `${ink.red("\u2717")} ffmpeg   not found \u2014 install it: ${ink.bold("brew install ffmpeg")} (macOS) \xB7 ${ink.bold("apt install ffmpeg")} (Linux)`
+    );
+  }
+  console.log(`${ink.green("\u2713")} Node     ${ink.dim(process.version)}`);
+  console.log(
+    ok ? `
+${ink.green("Ready to record.")}  Try: ${ink.bold("opul record --url http://localhost:3000")}` : `
+${ink.yellow("Install the missing tools above, then re-run")} ${ink.bold("opul doctor")}.`
+  );
+  if (!ok) process.exit(1);
+}
+
+// src/commands/record.ts
+import { resolve, relative } from "path";
+async function recordCommand(opts) {
+  if (!opts.url) {
+    console.error(
+      `${ink.red("\u2717")} --url is required. e.g. ${ink.bold("opul record --url http://localhost:3000")}`
+    );
+    process.exit(1);
+  }
+  const outPath = resolve(process.cwd(), opts.out);
+  try {
+    const file2 = await recordSteps({
+      url: opts.url,
+      outPath,
+      name: opts.name,
+      chromePath: opts.chrome
+    });
+    const rel = relative(process.cwd(), outPath) || opts.out;
+    const n = file2.steps.length;
+    console.log(
+      `${ink.green("\u2713")} wrote ${ink.bold(rel)} ${ink.dim(`(${n} step${n === 1 ? "" : "s"})`)}`
+    );
+    if (n === 0) {
+      console.log(
+        ink.yellow(
+          "  no steps captured \u2014 click/type inside the window next time before saving."
+        )
+      );
+    }
+    console.log(
+      `
+  review it, then record the video:
+  ${ink.bold(`opul demo --url ${opts.url} --steps ${rel}`)}`
+    );
+  } catch (e) {
+    if (e instanceof ChromeNotFoundError) {
+      console.error(`${ink.red("\u2717")} ${e.message}`);
+    } else {
+      console.error(`${ink.red("\u2717")} ${e.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/demo.ts
+import { readFile, mkdir as mkdir2, writeFile as writeFile6 } from "fs/promises";
+import { join as join5, resolve as resolve2, relative as relative2 } from "path";
+async function demoCommand(opts) {
+  const stepsPath = resolve2(process.cwd(), opts.steps);
+  const outDir = resolve2(process.cwd(), opts.out);
+  let raw;
+  try {
+    raw = await readFile(stepsPath, "utf8");
+  } catch {
+    fail(
+      `no steps file at ${ink.bold(opts.steps)}
+  run ${ink.bold("opul init")} to create one.`
+    );
+    return;
+  }
+  let steps;
+  try {
+    steps = parseSteps(JSON.parse(raw));
+  } catch (e) {
+    if (e instanceof StepsValidationError) fail(`invalid steps: ${e.message}`);
+    else fail(`steps file is not valid JSON: ${e.message}`);
+    return;
+  }
+  if (opts.url) steps.startUrl = opts.url;
+  if (opts.profile) {
+    console.error(
+      ink.yellow(
+        "\u26A0 using your Chrome profile \u2014 real cookies/logins may appear on screen. A fresh profile is safer."
+      )
+    );
+  }
+  await mkdir2(outDir, { recursive: true });
+  const progress = new Progress();
+  try {
+    const result = await record({
+      steps,
+      outDir,
+      headed: opts.headed,
+      chromePath: opts.chrome,
+      userDataDir: opts.profile,
+      height: opts.height ? Number(opts.height) : void 0,
+      watermark: true,
+      // free tier: end-card badge on local records
+      onProgress: (p) => {
+        if (p.phase === "step" && p.stepIndex != null && p.stepTotal != null) {
+          progress.update(p.stepIndex, p.stepTotal, p.stepName ?? "");
+        } else if (p.message) {
+          progress.message(p.message + "\u2026");
+        }
+      }
+    });
+    progress.stop();
+    await writeFile6(
+      join5(outDir, "demo.json"),
+      JSON.stringify(
+        {
+          title: steps.name,
+          durationMs: Math.round(result.durationMs),
+          width: result.width,
+          height: result.height,
+          byteSize: result.byteSize
+        },
+        null,
+        2
+      )
+    );
+    const rel = (p) => relative2(process.cwd(), p) || p;
+    console.log(`${ink.green("\u2713")} ${ink.bold("demo recorded")}`);
+    console.log(`  ${rel(result.videoPath)}  ${ink.dim(
+      `${fmtDuration(result.durationMs)} \xB7 ${fmtSize(result.byteSize)} \xB7 ${result.width}\xD7${result.height} \xB7 60fps`
+    )}`);
+    console.log(`  ${rel(result.posterPath)}`);
+    console.log(`
+  next:  ${ink.bold(`opul publish ${rel(result.videoPath)}`)}`);
+  } catch (e) {
+    progress.stop();
+    if (e instanceof ChromeNotFoundError) fail(e.message);
+    else if (e instanceof FfmpegError) fail(e.message);
+    else if (e instanceof StepFailure) {
+      fail(
+        `${e.message}
+  selector: ${ink.bold(e.selector ?? "\u2014")}
+  saved ${ink.bold(join5(opts.out, "failed.png"))} showing the page when it failed.`
+      );
+    } else fail(e.message);
+  }
+}
+function fail(msg) {
+  console.error(`${ink.red("\u2717")} ${msg}`);
+  process.exit(1);
+}
+
+// src/commands/auth.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/config.ts
+import { readFile as readFile2, writeFile as writeFile7, mkdir as mkdir3 } from "fs/promises";
+import { homedir } from "os";
+import { join as join6 } from "path";
+var dir = join6(homedir(), ".opul");
+var file = join6(dir, "config.json");
+var API_BASE = () => process.env.OPUL_API || "https://opul.dev";
+async function loadConfig() {
+  try {
+    return JSON.parse(await readFile2(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(cfg) {
+  await mkdir3(dir, { recursive: true });
+  await writeFile7(file, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+}
+async function requireToken() {
+  const { token } = await loadConfig();
+  if (!token) {
+    throw new Error("not logged in \u2014 run `opul login` first.");
+  }
+  return token;
+}
+
+// src/commands/auth.ts
+async function loginCommand() {
+  const base = API_BASE();
+  console.log(`Open ${ink.bold(`${base}/cli`)} and copy your device token.
+`);
+  const rl = createInterface2({ input: stdin, output: stdout });
+  const token = (await rl.question("Paste token: ")).trim();
+  rl.close();
+  if (!token) return fail2("no token entered.");
+  const res = await fetch(`${base}/api/me`, {
+    headers: { authorization: `Bearer ${token}` }
+  }).catch(() => null);
+  if (!res || !res.ok) return fail2("token rejected \u2014 check it and try again.");
+  const me = await res.json();
+  const cfg = await loadConfig();
+  await saveConfig({ ...cfg, token, apiBase: base });
+  console.log(
+    `${ink.green("\u2713")} logged in as ${ink.bold(me.email ?? "you")} ${ink.dim(`(${me.plan ?? "free"})`)}`
+  );
+}
+async function logoutCommand() {
+  const cfg = await loadConfig();
+  delete cfg.token;
+  await saveConfig(cfg);
+  console.log(`${ink.green("\u2713")} logged out.`);
+}
+async function whoamiCommand() {
+  const { token } = await loadConfig();
+  if (!token) return fail2("not logged in \u2014 run `opul login`.");
+  const res = await fetch(`${API_BASE()}/api/me`, {
+    headers: { authorization: `Bearer ${token}` }
+  }).catch(() => null);
+  if (!res || !res.ok) return fail2("session expired \u2014 run `opul login` again.");
+  const me = await res.json();
+  console.log(`${ink.bold(me.email ?? "you")} ${ink.dim(`\xB7 ${me.plan ?? "free"}`)}`);
+}
+function fail2(msg) {
+  console.error(`${ink.red("\u2717")} ${msg}`);
+  process.exit(1);
+}
+
+// src/commands/publish.ts
+import { readFile as readFile3, stat as stat2 } from "fs/promises";
+import { basename, resolve as resolve3, dirname, join as join7 } from "path";
+async function publishCommand(file2, opts) {
+  const base = API_BASE();
+  let token;
+  try {
+    token = await requireToken();
+  } catch (e) {
+    return fail3(e.message);
+  }
+  const videoPath = resolve3(process.cwd(), file2);
+  const posterPath = opts.poster ? resolve3(process.cwd(), opts.poster) : join7(dirname(videoPath), "poster.jpg");
+  let video;
+  try {
+    video = await readFile3(videoPath);
+  } catch {
+    return fail3(`file not found: ${file2}`);
+  }
+  const poster = await readFile3(posterPath).catch(() => null);
+  const size = (await stat2(videoPath)).size;
+  if (size > 200 * 1024 * 1024) return fail3("file exceeds 200 MB upload cap.");
+  const meta = await readFile3(join7(dirname(videoPath), "demo.json"), "utf8").then((s) => JSON.parse(s)).catch(() => ({}));
+  const title = opts.title ?? meta.title ?? basename(videoPath).replace(/\.[^.]+$/, "");
+  const auth = { authorization: `Bearer ${token}` };
+  const endpoint = opts.replace ? `${base}/api/demos/${encodeURIComponent(opts.replace)}/replace` : `${base}/api/demos`;
+  const presign = await fetch(endpoint, {
+    method: "POST",
+    headers: { ...auth, "content-type": "application/json" },
+    body: JSON.stringify({ title, hasPoster: !!poster, byteSize: size })
+  }).catch(() => null);
+  if (!presign || !presign.ok) {
+    return fail3(
+      presign ? `publish failed (${presign.status}): ${await presign.text()}` : "could not reach opul.dev \u2014 check your connection."
+    );
+  }
+  const { id, slug, uploadUrl, posterUploadUrl } = await presign.json();
+  process.stderr.write(ink.dim(`uploading ${fmtSize(size)}\u2026`));
+  const put = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "content-type": "video/mp4" },
+    body: video
+  }).catch(() => null);
+  if (!put || !put.ok) return fail3("\nupload failed.");
+  if (poster && posterUploadUrl) {
+    await fetch(posterUploadUrl, {
+      method: "PUT",
+      headers: { "content-type": "image/jpeg" },
+      body: poster
+    }).catch(() => null);
+  }
+  process.stderr.write("\r\x1B[2K");
+  const done = await fetch(`${base}/api/demos/${id}/complete`, {
+    method: "POST",
+    headers: { ...auth, "content-type": "application/json" },
+    body: JSON.stringify({
+      durationMs: meta.durationMs,
+      width: meta.width,
+      height: meta.height
+    })
+  }).catch(() => null);
+  if (!done || !done.ok) return fail3("failed to finalize the demo.");
+  console.log(`${ink.green("\u2713")} published`);
+  console.log(`  ${ink.bold(`${base}/d/${slug}`)}`);
+}
+function fail3(msg) {
+  console.error(`${ink.red("\u2717")} ${msg}`);
+  process.exit(1);
+}
+
+// src/commands/manage.ts
+async function lsCommand() {
+  const base = API_BASE();
+  let token;
+  try {
+    token = await requireToken();
+  } catch (e) {
+    return fail4(e.message);
+  }
+  const res = await fetch(`${base}/api/demos`, {
+    headers: { authorization: `Bearer ${token}` }
+  }).catch(() => null);
+  if (!res || !res.ok) return fail4("could not reach opul.dev \u2014 check your login.");
+  const { demos } = await res.json();
+  if (demos.length === 0) {
+    console.log(ink.dim("no demos yet \u2014 record one and `opul publish` it."));
+    return;
+  }
+  for (const d of demos) {
+    const meta = [
+      d.status,
+      fmtDuration(d.durationMs),
+      fmtSize(d.byteSize),
+      `${d.viewCount} views`
+    ].filter(Boolean).join(" \xB7 ");
+    console.log(`${ink.bold(d.title)}  ${ink.dim(d.slug)}`);
+    console.log(`  ${d.url}`);
+    console.log(`  ${ink.dim(meta)}
+`);
+  }
+}
+async function rmCommand(slug) {
+  const base = API_BASE();
+  let token;
+  try {
+    token = await requireToken();
+  } catch (e) {
+    return fail4(e.message);
+  }
+  const res = await fetch(`${base}/api/demos/${encodeURIComponent(slug)}`, {
+    method: "DELETE",
+    headers: { authorization: `Bearer ${token}` }
+  }).catch(() => null);
+  if (!res) return fail4("could not reach opul.dev.");
+  if (res.status === 404) return fail4(`no demo with slug "${slug}".`);
+  if (!res.ok) return fail4(`delete failed (${res.status}).`);
+  console.log(`${ink.green("\u2713")} deleted ${ink.bold(slug)}`);
+}
+function fail4(msg) {
+  console.error(`${ink.red("\u2717")} ${msg}`);
+  process.exit(1);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("opul").description("Record a product demo from your running web app.").version("0.1.0");
+program.command("init").description("Create an opul.steps.json stub").option("--out <file>", "output path", "opul.steps.json").action(initCommand);
+program.command("doctor").description("Check that Chrome and ffmpeg are installed").action(doctorCommand);
+program.command("record").description("Click through your app to generate a steps file").option("--url <url>", "app URL to open").option("--out <file>", "steps file to write", "opul.steps.json").option("--name <name>", "product/demo name").option("--chrome <path>", "path to Chrome executable").action(recordCommand);
+program.command("demo").description("Record a demo MP4 from your app").option("--url <url>", "app URL to open first (overrides startUrl)").option("--steps <file>", "steps file", "opul.steps.json").option("--out <dir>", "output directory", "opul-out").option("--headed", "run Chrome headed with a 3s pre-roll").option("--height <px>", "output height (width derived to 16:9)").option("--profile <dir>", "use an existing Chrome profile (prints a warning)").option("--chrome <path>", "path to Chrome executable").action(demoCommand);
+program.command("publish <file>").description("Publish an MP4 and get a shareable link").option("--title <title>", "demo title").option("--replace <slug>", "replace an existing demo, keeping its URL").option("--poster <file>", "poster image (defaults to ./poster.jpg)").action(publishCommand);
+program.command("ls").description("List your published demos").action(lsCommand);
+program.command("rm <slug>").description("Delete a published demo").action(rmCommand);
+program.command("login").description("Log in with GitHub").action(loginCommand);
+program.command("logout").description("Log out").action(logoutCommand);
+program.command("whoami").description("Show the logged-in account").action(whoamiCommand);
+program.parseAsync(process.argv).catch((e) => {
+  console.error(e);
+  process.exit(1);
+});