@oya-ai/cli 1.0.97 → 1.0.101

package/dist/index.js

@@ -1,1546 +1,2060 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { spawn as spawn2 } from "child_process";
-
-// ../sdk/dist/index.js
-var OyaError = class extends Error {
-  status;
-  body;
-  constructor(message, status, body) {
-    super(message);
-    this.name = "OyaError";
-    this.status = status;
-    this.body = body;
+// src/args.ts
+function parse(argv) {
+  const [command2 = "help", ...rest] = argv;
+  const args2 = [];
+  const flags2 = {};
+  for (let i = 0; i < rest.length; i++) {
+    if (!rest[i].startsWith("--")) args2.push(rest[i]);
+    else if (takeFlag(rest[i].slice("--".length), rest[i + 1], flags2)) i++;
   }
+  return { command: command2, args: args2, flags: flags2 };
+}
+function takeFlag(name, next, flags2) {
+  const bare = next === void 0 || next.startsWith("--");
+  flags2[name] = bare ? true : next;
+  return !bare;
+}
+var flagStr = (flags2, name) => typeof flags2[name] === "string" ? flags2[name] : void 0;
+var flagNum = (flags2, name) => flagStr(flags2, name) === void 0 ? void 0 : Number(flagStr(flags2, name));
+
+// src/install.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+
+// src/prompt/style.ts
+import { stdout } from "process";
+
+// src/prompt/constants.ts
+var DEFAULT_COLUMNS = 80;
+var DEFAULT_ROWS = 24;
+var MAX_RULE_WIDTH = 74;
+var SPINNER_FRAME_MS = 80;
+
+// src/prompt/style.ts
+var ESC = "\x1B";
+var plain = !stdout.isTTY || !!process.env.NO_COLOR || process.env.TERM === "dumb";
+var wrap = (open) => (s) => plain ? s : `${ESC}[${open}m${s}${ESC}[0m`;
+var style = {
+  bold: wrap("1"),
+  dim: wrap("2"),
+  green: wrap("32"),
+  cyan: wrap("36"),
+  yellow: wrap("33"),
+  red: wrap("31"),
+  grey: wrap("90")
 };
-var Http = class {
-  constructor(baseUrl, apiKey, timeoutMs, fetchImpl) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-    this.timeoutMs = timeoutMs;
-    this.fetchImpl = fetchImpl;
-  }
-  baseUrl;
-  apiKey;
-  timeoutMs;
-  fetchImpl;
-  async request(method, path, body, timeoutMs = this.timeoutMs, headers = {}) {
-    const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
-      method,
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        ...headers,
-        ...body === void 0 ? {} : { "Content-Type": "application/json" }
-      },
-      body: body === void 0 ? void 0 : JSON.stringify(body),
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-    const text = await res.text();
-    let payload;
-    try {
-      payload = text ? JSON.parse(text) : null;
-    } catch {
-      payload = text;
-    }
-    if (!res.ok) {
-      let message = payload?.error || `${method} ${path} failed (${res.status})`;
-      if (message === "Invalid API key") message += ` for ${this.baseUrl}. Check OYA_API_KEY: a value exported in your shell beats .env.`;
-      throw new OyaError(message, res.status, payload);
-    }
-    return payload;
-  }
+var icon = {
+  ok: style.green("\u2714"),
+  fail: style.red("\u2717"),
+  warn: style.yellow("!"),
+  arrow: style.green("\u276F")
 };
-var NAVIGATE_TIMEOUT_MS = 12e4;
-var Browser = class {
-  constructor(http, info, autoCaptcha) {
-    this.http = http;
-    this.autoCaptcha = autoCaptcha;
-    this.id = info.id;
-    this.provider = info.provider;
-    this.persona = info.persona;
-    this.cdpUrl = info.cdpUrl;
-  }
-  http;
-  autoCaptcha;
-  id;
-  provider;
-  persona;
-  /** Point Playwright, Puppeteer or browser-use here. */
-  cdpUrl;
-  async command(action, params = {}, timeoutMs) {
-    const result = await this.http.request(
-      "POST",
-      `/api/browsers/${this.id}/command`,
-      { action, params },
-      timeoutMs
-    );
-    if (result.ok === false) throw new OyaError(result.error || `${action} failed`, 422, result);
-    return result.data;
-  }
-  async goto(url) {
-    await this.command("navigate", { url }, NAVIGATE_TIMEOUT_MS);
-    if (this.autoCaptcha) {
-      const result = await this.solveCaptcha();
-      if (result.present && !result.solved && !result.invisible) throw new OyaError(result.error || "CAPTCHA needs attention. Call solveCaptcha() again or open the live view.", 409, result);
-    }
-  }
-  /** The page as markdown plus numbered elements to act on. */
-  async analyze() {
-    return this.command("analyze");
-  }
-  /** Only the visible elements, which is what an agent almost always wants. */
-  async elements() {
-    return (await this.analyze()).elements.filter((e) => e.visible);
-  }
-  async click(elementId) {
-    const id = this.elementId(elementId);
-    await this.command("click", { element_id: id, selector: `[data-ac-id="${id}"]` });
-  }
-  async type(elementId, text) {
-    const id = this.elementId(elementId);
-    return this.command("type", { element_id: id, selector: `[data-ac-id="${id}"]`, text });
-  }
-  elementId(value) {
-    const id = Number(value);
-    if (typeof value !== "number" && typeof value !== "string" || value === "" || !Number.isInteger(id) || id < 0) {
-      throw new OyaError("Use a numeric element id from browser.analyze().", 400, null);
-    }
-    return id;
-  }
-  async pressKey(key) {
-    await this.command("press_key", { key });
-  }
-  /**
-   * Answer a native dialog holding the page. alert() and beforeunload are
-   * answered for you; a confirm() or prompt() waits for this, and every other
-   * command fails fast with the dialog's text until it is answered.
-   */
-  async handleDialog(accept, promptText) {
-    return this.command("handle_dialog", { accept, prompt_text: promptText });
-  }
-  /** `at` aims the wheel at an inner scroller (a results panel, a chat pane) instead of the page. */
-  async scroll(direction, amount, at) {
-    await this.command("scroll", at ? { direction, amount: amount ?? 500, ...at, smooth: false } : { direction, amount });
-  }
-  async waitFor(selector, timeout = 3e4) {
-    await this.command("wait", { selector, timeout }, timeout + 5e3);
-  }
-  /** A `data:image/…;base64,` URL. PNG or JPEG depending on the driver. */
-  async screenshot() {
-    const data = await this.command("screenshot");
-    return data.screenshot;
-  }
-  async url() {
-    const tabs = await this.tabs();
-    return tabs.find((t) => t.active)?.url || "";
-  }
-  async tabs() {
-    const data = await this.command("list_tabs");
-    return data.tabs || [];
-  }
-  async openTab(url) {
-    const data = await this.command("open_tab", { url }, NAVIGATE_TIMEOUT_MS);
-    return data.tab_id;
-  }
-  async switchTab(tabId) {
-    await this.command("switch_tab", { tab_id: tabId });
-  }
-  async closeTab(tabId) {
-    await this.command("close_tab", { tab_id: tabId });
-  }
-  /**
-  x * Detect and clear a CAPTCHA. Providers that solve natively are left to do
-   * it; everything else goes to the configured solver.
-   */
-  solveCaptcha() {
-    return this.http.request("POST", `/api/browsers/${this.id}/captcha`, {}, 18e4);
+var clearLine = plain ? "" : `${ESC}[K`;
+var up = (n) => `${ESC}[${n}A`;
+var width = () => Math.min(stdout.columns || DEFAULT_COLUMNS, MAX_RULE_WIDTH);
+var COLOUR_CODE = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+var visible = (text) => text.replace(COLOUR_CODE, "").length;
+
+// src/prompt/frame.ts
+import { stdout as stdout2 } from "process";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var counter = { number: 0, total: 0 };
+function banner(title, subtitle) {
+  const line = "\u2500".repeat(width());
+  stdout2.write(`
+${style.grey(line)}
+  ${style.bold(title)}
+`);
+  if (subtitle) stdout2.write(`  ${style.grey(subtitle)}
+`);
+  stdout2.write(`${style.grey(line)}
+`);
+}
+function steps(total) {
+  counter.total = total;
+  counter.number = 0;
+}
+function step(title, hint2) {
+  counter.number += 1;
+  const shown = counter.total ? style.grey(`${counter.number}/${counter.total}`) : "";
+  stdout2.write(`
+${style.cyan("\u25C6")} ${style.bold(title)} ${shown}
+`);
+  if (hint2) stdout2.write(`${style.grey("  " + hint2)}
+`);
+}
+function note(text) {
+  stdout2.write(`${style.grey("  " + text)}
+`);
+}
+function success(text) {
+  stdout2.write(`${icon.ok} ${text}
+`);
+}
+function warn(text) {
+  stdout2.write(`${icon.warn} ${style.yellow(text)}
+`);
+}
+function animate(label) {
+  let i = 0;
+  const timer = setInterval(() => {
+    stdout2.write(`\r  ${style.cyan(FRAMES[i++ % FRAMES.length])} ${label}\u2026   `);
+  }, SPINNER_FRAME_MS);
+  return () => clearInterval(timer);
+}
+function spinner(label) {
+  if (plain) return plainSpinner(label);
+  const halt = animate(label);
+  const stop = (mark, msg) => {
+    halt();
+    stdout2.write(`\r  ${mark} ${label}  ${style.grey(msg)}${clearLine}
+`);
+  };
+  return { done: (msg = "") => stop(icon.ok, msg), fail: (msg = "") => stop(icon.fail, msg) };
+}
+function plainSpinner(label) {
+  stdout2.write(`  ${label}\u2026 `);
+  return {
+    done: (msg = "ok") => stdout2.write(`${msg}
+`),
+    fail: (msg = "failed") => stdout2.write(`${msg}
+`)
+  };
+}
+
+// src/prompt/lines.ts
+import { createInterface } from "readline";
+import { stdin, stdout as stdout3 } from "process";
+var rl = null;
+var masked = false;
+var pending = [];
+var waiter = null;
+var ended = false;
+function deliver(line) {
+  if (waiter) {
+    const w = waiter;
+    waiter = null;
+    w(line);
+  } else pending.push(line);
+}
+function close() {
+  ended = true;
+  if (waiter) deliver("");
+}
+function maskEcho(line) {
+  const asAny = line;
+  asAny._writeToOutput = (s) => {
+    if (masked) asAny.output.write(s.includes("\n") ? "\n" : "*");
+    else asAny.output.write(s);
+  };
+}
+function iface() {
+  if (rl) return rl;
+  rl = createInterface({ input: stdin, output: stdout3, terminal: !!stdin.isTTY });
+  rl.on("line", deliver);
+  rl.on("close", close);
+  maskEcho(rl);
+  return rl;
+}
+function nextLine() {
+  const queued = pending.shift();
+  if (queued !== void 0) return Promise.resolve(queued);
+  if (ended) return Promise.resolve("");
+  iface();
+  return new Promise((resolve) => {
+    waiter = resolve;
+  });
+}
+function setMasked(on) {
+  masked = on;
+}
+function inputExhausted() {
+  return ended && !pending.length;
+}
+function pauseLines() {
+  rl?.pause();
+}
+function resumeLines() {
+  rl?.resume();
+}
+function closePrompts() {
+  if (stdin.isTTY && stdin.isRaw) stdin.setRawMode(false);
+  rl?.close();
+  rl = null;
+}
+
+// src/prompt/ask.ts
+import { stdin as stdin2, stdout as stdout4 } from "process";
+var InputError = class extends Error {
+};
+function unmask() {
+  setMasked(false);
+  stdout4.write("\n");
+}
+async function readAnswer(fallback, secret) {
+  setMasked(secret);
+  try {
+    return (await nextLine()).trim() || fallback;
+  } finally {
+    if (secret) unmask();
   }
-  /**
-   * Answer an MFA prompt with the persona's configured factor. When nothing can
-   * answer it, `liveViewUrl` is where a person finishes by hand.
-   */
-  async completeMfa() {
-    const result = await this.http.request("POST", `/api/browsers/${this.id}/mfa`, {}, 18e4);
-    if (result.liveViewUrl) result.liveViewUrl = new URL(result.liveViewUrl, this.http.baseUrl).href;
-    return result;
+}
+function check(answer, options) {
+  if (!stdin2.isTTY && !options.secret) stdout4.write(`${answer}
+`);
+  const problem = options.validate?.(answer);
+  if (!problem) return answer;
+  stdout4.write(`  ${icon.fail} ${style.red(problem)}
+`);
+  if (inputExhausted()) throw new InputError(problem);
+  return void 0;
+}
+async function readValidated(render, fallback, options) {
+  for (; ; ) {
+    render();
+    const accepted = check(await readAnswer(fallback, !!options.secret), options);
+    if (accepted !== void 0) return accepted;
   }
-  /**
-   * Natural-language control, using this key's configured model. Refer to values as
-   * `{{name}}` in the prompt. `data` the agent can read, so it can split a name or pick
-   * the matching option; `secrets` it never sees. It types both through placeholders,
-   * with filters like `{{name|first}}`, so a playbook saved from the run stores no values.
-   */
-  async ask(prompt, { data, secrets } = {}) {
-    const res = await this.http.request(
-      "POST",
-      `/api/browsers/${this.id}/chat`,
-      { messages: [{ role: "user", content: prompt }], data, secrets },
-      6e5
-    );
-    if (res.error) throw new OyaError(res.error, res.status ?? 500, res);
-    return res.text;
+}
+function ask(question, fallback = "", options = {}) {
+  return readValidated(
+    () => stdout4.write(`  ${style.green("?")} ${question}${fallback ? style.grey(` (${fallback})`) : ""} `),
+    fallback,
+    options
+  );
+}
+function askSecret(question, options = {}) {
+  return readValidated(() => stdout4.write(`  ${style.green("?")} ${question} `), "", { ...options, secret: true });
+}
+async function confirm(question, fallback = false) {
+  const answer = await ask(`${question} ${style.grey(fallback ? "[Y/n]" : "[y/N]")}`, fallback ? "y" : "n");
+  return /^y/i.test(answer);
+}
+
+// src/prompt/menu.ts
+import { stdin as stdin3, stdout as stdout5 } from "process";
+var hint = () => style.grey("  \u2191\u2193 move \xB7 enter select");
+function optionLine(o, i, chosen, interactive) {
+  const bullet = chosen ? icon.arrow : " ";
+  const number = interactive ? "" : style.grey(`${i + 1}) `);
+  const note2 = o.disabled ? `\u2014 ${o.disabled}` : o.note ? `\u2014 ${o.note}` : "";
+  const label = o.disabled ? style.grey(o.label) : chosen ? style.green(o.label) : o.label;
+  return `  ${bullet} ${number}${label}${note2 ? style.grey(`  ${note2}`) : ""}`;
+}
+function renderOptions(options, active, interactive) {
+  const columns = stdout5.columns || DEFAULT_COLUMNS;
+  let rows = 0;
+  options.forEach((o, i) => {
+    const line = optionLine(o, i, interactive && i === active, interactive);
+    stdout5.write(`${line}${clearLine}
+`);
+    rows += Math.max(1, Math.ceil(visible(line) / columns));
+  });
+  return rows;
+}
+function redraw(menu) {
+  if (!menu.canRedraw) return;
+  stdout5.write(up(menu.rows));
+  menu.rows = renderOptions(menu.options, menu.active, true) + 1;
+  stdout5.write(`${hint()}
+`);
+}
+var move = (delta) => (menu) => {
+  const here = menu.pickable.indexOf(menu.active);
+  menu.active = menu.pickable[(here + delta + menu.pickable.length) % menu.pickable.length];
+  redraw(menu);
+};
+var jump = (key) => (menu) => {
+  const target = Number(key) - 1;
+  if (menu.options[target] && !menu.options[target].disabled) {
+    menu.active = target;
+    redraw(menu);
   }
-  /**
-   * Save the last `ask()` on this browser as a named playbook. Every value that was
-   * typed, picked or clicked becomes a variable, with what the run used kept in
-   * `defaults`, so `play()` with nothing repeats the run and any one value can be
-   * swapped. `code` is the same flow as a Playwright module, to read or run yourself.
-   */
-  toPlaybook(name) {
-    return this.http.request("POST", `/api/browsers/${this.id}/playbooks`, { name }, 12e4);
+};
+var select = (menu) => ({ id: menu.options[menu.active].id });
+var KEYS = {
+  "": () => ({ id: null }),
+  [`${ESC}[A`]: move(-1),
+  k: move(-1),
+  [`${ESC}[B`]: move(1),
+  j: move(1),
+  "\r": select,
+  "\n": select
+};
+function actionFor(key) {
+  if (Object.hasOwn(KEYS, key)) return KEYS[key];
+  return /^[1-9]$/.test(key) ? jump(key) : void 0;
+}
+function collapse(menu, chosen) {
+  stdout5.write(up(menu.rows));
+  for (let i = 0; i < menu.rows; i++) stdout5.write(`${clearLine}
+`);
+  stdout5.write(up(menu.rows));
+  stdout5.write(`${chosen}${clearLine}
+`);
+}
+function recordChoice(menu) {
+  const chosen = `  ${icon.arrow} ${style.green(menu.options[menu.active].label)}`;
+  if (menu.canRedraw) collapse(menu, chosen);
+  else stdout5.write(`${chosen}
+`);
+}
+var findOption = (options, v) => options[Number(v) - 1] || options.find((o) => o.id === v);
+function pipedProblem(options, v) {
+  const picked = findOption(options, v);
+  if (!picked) return "Pick one of the numbers above.";
+  if (picked.disabled) return `${picked.label} is ${picked.disabled}. Pick another.`;
+}
+async function choosePiped(options, pickable) {
+  renderOptions(options, -1, false);
+  const answer = await ask("choice:", String(pickable[0] + 1), { validate: (v) => pipedProblem(options, v) });
+  return findOption(options, answer).id;
+}
+function openMenu(options, pickable) {
+  const rows = renderOptions(options, pickable[0], true) + 1;
+  const canRedraw = rows < (stdout5.rows || DEFAULT_ROWS) - 1;
+  return { options, pickable, active: pickable[0], rows, canRedraw };
+}
+function finish(menu, outcome, resolve, reject) {
+  if (outcome.id === null) {
+    stdout5.write("\n");
+    reject(new InputError("Cancelled."));
+  } else {
+    recordChoice(menu);
+    resolve(outcome.id);
   }
-  /**
-   * Replay a playbook with no LLM in the loop. Variables left out reuse the
-   * recorded values where there are any. If a step no longer fits the page and
-   * `autoHeal` is on (the default), the agent finishes the task and its fix is
-   * saved as a draft (`healed`, `draft`); off, the step's error is thrown.
-   * Play `'<name>:draft'` to try a draft before promoting it.
-   */
-  async play(name, data = {}, { autoHeal = true } = {}) {
-    const res = await this.http.request(
-      "POST",
-      `/api/browsers/${this.id}/playbooks/${encodeURIComponent(name)}/play`,
-      { variables: data, autoHeal },
-      6e5
-    );
-    if (res.error) throw new OyaError(res.error, res.status ?? 500, res);
-    return res;
+}
+function release(onData, wasRaw) {
+  stdin3.off("data", onData);
+  if (!wasRaw) stdin3.setRawMode(false);
+  resumeLines();
+}
+function listen(menu, wasRaw, resolve, reject) {
+  const onData = (buf) => {
+    const outcome = actionFor(buf.toString())?.(menu);
+    if (!outcome) return;
+    release(onData, wasRaw);
+    finish(menu, outcome, resolve, reject);
+  };
+  stdin3.on("data", onData);
+}
+var readKeys = (menu, wasRaw) => new Promise((resolve, reject) => listen(menu, wasRaw, resolve, reject));
+function enterRaw() {
+  pauseLines();
+  const wasRaw = !!stdin3.isRaw;
+  stdin3.setRawMode(true);
+  stdin3.resume();
+  return wasRaw;
+}
+async function chooseInteractive(options, pickable) {
+  const menu = openMenu(options, pickable);
+  const wasRaw = enterRaw();
+  stdout5.write(`${hint()}
+`);
+  try {
+    return await readKeys(menu, wasRaw);
+  } finally {
+    if (!wasRaw && stdin3.isTTY && stdin3.isRaw) stdin3.setRawMode(false);
   }
-  /**
-   * Start a prompt or playbook in the background and hear back through callbacks.
-   * `onHumanAttention` fires for an unsolved CAPTCHA, an unfinished MFA, the agent
-   * asking for help, or a replay the agent could not heal; the run waits (up to 30
-   * minutes) until you call `respond()`.
-   */
-  async submit(task, options = {}) {
-    const { onSuccess, onFailure, onHumanAttention, onHealed, pollMs, ...body } = options;
-    const started = await this.http.request("POST", `/api/browsers/${this.id}/runs`, { ...task, ...body });
-    return new Run(this.http, started.id, { onSuccess, onFailure, onHumanAttention, onHealed }, pollMs);
+}
+async function choose(question, options) {
+  const pickable = options.map((o, i) => o.disabled ? -1 : i).filter((i) => i >= 0);
+  if (!pickable.length) throw new Error(`No option available for: ${question}`);
+  stdout5.write(`  ${style.green("?")} ${style.bold(question)}
+`);
+  return stdin3.isTTY ? chooseInteractive(options, pickable) : choosePiped(options, pickable);
+}
+
+// src/install/repo.ts
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+
+// src/install/shell.ts
+import { spawn } from "child_process";
+import { createConnection } from "net";
+
+// src/install/constants.ts
+var TOKEN_BYTES = 32;
+var PORT_PROBE_MS = 700;
+var REPO_SEARCH_DEPTH = 8;
+var ENV_FILE_MODE = 384;
+var PERMISSION_BITS = 511;
+var OCTAL = 8;
+var DEFAULT_PORT = 3100;
+var EGRESS_PORT = "3128";
+var DNS_PORT = 53;
+var READY_TIMEOUT_MS = 18e4;
+var READY_POLL_MS = 2e3;
+var DIGEST_PREVIEW = 19;
+var INTERVIEW_STEPS = 6;
+var PLAN_LABEL_WIDTH = 12;
+var JSON_INDENT = 2;
+var COMPOSE_MIN = { major: 2, minor: 24 };
+var NODE_MIN = { major: 22, minor: 13 };
+var Status = {
+  /** The key is wrong. */
+  UNAUTHORIZED: 401,
+  /** The key may not use this endpoint. */
+  FORBIDDEN: 403
+};
+
+// src/install/shell.ts
+function settle(cmd, args2, resolve, reject) {
+  return (code) => code === 0 ? resolve() : reject(new Error(`${cmd} ${args2.join(" ")} exited ${code}`));
+}
+function run(cmd, args2, opts = { cwd: process.cwd() }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args2, { cwd: opts.cwd, stdio: opts.quiet ? "ignore" : "inherit" });
+    child.on("error", reject);
+    child.on("close", settle(cmd, args2, resolve, reject));
+  });
+}
+function pipeTo(cmd, args2, stdin4, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args2, { cwd, stdio: ["pipe", "inherit", "inherit"] });
+    child.on("error", reject);
+    child.on("close", settle(cmd, args2, resolve, reject));
+    child.stdin.end(stdin4);
+  });
+}
+async function capture(cmd, args2, cwd = process.cwd()) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args2, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    const out2 = [];
+    child.stdout.on("data", (d) => out2.push(String(d)));
+    child.on("error", () => resolve(null));
+    child.on("close", (code) => resolve(code === 0 ? out2.join("").trim() : null));
+  });
+}
+var has = async (cmd) => await capture(cmd, ["--version"]) !== null;
+function atLeast(version, major, minor) {
+  const m = /(\d+)\.(\d+)/.exec(version || "");
+  if (!m) return false;
+  return Number(m[1]) > major || Number(m[1]) === major && Number(m[2]) >= minor;
+}
+function watchProbe(socket, resolve) {
+  const settle2 = (free) => {
+    socket.destroy();
+    resolve(free);
+  };
+  socket.on("connect", () => settle2(false)).on("error", () => resolve(true));
+  setTimeout(() => settle2(true), PORT_PROBE_MS);
+}
+function portFree(port) {
+  return new Promise((resolve) => watchProbe(createConnection({ port, host: "127.0.0.1" }), resolve));
+}
+
+// src/install/repo.ts
+var SERVER_ENTRIES = ["index.ts", "index.js"];
+var isRepoRoot = (dir) => existsSync(join(dir, "docker-compose.yml")) && SERVER_ENTRIES.some((entry) => existsSync(join(dir, "server", "src", entry)));
+function findRepoRoot(from = process.cwd()) {
+  let dir = from;
+  for (let i = 0; i < REPO_SEARCH_DEPTH; i++) {
+    if (isRepoRoot(dir)) return dir;
+    const up2 = dirname(dir);
+    if (up2 === dir) break;
+    dir = up2;
   }
-  /**
-   * Watch it work: the console, opened on this browser.
-   *
-   * This used to return the raw frame stream with the project's API key in the
-   * query string — a permanent credential in browser history, Referer headers
-   * and every proxy log on the way, and a URL that renders as a wall of
-   * text/event-stream if a person actually opens it. It is the console deep
-   * link now, the same one the server hands back from `completeMfa()`, and it
-   * carries no credential at all.
-   *
-   * For the frames themselves, use `liveStreamUrl()`.
-   */
-  liveViewUrl() {
-    return `${this.http.baseUrl}/dashboard/?browser=${encodeURIComponent(this.id)}`;
+  return null;
+}
+async function locateRepo() {
+  const found = findRepoRoot();
+  if (found) return found;
+  console.log("\nThis does not look like an oya-browser checkout.");
+  const where = await ask("Clone it to:", join(process.cwd(), "oya-browser"));
+  if (existsSync(where)) throw new Error(`${where} already exists`);
+  const repo = "https://github.com/OyadotAI/oya-browser.git";
+  await run("git", ["clone", "--depth", "1", repo, where], { cwd: process.cwd() });
+  return where;
+}
+
+// src/install/llm.ts
+var LLM_PRESETS = {
+  anthropic: { base: "https://api.anthropic.com/v1", model: "claude-sonnet-4-5", label: "Anthropic (Claude)" },
+  openai: { base: "https://api.openai.com/v1", model: "gpt-4o-mini", label: "OpenAI" },
+  gemini: {
+    base: "https://generativelanguage.googleapis.com/v1beta/openai",
+    model: "gemini-3.8-flash",
+    label: "Gemini (Google)"
+  },
+  // Express mode: a global endpoint, no GCP project or location needed.
+  vertex: {
+    base: "https://aiplatform.googleapis.com/v1/publishers/google",
+    model: "gemini-2.5-flash",
+    label: "Gemini Enterprise (Vertex AI)"
   }
-  /**
-   * The SSE stream of JPEG frames, for embedding in your own UI. EventSource
-   * cannot set headers, so the URL carries a connection ticket: single use,
-   * 60 seconds. Mint one per viewer — the first connection spends it.
-   */
-  async liveStreamUrl() {
-    const { ticket } = await this.http.request(
-      "POST",
-      `/api/control/sessions/${encodeURIComponent(this.id)}/ticket`,
-      {}
-    );
-    return `${this.http.baseUrl}/api/live/${this.id}?ticket=${encodeURIComponent(ticket)}`;
+};
+var LLM_OPTIONS = [
+  { id: "anthropic", label: "Anthropic (Claude)" },
+  { id: "openai", label: "OpenAI" },
+  { id: "gemini", label: "Gemini (Google)" },
+  { id: "vertex", label: "Gemini Enterprise (Vertex AI)", note: "express-mode API key" },
+  { id: "compatible", label: "An OpenAI-compatible endpoint", note: "OpenRouter, Together, Groq, Azure" },
+  { id: "local", label: "A local model", note: "Ollama, vLLM, LM Studio" },
+  { id: "skip", label: "Skip", note: "no agent control; add it later with `oya config`" }
+];
+var SKIPPED = { answers: { provider: "skip", baseUrl: "", model: "" }, key: "" };
+async function endpointFor(provider) {
+  const preset = LLM_PRESETS[provider];
+  if (preset) return preset.base;
+  const fallback = provider === "local" ? "http://localhost:11434/v1" : "https://openrouter.ai/api/v1";
+  return (await ask("Base URL:", fallback)).replace(/\/+$/, "");
+}
+async function askLlm() {
+  step("Agent LLM", "Drives `oya ask` and the chat API.");
+  note("CDP, the SDK and MCP all work without one.");
+  const provider = await choose("Which LLM should agents use?", LLM_OPTIONS);
+  if (provider === "skip") return { answers: { provider, baseUrl: "", model: "" }, key: "" };
+  const baseUrl = await endpointFor(provider);
+  const model = await ask("Model:", LLM_PRESETS[provider]?.model || (provider === "local" ? "qwen2.5" : ""));
+  return askKey({ provider, baseUrl, model });
+}
+async function askKey(answers) {
+  for (; ; ) {
+    const key = await askSecret(answers.provider === "local" ? "API key (blank if none):" : "API key:");
+    if (!key) return { answers, key: "" };
+    const problem = await verifyLlm(answers.baseUrl, key, answers.model);
+    if (!problem) return { answers, key };
+    warn(problem);
+    if (await retryOrSkip() === "skip") return SKIPPED;
   }
-  /**
-   * A shareable link to this browser's live view, for handing to a person or
-   * embedding in your own app. The token rides in the URL fragment, so it never
-   * reaches a server log or Referer header. `control: true` lets whoever opens
-   * it take over and act in the browser; otherwise it is view-only. The link
-   * expires (default one hour) and is revocable with `revokeShare(id)`.
-   *
-   * The credential is scoped to this one browser: it cannot see or touch the
-   * rest of your project. Anyone holding the link has that access until it
-   * expires or you revoke it, so treat it like a password.
-   */
-  async shareUrl({ control = false, expiresInSeconds = 3600 } = {}) {
-    const c = await this.http.request(
-      "POST",
-      `/api/control/sessions/${encodeURIComponent(this.id)}/share`,
-      { control, expiresIn: expiresInSeconds }
-    );
-    return { url: `${this.http.baseUrl}/live/${encodeURIComponent(this.id)}#t=${encodeURIComponent(c.token)}`, id: c.id, expiresAt: c.expiresAt };
+}
+function retryOrSkip() {
+  return choose("What now?", [
+    { id: "retry", label: "Enter the key again" },
+    { id: "skip", label: "Continue without an LLM", note: "add it later with `oya config`" }
+  ]);
+}
+function authHeaders(baseUrl, key) {
+  const anthropic = /(^|\.)anthropic\.com$/i.test(new URL(baseUrl).hostname);
+  return anthropic ? { "x-api-key": key, "anthropic-version": "2023-06-01" } : { Authorization: `Bearer ${key}` };
+}
+function generateOnce(baseUrl, key, model) {
+  const name = encodeURIComponent(model || "gemini-2.5-flash");
+  const body = { contents: [{ role: "user", parts: [{ text: "hi" }] }], generationConfig: { maxOutputTokens: 1 } };
+  const url = `${baseUrl.replace(/\/+$/, "")}/models/${name}:generateContent?key=${encodeURIComponent(key)}`;
+  return fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+}
+function probe(baseUrl, key, model) {
+  const headers = authHeaders(baseUrl, key);
+  if (/\/publishers\/google\/?$/.test(baseUrl)) return generateOnce(baseUrl, key, model);
+  return fetch(`${baseUrl}/models`, { headers });
+}
+async function judge(res, spin, baseUrl, model) {
+  if (res.status === Status.UNAUTHORIZED || res.status === Status.FORBIDDEN) {
+    spin.fail();
+    return `${baseUrl} rejected that key (HTTP ${res.status}).`;
   }
-  /** Revoke a link from `shareUrl()` before it expires, by the id it returned. */
-  async revokeShare(id) {
-    await this.http.request("DELETE", `/api/control/credentials/${encodeURIComponent(id)}`);
+  if (res.ok) await confirmModel(res, spin, model);
+  else spin.fail(`could not verify (HTTP ${res.status}) \u2014 continuing anyway`);
+  return null;
+}
+async function confirmModel(res, spin, model) {
+  const body = await res.json().catch(() => null);
+  const ids = (body?.data || []).map((m) => m.id);
+  if (model && ids.length && !ids.includes(model)) {
+    spin.done(`key works, though "${model}" is not in this endpoint's list`);
+  } else {
+    spin.done("ok");
   }
-  /** Counters, health and the last 50 things this browser did. */
-  status() {
-    return this.http.request("GET", `/api/browsers/${this.id}`);
+}
+async function verifyLlm(baseUrl, key, model) {
+  const spin = spinner("checking the key");
+  try {
+    return await judge(await probe(baseUrl, key, model), spin, baseUrl, model);
+  } catch (err) {
+    spin.fail(`could not reach it (${err.message}) \u2014 continuing anyway`);
+    return null;
   }
-  /**
-   * Stop it, whatever it is: a cloud sandbox is destroyed so billing ends, a
-   * CDP session is handed back to its provider, a desktop browser disconnects.
-   */
-  stop() {
-    return this.http.request("POST", `/api/browsers/${this.id}/stop`, {}, 6e4);
+}
+
+// src/install/interview.ts
+var HOST_OPTIONS = [
+  { id: "docker", label: "Docker on this machine", note: "one command, no cluster" },
+  { id: "k8s", label: "Kubernetes", disabled: "not in this build yet" },
+  { id: "ecs", label: "Amazon ECS", disabled: "not in this build yet" },
+  { id: "fly", label: "Fly.io", disabled: "coming soon" },
+  { id: "exe", label: "exe.dev", disabled: "coming soon" }
+];
+var DB_OPTIONS = [
+  { id: "sqlite", label: "SQLite", note: "zero config, one replica, API keys only" },
+  { id: "supabase", label: "Supabase", note: "adds email sign-in and the dashboard" },
+  { id: "postgres", label: "Postgres", note: "many replicas; needs psql for migrations" }
+];
+var FLEET_OPTIONS = [
+  { id: "docker-workers", label: "Docker browser workers here", note: "always-on containers, no daemon access needed" },
+  {
+    id: "oya-selfhosted",
+    label: "Governed Docker, one container per session",
+    note: "policies and budgets; needs Docker socket access"
+  },
+  { id: "oya-cloud", label: "Oya Cloud", note: "managed sandboxes, nothing to run yourself" },
+  { id: "browserbase", label: "Browserbase" },
+  { id: "steel", label: "Steel" },
+  { id: "anchor", label: "Anchor" },
+  { id: "browseruse", label: "Browser Use Cloud" },
+  { id: "cdp", label: "Your own Chrome over CDP" },
+  { id: "k8s", label: "Kubernetes fleet, one pod per session", note: "needs kubectl and a cluster" },
+  { id: "ecs", label: "ECS fleet, one task per session", disabled: "not in this build yet" }
+];
+var VENDOR_KEYS = {
+  browserbase: ["BROWSERBASE_API_KEY", "BROWSERBASE_PROJECT_ID"],
+  steel: ["STEEL_API_KEY"],
+  anchor: ["ANCHOR_API_KEY"],
+  browseruse: ["BROWSERUSE_API_KEY"]
+};
+var HEADINGS = {
+  host: ["Control plane", "Where the server itself runs."],
+  database: ["Database", "What holds sessions, keys and personas."],
+  fleet: ["Browsers", "What actually runs Chrome."]
+};
+var MORE_OPTIONS = [
+  { id: "no", label: "No", note: "change any of it later" },
+  { id: "yes", label: "Yes", note: "CAPTCHA solver, recording storage, metrics" }
+];
+var CAPTCHA_OPTIONS = [
+  { id: "", label: "No", note: "hosted vendors still solve natively" },
+  { id: "capsolver", label: "CapSolver" },
+  { id: "2captcha", label: "2Captcha" }
+];
+var METRICS_OPTIONS = [
+  { id: "no", label: "No" },
+  { id: "yes", label: "Yes", note: "generates a scrape token" }
+];
+var K8S_QUESTIONS = [
+  ["namespace", "Namespace for browser pods:", "oya-browsers"],
+  ["image", "Browser image:", "ghcr.io/oyadotai/oya-browser:latest"],
+  [
+    "controlUrl",
+    "Control-plane WebSocket URL, as reachable from the cluster:",
+    "ws://oya-server.oya-browser.svc:3100/ws"
+  ],
+  ["proxyUrl", "Egress proxy URL, as reachable from the cluster:", "http://oya-server.oya-browser.svc:3128"]
+];
+var FLEET_SECRETS = { "oya-cloud": "OYA_CLOUD_API_KEY", cdp: "OYA_CDP_WS_URL" };
+function secretFor(s, field, hidden = true) {
+  if (s.replay) return Promise.resolve(process.env[field] || "");
+  return hidden ? askSecret(`${field}:`) : ask(`${field}:`);
+}
+function isPostgresUrl(v) {
+  if (!v) return;
+  try {
+    const url = new URL(v);
+    if (!["postgres:", "postgresql:"].includes(url.protocol)) return "Must start with postgres://";
+  } catch {
+    return "That is not a connection string \u2014 postgres://user:pass@host:5432/db";
   }
-  /** `await using browser = await oya.browser.start()` stops it however the block exits, errors included. */
-  async [Symbol.asyncDispose]() {
-    await this.stop();
+}
+async function pick(preset, heading, question, options) {
+  if (preset) return preset;
+  step(...heading);
+  return choose(question, options);
+}
+async function askSupabase(s) {
+  s.secrets.SUPABASE_URL = s.replay ? process.env.SUPABASE_URL || "" : await ask("Supabase project URL:");
+  s.secrets.SUPABASE_SERVICE_KEY = await secretFor(s, "SUPABASE_SERVICE_KEY");
+  if (s.replay) return;
+  note("Migrations need the Postgres connection string, not the API URL.");
+  note("Leave it blank to apply them yourself later with `make migrate`.");
+  s.migrateUrl = await askSecret("Postgres connection string (optional):", { validate: isPostgresUrl });
+}
+async function askPostgres(s) {
+  s.secrets.DATABASE_URL = s.replay ? process.env.DATABASE_URL || "" : await askSecret("Postgres connection string:", {
+    validate: (v) => !v ? "Required for a Postgres deployment." : isPostgresUrl(v)
+  });
+  s.migrateUrl = s.secrets.DATABASE_URL;
+}
+function sqliteNotes() {
+  note("SQLite means API-key auth only \u2014 email sign-in needs Supabase.");
+  note("The dashboard still works: sign in with the API key printed at the end.");
+}
+async function askDatabase(s) {
+  const database = await pick(s.preset.database, HEADINGS.database, "Which database?", DB_OPTIONS);
+  if (database === "sqlite") sqliteNotes();
+  if (database === "supabase") await askSupabase(s);
+  if (database === "postgres") await askPostgres(s);
+  return database;
+}
+async function askWorkers(s, fleet) {
+  if (fleet !== "docker-workers" || s.preset.workers !== void 0) return s.preset.workers ?? 0;
+  const answer = await ask("How many browser workers?", "2", {
+    validate: (v) => /^[1-9][0-9]*$/.test(v) ? void 0 : "Enter a whole number of 1 or more."
+  });
+  return Number(answer);
+}
+async function askFleetSecrets(s, fleet) {
+  for (const field of VENDOR_KEYS[fleet] || []) {
+    s.secrets[field] = await secretFor(s, field, !field.endsWith("PROJECT_ID"));
   }
-  /** @deprecated use stop() — close() only dropped the socket, and a cloud browser redialled. */
-  async close() {
-    await this.stop();
+  if (Object.hasOwn(FLEET_SECRETS, fleet)) {
+    s.secrets[FLEET_SECRETS[fleet]] = await secretFor(s, FLEET_SECRETS[fleet]);
   }
-};
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-var Run = class {
-  constructor(http, id, callbacks, pollMs = 2e3) {
-    this.http = http;
-    this.id = id;
-    this.done = this.watch(callbacks, pollMs);
-    this.done.catch(() => {
-    });
+}
+async function askK8s(s, fleet) {
+  if (fleet !== "k8s" || s.preset.k8sFleet) return s.preset.k8sFleet;
+  step("Kubernetes fleet", "One pod per session.");
+  note("The image must be digest-pinned: a tag can move between verification and scheduling.");
+  const answers = {};
+  for (const [field, question, fallback] of K8S_QUESTIONS) answers[field] = await ask(question, fallback);
+  return answers;
+}
+async function llmFor(s) {
+  const llm = s.preset.llm ? { answers: s.preset.llm, key: s.replay ? process.env.OPENAI_API_KEY || "" : "" } : await askLlm();
+  if (llm.key) s.secrets.OPENAI_API_KEY = llm.key;
+  return llm.answers;
+}
+function checkPublicUrl(v) {
+  try {
+    const url = new URL(v);
+    if (!["http:", "https:"].includes(url.protocol)) return "Must be http:// or https://";
+  } catch {
+    return "That is not a URL \u2014 try http://localhost:3100";
   }
-  http;
-  id;
-  done;
-  status() {
-    return this.http.request("GET", `/api/runs/${encodeURIComponent(this.id)}`);
+}
+async function askPublicUrl(s) {
+  step("Address", "Where clients and browsers reach this control plane.");
+  const url = s.preset.publicUrl || await ask("Public URL of this control plane:", "http://localhost:3100", { validate: checkPublicUrl });
+  return url.replace(/\/+$/, "");
+}
+async function askOptional(s, database) {
+  const optional = s.preset.optional || { captcha: "", recordingBucket: "", metrics: false };
+  if (s.preset.optional) return optional;
+  step("Optional services", "Everything here has a sensible default.");
+  const more = await choose("Configure optional services now?", MORE_OPTIONS);
+  if (more === "yes") await askServices(s, database, optional);
+  return optional;
+}
+async function askServices(s, database, optional) {
+  optional.captcha = await choose("Solve CAPTCHAs automatically?", CAPTCHA_OPTIONS);
+  if (optional.captcha) s.secrets.OYA_CAPTCHA_API_KEY = await secretFor(s, "OYA_CAPTCHA_API_KEY");
+  if (database === "supabase") {
+    optional.recordingBucket = await ask("Private Storage bucket for recordings (blank to keep them on disk):", "");
   }
-  /** Answer the open attention request: `'done'` after handling it by hand, or your reply to the agent. */
-  async respond(response = "done") {
-    await this.http.request("POST", `/api/runs/${encodeURIComponent(this.id)}/respond`, { response });
+  optional.metrics = await choose("Expose /metrics to a Prometheus scraper?", METRICS_OPTIONS) === "yes";
+}
+async function askFleet(s) {
+  const fleet = await pick(s.preset.fleet, HEADINGS.fleet, "Where should browsers run?", FLEET_OPTIONS);
+  const workers = await askWorkers(s, fleet);
+  await askFleetSecrets(s, fleet);
+  return { fleet, workers, k8sFleet: await askK8s(s, fleet) };
+}
+async function interview(preset, replay) {
+  const s = { preset, replay, secrets: {}, migrateUrl: "" };
+  const host = await pick(preset.host, HEADINGS.host, "Where should the control plane run?", HOST_OPTIONS);
+  const database = await askDatabase(s);
+  const { fleet, workers, k8sFleet } = await askFleet(s);
+  const [llm, publicUrl] = [await llmFor(s), await askPublicUrl(s)];
+  const optional = await askOptional(s, database);
+  const answers = { version: 1, host, database, fleet, workers, k8sFleet, llm, publicUrl, optional };
+  return { answers, secrets: s.secrets, migrateUrl: s.migrateUrl };
+}
+
+// src/install/preflight.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { join as join2 } from "path";
+function composeCheck(compose) {
+  const ok = atLeast(compose, COMPOSE_MIN.major, COMPOSE_MIN.minor);
+  return { ok, label: "docker compose \u2265 2.24", detail: compose || "not found", fatal: true };
+}
+async function dockerChecks() {
+  const version = await capture("docker", ["--version"]);
+  const daemon = await capture("docker", ["info", "--format", "{{.ID}}"]);
+  const compose = await capture("docker", ["compose", "version", "--short"]);
+  return [
+    { ok: !!version, label: "docker", detail: version || "not found", fatal: true },
+    { ok: !!daemon, label: "docker daemon reachable", detail: daemon ? "ok" : "not running", fatal: true },
+    composeCheck(compose)
+  ];
+}
+function nodeCheck() {
+  const ok = atLeast(process.versions.node, NODE_MIN.major, NODE_MIN.minor);
+  return { ok, label: "node \u2265 22.13 (node:sqlite)", detail: process.versions.node, fatal: true };
+}
+async function kubeChecks() {
+  const version = await capture("kubectl", ["version", "--client=true", "-o", "json"]);
+  const cluster = await capture("kubectl", ["get", "namespace", "kube-system", "-o", "name"]);
+  return [
+    { ok: !!version, label: "kubectl", detail: version ? "ok" : "not found", fatal: true },
+    { ok: !!cluster, label: "cluster reachable", detail: cluster || "kubectl cannot reach a cluster", fatal: true }
+  ];
+}
+async function portCheck(publicUrl) {
+  const port = Number(new URL(publicUrl).port || DEFAULT_PORT);
+  const free = await portFree(port);
+  return { ok: free, label: `port ${port} free`, detail: free ? "ok" : "something is already listening" };
+}
+function envCheck(root) {
+  const envPath = join2(root, ".env");
+  if (!existsSync2(envPath)) return [];
+  const mode = (statSync(envPath).mode & PERMISSION_BITS).toString(OCTAL);
+  return [{ ok: true, label: ".env exists \u2014 keeping its OYA_PROFILE_SECRET and API keys", detail: `mode ${mode}` }];
+}
+var psqlCheck = async () => ({
+  ok: await has("psql"),
+  label: "psql (to apply migrations)",
+  detail: "from libpq/postgresql-client",
+  fatal: true
+});
+async function toolChecks(a) {
+  const checks = [];
+  const needsDocker = a.host === "docker" || a.fleet === "docker-workers" || a.fleet === "oya-selfhosted";
+  if (needsDocker) checks.push(...await dockerChecks());
+  if (a.host !== "docker") checks.push(nodeCheck());
+  if (a.fleet === "k8s" || a.host === "k8s") checks.push(...await kubeChecks());
+  if (a.database === "postgres" || a.database === "supabase") checks.push(await psqlCheck());
+  return checks;
+}
+async function preflight(root, a) {
+  return [...await toolChecks(a), await portCheck(a.publicUrl), ...envCheck(root)];
+}
+
+// src/install/env-file.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync, chmodSync } from "fs";
+var SECRET_KEYS = /* @__PURE__ */ new Set([
+  "OYA_PROFILE_SECRET",
+  "OYA_OPERATOR_TOKEN",
+  "OYA_METRICS_TOKEN",
+  "API_KEYS",
+  "FLEET_TOKEN",
+  "OYA_CLUSTER_SECRET",
+  "DATABASE_URL",
+  "SUPABASE_SERVICE_KEY",
+  "OPENAI_API_KEY",
+  "OYA_CLOUD_API_KEY",
+  "ANCHOR_API_KEY",
+  "BROWSERBASE_API_KEY",
+  "STEEL_API_KEY",
+  "BROWSERUSE_API_KEY",
+  "OYA_CAPTCHA_API_KEY",
+  "OYA_CDP_WS_URL"
+]);
+var SECTIONS = [
+  ["Server", ["PORT", "OYA_UI_MODE", "OYA_DATA_DIR"]],
+  ["Tenant keys \u2014 each is an identity; add more from the dashboard", ["API_KEYS"]],
+  ["Host operations: /metrics, drain, fleet provision", ["OYA_OPERATOR_TOKEN", "OYA_METRICS_TOKEN"]],
+  ["Credentials at rest. Lose this and every stored cookie, proxy and TOTP seed is unreadable", ["OYA_PROFILE_SECRET"]],
+  ["Database", ["SUPABASE_URL", "SUPABASE_SERVICE_KEY", "DATABASE_URL", "OYA_RECORDING_BUCKET"]],
+  [
+    "Agent LLM. A private or http base URL is operator-only: the dashboard and\n# POST /config/host reject one, on purpose \u2014 tenants can set that field too",
+    ["OPENAI_API_KEY", "OPENAI_BASE_URL", "CHAT_MODEL"]
+  ],
+  ["Browser fleet", ["OYA_BROWSER_PROVIDER", "OYA_FLEET_RUNTIME", "OYA_PUBLIC_WS_URL", "OYA_CDP_WS_URL"]],
+  [
+    "Governed Docker runtime",
+    [
+      "OYA_MANAGED_NETWORK",
+      "OYA_MANAGED_IMAGE",
+      "OYA_MANAGED_CONTROL_URL",
+      "OYA_MANAGED_PROXY_URL",
+      "OYA_MANAGED_REGION",
+      "OYA_EGRESS_PORT",
+      "OYA_EGRESS_HOST"
+    ]
+  ],
+  ["Oya Cloud", ["OYA_CLOUD_API_KEY", "OYA_CLOUD_SNAPSHOT", "OYA_CLOUD_TARGET"]],
+  [
+    "Hosted CDP vendors",
+    ["BROWSERBASE_API_KEY", "BROWSERBASE_PROJECT_ID", "STEEL_API_KEY", "ANCHOR_API_KEY", "BROWSERUSE_API_KEY"]
+  ],
+  ["CAPTCHA", ["OYA_CAPTCHA_PROVIDER", "OYA_CAPTCHA_API_KEY"]],
+  ["Multi-replica. One SQLite control database allows exactly one writer", ["OYA_INSTANCE_URL", "OYA_CLUSTER_SECRET"]]
+];
+function readEnv(path) {
+  if (!existsSync3(path)) return {};
+  const out2 = {};
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    const m = /^([A-Z0-9_]+)=(.*)$/.exec(line.trim());
+    if (m) out2[m[1]] = m[2];
   }
-  async watch(cb, pollMs) {
-    const call = async (fn) => {
-      try {
-        await fn();
-      } catch (err) {
-        console.error("[oya] run callback threw:", err);
-      }
-    };
-    let seen;
-    for (let errors = 0; ; ) {
-      let run2;
-      try {
-        run2 = await this.status();
-        errors = 0;
-      } catch (err) {
-        if (++errors < 5) {
-          await sleep(pollMs);
-          continue;
-        }
-        const failure = err instanceof OyaError ? err : new OyaError(String(err), 0, null);
-        await call(() => cb.onFailure?.(failure));
-        throw failure;
-      }
-      if (run2.status === "needs_attention" && run2.attention && run2.attention.id !== seen) {
-        seen = run2.attention.id;
-        const request = {
-          ...run2.attention,
-          liveViewUrl: run2.attention.liveViewUrl && new URL(run2.attention.liveViewUrl, this.http.baseUrl).href,
-          respond: (response) => this.respond(response)
-        };
-        void call(() => cb.onHumanAttention?.(request));
-      }
-      if (run2.status === "succeeded") {
-        const result = run2.result || {};
-        if (result.healed) await call(() => cb.onHealed?.(result));
-        await call(() => cb.onSuccess?.(result));
-        return result;
-      }
-      if (run2.status === "failed") {
-        const failure = new OyaError(run2.error || "Run failed", run2.errorStatus ?? 500, run2);
-        await call(() => cb.onFailure?.(failure));
-        throw failure;
-      }
-      await sleep(pollMs);
-    }
+  return out2;
+}
+function block(title, keys, values) {
+  return [`# \u2500\u2500 ${title} \u2500\u2500`, ...keys.map((k) => `${k}=${values[k]}`), ""];
+}
+function sectionLines(values, placed) {
+  const lines = [];
+  for (const [title, keys] of SECTIONS) {
+    const present = keys.filter((k) => values[k] !== void 0 && values[k] !== "");
+    present.forEach((k) => placed.add(k));
+    if (present.length) lines.push(...block(title, present, values));
   }
+  return lines;
+}
+function renderEnv(values, extra) {
+  const lines = ["# Written by `oya install`. Re-run it, or edit by hand \u2014 both are fine.", ""];
+  const placed = /* @__PURE__ */ new Set();
+  lines.push(...sectionLines(values, placed));
+  const leftover = Object.keys(values).filter((k) => !placed.has(k) && values[k]);
+  if (leftover.length) lines.push(...block("Other", leftover, values));
+  if (extra.length) lines.push(...extra, "");
+  return lines.join("\n");
+}
+function writeEnv(path, body) {
+  writeFileSync(path, body, { mode: ENV_FILE_MODE });
+  chmodSync(path, ENV_FILE_MODE);
+}
+
+// src/install/build-env.ts
+import { randomBytes } from "crypto";
+var token = () => randomBytes(TOKEN_BYTES).toString("base64url");
+var egress = (v) => Object.assign(v, { OYA_EGRESS_PORT: EGRESS_PORT, OYA_EGRESS_HOST: "0.0.0.0" });
+var oyaCloud = (v, { existing, wsUrl }) => {
+  v.OYA_BROWSER_PROVIDER = "oya-cloud";
+  v.OYA_PUBLIC_WS_URL = wsUrl;
+  v.OYA_CLOUD_SNAPSHOT = existing.OYA_CLOUD_SNAPSHOT || existing.DAYTONA_SNAPSHOT || "oya-browser";
 };
-var MAX_FILE_BYTES = 10 * 1024 * 1024;
-var DEFAULT_BASE_URL = "https://browser.getoya.ai";
-var READY_POLL_MS = 2e3;
-var env = (name) => globalThis.process?.env?.[name];
-var Oya = class {
-  http;
-  constructor(options = {}) {
-    const apiKey = options.apiKey || env("OYA_API_KEY");
-    if (!apiKey) {
-      throw new Error("No API key. Pass { apiKey } or set OYA_API_KEY \u2014 run `oya login` to get one.");
-    }
-    const baseUrl = (options.baseUrl || env("OYA_BASE_URL") || DEFAULT_BASE_URL).replace(/\/+$/, "");
-    const fetchImpl = options.fetch || globalThis.fetch;
-    if (!fetchImpl) throw new Error("No fetch available \u2014 pass { fetch } or use Node 18+.");
-    this.http = new Http(baseUrl, apiKey, options.timeoutMs ?? 6e4, fetchImpl.bind(globalThis));
-  }
-  browser = {
-    /** Start a browser and wait until it can take commands. */
-    start: async (options = {}) => {
-      const started = await this.http.request("POST", "/api/browsers/start", {
-        profile: options.profile || options.persona,
-        provider: options.provider,
-        wsUrl: options.wsUrl,
-        name: options.name,
-        queueMs: options.queueMs,
-        priority: options.priority,
-        budgetUsd: options.budgetUsd,
-        governed: options.governed,
-        policy: options.policy
-      }, 12e4, { "Idempotency-Key": options.idempotencyKey || globalThis.crypto.randomUUID() });
-      if (started.status === "starting") {
-        await this.waitUntilConnected(started.id, options.readyTimeoutMs ?? 12e4 + (options.queueMs || 0));
-        const connected = await this.http.request("GET", `/api/browsers/${encodeURIComponent(started.id)}`);
-        started.cdpUrl = connected.cdpUrl;
-      }
-      return new Browser(this.http, started, options.captcha === "auto");
-    },
-    /** Reattach to a browser that is already running. */
-    get: async (id) => {
-      const found = await this.http.request("GET", `/api/browsers/${encodeURIComponent(id)}`);
-      return new Browser(this.http, {
-        id: found.id,
-        provider: found.provider || "cdp",
-        persona: found.persona || "default",
-        status: "ready",
-        cdpUrl: found.cdpUrl
-      }, false);
-    },
-    list: () => this.http.request("GET", "/api/browsers"),
-    /** Stop some (`ids`) or every browser on this key. Each reports separately. */
-    stop: (ids) => this.http.request("POST", "/api/browsers/stop", ids === "all" ? { all: true } : { ids }, 12e4),
-    stopAll: async () => (await this.browser.stop("all")).stopped
-  };
-  /** Durable operational controls, including disconnected and cleanup-pending sessions. */
-  control = {
-    overview: () => this.http.request("GET", "/api/control"),
-    sessions: () => this.http.request("GET", "/api/control/sessions"),
-    session: (id) => this.http.request("GET", `/api/control/sessions/${encodeURIComponent(id)}`),
-    settings: (changes) => this.http.request("PATCH", "/api/control/project", changes),
-    cancel: (id) => this.http.request("POST", `/api/control/sessions/${encodeURIComponent(id)}/cancel`, {}),
-    stop: (id, force = false) => this.http.request("POST", `/api/control/sessions/${encodeURIComponent(id)}/stop`, { force }),
-    takeover: (id, action) => this.http.request("POST", `/api/control/sessions/${encodeURIComponent(id)}/control`, { action }),
-    input: (id, action, params) => this.http.request("POST", `/api/control/sessions/${encodeURIComponent(id)}/input`, { action, params }),
-    recover: (id, replace = false) => this.http.request("POST", `/api/control/sessions/${encodeURIComponent(id)}/recover`, { replace }),
-    ticket: (id) => this.http.request("POST", `/api/control/sessions/${encodeURIComponent(id)}/ticket`, {}),
-    events: (after = 0) => this.http.request("GET", `/api/control/events?after=${after}`),
-    createCredential: (options) => this.http.request("POST", "/api/control/credentials", options),
-    revokeCredential: (id) => this.http.request("DELETE", `/api/control/credentials/${encodeURIComponent(id)}`),
-    members: () => this.http.request("GET", "/api/control/members"),
-    inviteMember: (role = "operator") => this.http.request("POST", "/api/control/members/invite", { role }),
-    removeMember: (userId) => this.http.request("DELETE", `/api/control/members/${encodeURIComponent(userId)}`),
-    createWebhook: (url, types = []) => this.http.request("POST", "/api/control/webhooks", { url, types }),
-    removeWebhook: (id) => this.http.request("DELETE", `/api/control/webhooks/${encodeURIComponent(id)}`),
-    replayDelivery: (id) => this.http.request("POST", `/api/control/deliveries/${encodeURIComponent(id)}/replay`, {})
-  };
-  /** Playbooks saved with `browser.toPlaybook()`. */
-  playbooks = {
-    list: async () => (await this.http.request("GET", "/api/playbooks")).playbooks,
-    /** Delete a playbook and its draft, or only the draft with `'<name>:draft'`. */
-    remove: async (name) => {
-      await this.http.request("DELETE", `/api/playbooks/${encodeURIComponent(name)}`);
-    },
-    /** Replace a playbook with the draft a healed replay saved. Try it first with `browser.play('<name>:draft')`. */
-    promote: (name) => this.http.request("POST", `/api/playbooks/${encodeURIComponent(name)}/promote`, {})
-  };
-  /**
-   * Proxy exits for your personas. A persona takes one at first connect (by its
-   * geo hint) or by `personas.pinProxy`, and keeps it.
-   */
-  proxies = {
-    list: async () => (await this.http.request("GET", "/api/proxies")).proxies,
-    create: (proxy) => this.http.request("POST", "/api/proxies", proxy),
-    remove: async (id) => {
-      await this.http.request("DELETE", `/api/proxies/${encodeURIComponent(id)}`);
-    },
-    /** Dial each proxy and learn its real exit IP. Failing ones cool down and are skipped. */
-    check: async () => (await this.http.request("POST", "/api/proxies/check", {})).results
-  };
-  personas = {
-    list: async () => (await this.http.request("GET", "/api/personas")).personas,
-    get: (id) => this.http.request("GET", `/api/personas/${id}`),
-    /**
-     * Create an identity. The device — platform, timezone, locale — is chosen
-     * here and fixed for its life; `preview()` shows what a choice produces.
-     */
-    create: (options = {}) => this.http.request("POST", "/api/personas", options),
-    /** Name, concurrency cap and proxy hint. Never the device — clone for that. */
-    update: (id, changes) => this.http.request("PUT", `/api/personas/${id}`, changes),
-    /** A new persona of the same kind of device: same choices, fresh identity, empty jar. */
-    clone: (id, options = {}) => this.http.request("POST", `/api/personas/${id}/clone`, options),
-    /** The fingerprint these choices would produce. Persists nothing. */
-    preview: async (prefs = {}) => (await this.http.request("POST", "/api/personas/preview", { prefs })).fingerprint,
-    /** Platforms, and the timezones and locales each may coherently claim. */
-    options: () => this.http.request("GET", "/api/personas/options"),
-    /** Pin the persona to one of your proxies, or `null` to let assignment happen at connect. */
-    pinProxy: (id, proxyId) => this.http.request("PUT", `/api/personas/${id}/proxy`, { proxyId }),
-    remove: async (id) => {
-      await this.http.request("DELETE", `/api/personas/${id}`);
-    },
-    /** Store the second factor for this identity. Sealed at rest, never read back. */
-    setMfa: (id, config) => this.http.request("PUT", `/api/personas/${id}/mfa`, config),
-    clearMfa: async (id, domain) => {
-      await this.http.request("DELETE", `/api/personas/${id}/mfa${domain ? `?domain=${encodeURIComponent(domain)}` : ""}`);
-    },
-    /**
-     * Store a site login for this identity. Sealed at rest, never read back.
-     *
-     * Signing in once on the desktop and inheriting the cookies is still the
-     * better path. This is for portals that expire a session server-side
-     * between runs, where an unattended run has nothing else to recover with.
-     */
-    setCredentials: (id, config) => this.http.request("PUT", `/api/personas/${id}/credentials`, config),
-    /** Which sites this identity can sign in to. Usernames only. */
-    credentials: (id) => this.http.request("GET", `/api/personas/${id}/credentials`),
-    clearCredentials: async (id, domain) => {
-      await this.http.request("DELETE", `/api/personas/${id}/credentials?domain=${encodeURIComponent(domain)}`);
-    }
-  };
-  /**
-   * This key's settings: LLM credentials, browser provider, solver.
-   *
-   * Bring your own LLM key (it pays for its own tokens, so no hourly chat quota applies):
-   *   await oya.config.set({ llm_provider: 'gemini', openai_api_key: process.env.GEMINI_API_KEY });
-   * `llm_provider` is the {@link LlmProvider} union, so an editor offers the choices and a
-   * typo is a compile error; `chat_model` overrides its default model. 'vertex' is Gemini
-   * Enterprise (ex-Vertex AI) in express mode, which needs no GCP project; for a
-   * project-scoped endpoint, set `openai_base_url` to `.../endpoints/openapi` and pass an
-   * OAuth access token as `openai_api_key`. See {@link ConfigUpdate} for every field.
-   */
-  config = {
-    get: () => this.http.request("GET", "/api/config"),
-    set: (values) => this.http.request("POST", "/api/config", values)
-  };
-  /** Saved profiles. `personas` is retained as an alias for existing clients. */
-  profiles = this.personas;
-  usage() {
-    return this.http.request("GET", "/api/usage");
+var governedDocker = (v, { a, wsUrl }) => {
+  const inCompose = a.host === "docker";
+  Object.assign(v, { OYA_BROWSER_PROVIDER: "oya-selfhosted", OYA_FLEET_RUNTIME: "docker" });
+  Object.assign(v, { OYA_MANAGED_NETWORK: "oya-browsers", OYA_MANAGED_IMAGE: "oya-browser:local" });
+  v.OYA_MANAGED_CONTROL_URL = inCompose ? `ws://server:${DEFAULT_PORT}/ws` : wsUrl;
+  egress(v);
+  v.OYA_MANAGED_PROXY_URL = inCompose ? `http://server:${EGRESS_PORT}` : `http://127.0.0.1:${EGRESS_PORT}`;
+  v.OYA_MANAGED_REGION = "local";
+};
+function kubeSettings(v, k) {
+  const runtime = { OYA_BROWSER_PROVIDER: "oya-selfhosted", OYA_FLEET_RUNTIME: "k8s", OYA_K8S_NAMESPACE: k.namespace };
+  Object.assign(v, runtime);
+  v.OYA_MANAGED_NETWORK = "oya-governed-egress";
+  v.OYA_MANAGED_IMAGE = k.image;
+  Object.assign(v, { OYA_MANAGED_CONTROL_URL: k.controlUrl, OYA_MANAGED_PROXY_URL: k.proxyUrl });
+  v.OYA_MANAGED_REGION = k.namespace;
+  egress(v);
+}
+var kubernetes = (v, { a }) => {
+  if (a.k8sFleet) kubeSettings(v, a.k8sFleet);
+  else v.OYA_BROWSER_PROVIDER = a.fleet;
+};
+var FLEETS = {
+  "oya-cloud": oyaCloud,
+  "oya-selfhosted": governedDocker,
+  k8s: kubernetes,
+  "docker-workers": (v) => {
+    v.OYA_BROWSER_PROVIDER = "oya-selfhosted";
+  }
+};
+function fleetSettings(v, input) {
+  if (Object.hasOwn(FLEETS, input.a.fleet)) FLEETS[input.a.fleet](v, input);
+  else v.OYA_BROWSER_PROVIDER = input.a.fleet;
+}
+function baseSecrets(a, existing) {
+  const v = { OYA_PROFILE_SECRET: existing.OYA_PROFILE_SECRET || token() };
+  const apiKey = existing.API_KEYS?.split(",")[0] || `oya_${token()}`;
+  v.API_KEYS = existing.API_KEYS || apiKey;
+  v.OYA_OPERATOR_TOKEN = existing.OYA_OPERATOR_TOKEN || token();
+  if (a.host !== "docker") v.PORT = String(Number(new URL(a.publicUrl).port || DEFAULT_PORT));
+  return { v, apiKey };
+}
+function optionalSettings(v, a, existing) {
+  if (a.optional.captcha) v.OYA_CAPTCHA_PROVIDER = a.optional.captcha;
+  if (a.optional.recordingBucket) v.OYA_RECORDING_BUCKET = a.optional.recordingBucket;
+  if (a.optional.metrics) v.OYA_METRICS_TOKEN = existing.OYA_METRICS_TOKEN || token();
+}
+var fleetTokenLines = () => [
+  "# \u2500\u2500 Shared fleet enrolment \u2500\u2500",
+  "# Uncomment to let any browser presenting this token enrol itself.",
+  `# FLEET_TOKEN=${token()}`
+];
+function buildEnv(a, secrets, existing) {
+  const { v, apiKey } = baseSecrets(a, existing);
+  Object.assign(v, secrets);
+  if (a.llm.provider !== "skip") Object.assign(v, { OPENAI_BASE_URL: a.llm.baseUrl, CHAT_MODEL: a.llm.model });
+  fleetSettings(v, { a, existing, wsUrl: a.publicUrl.replace(/^http/, "ws") + "/ws" });
+  optionalSettings(v, a, existing);
+  return { values: v, extra: fleetTokenLines(), apiKey };
+}
+
+// src/install/kek.ts
+var PROBE_IMAGE = "alpine@sha256:14358309a308569c32bdc37e2e0e9694be33a9d99e68afb0f5ff33cc1f695dce";
+var SEALED = /cookies\.json|personas\.json|profiles|\.secret/;
+async function isSealed(name) {
+  const listing = await capture("docker", ["run", "--rm", "-v", `${name}:/d`, PROBE_IMAGE, "ls", "/d"]);
+  return listing === null || SEALED.test(listing);
+}
+async function priorState() {
+  const volumes = await capture("docker", ["volume", "ls", "-q", "--filter", "name=oya-data"]) || "";
+  for (const name of volumes.split("\n").map((v) => v.trim()).filter(Boolean)) {
+    if (await isSealed(name)) return name;
   }
-  async waitUntilConnected(id, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const all = await this.browser.list();
-      if (all.some((b) => b.id === id && b.health !== "dead")) return;
-      try {
-        const session = await this.control.session(id);
-        if (["failed", "stopped", "unknown_outcome"].includes(session.state)) throw new OyaError(`Browser creation ended in ${session.state}`, 409, session);
-      } catch (e) {
-        if (!(e instanceof OyaError) || e.status !== 404) throw e;
-      }
-      await new Promise((r) => setTimeout(r, READY_POLL_MS));
-    }
-    throw new OyaError(`Browser ${id} did not come up within ${Math.round(timeoutMs / 1e3)}s`, 504, null);
+  return null;
+}
+var RESOLUTIONS = [
+  { id: "paste", label: "I have the previous OYA_PROFILE_SECRET", note: "reuse it and keep the data" },
+  { id: "reset", label: "Delete the old data and start clean", note: "personas, cookies and sessions are lost" },
+  { id: "abort", label: "Stop so I can go and find it" }
+];
+function askResolution(volume) {
+  warn(`${volume} already holds encrypted data from an earlier install.`);
+  note("Cookies, proxy credentials and TOTP seeds in it were sealed with that");
+  note("install's OYA_PROFILE_SECRET. A new secret cannot open them, and the");
+  note("server refuses to start rather than silently losing them.");
+  return choose("How should that be handled?", RESOLUTIONS);
+}
+async function deleteVolume(volume, root) {
+  if (!await confirm(`Delete ${volume} and everything stored in it?`, false)) {
+    throw new InputError("Stopped without changing anything.");
   }
-};
+  await run("docker", ["compose", "down", "-v"], { cwd: root, quiet: true }).catch(() => {
+  });
+  await run("docker", ["volume", "rm", "-f", volume], { cwd: root, quiet: true });
+  success(`removed ${volume}`);
+}
+var askPrevious = () => askSecret("Previous OYA_PROFILE_SECRET:", {
+  validate: (v) => v ? void 0 : "Paste the secret, or pick another option."
+});
+async function resolveKekConflict(volume, root) {
+  const choice = await askResolution(volume);
+  if (choice === "paste") return askPrevious();
+  if (choice === "abort") throw new InputError("Stopped without changing anything.");
+  await deleteVolume(volume, root);
+  return null;
+}
 
-// src/config.ts
-import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
-import { homedir } from "os";
-import { join, dirname } from "path";
-var FILE = join(process.env.OYA_CONFIG_HOME || join(homedir(), ".oya"), "config.json");
-function load() {
+// src/install/migrate.ts
+import { spawn as spawn2 } from "child_process";
+import { join as join3 } from "path";
+var startMigrations = (root, databaseUrl) => spawn2(process.execPath, [join3(root, "server", "migrations", "run.mjs")], {
+  cwd: root,
+  stdio: ["ignore", "pipe", "pipe"],
+  env: { ...process.env, DATABASE_URL: databaseUrl }
+});
+function runMigrations(root, databaseUrl) {
+  return new Promise((resolve, reject) => {
+    const child = startMigrations(root, databaseUrl);
+    let err = "";
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", reject);
+    const failure2 = (code) => new Error(err.trim() || `migrations exited ${code}`);
+    child.on("close", (code) => code === 0 ? resolve() : reject(failure2(code)));
+  });
+}
+var RETRY = "Fix the database, then re-run: DATABASE_URL=\u2026 make migrate";
+async function migrate(root, databaseUrl) {
+  const spin = spinner("applying migrations");
   try {
-    return JSON.parse(readFileSync(FILE, "utf8"));
-  } catch {
-    return {};
+    await runMigrations(root, databaseUrl);
+    spin.done();
+  } catch (e) {
+    spin.fail();
+    throw new Error(`Migrations failed: ${e.message}
+  ${RETRY}`);
   }
 }
-function save(values) {
-  const merged = { ...load(), ...values };
-  mkdirSync(dirname(FILE), { recursive: true });
-  writeFileSync(FILE, JSON.stringify(merged, null, 2), { mode: 384 });
-  chmodSync(FILE, 384);
+
+// src/install/k8s.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+var POLICY_NAME = "oya-governed-egress";
+function unpinnable(reference) {
+  return new Error(
+    `Kubernetes browsers must run a digest-pinned image, and ${reference} is a tag.
+  Get the digest with:  docker manifest inspect --verbose ${reference}
+  then re-run with the image written as ${reference.split(":")[0]}@sha256:<digest>`
+  );
 }
-var configPath = FILE;
-function resolved() {
-  const saved = load();
-  return {
-    apiKey: process.env.OYA_API_KEY || saved.apiKey || "",
-    baseUrl: (process.env.OYA_BASE_URL || saved.baseUrl || "https://browser.getoya.ai").replace(/\/+$/, "")
+async function resolveDigest(reference) {
+  const raw = await capture("docker", ["manifest", "inspect", "--verbose", reference]);
+  return raw && /"digest":\s*"(sha256:[0-9a-f]{64})"/.exec(raw)?.[1];
+}
+async function pinImage(reference) {
+  if (/@sha256:[0-9a-f]{64}$/.test(reference)) return reference;
+  process.stdout.write(`  resolving ${reference} to a digest\u2026 `);
+  const digest = await resolveDigest(reference);
+  console.log(digest ? digest.slice(0, DIGEST_PREVIEW) + "\u2026" : "could not");
+  if (!digest) throw unpinnable(reference);
+  return `${reference.split("@")[0].replace(/:[^:/]+$/, "")}@${digest}`;
+}
+var EGRESS = [
+  // DNS only, to the cluster resolver.
+  {
+    ports: [
+      { protocol: "UDP", port: DNS_PORT },
+      { protocol: "TCP", port: DNS_PORT }
+    ]
+  },
+  // Everything else must go through the control plane's egress proxy, which
+  // is what makes per-session egress policy and budgets enforceable.
+  // `app: server` is the label k8s/base/server.yaml gives the control plane;
+  // the empty namespaceSelector lets the browsers live in their own namespace.
+  // A control plane OUTSIDE the cluster is not matched by any pod selector —
+  // add an ipBlock rule here for that case, or the pods will resolve DNS and
+  // then fail to enrol.
+  { to: [{ namespaceSelector: {}, podSelector: { matchLabels: { app: "server" } } }] }
+];
+function networkPolicy(namespace, name) {
+  const spec = {
+    podSelector: { matchLabels: { app: "oya-managed-browser" } },
+    policyTypes: ["Egress"],
+    egress: EGRESS
   };
+  const policy = { apiVersion: "networking.k8s.io/v1", kind: "NetworkPolicy", metadata: { name, namespace }, spec };
+  return JSON.stringify(policy, null, JSON_INDENT);
 }
-
-// src/prompt.ts
-import { createInterface } from "readline";
-import { stdin, stdout } from "process";
-var ESC = "\x1B";
-var plain = !stdout.isTTY || !!process.env.NO_COLOR || process.env.TERM === "dumb";
-var wrap = (open) => (s) => plain ? s : `${ESC}[${open}m${s}${ESC}[0m`;
-var style = {
-  bold: wrap("1"),
-  dim: wrap("2"),
-  green: wrap("32"),
-  cyan: wrap("36"),
-  yellow: wrap("33"),
-  red: wrap("31"),
-  grey: wrap("90")
-};
-var icon = {
-  ok: style.green("\u2714"),
-  fail: style.red("\u2717"),
-  warn: style.yellow("!"),
-  arrow: style.green("\u276F")
-};
-var clearLine = plain ? "" : `${ESC}[K`;
-var up = (n) => `${ESC}[${n}A`;
-var width = () => Math.min(stdout.columns || 80, 74);
-function banner(title, subtitle) {
-  const line = "\u2500".repeat(width());
-  stdout.write(`
-${style.grey(line)}
-  ${style.bold(title)}
-`);
-  if (subtitle) stdout.write(`  ${style.grey(subtitle)}
-`);
-  stdout.write(`${style.grey(line)}
-`);
+function savePolicy(root, namespace) {
+  const policyPath = join4(root, "k8s", "fleet", "networkpolicy.json");
+  mkdirSync(join4(root, "k8s", "fleet"), { recursive: true });
+  writeFileSync2(policyPath, networkPolicy(namespace, POLICY_NAME) + "\n");
+  return policyPath;
 }
-var stepNumber = 0;
-var stepTotal = 0;
-function steps(total) {
-  stepTotal = total;
-  stepNumber = 0;
-}
-function step(title, hint) {
-  stepNumber += 1;
-  const counter = stepTotal ? style.grey(`${stepNumber}/${stepTotal}`) : "";
-  stdout.write(`
-${style.cyan("\u25C6")} ${style.bold(title)} ${counter}
-`);
-  if (hint) stdout.write(`${style.grey("  " + hint)}
-`);
+var apply = (manifest, root) => pipeTo("kubectl", ["apply", "-f", "-"], manifest, root);
+async function provisionK8sFleet(root, a) {
+  const fleet = a.k8sFleet;
+  const pinned = await pinImage(fleet.image);
+  await apply(JSON.stringify({ apiVersion: "v1", kind: "Namespace", metadata: { name: fleet.namespace } }), root);
+  const policyPath = savePolicy(root, fleet.namespace);
+  await apply(networkPolicy(fleet.namespace, POLICY_NAME), root);
+  console.log(`  applied namespace ${fleet.namespace} and NetworkPolicy ${POLICY_NAME}`);
+  console.log(`  policy written to ${policyPath} \u2014 review it; it is your egress boundary`);
+  return pinned;
 }
-function note(text) {
-  stdout.write(`${style.grey("  " + text)}
-`);
+
+// src/install/docker.ts
+async function provisionGoverned(root) {
+  const exists = await capture("docker", ["network", "inspect", "oya-browsers"]);
+  if (!exists)
+    await run("docker", ["network", "create", "--internal", "--driver", "bridge", "oya-browsers"], { cwd: root });
+  console.log("  building the governed browser image\u2026");
+  await run("docker", ["build", "-t", "oya-browser:local", "browser"], { cwd: root });
+  console.log("\n  Governed browsers need Docker daemon access from the server container.");
+  console.log("  Add this to the server service in docker-compose.yml, then re-run `docker compose up -d`:");
+  console.log("    volumes:\n      - /var/run/docker.sock:/var/run/docker.sock");
 }
-function success(text) {
-  stdout.write(`${icon.ok} ${text}
-`);
+async function provisionDocker(root, a) {
+  if (a.fleet === "oya-selfhosted") await provisionGoverned(root);
+  const scale = a.fleet === "docker-workers" ? ["--scale", `browser=${a.workers}`] : ["--scale", "browser=0"];
+  await run("docker", ["compose", "up", "-d", "--build", ...scale], { cwd: root });
 }
-function warn(text) {
-  stdout.write(`${icon.warn} ${style.yellow(text)}
-`);
+async function isReady(url) {
+  try {
+    return (await fetch(`${url}/readyz`)).ok;
+  } catch {
+    return false;
+  }
 }
-function spinner(label) {
-  if (plain) {
-    stdout.write(`  ${label}\u2026 `);
-    return {
-      done: (msg = "ok") => stdout.write(`${msg}
-`),
-      fail: (msg = "failed") => stdout.write(`${msg}
-`)
-    };
+async function pollReady(url, deadline) {
+  while (Date.now() < deadline) {
+    if (await isReady(url)) return true;
+    await new Promise((r) => setTimeout(r, READY_POLL_MS));
   }
-  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  let i = 0;
-  const timer = setInterval(() => {
-    stdout.write(`\r  ${style.cyan(frames[i++ % frames.length])} ${label}\u2026   `);
-  }, 80);
-  const stop = (mark, msg) => {
-    clearInterval(timer);
-    stdout.write(`\r  ${mark} ${label}  ${style.grey(msg)}${clearLine}
-`);
-  };
-  return { done: (msg = "") => stop(icon.ok, msg), fail: (msg = "") => stop(icon.fail, msg) };
+  return false;
 }
-var rl = null;
-var masked = false;
-var pending = [];
-var waiter = null;
-var ended = false;
-function iface() {
-  if (rl) return rl;
-  rl = createInterface({ input: stdin, output: stdout, terminal: !!stdin.isTTY });
-  const deliver = (line) => {
-    if (waiter) {
-      const w = waiter;
-      waiter = null;
-      w(line);
-    } else pending.push(line);
-  };
-  rl.on("line", deliver);
-  rl.on("close", () => {
-    ended = true;
-    if (waiter) {
-      const w = waiter;
-      waiter = null;
-      w("");
-    }
-  });
-  const asAny = rl;
-  asAny._writeToOutput = (s) => {
-    if (!masked) {
-      asAny.output.write(s);
-      return;
-    }
-    asAny.output.write(s.includes("\n") ? "\n" : "*");
-  };
-  return rl;
+async function waitReady(url, timeoutMs = READY_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  process.stdout.write("  waiting for /readyz\u2026 ");
+  if (await pollReady(url, deadline)) {
+    console.log("ready");
+    return;
+  }
+  console.log("timed out");
+  throw new Error(`${url}/readyz did not become ready. Check logs with: docker compose logs -f server`);
 }
-function nextLine() {
-  const queued = pending.shift();
-  if (queued !== void 0) return Promise.resolve(queued);
-  if (ended) return Promise.resolve("");
-  iface();
-  return new Promise((resolve) => {
-    waiter = resolve;
-  });
+
+// src/install/report.ts
+function printPreflight(checks) {
+  console.log(`
+${style.bold("  Preflight")}`);
+  for (const c of checks) {
+    const mark = c.ok ? icon.ok : c.fatal ? icon.fail : icon.warn;
+    console.log(`  ${mark} ${c.label}${c.detail ? style.grey(`  \u2014 ${c.detail}`) : ""}`);
+  }
 }
-function closePrompts() {
-  if (stdin.isTTY && stdin.isRaw) stdin.setRawMode(false);
-  rl?.close();
-  rl = null;
+var row = (k, v) => console.log(`  ${style.grey(k.padEnd(PLAN_LABEL_WIDTH))}${v}`);
+function printPlan(answers, envPath) {
+  console.log(`
+${style.bold("  Plan")}`);
+  const { llm } = answers;
+  row("control", `${answers.host} \xB7 ${answers.database}`);
+  row("browsers", `${answers.fleet}${answers.workers ? ` \xD7${answers.workers}` : ""}`);
+  row("llm", llm.provider === "skip" ? style.grey("none") : `${llm.model} ${style.grey(`@ ${llm.baseUrl}`)}`);
+  row("writes", `${envPath} ${style.grey("(0600)")}`);
+  row("then", `docker compose up -d, wait for ${answers.publicUrl}/readyz`);
 }
-var InputError = class extends Error {
-};
-async function readValidated(render, fallback, options) {
-  for (; ; ) {
-    render();
-    masked = !!options.secret;
-    let answer;
-    try {
-      answer = (await nextLine()).trim() || fallback;
-    } finally {
-      if (options.secret) {
-        masked = false;
-        stdout.write("\n");
-      }
-    }
-    if (!stdin.isTTY && !options.secret) stdout.write(`${answer}
+function printDryRun(values) {
+  console.log("\n--dry-run: nothing was written. Settings that would be applied:");
+  for (const k of Object.keys(values)) {
+    console.log(`  ${k}=${SECRET_KEYS.has(k) ? style.grey("<hidden>") : values[k]}`);
+  }
+}
+function printDone(publicUrl, apiKey) {
+  banner(`${publicUrl} is up`, "Sign in to the dashboard with the key below.");
+  console.log(`
+  ${style.bold("API key")}  ${style.green(apiKey)}
 `);
-    const problem = options.validate?.(answer);
-    if (!problem) return answer;
-    stdout.write(`  ${icon.fail} ${style.red(problem)}
+  console.log(`  ${style.grey("# your shell may export OYA_API_KEY for the hosted service")}`);
+  console.log(`  unset OYA_API_KEY`);
+  console.log(`  oya login --url ${publicUrl} --key ${apiKey}`);
+  console.log(`  oya ls && oya goto https://example.com
 `);
-    if (ended && !pending.length) throw new InputError(problem);
+}
+
+// src/install.ts
+var ANSWERS_FILE = "oya-install.json";
+async function gather(configPath2) {
+  const root = await locateRepo();
+  const preset = configPath2 ? JSON.parse(readFileSync2(configPath2, "utf8")) : {};
+  banner("Oya Browser \u2014 self-host install", root);
+  if (configPath2) note(`replaying ${configPath2}`);
+  steps(configPath2 ? 0 : INTERVIEW_STEPS);
+  return { root, ...await interview(preset, !!configPath2) };
+}
+async function checkMachine(root, answers, dryRun) {
+  const checks = await preflight(root, answers);
+  printPreflight(checks);
+  const blocking = checks.filter((c) => !c.ok && c.fatal);
+  if (blocking.length && !dryRun) {
+    throw new Error(`Install cannot continue: ${blocking.map((c) => c.label).join(", ")}`);
   }
 }
-function ask(question, fallback = "", options = {}) {
-  return readValidated(
-    () => stdout.write(`  ${style.green("?")} ${question}${fallback ? style.grey(` (${fallback})`) : ""} `),
-    fallback,
-    options
-  );
+function warnLocalDatabase(answers, databaseUrl = "") {
+  if (answers.host !== "docker" || !/(localhost|127\.0\.0\.1)/.test(databaseUrl)) return;
+  warn("DATABASE_URL points at localhost, which inside a container means the container itself.");
+  note("Use host.docker.internal (macOS, Windows) or the host IP so the server can reach it.");
 }
-function askSecret(question, options = {}) {
-  return readValidated(
-    () => stdout.write(`  ${style.green("?")} ${question} `),
-    "",
-    { ...options, secret: true }
-  );
+async function guardKek(existing, answers, root, dryRun) {
+  if (existing.OYA_PROFILE_SECRET || answers.host !== "docker" || dryRun) return;
+  const volume = await priorState();
+  if (!volume) return;
+  const reused = await resolveKekConflict(volume, root);
+  if (reused) existing.OYA_PROFILE_SECRET = reused;
 }
-async function confirm(question, fallback = false) {
-  const answer = await ask(`${question} ${style.grey(fallback ? "[Y/n]" : "[y/N]")}`, fallback ? "y" : "n");
-  return /^y/i.test(answer);
+async function plan(flags2, dryRun) {
+  const interviewed = await gather(typeof flags2.config === "string" ? flags2.config : null);
+  const { root, answers, secrets } = interviewed;
+  await checkMachine(root, answers, dryRun);
+  warnLocalDatabase(answers, secrets.DATABASE_URL);
+  const envPath = join5(root, ".env");
+  const existing = readEnv(envPath);
+  await guardKek(existing, answers, root, dryRun);
+  return { ...interviewed, envPath, existing, env: buildEnv(answers, secrets, existing) };
 }
-var visible = (text) => text.replace(/\u001b\[[0-9;]*m/g, "").length;
-function renderOptions(options, active, interactive) {
-  const columns = stdout.columns || 80;
-  let rows = 0;
-  options.forEach((o, i) => {
-    const chosen = interactive && i === active;
-    const bullet = chosen ? icon.arrow : " ";
-    const number = interactive ? "" : style.grey(`${i + 1}) `);
-    const hint = o.disabled ? `\u2014 ${o.disabled}` : o.note ? `\u2014 ${o.note}` : "";
-    const label = o.disabled ? style.grey(o.label) : chosen ? style.green(o.label) : o.label;
-    const line = `  ${bullet} ${number}${label}${hint ? style.grey(`  ${hint}`) : ""}`;
-    stdout.write(`${line}${clearLine}
-`);
-    rows += Math.max(1, Math.ceil(visible(line) / columns));
-  });
-  return rows;
+function writeFiles(p) {
+  writeEnv(p.envPath, renderEnv(p.env.values, p.env.extra));
+  writeFileSync3(join5(p.root, ANSWERS_FILE), JSON.stringify(p.answers, null, JSON_INDENT) + "\n");
+  success(`wrote ${p.envPath}`);
+  if (p.existing.OYA_PROFILE_SECRET) return;
+  warn("OYA_PROFILE_SECRET was generated \u2014 back it up.");
+  note("Without it, stored cookies, proxy credentials and TOTP seeds cannot be decrypted.");
 }
-async function choose(question, options) {
-  const pickable = options.map((o, i) => o.disabled ? -1 : i).filter((i) => i >= 0);
-  if (!pickable.length) throw new Error(`No option available for: ${question}`);
-  stdout.write(`  ${style.green("?")} ${style.bold(question)}
-`);
-  if (!stdin.isTTY) {
-    renderOptions(options, -1, false);
-    const answer = await ask("choice:", String(pickable[0] + 1), {
-      validate: (v) => {
-        const picked = options[Number(v) - 1] || options.find((o) => o.id === v);
-        if (!picked) return "Pick one of the numbers above.";
-        if (picked.disabled) return `${picked.label} is ${picked.disabled}. Pick another.`;
-      }
-    });
-    return (options[Number(answer) - 1] || options.find((o) => o.id === answer)).id;
-  }
-  const hint = style.grey("  \u2191\u2193 move \xB7 enter select");
-  let active = pickable[0];
-  let rows = renderOptions(options, active, true) + 1;
-  const canRedraw = rows < (stdout.rows || 24) - 1;
-  rl?.pause();
-  const wasRaw = !!stdin.isRaw;
-  stdin.setRawMode(true);
-  stdin.resume();
-  stdout.write(`${hint}
-`);
-  const redraw = () => {
-    if (!canRedraw) return;
-    stdout.write(up(rows));
-    rows = renderOptions(options, active, true) + 1;
-    stdout.write(`${hint}
-`);
-  };
-  const move = (delta) => {
-    const here = pickable.indexOf(active);
-    active = pickable[(here + delta + pickable.length) % pickable.length];
-    redraw();
-  };
+async function provisionK8s(p) {
+  const pinned = await provisionK8sFleet(p.root, p.answers);
+  if (pinned === p.env.values.OYA_MANAGED_IMAGE) return;
+  p.env.values.OYA_MANAGED_IMAGE = pinned;
+  writeEnv(p.envPath, renderEnv(p.env.values, p.env.extra));
+  console.log("  .env updated with the pinned image digest");
+}
+async function apply2(p) {
+  writeFiles(p);
+  if (p.migrateUrl) await migrate(p.root, p.migrateUrl);
+  if (p.answers.fleet === "k8s") await provisionK8s(p);
+  if (p.answers.host === "docker") await provisionDocker(p.root, p.answers);
+  await waitReady(p.answers.publicUrl);
+  printDone(p.answers.publicUrl, p.env.apiKey);
+}
+async function cmdInstall(flags2) {
+  const dryRun = flags2["dry-run"] === true;
+  const p = await plan(flags2, dryRun);
+  printPlan(p.answers, p.envPath);
+  if (dryRun) return printDryRun(p.env.values);
+  await apply2(p);
+}
+
+// src/config.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
+import { homedir } from "os";
+import { join as join6, dirname as dirname2 } from "path";
+
+// src/constants.ts
+var ARGV_SKIP = 2;
+var JSON_INDENT2 = 2;
+var DEFAULT_BASE_URL = "https://browser.getoya.ai";
+var CONFIG_FILE_MODE = 384;
+var LsColumns = {
+  /** Provider name. */
+  PROVIDER: 14,
+  /** Persona name. */
+  PERSONA: 14,
+  /** Browser name. */
+  NAME: 18,
+  /** Current URL, after the scheme is dropped. */
+  URL: 40
+};
+var StatusColumns = {
+  /** Recent actions shown. */
+  RECENT: 10,
+  /** Action name column. */
+  ACTION: 18
+};
+var PERSONA_NAME_WIDTH = 20;
+var Status2 = {
+  /** The API key was rejected. */
+  UNAUTHORIZED: 401,
+  /** A quota or a persona concurrency cap. */
+  TOO_MANY_REQUESTS: 429
+};
+
+// src/config.ts
+var FILE = join6(process.env.OYA_CONFIG_HOME || join6(homedir(), ".oya"), "config.json");
+function load() {
   try {
-    return await new Promise((resolve, reject) => {
-      const cleanup = () => {
-        stdin.off("data", onData);
-        if (!wasRaw) stdin.setRawMode(false);
-        rl?.resume();
-      };
-      const onData = (buf) => {
-        const key = buf.toString();
-        if (key === "") {
-          cleanup();
-          stdout.write("\n");
-          reject(new InputError("Cancelled."));
-          return;
-        }
-        if (key === `${ESC}[A` || key === "k") return move(-1);
-        if (key === `${ESC}[B` || key === "j") return move(1);
-        if (/^[1-9]$/.test(key)) {
-          const target = Number(key) - 1;
-          if (options[target] && !options[target].disabled) {
-            active = target;
-            redraw();
-          }
-          return;
-        }
-        if (key === "\r" || key === "\n") {
-          cleanup();
-          if (canRedraw) {
-            stdout.write(up(rows));
-            for (let i = 0; i < rows; i++) stdout.write(`${clearLine}
-`);
-            stdout.write(up(rows));
-            stdout.write(`  ${icon.arrow} ${style.green(options[active].label)}${clearLine}
-`);
-          } else {
-            stdout.write(`  ${icon.arrow} ${style.green(options[active].label)}
-`);
-          }
-          resolve(options[active].id);
-        }
-      };
-      stdin.on("data", onData);
-    });
-  } finally {
-    if (!wasRaw && stdin.isTTY && stdin.isRaw) stdin.setRawMode(false);
+    return JSON.parse(readFileSync3(FILE, "utf8"));
+  } catch {
+    return {};
   }
 }
+function save(values) {
+  const merged = { ...load(), ...values };
+  mkdirSync2(dirname2(FILE), { recursive: true });
+  writeFileSync4(FILE, JSON.stringify(merged, null, JSON_INDENT2), { mode: CONFIG_FILE_MODE });
+  chmodSync2(FILE, CONFIG_FILE_MODE);
+}
+var configPath = FILE;
+function resolved() {
+  const saved = load();
+  return {
+    apiKey: process.env.OYA_API_KEY || saved.apiKey || "",
+    baseUrl: (process.env.OYA_BASE_URL || saved.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "")
+  };
+}
 
-// src/install.ts
-import { randomBytes } from "crypto";
-import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, chmodSync as chmodSync2, statSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-import { spawn } from "child_process";
-import { createConnection } from "net";
-var ANSWERS_FILE = "oya-install.json";
-var token = () => randomBytes(32).toString("base64url");
-var SECRET_KEYS = /* @__PURE__ */ new Set([
-  "OYA_PROFILE_SECRET",
-  "OYA_OPERATOR_TOKEN",
-  "OYA_METRICS_TOKEN",
-  "API_KEYS",
-  "FLEET_TOKEN",
-  "OYA_CLUSTER_SECRET",
-  "DATABASE_URL",
-  "SUPABASE_SERVICE_KEY",
-  "OPENAI_API_KEY",
-  "OYA_CLOUD_API_KEY",
-  "ANCHOR_API_KEY",
-  "BROWSERBASE_API_KEY",
-  "STEEL_API_KEY",
-  "BROWSERUSE_API_KEY",
-  "OYA_CAPTCHA_API_KEY",
-  "OYA_CDP_WS_URL"
-]);
-function run(cmd, args2, opts = { cwd: process.cwd() }) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args2, { cwd: opts.cwd, stdio: opts.quiet ? "ignore" : "inherit" });
-    child.on("error", reject);
-    child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${cmd} ${args2.join(" ")} exited ${code}`)));
-  });
+// src/commands/login.ts
+async function postJson(url, body, token2) {
+  const headers = { ...token2 ? { Authorization: `Bearer ${token2}` } : {}, "Content-Type": "application/json" };
+  const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body) });
+  return { ok: res.ok, body: await res.json() };
 }
-async function capture(cmd, args2, cwd = process.cwd()) {
-  return new Promise((resolve) => {
-    const child = spawn(cmd, args2, { cwd, stdio: ["ignore", "pipe", "ignore"] });
-    let out2 = "";
-    child.stdout.on("data", (d) => {
-      out2 += d;
-    });
-    child.on("error", () => resolve(null));
-    child.on("close", (code) => resolve(code === 0 ? out2.trim() : null));
-  });
+async function mintKey(baseUrl) {
+  const email = await ask("Email:");
+  const password = await askSecret("Password:");
+  const session2 = await postJson(`${baseUrl}/api/auth/login`, { email, password });
+  if (!session2.ok || !session2.body.access_token) throw new Error(session2.body.error || "Sign-in failed");
+  const minted = await postJson(`${baseUrl}/api/auth/keys`, { label: "CLI" }, session2.body.access_token);
+  if (!minted.ok || !minted.body.key) throw new Error(minted.body.error || "Could not create an API key");
+  console.log('  Created a new API key labelled "CLI".');
+  return minted.body.key;
 }
-var has = async (cmd) => await capture(cmd, ["--version"]) !== null;
-function atLeast(version, major, minor) {
-  const m = /(\d+)\.(\d+)/.exec(version || "");
-  if (!m) return false;
-  return Number(m[1]) > major || Number(m[1]) === major && Number(m[2]) >= minor;
+function chooseMethod() {
+  return choose("How do you want to authenticate?", [
+    { id: "paste", label: "Paste an API key", note: "from the dashboard, or a self-hosted key" },
+    { id: "password", label: "Sign in with email and password", note: "mints a new key for this machine" }
+  ]);
 }
-function portFree(port) {
-  return new Promise((resolve) => {
-    const socket = createConnection({ port, host: "127.0.0.1" }).on("connect", () => {
-      socket.destroy();
-      resolve(false);
-    }).on("error", () => resolve(true));
-    setTimeout(() => {
-      socket.destroy();
-      resolve(true);
-    }, 700);
-  });
+async function obtainKey(flags2, baseUrl) {
+  const given = flagStr(flags2, "key") || "";
+  if (given) return given;
+  const how = await chooseMethod();
+  if (how === "paste") return askSecret("API key:");
+  return mintKey(baseUrl);
 }
-function findRepoRoot(from = process.cwd()) {
-  let dir = from;
-  for (let i = 0; i < 8; i++) {
-    if (existsSync(join2(dir, "docker-compose.yml")) && existsSync(join2(dir, "server", "src", "index.js"))) return dir;
-    const up2 = dirname2(dir);
-    if (up2 === dir) break;
-    dir = up2;
+async function verifyKey(baseUrl, apiKey) {
+  const check2 = await fetch(`${baseUrl}/api/config`, { headers: { Authorization: `Bearer ${apiKey}` } });
+  if (!check2.ok) throw new Error(`That key was rejected by ${baseUrl} (${check2.status})`);
+}
+async function loginUrl(flags2) {
+  const current = resolved().baseUrl;
+  const url = flagStr(flags2, "url") || (flagStr(flags2, "key") ? current : await ask("Control plane URL:", current));
+  return url.replace(/\/+$/, "");
+}
+async function cmdLogin(flags2) {
+  const baseUrl = await loginUrl(flags2);
+  const apiKey = await obtainKey(flags2, baseUrl);
+  if (!apiKey) throw new Error("No API key given");
+  await verifyKey(baseUrl, apiKey);
+  save({ apiKey, baseUrl });
+  console.log(`
+\u2705 Signed in to ${baseUrl}. Saved to ${configPath}`);
+  console.log("   Next: `oya init` to pick your model and browser provider.");
+}
+
+// ../sdk/dist/index.js
+var OyaError = class extends Error {
+  /** The HTTP status, or the SDK's own status for errors it raises itself. */
+  status;
+  /** The server's response body, parsed when it was JSON. */
+  body;
+  /** Records the message, status and body. */
+  constructor(message, status, body) {
+    super(message);
+    this.name = "OyaError";
+    this.status = status;
+    this.body = body;
   }
-  return null;
+};
+var DEFAULT_BASE_URL2 = "https://browser.getoya.ai";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var START_TIMEOUT_MS = 12e4;
+var READY_TIMEOUT_MS2 = 12e4;
+var READY_POLL_MS2 = 2e3;
+var NAVIGATE_TIMEOUT_MS = 12e4;
+var CHALLENGE_TIMEOUT_MS = 18e4;
+var AGENT_TIMEOUT_MS = 6e5;
+var PLAYBOOK_TIMEOUT_MS = 12e4;
+var STOP_TIMEOUT_MS = 6e4;
+var WAIT_FOR_DEFAULT_MS = 3e4;
+var WAIT_FOR_GRACE_MS = 5e3;
+var AIMED_SCROLL_AMOUNT = 500;
+var RUN_POLL_MS = 2e3;
+var MAX_RUN_POLL_ERRORS = 5;
+var BYTES_PER_MB = 1048576;
+var MAX_FILE_MB = 10;
+var MS_PER_SECOND = 1e3;
+var Status3 = {
+  /** The caller passed something unusable, such as a non-numeric element id. */
+  BAD_REQUEST: 400,
+  /** The server does not know that session. */
+  NOT_FOUND: 404,
+  /** The browser is in a state that needs attention first. */
+  CONFLICT: 409,
+  /** A browser command ran and failed. */
+  UNPROCESSABLE: 422,
+  /** A run failed without saying why. */
+  SERVER_ERROR: 500,
+  /** A browser did not come up in time. */
+  GATEWAY_TIMEOUT: 504
+};
+var Http = class {
+  /** Stores where to call, with which key, how long to wait and which fetch to use. */
+  constructor(baseUrl, apiKey, timeoutMs, fetchImpl) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.timeoutMs = timeoutMs;
+    this.fetchImpl = fetchImpl;
+  }
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  fetchImpl;
+  /** Sends one request and returns the parsed answer, or throws an OyaError when it failed. */
+  async request(method, path, body, timeoutMs = this.timeoutMs, headers = {}) {
+    const init = requestInit(method, body, timeoutMs, { Authorization: `Bearer ${this.apiKey}`, ...headers });
+    return readAnswer2(await this.fetchImpl(`${this.baseUrl}${path}`, init), `${method} ${path}`, this.baseUrl);
+  }
+};
+function requestInit(method, body, timeoutMs, headers) {
+  const json = body === void 0 ? {} : { "Content-Type": "application/json" };
+  const payload = body === void 0 ? void 0 : JSON.stringify(body);
+  return { method, headers: { ...headers, ...json }, body: payload, signal: AbortSignal.timeout(timeoutMs) };
 }
-async function locateRepo() {
-  const found = findRepoRoot();
-  if (found) return found;
-  console.log("\nThis does not look like an oya-browser checkout.");
-  const where = await ask("Clone it to:", join2(process.cwd(), "oya-browser"));
-  if (existsSync(where)) throw new Error(`${where} already exists`);
-  await run("git", ["clone", "--depth", "1", "https://github.com/OyadotAI/oya-browser.git", where], { cwd: process.cwd() });
-  return where;
+async function readAnswer2(res, call2, baseUrl) {
+  const payload = parseBody(await res.text());
+  if (!res.ok) throw failure(call2, res.status, payload, baseUrl);
+  return payload;
 }
-function readEnv(path) {
-  if (!existsSync(path)) return {};
-  const out2 = {};
-  for (const line of readFileSync2(path, "utf8").split("\n")) {
-    const m = /^([A-Z0-9_]+)=(.*)$/.exec(line.trim());
-    if (m) out2[m[1]] = m[2];
+function parseBody(text) {
+  try {
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return text;
   }
-  return out2;
 }
-var SECTIONS = [
-  ["Server", ["PORT", "OYA_UI_MODE", "OYA_DATA_DIR"]],
-  ["Tenant keys \u2014 each is an identity; add more from the dashboard", ["API_KEYS"]],
-  ["Host operations: /metrics, drain, fleet provision", ["OYA_OPERATOR_TOKEN", "OYA_METRICS_TOKEN"]],
-  ["Credentials at rest. Lose this and every stored cookie, proxy and TOTP seed is unreadable", ["OYA_PROFILE_SECRET"]],
-  ["Database", ["SUPABASE_URL", "SUPABASE_SERVICE_KEY", "DATABASE_URL", "OYA_RECORDING_BUCKET"]],
-  ["Agent LLM. A private or http base URL is operator-only: the dashboard and\n# POST /config/host reject one, on purpose \u2014 tenants can set that field too", ["OPENAI_API_KEY", "OPENAI_BASE_URL", "CHAT_MODEL"]],
-  ["Browser fleet", ["OYA_BROWSER_PROVIDER", "OYA_FLEET_RUNTIME", "OYA_PUBLIC_WS_URL", "OYA_CDP_WS_URL"]],
-  ["Governed Docker runtime", ["OYA_MANAGED_NETWORK", "OYA_MANAGED_IMAGE", "OYA_MANAGED_CONTROL_URL", "OYA_MANAGED_PROXY_URL", "OYA_MANAGED_REGION", "OYA_EGRESS_PORT", "OYA_EGRESS_HOST"]],
-  ["Oya Cloud", ["OYA_CLOUD_API_KEY", "OYA_CLOUD_SNAPSHOT", "OYA_CLOUD_TARGET"]],
-  ["Hosted CDP vendors", ["BROWSERBASE_API_KEY", "BROWSERBASE_PROJECT_ID", "STEEL_API_KEY", "ANCHOR_API_KEY", "BROWSERUSE_API_KEY"]],
-  ["CAPTCHA", ["OYA_CAPTCHA_PROVIDER", "OYA_CAPTCHA_API_KEY"]],
-  ["Multi-replica. One SQLite control database allows exactly one writer", ["OYA_INSTANCE_URL", "OYA_CLUSTER_SECRET"]]
-];
-function renderEnv(values, extra) {
-  const lines = ["# Written by `oya install`. Re-run it, or edit by hand \u2014 both are fine.", ""];
-  const placed = /* @__PURE__ */ new Set();
-  for (const [title, keys] of SECTIONS) {
-    const present = keys.filter((k) => values[k] !== void 0 && values[k] !== "");
-    if (!present.length) continue;
-    lines.push(`# \u2500\u2500 ${title} \u2500\u2500`);
-    for (const k of present) {
-      lines.push(`${k}=${values[k]}`);
-      placed.add(k);
-    }
-    lines.push("");
+function failure(call2, status, payload, baseUrl) {
+  let message = payload?.error || `${call2} failed (${status})`;
+  if (message === "Invalid API key") {
+    message += ` for ${baseUrl}. Check OYA_API_KEY: a value exported in your shell beats .env.`;
   }
-  const leftover = Object.keys(values).filter((k) => !placed.has(k) && values[k]);
-  if (leftover.length) {
-    lines.push("# \u2500\u2500 Other \u2500\u2500");
-    for (const k of leftover) lines.push(`${k}=${values[k]}`);
-    lines.push("");
+  return new OyaError(message, status, payload);
+}
+var env = (name) => globalThis.process?.env?.[name];
+function createHttp(options) {
+  const apiKey = options.apiKey || env("OYA_API_KEY");
+  if (!apiKey) {
+    throw new Error("No API key. Pass { apiKey } or set OYA_API_KEY \u2014 run `oya login` to get one.");
   }
-  if (extra.length) lines.push(...extra, "");
-  return lines.join("\n");
+  const baseUrl = (options.baseUrl || env("OYA_BASE_URL") || DEFAULT_BASE_URL2).replace(/\/+$/, "");
+  const fetchImpl = options.fetch || globalThis.fetch;
+  if (!fetchImpl) throw new Error("No fetch available \u2014 pass { fetch } or use Node 18+.");
+  return new Http(baseUrl, apiKey, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, fetchImpl.bind(globalThis));
 }
-function writeEnv(path, body) {
-  writeFileSync2(path, body, { mode: 384 });
-  chmodSync2(path, 384);
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function call(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    console.error("[oya] run callback threw:", err);
+  }
 }
-var LLM_PRESETS = {
-  anthropic: { base: "https://api.anthropic.com/v1", model: "claude-sonnet-4-5", label: "Anthropic (Claude)" },
-  openai: { base: "https://api.openai.com/v1", model: "gpt-4o-mini", label: "OpenAI" },
-  gemini: { base: "https://generativelanguage.googleapis.com/v1beta/openai", model: "gemini-3.8-flash", label: "Gemini (Google)" },
-  // Express mode: a global endpoint, no GCP project or location needed.
-  vertex: { base: "https://aiplatform.googleapis.com/v1/publishers/google", model: "gemini-2.5-flash", label: "Gemini Enterprise (Vertex AI)" }
-};
-async function askLlm() {
-  step("Agent LLM", "Drives `oya ask` and the chat API.");
-  note("CDP, the SDK and MCP all work without one.");
-  const provider = await choose("Which LLM should agents use?", [
-    { id: "anthropic", label: "Anthropic (Claude)" },
-    { id: "openai", label: "OpenAI" },
-    { id: "gemini", label: "Gemini (Google)" },
-    { id: "vertex", label: "Gemini Enterprise (Vertex AI)", note: "express-mode API key" },
-    { id: "compatible", label: "An OpenAI-compatible endpoint", note: "OpenRouter, Together, Groq, Azure" },
-    { id: "local", label: "A local model", note: "Ollama, vLLM, LM Studio" },
-    { id: "skip", label: "Skip", note: "no agent control; add it later with `oya config`" }
-  ]);
-  if (provider === "skip") return { answers: { provider, baseUrl: "", model: "" }, key: "" };
-  const preset = LLM_PRESETS[provider];
-  const baseUrl = preset ? preset.base : (await ask("Base URL:", provider === "local" ? "http://localhost:11434/v1" : "https://openrouter.ai/api/v1")).replace(/\/+$/, "");
-  const model = await ask("Model:", preset?.model || (provider === "local" ? "qwen2.5" : ""));
+async function watchRun(run2, baseUrl, cb, pollMs) {
+  const watch = { run: run2, baseUrl, cb, errors: 0 };
   for (; ; ) {
-    const key = await askSecret(provider === "local" ? "API key (blank if none):" : "API key:");
-    if (!key) return { answers: { provider, baseUrl, model }, key: "" };
-    const problem = await verifyLlm(baseUrl, key, model);
-    if (!problem) return { answers: { provider, baseUrl, model }, key };
-    warn(problem);
-    const what = await choose("What now?", [
-      { id: "retry", label: "Enter the key again" },
-      { id: "skip", label: "Continue without an LLM", note: "add it later with `oya config`" }
-    ]);
-    if (what === "skip") return { answers: { provider: "skip", baseUrl: "", model: "" }, key: "" };
+    const result = await step2(watch);
+    if (result) return result;
+    await sleep(pollMs);
   }
 }
-async function verifyLlm(baseUrl, key, model) {
-  const spin = spinner("checking the key");
+async function step2(watch) {
+  const info = await poll(watch);
+  if (!info) return void 0;
+  noticeAttention(watch, info);
+  if (info.status === "succeeded") return succeed(watch.cb, info);
+  if (info.status === "failed") return fail(watch.cb, info);
+  return void 0;
+}
+async function poll(watch) {
   try {
-    const anthropic = /(^|\.)anthropic\.com$/i.test(new URL(baseUrl).hostname);
-    const headers = anthropic ? { "x-api-key": key, "anthropic-version": "2023-06-01" } : { Authorization: `Bearer ${key}` };
-    const res = /\/publishers\/google\/?$/.test(baseUrl) ? await fetch(`${baseUrl.replace(/\/+$/, "")}/models/${encodeURIComponent(model || "gemini-2.5-flash")}:generateContent?key=${encodeURIComponent(key)}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ contents: [{ role: "user", parts: [{ text: "hi" }] }], generationConfig: { maxOutputTokens: 1 } })
-    }) : await fetch(`${baseUrl}/models`, { headers });
-    if (res.status === 401 || res.status === 403) {
-      spin.fail();
-      return `${baseUrl} rejected that key (HTTP ${res.status}).`;
-    }
-    if (!res.ok) {
-      spin.fail(`could not verify (HTTP ${res.status}) \u2014 continuing anyway`);
-      return null;
-    }
-    const body = await res.json().catch(() => null);
-    const ids = (body?.data || []).map((m) => m.id);
-    if (model && ids.length && !ids.includes(model)) {
-      spin.done(`key works, though "${model}" is not in this endpoint's list`);
-      return null;
-    }
-    spin.done("ok");
-    return null;
+    const info = await watch.run.status();
+    watch.errors = 0;
+    return info;
   } catch (err) {
-    spin.fail(`could not reach it (${err.message}) \u2014 continuing anyway`);
-    return null;
+    if (++watch.errors < MAX_RUN_POLL_ERRORS) return null;
+    return giveUp(watch.cb, err);
   }
 }
-var hostOptions = [
-  { id: "docker", label: "Docker on this machine", note: "one command, no cluster" },
-  { id: "k8s", label: "Kubernetes", disabled: "not in this build yet" },
-  { id: "ecs", label: "Amazon ECS", disabled: "not in this build yet" },
-  { id: "fly", label: "Fly.io", disabled: "coming soon" },
-  { id: "exe", label: "exe.dev", disabled: "coming soon" }
-];
-var dbOptions = (host) => [
-  { id: "sqlite", label: "SQLite", note: "zero config, one replica, API keys only" },
-  { id: "supabase", label: "Supabase", note: "adds email sign-in and the dashboard" },
-  { id: "postgres", label: "Postgres", note: "many replicas; needs psql for migrations" }
-];
-var fleetOptions = [
-  { id: "docker-workers", label: "Docker browser workers here", note: "always-on containers, no daemon access needed" },
-  { id: "oya-selfhosted", label: "Governed Docker, one container per session", note: "policies and budgets; needs Docker socket access" },
-  { id: "oya-cloud", label: "Oya Cloud", note: "managed sandboxes, nothing to run yourself" },
-  { id: "browserbase", label: "Browserbase" },
-  { id: "steel", label: "Steel" },
-  { id: "anchor", label: "Anchor" },
-  { id: "browseruse", label: "Browser Use Cloud" },
-  { id: "cdp", label: "Your own Chrome over CDP" },
-  { id: "k8s", label: "Kubernetes fleet, one pod per session", note: "needs kubectl and a cluster" },
-  { id: "ecs", label: "ECS fleet, one task per session", disabled: "not in this build yet" }
-];
-var VENDOR_KEYS = {
-  browserbase: ["BROWSERBASE_API_KEY", "BROWSERBASE_PROJECT_ID"],
-  steel: ["STEEL_API_KEY"],
-  anchor: ["ANCHOR_API_KEY"],
-  browseruse: ["BROWSERUSE_API_KEY"]
-};
-async function interview(preset, replay) {
-  const secrets = {};
-  let migrateUrl = "";
-  const secretFor = async (field, hidden = true) => {
-    if (replay) return process.env[field] || "";
-    return hidden ? askSecret(`${field}:`) : ask(`${field}:`);
-  };
-  if (!preset.host) step("Control plane", "Where the server itself runs.");
-  const host = preset.host || await choose("Where should the control plane run?", hostOptions);
-  if (!preset.database) step("Database", "What holds sessions, keys and personas.");
-  const database = preset.database || await choose("Which database?", dbOptions(host));
-  if (database === "sqlite") {
-    note("SQLite means API-key auth only \u2014 email sign-in needs Supabase.");
-    note("The dashboard still works: sign in with the API key printed at the end.");
-  }
-  const isPostgresUrl = (v) => {
-    if (!v) return;
-    try {
-      const url = new URL(v);
-      if (!["postgres:", "postgresql:"].includes(url.protocol)) return "Must start with postgres://";
-    } catch {
-      return "That is not a connection string \u2014 postgres://user:pass@host:5432/db";
-    }
+async function giveUp(cb, err) {
+  const failure2 = err instanceof OyaError ? err : new OyaError(String(err), 0, null);
+  await call(() => cb.onFailure?.(failure2));
+  throw failure2;
+}
+function noticeAttention(watch, info) {
+  if (info.status !== "needs_attention" || !info.attention || info.attention.id === watch.seen) return;
+  watch.seen = info.attention.id;
+  const request = {
+    ...info.attention,
+    liveViewUrl: info.attention.liveViewUrl && new URL(info.attention.liveViewUrl, watch.baseUrl).href,
+    respond: (response) => watch.run.respond(response)
   };
-  if (database === "supabase") {
-    secrets.SUPABASE_URL = replay ? process.env.SUPABASE_URL || "" : await ask("Supabase project URL:");
-    secrets.SUPABASE_SERVICE_KEY = await secretFor("SUPABASE_SERVICE_KEY");
-    if (!replay) {
-      note("Migrations need the Postgres connection string, not the API URL.");
-      note("Leave it blank to apply them yourself later with `make migrate`.");
-      migrateUrl = await askSecret("Postgres connection string (optional):", { validate: isPostgresUrl });
-    }
+  void call(() => watch.cb.onHumanAttention?.(request));
+}
+async function succeed(cb, info) {
+  const result = info.result || {};
+  if (result.healed) await call(() => cb.onHealed?.(result));
+  await call(() => cb.onSuccess?.(result));
+  return result;
+}
+async function fail(cb, info) {
+  const failure2 = new OyaError(info.error || "Run failed", info.errorStatus ?? Status3.SERVER_ERROR, info);
+  await call(() => cb.onFailure?.(failure2));
+  throw failure2;
+}
+var Run = class {
+  /** Starts watching the run straight away. */
+  constructor(http, id, callbacks, pollMs = RUN_POLL_MS) {
+    this.http = http;
+    this.id = id;
+    this.done = this.watch(callbacks, pollMs);
+    this.done.catch(() => {
+    });
+  }
+  http;
+  id;
+  /** Settles with the result when the run succeeds, or rejects when it fails. */
+  done;
+  /** The run's current state. */
+  status() {
+    return this.http.request("GET", `/api/runs/${encodeURIComponent(this.id)}`);
+  }
+  /** Answer the open attention request: `'done'` after handling it by hand, or your reply to the agent. */
+  async respond(response = "done") {
+    await this.http.request("POST", `/api/runs/${encodeURIComponent(this.id)}/respond`, { response });
+  }
+  /** Polls until the run ends, firing callbacks on the way. */
+  watch(cb, pollMs) {
+    return watchRun(this, this.http.baseUrl, cb, pollMs);
+  }
+};
+var Browser = class {
+  /** Wraps a started browser; `autoCaptcha` solves CAPTCHAs after every `goto()`. */
+  constructor(http, info, autoCaptcha) {
+    this.http = http;
+    this.autoCaptcha = autoCaptcha;
+    this.id = info.id;
+    this.provider = info.provider;
+    this.persona = info.persona;
+    this.cdpUrl = info.cdpUrl;
+  }
+  http;
+  autoCaptcha;
+  /** The browser's id. */
+  id;
+  /** Which provider runs it. */
+  provider;
+  /** Which persona it runs as. */
+  persona;
+  /** Point Playwright, Puppeteer or browser-use here. */
+  cdpUrl;
+  /** Runs one browser command; a command that ran and failed throws. */
+  async command(action, params = {}, timeoutMs) {
+    const path = `/api/browsers/${this.id}/command`;
+    const result = await this.http.request("POST", path, { action, params }, timeoutMs);
+    if (result.ok === false) throw new OyaError(result.error || `${action} failed`, Status3.UNPROCESSABLE, result);
+    return result.data;
+  }
+  /** Navigates, then clears any CAPTCHA when `captcha: 'auto'` was asked for. */
+  async goto(url) {
+    await this.command("navigate", { url }, NAVIGATE_TIMEOUT_MS);
+    if (this.autoCaptcha) assertCaptchaCleared(await this.solveCaptcha());
+  }
+  /**
+   * The page, written as markdown (the default), TOON or JSONL, plus its blocks and
+   * the numbered elements to act on.
+   */
+  async analyze(options = {}) {
+    return this.command("analyze", options.format ? { format: options.format } : {});
+  }
+  /** Only the visible elements, which is what an agent almost always wants. */
+  async elements() {
+    return (await this.analyze()).elements.filter((e) => e.visible);
+  }
+  /** Clicks an element by its id from `analyze()`. */
+  async click(elementId) {
+    const id = this.elementId(elementId);
+    await this.command("click", { element_id: id, selector: `[data-ac-id="${id}"]` });
+  }
+  /** Types into an element by its id from `analyze()`. */
+  async type(elementId, text) {
+    const id = this.elementId(elementId);
+    return this.command("type", { element_id: id, selector: `[data-ac-id="${id}"]`, text });
+  }
+  /** A valid element id, or an OyaError saying where ids come from. */
+  elementId(value) {
+    return toElementId(value);
+  }
+  /** Presses one key, such as Enter or Escape. */
+  async pressKey(key) {
+    await this.command("press_key", { key });
+  }
+  /**
+   * Answer a native dialog holding the page. alert() and beforeunload are
+   * answered for you; a confirm() or prompt() waits for this, and every other
+   * command fails fast with the dialog's text until it is answered.
+   */
+  async handleDialog(accept, promptText) {
+    return this.command("handle_dialog", { accept, prompt_text: promptText });
   }
-  if (database === "postgres") {
-    secrets.DATABASE_URL = replay ? process.env.DATABASE_URL || "" : await askSecret("Postgres connection string:", {
-      validate: (v) => !v ? "Required for a Postgres deployment." : isPostgresUrl(v)
-    });
-    migrateUrl = secrets.DATABASE_URL;
+  /** `at` aims the wheel at an inner scroller (a results panel, a chat pane) instead of the page. */
+  async scroll(direction, amount, at) {
+    await this.command("scroll", scrollParams(direction, amount, at));
   }
-  if (!preset.fleet) step("Browsers", "What actually runs Chrome.");
-  const fleet = preset.fleet || await choose("Where should browsers run?", fleetOptions);
-  let workers = preset.workers ?? 0;
-  if (fleet === "docker-workers" && preset.workers === void 0) {
-    workers = Number(await ask("How many browser workers?", "2", {
-      validate: (v) => /^[1-9][0-9]*$/.test(v) ? void 0 : "Enter a whole number of 1 or more."
-    }));
+  /** Waits until `selector` matches, up to `timeout` milliseconds. */
+  async waitFor(selector, timeout = WAIT_FOR_DEFAULT_MS) {
+    await this.command("wait", { selector, timeout }, timeout + WAIT_FOR_GRACE_MS);
   }
-  for (const field of VENDOR_KEYS[fleet] || []) {
-    secrets[field] = await secretFor(field, !field.endsWith("PROJECT_ID"));
-  }
-  if (fleet === "oya-cloud") secrets.OYA_CLOUD_API_KEY = await secretFor("OYA_CLOUD_API_KEY");
-  if (fleet === "cdp") secrets.OYA_CDP_WS_URL = await secretFor("OYA_CDP_WS_URL");
-  let k8sFleet = preset.k8sFleet;
-  if (fleet === "k8s" && !k8sFleet) {
-    step("Kubernetes fleet", "One pod per session.");
-    note("The image must be digest-pinned: a tag can move between verification and scheduling.");
-    k8sFleet = {
-      namespace: await ask("Namespace for browser pods:", "oya-browsers"),
-      image: await ask("Browser image:", "ghcr.io/oyadotai/oya-browser:latest"),
-      controlUrl: await ask("Control-plane WebSocket URL, as reachable from the cluster:", "ws://oya-server.oya-browser.svc:3100/ws"),
-      proxyUrl: await ask("Egress proxy URL, as reachable from the cluster:", "http://oya-server.oya-browser.svc:3128")
-    };
-  }
-  const llm = preset.llm ? { answers: preset.llm, key: replay ? process.env.OPENAI_API_KEY || "" : "" } : await askLlm();
-  if (llm.key) secrets.OPENAI_API_KEY = llm.key;
-  step("Address", "Where clients and browsers reach this control plane.");
-  const publicUrl = (preset.publicUrl || await ask("Public URL of this control plane:", "http://localhost:3100", {
-    validate: (v) => {
-      try {
-        const url = new URL(v);
-        if (!["http:", "https:"].includes(url.protocol)) return "Must be http:// or https://";
-      } catch {
-        return "That is not a URL \u2014 try http://localhost:3100";
-      }
-    }
-  })).replace(/\/+$/, "");
-  const optional = preset.optional || { captcha: "", recordingBucket: "", metrics: false };
-  if (!preset.optional) {
-    step("Optional services", "Everything here has a sensible default.");
-    const more = await choose("Configure optional services now?", [
-      { id: "no", label: "No", note: "change any of it later" },
-      { id: "yes", label: "Yes", note: "CAPTCHA solver, recording storage, metrics" }
-    ]);
-    if (more === "yes") {
-      optional.captcha = await choose("Solve CAPTCHAs automatically?", [
-        { id: "", label: "No", note: "hosted vendors still solve natively" },
-        { id: "capsolver", label: "CapSolver" },
-        { id: "2captcha", label: "2Captcha" }
-      ]);
-      if (optional.captcha) secrets.OYA_CAPTCHA_API_KEY = await secretFor("OYA_CAPTCHA_API_KEY");
-      if (database === "supabase") optional.recordingBucket = await ask("Private Storage bucket for recordings (blank to keep them on disk):", "");
-      optional.metrics = await choose("Expose /metrics to a Prometheus scraper?", [
-        { id: "no", label: "No" },
-        { id: "yes", label: "Yes", note: "generates a scrape token" }
-      ]) === "yes";
-    }
+  /** A `data:image/…;base64,` URL. PNG or JPEG depending on the driver. */
+  async screenshot() {
+    return (await this.command("screenshot")).screenshot;
   }
-  return {
-    answers: { version: 1, host, database, fleet, workers, k8sFleet, llm: llm.answers, publicUrl, optional },
-    secrets,
-    migrateUrl
-  };
-}
-async function preflight(root, a) {
-  const checks = [];
-  const needsDocker = a.host === "docker" || a.fleet === "docker-workers" || a.fleet === "oya-selfhosted";
-  if (needsDocker) {
-    const version = await capture("docker", ["--version"]);
-    checks.push({ ok: !!version, label: "docker", detail: version || "not found", fatal: true });
-    const daemon = await capture("docker", ["info", "--format", "{{.ID}}"]);
-    checks.push({ ok: !!daemon, label: "docker daemon reachable", detail: daemon ? "ok" : "not running", fatal: true });
-    const compose = await capture("docker", ["compose", "version", "--short"]);
-    checks.push({ ok: atLeast(compose, 2, 24), label: "docker compose \u2265 2.24", detail: compose || "not found", fatal: true });
-  }
-  if (a.host !== "docker") {
-    checks.push({ ok: atLeast(process.versions.node, 22, 13), label: "node \u2265 22.13 (node:sqlite)", detail: process.versions.node, fatal: true });
-  }
-  if (a.fleet === "k8s" || a.host === "k8s") {
-    const version = await capture("kubectl", ["version", "--client=true", "-o", "json"]);
-    checks.push({ ok: !!version, label: "kubectl", detail: version ? "ok" : "not found", fatal: true });
-    const cluster = await capture("kubectl", ["get", "namespace", "kube-system", "-o", "name"]);
-    checks.push({ ok: !!cluster, label: "cluster reachable", detail: cluster || "kubectl cannot reach a cluster", fatal: true });
-  }
-  if (a.database === "postgres" || a.database === "supabase") {
-    checks.push({ ok: await has("psql"), label: "psql (to apply migrations)", detail: "from libpq/postgresql-client", fatal: true });
-  }
-  const port = Number(new URL(a.publicUrl).port || 3100);
-  const free = await portFree(port);
-  checks.push({ ok: free, label: `port ${port} free`, detail: free ? "ok" : "something is already listening" });
-  const envPath = join2(root, ".env");
-  if (existsSync(envPath)) {
-    const mode = (statSync(envPath).mode & 511).toString(8);
-    checks.push({ ok: true, label: ".env exists \u2014 keeping its OYA_PROFILE_SECRET and API keys", detail: `mode ${mode}` });
+  /** The active tab's URL, or empty when there is none. */
+  async url() {
+    return (await this.tabs()).find((t) => t.active)?.url || "";
   }
-  return checks;
-}
-function buildEnv(a, secrets, existing) {
-  const v = {};
-  const port = String(Number(new URL(a.publicUrl).port || 3100));
-  v.OYA_PROFILE_SECRET = existing.OYA_PROFILE_SECRET || token();
-  const apiKey = existing.API_KEYS?.split(",")[0] || `oya_${token()}`;
-  v.API_KEYS = existing.API_KEYS || apiKey;
-  v.OYA_OPERATOR_TOKEN = existing.OYA_OPERATOR_TOKEN || token();
-  if (a.host !== "docker") v.PORT = port;
-  Object.assign(v, secrets);
-  if (a.llm.provider !== "skip") {
-    v.OPENAI_BASE_URL = a.llm.baseUrl;
-    v.CHAT_MODEL = a.llm.model;
-  }
-  const wsUrl = a.publicUrl.replace(/^http/, "ws") + "/ws";
-  if (a.fleet === "oya-cloud") {
-    v.OYA_BROWSER_PROVIDER = "oya-cloud";
-    v.OYA_PUBLIC_WS_URL = wsUrl;
-    v.OYA_CLOUD_SNAPSHOT = existing.OYA_CLOUD_SNAPSHOT || existing.DAYTONA_SNAPSHOT || "oya-browser";
-  } else if (a.fleet === "oya-selfhosted") {
-    v.OYA_BROWSER_PROVIDER = "oya-selfhosted";
-    v.OYA_FLEET_RUNTIME = "docker";
-    v.OYA_MANAGED_NETWORK = "oya-browsers";
-    v.OYA_MANAGED_IMAGE = "oya-browser:local";
-    v.OYA_MANAGED_CONTROL_URL = a.host === "docker" ? "ws://server:3100/ws" : wsUrl;
-    v.OYA_EGRESS_PORT = "3128";
-    v.OYA_EGRESS_HOST = "0.0.0.0";
-    v.OYA_MANAGED_PROXY_URL = a.host === "docker" ? "http://server:3128" : "http://127.0.0.1:3128";
-    v.OYA_MANAGED_REGION = "local";
-  } else if (a.fleet === "k8s" && a.k8sFleet) {
-    v.OYA_BROWSER_PROVIDER = "oya-selfhosted";
-    v.OYA_FLEET_RUNTIME = "k8s";
-    v.OYA_K8S_NAMESPACE = a.k8sFleet.namespace;
-    v.OYA_MANAGED_NETWORK = "oya-governed-egress";
-    v.OYA_MANAGED_IMAGE = a.k8sFleet.image;
-    v.OYA_MANAGED_CONTROL_URL = a.k8sFleet.controlUrl;
-    v.OYA_MANAGED_PROXY_URL = a.k8sFleet.proxyUrl;
-    v.OYA_MANAGED_REGION = a.k8sFleet.namespace;
-    v.OYA_EGRESS_PORT = "3128";
-    v.OYA_EGRESS_HOST = "0.0.0.0";
-  } else if (a.fleet === "docker-workers") {
-    v.OYA_BROWSER_PROVIDER = "oya-selfhosted";
-  } else {
-    v.OYA_BROWSER_PROVIDER = a.fleet;
+  /** Every open tab. */
+  async tabs() {
+    return (await this.command("list_tabs")).tabs || [];
   }
-  if (a.optional.captcha) v.OYA_CAPTCHA_PROVIDER = a.optional.captcha;
-  if (a.optional.recordingBucket) v.OYA_RECORDING_BUCKET = a.optional.recordingBucket;
-  if (a.optional.metrics) v.OYA_METRICS_TOKEN = existing.OYA_METRICS_TOKEN || token();
-  const extra = [
-    "# \u2500\u2500 Shared fleet enrolment \u2500\u2500",
-    "# Uncomment to let any browser presenting this token enrol itself.",
-    `# FLEET_TOKEN=${token()}`
-  ];
-  return { values: v, extra, apiKey };
-}
-var PROBE_IMAGE = "alpine@sha256:14358309a308569c32bdc37e2e0e9694be33a9d99e68afb0f5ff33cc1f695dce";
-async function priorState() {
-  const volumes = await capture("docker", ["volume", "ls", "-q", "--filter", "name=oya-data"]) || "";
-  for (const name of volumes.split("\n").map((v) => v.trim()).filter(Boolean)) {
-    const listing = await capture("docker", ["run", "--rm", "-v", `${name}:/d`, PROBE_IMAGE, "ls", "/d"]);
-    if (listing === null || /cookies\.json|personas\.json|profiles|\.secret/.test(listing)) return name;
+  /** Opens a tab, optionally at `url`, and returns its id. */
+  async openTab(url) {
+    return (await this.command("open_tab", { url }, NAVIGATE_TIMEOUT_MS)).tab_id;
   }
-  return null;
-}
-async function resolveKekConflict(volume, root) {
-  warn(`${volume} already holds encrypted data from an earlier install.`);
-  note("Cookies, proxy credentials and TOTP seeds in it were sealed with that");
-  note("install's OYA_PROFILE_SECRET. A new secret cannot open them, and the");
-  note("server refuses to start rather than silently losing them.");
-  const choice = await choose("How should that be handled?", [
-    { id: "paste", label: "I have the previous OYA_PROFILE_SECRET", note: "reuse it and keep the data" },
-    { id: "reset", label: "Delete the old data and start clean", note: "personas, cookies and sessions are lost" },
-    { id: "abort", label: "Stop so I can go and find it" }
-  ]);
-  if (choice === "paste") {
-    return askSecret("Previous OYA_PROFILE_SECRET:", {
-      validate: (v) => v ? void 0 : "Paste the secret, or pick another option."
-    });
+  /** Makes a tab the one commands act on. */
+  async switchTab(tabId) {
+    await this.command("switch_tab", { tab_id: tabId });
   }
-  if (choice === "abort") throw new InputError("Stopped without changing anything.");
-  if (!await confirm(`Delete ${volume} and everything stored in it?`, false)) {
-    throw new InputError("Stopped without changing anything.");
+  /** Closes a tab. */
+  async closeTab(tabId) {
+    await this.command("close_tab", { tab_id: tabId });
   }
-  await run("docker", ["compose", "down", "-v"], { cwd: root, quiet: true }).catch(() => {
-  });
-  await run("docker", ["volume", "rm", "-f", volume], { cwd: root, quiet: true });
-  success(`removed ${volume}`);
-  return null;
-}
-async function waitReady(url, timeoutMs = 18e4) {
-  const deadline = Date.now() + timeoutMs;
-  process.stdout.write("  waiting for /readyz\u2026 ");
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`${url}/readyz`);
-      if (res.ok) {
-        console.log("ready");
-        return;
-      }
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, 2e3));
+  /**
+   * Detect and clear a CAPTCHA. Providers that solve natively are left to do
+   * it; everything else goes to the configured solver.
+   */
+  solveCaptcha() {
+    return this.http.request("POST", `/api/browsers/${this.id}/captcha`, {}, CHALLENGE_TIMEOUT_MS);
   }
-  console.log("timed out");
-  throw new Error(`${url}/readyz did not become ready. Check logs with: docker compose logs -f server`);
-}
-async function pinImage(reference) {
-  if (/@sha256:[0-9a-f]{64}$/.test(reference)) return reference;
-  process.stdout.write(`  resolving ${reference} to a digest\u2026 `);
-  const raw = await capture("docker", ["manifest", "inspect", "--verbose", reference]);
-  const digest = raw && /"digest":\s*"(sha256:[0-9a-f]{64})"/.exec(raw)?.[1];
-  if (!digest) {
-    console.log("could not");
-    throw new Error(
-      `Kubernetes browsers must run a digest-pinned image, and ${reference} is a tag.
-  Get the digest with:  docker manifest inspect --verbose ${reference}
-  then re-run with the image written as ${reference.split(":")[0]}@sha256:<digest>`
-    );
+  /**
+   * Answer an MFA prompt with the persona's configured factor. When nothing can
+   * answer it, `liveViewUrl` is where a person finishes by hand.
+   */
+  async completeMfa() {
+    const result = await this.http.request("POST", `/api/browsers/${this.id}/mfa`, {}, CHALLENGE_TIMEOUT_MS);
+    if (result.liveViewUrl) result.liveViewUrl = new URL(result.liveViewUrl, this.http.baseUrl).href;
+    return result;
   }
-  const pinned = `${reference.split("@")[0].replace(/:[^:/]+$/, "")}@${digest}`;
-  console.log(digest.slice(0, 19) + "\u2026");
-  return pinned;
-}
-function networkPolicy(namespace, name) {
-  return JSON.stringify({
-    apiVersion: "networking.k8s.io/v1",
-    kind: "NetworkPolicy",
-    metadata: { name, namespace },
-    spec: {
-      podSelector: { matchLabels: { app: "oya-managed-browser" } },
-      policyTypes: ["Egress"],
-      egress: [
-        // DNS only, to the cluster resolver.
-        { ports: [{ protocol: "UDP", port: 53 }, { protocol: "TCP", port: 53 }] },
-        // Everything else must go through the control plane's egress proxy, which
-        // is what makes per-session egress policy and budgets enforceable.
-        // `app: server` is the label k8s/base/server.yaml gives the control plane;
-        // the empty namespaceSelector lets the browsers live in their own namespace.
-        // A control plane OUTSIDE the cluster is not matched by any pod selector —
-        // add an ipBlock rule here for that case, or the pods will resolve DNS and
-        // then fail to enrol.
-        { to: [{ namespaceSelector: {}, podSelector: { matchLabels: { app: "server" } } }] }
-      ]
-    }
-  }, null, 2);
-}
-async function provisionK8sFleet(root, a) {
-  const fleet = a.k8sFleet;
-  const policyName = "oya-governed-egress";
-  const pinned = await pinImage(fleet.image);
-  const nsDoc = JSON.stringify({ apiVersion: "v1", kind: "Namespace", metadata: { name: fleet.namespace } });
-  await pipeTo("kubectl", ["apply", "-f", "-"], nsDoc, root);
-  const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync2 } = await import("fs");
-  mkdirSync2(join2(root, "k8s", "fleet"), { recursive: true });
-  const policyPath = join2(root, "k8s", "fleet", "networkpolicy.json");
-  writeFileSync3(policyPath, networkPolicy(fleet.namespace, policyName) + "\n");
-  await pipeTo("kubectl", ["apply", "-f", "-"], networkPolicy(fleet.namespace, policyName), root);
-  console.log(`  applied namespace ${fleet.namespace} and NetworkPolicy ${policyName}`);
-  console.log(`  policy written to ${policyPath} \u2014 review it; it is your egress boundary`);
-  return pinned;
-}
-function pipeTo(cmd, args2, stdin2, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args2, { cwd, stdio: ["pipe", "inherit", "inherit"] });
-    child.on("error", reject);
-    child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${cmd} ${args2.join(" ")} exited ${code}`)));
-    child.stdin.end(stdin2);
-  });
-}
-async function provisionDocker(root, a) {
-  if (a.fleet === "oya-selfhosted") {
-    const exists = await capture("docker", ["network", "inspect", "oya-browsers"]);
-    if (!exists) await run("docker", ["network", "create", "--internal", "--driver", "bridge", "oya-browsers"], { cwd: root });
-    console.log("  building the governed browser image\u2026");
-    await run("docker", ["build", "-t", "oya-browser:local", "browser"], { cwd: root });
-    console.log("\n  Governed browsers need Docker daemon access from the server container.");
-    console.log("  Add this to the server service in docker-compose.yml, then re-run `docker compose up -d`:");
-    console.log("    volumes:\n      - /var/run/docker.sock:/var/run/docker.sock");
+  /**
+   * Natural-language control, using this key's configured model. Refer to values as
+   * `{{name}}` in the prompt. `data` the agent can read, so it can split a name or pick
+   * the matching option; `secrets` it never sees. It types both through placeholders,
+   * with filters like `{{name|first}}`, so a playbook saved from the run stores no values.
+   */
+  async ask(prompt, { data, secrets } = {}) {
+    const body = { messages: [{ role: "user", content: prompt }], data, secrets };
+    const path = `/api/browsers/${this.id}/chat`;
+    return agentAnswer(await this.http.request("POST", path, body, AGENT_TIMEOUT_MS)).text;
   }
-  const scale = a.fleet === "docker-workers" ? ["--scale", `browser=${a.workers}`] : ["--scale", "browser=0"];
-  await run("docker", ["compose", "up", "-d", "--build", ...scale], { cwd: root });
-}
-async function cmdInstall(flags2) {
-  const dryRun = flags2["dry-run"] === true;
-  const root = await locateRepo();
-  const configPath2 = typeof flags2.config === "string" ? flags2.config : null;
-  const preset = configPath2 ? JSON.parse(readFileSync2(configPath2, "utf8")) : {};
-  banner("Oya Browser \u2014 self-host install", root);
-  if (configPath2) note(`replaying ${configPath2}`);
-  steps(configPath2 ? 0 : 6);
-  const { answers, secrets, migrateUrl } = await interview(preset, !!configPath2);
-  const checks = await preflight(root, answers);
-  console.log(`
-${style.bold("  Preflight")}`);
-  for (const c of checks) {
-    const mark = c.ok ? icon.ok : c.fatal ? icon.fail : icon.warn;
-    console.log(`  ${mark} ${c.label}${c.detail ? style.grey(`  \u2014 ${c.detail}`) : ""}`);
+  /**
+   * Save the last `ask()` on this browser as a named playbook. Every value that was
+   * typed, picked or clicked becomes a variable, with what the run used kept in
+   * `defaults`, so `play()` with nothing repeats the run and any one value can be
+   * swapped. `code` is the same flow as a Playwright module, to read or run yourself.
+   */
+  toPlaybook(name) {
+    return this.http.request("POST", `/api/browsers/${this.id}/playbooks`, { name }, PLAYBOOK_TIMEOUT_MS);
   }
-  const blocking = checks.filter((c) => !c.ok && c.fatal);
-  if (blocking.length && !dryRun) throw new Error(`Install cannot continue: ${blocking.map((c) => c.label).join(", ")}`);
-  if (answers.host === "docker" && /(localhost|127\.0\.0\.1)/.test(secrets.DATABASE_URL || "")) {
-    warn("DATABASE_URL points at localhost, which inside a container means the container itself.");
-    note("Use host.docker.internal (macOS, Windows) or the host IP so the server can reach it.");
+  /**
+   * Replay a playbook with no LLM in the loop. Variables left out reuse the
+   * recorded values where there are any. If a step no longer fits the page and
+   * `autoHeal` is on (the default), the agent finishes the task and its fix is
+   * saved as a draft (`healed`, `draft`); off, the step's error is thrown.
+   * Play `'<name>:draft'` to try a draft before promoting it.
+   */
+  async play(name, data = {}, { autoHeal = true } = {}) {
+    const path = `/api/browsers/${this.id}/playbooks/${encodeURIComponent(name)}/play`;
+    return agentAnswer(
+      await this.http.request("POST", path, { variables: data, autoHeal }, AGENT_TIMEOUT_MS)
+    );
   }
-  const envPath = join2(root, ".env");
-  const existing = readEnv(envPath);
-  if (!existing.OYA_PROFILE_SECRET && answers.host === "docker" && !dryRun) {
-    const volume = await priorState();
-    if (volume) {
-      const reused = await resolveKekConflict(volume, root);
-      if (reused) existing.OYA_PROFILE_SECRET = reused;
-    }
+  /**
+   * Start a prompt or playbook in the background and hear back through callbacks.
+   * `onHumanAttention` fires for an unsolved CAPTCHA, an unfinished MFA, the agent
+   * asking for help, or a replay the agent could not heal; the run waits (up to 30
+   * minutes) until you call `respond()`.
+   */
+  async submit(task, options = {}) {
+    const { onSuccess, onFailure, onHumanAttention, onHealed, pollMs, ...body } = options;
+    const started = await this.http.request("POST", `/api/browsers/${this.id}/runs`, { ...task, ...body });
+    return new Run(this.http, started.id, { onSuccess, onFailure, onHumanAttention, onHealed }, pollMs);
   }
-  const { values, extra, apiKey } = buildEnv(answers, secrets, existing);
-  const body = renderEnv(values, extra);
-  console.log(`
-${style.bold("  Plan")}`);
-  const row = (k, v) => console.log(`  ${style.grey(k.padEnd(12))}${v}`);
-  row("control", `${answers.host} \xB7 ${answers.database}`);
-  row("browsers", `${answers.fleet}${answers.workers ? ` \xD7${answers.workers}` : ""}`);
-  row("llm", answers.llm.provider === "skip" ? style.grey("none") : `${answers.llm.model} ${style.grey(`@ ${answers.llm.baseUrl}`)}`);
-  row("writes", `${envPath} ${style.grey("(0600)")}`);
-  row("then", `docker compose up -d, wait for ${answers.publicUrl}/readyz`);
-  if (dryRun) {
-    console.log("\n--dry-run: nothing was written. Settings that would be applied:");
-    for (const k of Object.keys(values)) {
-      console.log(`  ${k}=${SECRET_KEYS.has(k) ? style.grey("<hidden>") : values[k]}`);
-    }
-    return;
+  /**
+   * Watch it work: the console, opened on this browser. It carries no
+   * credential. For the frames themselves, use `liveStreamUrl()`.
+   */
+  liveViewUrl() {
+    return consoleLink(this.http.baseUrl, this.id);
   }
-  writeEnv(envPath, body);
-  writeFileSync2(join2(root, ANSWERS_FILE), JSON.stringify(answers, null, 2) + "\n");
-  success(`wrote ${envPath}`);
-  if (!existing.OYA_PROFILE_SECRET) {
-    warn("OYA_PROFILE_SECRET was generated \u2014 back it up.");
-    note("Without it, stored cookies, proxy credentials and TOTP seeds cannot be decrypted.");
-  }
-  if (migrateUrl) {
-    const spin = spinner("applying migrations");
-    try {
-      await new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [join2(root, "server", "migrations", "run.mjs")], {
-          cwd: root,
-          stdio: ["ignore", "pipe", "pipe"],
-          env: { ...process.env, DATABASE_URL: migrateUrl }
-        });
-        let err = "";
-        child.stderr.on("data", (d) => {
-          err += d;
-        });
-        child.on("error", reject);
-        child.on("close", (code) => code === 0 ? resolve() : reject(new Error(err.trim() || `migrations exited ${code}`)));
-      });
-      spin.done();
-    } catch (e) {
-      spin.fail();
-      throw new Error(`Migrations failed: ${e.message}
-  Fix the database, then re-run: DATABASE_URL=\u2026 make migrate`);
-    }
+  /**
+   * The SSE stream of JPEG frames, for embedding in your own UI. EventSource
+   * cannot set headers, so the URL carries a connection ticket: single use,
+   * 60 seconds. Mint one per viewer — the first connection spends it.
+   */
+  async liveStreamUrl() {
+    const path = `/api/control/sessions/${encodeURIComponent(this.id)}/ticket`;
+    const { ticket } = await this.http.request("POST", path, {});
+    return `${this.http.baseUrl}/api/live/${this.id}?ticket=${encodeURIComponent(ticket)}`;
   }
-  if (answers.fleet === "k8s") {
-    const pinned = await provisionK8sFleet(root, answers);
-    if (pinned !== values.OYA_MANAGED_IMAGE) {
-      values.OYA_MANAGED_IMAGE = pinned;
-      writeEnv(envPath, renderEnv(values, extra));
-      console.log("  .env updated with the pinned image digest");
-    }
+  /**
+   * A shareable link to this browser's live view, for handing to a person or
+   * embedding in your own app. The token rides in the URL fragment, so it never
+   * reaches a server log or Referer header. `control: true` lets whoever opens
+   * it take over and act in the browser; otherwise it is view-only. The link
+   * expires (default one hour) and is revocable with `revokeShare(id)`.
+   *
+   * The credential is scoped to this one browser: it cannot see or touch the
+   * rest of your project. Anyone holding the link has that access until it
+   * expires or you revoke it, so treat it like a password.
+   */
+  async shareUrl({ control = false, expiresInSeconds = 3600 } = {}) {
+    const path = `/api/control/sessions/${encodeURIComponent(this.id)}/share`;
+    const c = await this.http.request("POST", path, { control, expiresIn: expiresInSeconds });
+    return { url: shareLink(this.http.baseUrl, this.id, c.token), id: c.id, expiresAt: c.expiresAt };
   }
-  if (answers.host === "docker") await provisionDocker(root, answers);
-  await waitReady(answers.publicUrl);
-  banner(`${answers.publicUrl} is up`, "Sign in to the dashboard with the key below.");
-  console.log(`
-  ${style.bold("API key")}  ${style.green(apiKey)}
-`);
-  console.log(`  ${style.grey("# your shell may export OYA_API_KEY for the hosted service")}`);
-  console.log(`  unset OYA_API_KEY`);
-  console.log(`  oya login --url ${answers.publicUrl} --key ${apiKey}`);
-  console.log(`  oya ls && oya goto https://example.com
-`);
-}
-
-// src/index.ts
-var HELP = `oya \u2014 thousands of browsers, one API
-
-  oya install                     Stand up a self-hosted control plane
-            [--dry-run] [--config oya-install.json]
-  oya login                       Save an API key for this machine
-  oya init                        Set your model, browser provider and sign-ins
-  oya start [--persona auto]      Start a browser and print its id
-  oya goto <url> [--id <id>]      Navigate (defaults to the newest browser)
-  oya ask "<prompt>" [--id <id>]  Drive it in plain language
-  oya ls                          List running browsers
-  oya rm <id> | --all             Stop browsers
-  oya personas                    Identities: fingerprint + cookies + proxy
-  oya personas new [name]         --platform Win32|MacIntel|Linux --tz <zone> --locale <l> --max <n>
-  oya personas edit <id>          --name <n> --max <n> --geo <cc>
-  oya personas clone|rm <id>      A new device of the same kind \xB7 delete
-  oya status [--id <id>]          Health, counters and what it has been doing
-  oya open [--id <id>]            Open the live view in your browser
-  oya config [key=value ...]      Show or change this key's settings
-  oya control                     Durable project overview
-  oya sessions [id]               All sessions, including pending cleanup
-  oya stop <id> --force           Stop despite a profile-save error, or reconcile
-  oya takeover <id>               Acquire human control
-  oya release <id>                Release human control, leaving the agent paused
-  oya resume <id>                 Acknowledge agent resume
-  oya events [--after <cursor>]   Read durable lifecycle events
-  oya project <settings-json>     Update limits, rate cards and retention
-  oya start --governed --provider oya-selfhosted [--queue-ms 30000]
-            [--budget-usd 5] [--policy JSON] [--idempotency-key ID]
-  oya cancel <id>               Cancel queued or provisioning work
-  oya recover <id> [--replace]   Explicitly recover or replace a session
-  oya members [invite|remove]   List members, invite, or remove a user
-  oya credential new [--role viewer|operator|administrator]
-  oya credential revoke <id>     Revoke a service credential
-  oya webhook new <https-url>    Register a signed event webhook
-  oya webhook remove <id>        Disable a webhook
-  oya webhook replay <id>        Replay a delivery
-  oya usage                       What this key has spent
-  oya stealth-test [--live]       Score this deployment against bot detectors
-
-Options: --url <control plane>   --key <api key>   --json
-Config:  ${configPath}
-`;
-function parse(argv) {
-  const [command2 = "help", ...rest] = argv;
-  const args2 = [];
-  const flags2 = {};
-  for (let i = 0; i < rest.length; i++) {
-    const token2 = rest[i];
-    if (!token2.startsWith("--")) {
-      args2.push(token2);
-      continue;
-    }
-    const name = token2.slice(2);
-    const next = rest[i + 1];
-    if (next === void 0 || next.startsWith("--")) flags2[name] = true;
-    else {
-      flags2[name] = next;
-      i++;
+  /** Revoke a link from `shareUrl()` before it expires, by the id it returned. */
+  async revokeShare(id) {
+    await this.http.request("DELETE", `/api/control/credentials/${encodeURIComponent(id)}`);
+  }
+  /** Counters, health and the last 50 things this browser did. */
+  status() {
+    return this.http.request("GET", `/api/browsers/${this.id}`);
+  }
+  /**
+   * Stop it, whatever it is: a cloud sandbox is destroyed so billing ends, a
+   * CDP session is handed back to its provider, a desktop browser disconnects.
+   */
+  stop() {
+    return this.http.request("POST", `/api/browsers/${this.id}/stop`, {}, STOP_TIMEOUT_MS);
+  }
+  /** `await using browser = await oya.browser.start()` stops it however the block exits, errors included. */
+  async [Symbol.asyncDispose]() {
+    await this.stop();
+  }
+  /** @deprecated use stop() — close() only dropped the socket, and a cloud browser redialled. */
+  async close() {
+    await this.stop();
+  }
+};
+function assertCaptchaCleared(result) {
+  if (!result.present || result.solved || result.invisible) return;
+  const message = result.error || "CAPTCHA needs attention. Call solveCaptcha() again or open the live view.";
+  throw new OyaError(message, Status3.CONFLICT, result);
+}
+function toElementId(value) {
+  const id = Number(value);
+  const wrongType = typeof value !== "number" && typeof value !== "string";
+  if (wrongType || value === "" || !Number.isInteger(id) || id < 0) {
+    throw new OyaError("Use a numeric element id from browser.analyze().", Status3.BAD_REQUEST, null);
+  }
+  return id;
+}
+function scrollParams(direction, amount, at) {
+  if (!at) return { direction, amount };
+  return { direction, amount: amount ?? AIMED_SCROLL_AMOUNT, ...at, smooth: false };
+}
+function agentAnswer(res) {
+  if (res.error) throw new OyaError(res.error, res.status ?? Status3.SERVER_ERROR, res);
+  return res;
+}
+function consoleLink(baseUrl, id) {
+  return `${baseUrl}/dashboard/?browser=${encodeURIComponent(id)}`;
+}
+function shareLink(baseUrl, id, token2) {
+  return `${baseUrl}/live/${encodeURIComponent(id)}#t=${encodeURIComponent(token2)}`;
+}
+function startBody(options) {
+  const { profile, persona, provider, wsUrl, name, queueMs, priority, budgetUsd, governed, policy } = options;
+  return { profile: profile || persona, provider, wsUrl, name, queueMs, priority, budgetUsd, governed, policy };
+}
+async function start(http, wait, options) {
+  const headers = { "Idempotency-Key": options.idempotencyKey || globalThis.crypto.randomUUID() };
+  const path = "/api/browsers/start";
+  const started = await http().request("POST", path, startBody(options), START_TIMEOUT_MS, headers);
+  if (started.status === "starting") {
+    await wait(started.id, options.readyTimeoutMs ?? READY_TIMEOUT_MS2 + (options.queueMs || 0));
+    started.cdpUrl = (await fetchBrowser(http, started.id)).cdpUrl;
+  }
+  return new Browser(http(), started, options.captcha === "auto");
+}
+var fetchBrowser = (http, id) => http().request("GET", `/api/browsers/${encodeURIComponent(id)}`);
+async function reattach(http, id) {
+  const found = await fetchBrowser(http, id);
+  return new Browser(http(), asStarted(found), false);
+}
+function asStarted(found) {
+  const provider = found.provider || "cdp";
+  return { id: found.id, provider, persona: found.persona || "default", status: "ready", cdpUrl: found.cdpUrl };
+}
+var stopBrowsers = (http, ids) => http().request("POST", "/api/browsers/stop", ids === "all" ? { all: true } : { ids }, START_TIMEOUT_MS);
+var browserApi = (http, wait) => ({
+  /** Start a browser and wait until it can take commands. */
+  start: (options = {}) => start(http, wait, options),
+  /** Reattach to a browser that is already running. */
+  get: (id) => reattach(http, id),
+  /** Every browser on this key. */
+  list: () => http().request("GET", "/api/browsers"),
+  /** Stop some (`ids`) or every browser on this key. Each reports separately. */
+  stop: (ids) => stopBrowsers(http, ids),
+  /** Stop every browser on this key; returns how many stopped. */
+  stopAll: async () => (await stopBrowsers(http, "all")).stopped
+});
+var session = (id, action = "") => `/api/control/sessions/${encodeURIComponent(id)}${action}`;
+var item = (kind, id) => `/api/control/${kind}/${encodeURIComponent(id)}`;
+var sessionCalls = (http) => ({
+  /** Settings, sessions and recent events at a glance. */
+  overview: () => http().request("GET", "/api/control"),
+  /** Every session, including disconnected and cleanup-pending ones. */
+  sessions: () => http().request("GET", "/api/control/sessions"),
+  /** One session. */
+  session: (id) => http().request("GET", session(id)),
+  /** Update limits, rate cards and retention. */
+  settings: (changes) => http().request("PATCH", "/api/control/project", changes)
+});
+var lifecycleCalls = (http) => ({
+  /** Cancel queued or provisioning work. */
+  cancel: (id) => http().request("POST", session(id, "/cancel"), {}),
+  /** Stop a session; `force` stops despite a profile-save error, or reconciles. */
+  stop: (id, force = false) => http().request("POST", session(id, "/stop"), { force }),
+  /** Acquire or release human control, or acknowledge the agent's resume. */
+  takeover: (id, action) => http().request("POST", session(id, "/control"), { action }),
+  /** Send one input as the human holding the control lease. */
+  input: (id, action, params) => http().request("POST", session(id, "/input"), { action, params })
+});
+var recoveryCalls = (http) => ({
+  /** Explicitly recover a session, or replace it with a fresh one. */
+  recover: (id, replace = false) => http().request("POST", session(id, "/recover"), { replace }),
+  /** A single-use ticket for the live stream. */
+  ticket: (id) => http().request("POST", session(id, "/ticket"), {}),
+  /** Durable lifecycle events after a cursor. */
+  events: (after = 0) => http().request("GET", `/api/control/events?after=${after}`)
+});
+var credentialCalls = (http) => ({
+  /** Mint a service credential. Its token is returned this once. */
+  createCredential: (options) => http().request("POST", "/api/control/credentials", options),
+  /** Revoke a service credential. */
+  revokeCredential: (id) => http().request("DELETE", item("credentials", id))
+});
+var memberCalls = (http) => ({
+  /** The owner and every member. */
+  members: () => http().request("GET", "/api/control/members"),
+  /** An invitation code for a new member. */
+  inviteMember: (role = "operator") => http().request("POST", "/api/control/members/invite", { role }),
+  /** Remove a member. */
+  removeMember: (userId) => http().request("DELETE", item("members", userId))
+});
+var webhookCalls = (http) => ({
+  /** Register a webhook; `types` limits which events it receives. */
+  createWebhook: (url, types = []) => http().request("POST", "/api/control/webhooks", { url, types }),
+  /** Disable a webhook. */
+  removeWebhook: (id) => http().request("DELETE", item("webhooks", id)),
+  /** Send a delivery again. */
+  replayDelivery: (id) => http().request("POST", `${item("deliveries", id)}/replay`, {})
+});
+var controlApi = (http) => ({
+  ...sessionCalls(http),
+  ...lifecycleCalls(http),
+  ...recoveryCalls(http),
+  ...credentialCalls(http),
+  ...memberCalls(http),
+  ...webhookCalls(http)
+});
+var playbook = (name) => `/api/playbooks/${encodeURIComponent(name)}`;
+var playbookApi = (http) => ({
+  /** Every saved playbook, with any draft waiting on it. */
+  list: async () => (await http().request("GET", "/api/playbooks")).playbooks,
+  /** Delete a playbook and its draft, or only the draft with `'<name>:draft'`. */
+  remove: async (name) => {
+    await http().request("DELETE", playbook(name));
+  },
+  /** Replace a playbook with the draft a healed replay saved. Try it first with `browser.play('<name>:draft')`. */
+  promote: (name) => http().request("POST", `${playbook(name)}/promote`, {})
+});
+var proxyApi = (http) => ({
+  /** Every proxy this key can use, shared ones included. */
+  list: async () => (await http().request("GET", "/api/proxies")).proxies,
+  /** Add a proxy. Its credentials are never read back. */
+  create: (proxy) => http().request("POST", "/api/proxies", proxy),
+  /** Remove one of this key's proxies. */
+  remove: async (id) => {
+    await http().request("DELETE", `/api/proxies/${encodeURIComponent(id)}`);
+  },
+  /** Dial each proxy and learn its real exit IP. Failing ones cool down and are skipped. */
+  check: async () => (await http().request("POST", "/api/proxies/check", {})).results
+});
+var identityCalls = (http) => ({
+  /** Every persona on this key. */
+  list: async () => (await http().request("GET", "/api/personas")).personas,
+  /** One persona. */
+  get: (id) => http().request("GET", `/api/personas/${id}`),
+  /**
+   * Create an identity. The device — platform, timezone, locale — is chosen
+   * here and fixed for its life; `preview()` shows what a choice produces.
+   */
+  create: (options = {}) => http().request("POST", "/api/personas", options),
+  /** Name, concurrency cap and proxy hint. Never the device — clone for that. */
+  update: (id, changes) => http().request("PUT", `/api/personas/${id}`, changes),
+  /** A new persona of the same kind of device: same choices, fresh identity, empty jar. */
+  clone: (id, options = {}) => http().request("POST", `/api/personas/${id}/clone`, options)
+});
+var deviceCalls = (http) => ({
+  /** The fingerprint these choices would produce. Persists nothing. */
+  preview: async (prefs = {}) => (await http().request("POST", "/api/personas/preview", { prefs })).fingerprint,
+  /** Platforms, and the timezones and locales each may coherently claim. */
+  options: () => http().request("GET", "/api/personas/options"),
+  /** Pin the persona to one of your proxies, or `null` to let assignment happen at connect. */
+  pinProxy: (id, proxyId) => http().request("PUT", `/api/personas/${id}/proxy`, { proxyId }),
+  /** Delete a persona. */
+  remove: async (id) => {
+    await http().request("DELETE", `/api/personas/${id}`);
+  }
+});
+var mfaCalls = (http) => ({
+  /** Store the second factor for this identity. Sealed at rest, never read back. */
+  setMfa: (id, config) => http().request("PUT", `/api/personas/${id}/mfa`, config),
+  /** Remove the persona-wide factor, or the one filed against `domain`. */
+  clearMfa: async (id, domain) => {
+    await http().request("DELETE", `/api/personas/${id}/mfa${domain ? `?domain=${encodeURIComponent(domain)}` : ""}`);
+  }
+});
+var loginCalls = (http) => ({
+  /**
+   * Store a site login for this identity. Sealed at rest, never read back.
+   *
+   * Signing in once on the desktop and inheriting the cookies is still the
+   * better path. This is for portals that expire a session server-side
+   * between runs, where an unattended run has nothing else to recover with.
+   */
+  setCredentials: (id, config) => http().request("PUT", `/api/personas/${id}/credentials`, config),
+  /** Which sites this identity can sign in to. Usernames only. */
+  credentials: (id) => http().request("GET", `/api/personas/${id}/credentials`),
+  /** Remove the login stored for one site. */
+  clearCredentials: async (id, domain) => {
+    await http().request("DELETE", `/api/personas/${id}/credentials?domain=${encodeURIComponent(domain)}`);
+  }
+});
+var personaApi = (http) => ({
+  ...identityCalls(http),
+  ...deviceCalls(http),
+  ...mfaCalls(http),
+  ...loginCalls(http)
+});
+var configApi = (http) => ({
+  /** This key's settings. Secrets read back masked. */
+  get: () => http().request("GET", "/api/config"),
+  /** Change settings; `null` clears a field back to the deployment default. */
+  set: (values) => http().request("POST", "/api/config", values)
+});
+var ENDED = ["failed", "stopped", "unknown_outcome"];
+async function waitUntilConnected(checks, id, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isUp(checks, id)) return;
+    await new Promise((r) => setTimeout(r, READY_POLL_MS2));
+  }
+  const seconds = Math.round(timeoutMs / MS_PER_SECOND);
+  throw new OyaError(`Browser ${id} did not come up within ${seconds}s`, Status3.GATEWAY_TIMEOUT, null);
+}
+async function isUp(checks, id) {
+  const all = await checks.list();
+  if (all.some((b) => b.id === id && b.health !== "dead")) return true;
+  await assertNotEnded(checks, id);
+  return false;
+}
+async function assertNotEnded(checks, id) {
+  try {
+    const session2 = await checks.session(id);
+    if (ENDED.includes(session2.state)) {
+      throw new OyaError(`Browser creation ended in ${session2.state}`, Status3.CONFLICT, session2);
     }
+  } catch (e) {
+    if (!(e instanceof OyaError) || e.status !== Status3.NOT_FOUND) throw e;
   }
-  return { command: command2, args: args2, flags: flags2 };
 }
-var flagStr = (flags2, name) => typeof flags2[name] === "string" ? flags2[name] : void 0;
+var MAX_FILE_BYTES = MAX_FILE_MB * BYTES_PER_MB;
+var Oya = class {
+  /** The one HTTP path every call goes through. */
+  http;
+  /** Reads the key and URL from `options`, then OYA_API_KEY and OYA_BASE_URL. Throws without a key. */
+  constructor(options = {}) {
+    this.http = createHttp(options);
+  }
+  /** Start, reattach to, list and stop browsers. */
+  browser = browserApi(
+    () => this.http,
+    (id, timeoutMs) => this.waitUntilConnected(id, timeoutMs)
+  );
+  /** Durable operational controls, including disconnected and cleanup-pending sessions. */
+  control = controlApi(() => this.http);
+  /** Playbooks saved with `browser.toPlaybook()`. */
+  playbooks = playbookApi(() => this.http);
+  /**
+   * Proxy exits for your personas. A persona takes one at first connect (by its
+   * geo hint) or by `personas.pinProxy`, and keeps it.
+   */
+  proxies = proxyApi(() => this.http);
+  /** Identities: fingerprint, cookie jar and proxy bound together, plus their stored factors and logins. */
+  personas = personaApi(() => this.http);
+  /**
+   * This key's settings: LLM credentials, browser provider, solver.
+   *
+   * Bring your own LLM key (it pays for its own tokens, so no hourly chat quota applies):
+   *   await oya.config.set({ llm_provider: 'gemini', openai_api_key: process.env.GEMINI_API_KEY });
+   * `llm_provider` is the {@link LlmProvider} union, so an editor offers the choices and a
+   * typo is a compile error; `chat_model` overrides its default model. 'vertex' is Gemini
+   * Enterprise (ex-Vertex AI) in express mode, which needs no GCP project; for a
+   * project-scoped endpoint, set `openai_base_url` to `.../endpoints/openapi` and pass an
+   * OAuth access token as `openai_api_key`. See {@link ConfigUpdate} for every field.
+   */
+  config = configApi(() => this.http);
+  /** Saved profiles. `personas` is retained as an alias for existing clients. */
+  profiles = this.personas;
+  /** What this key has spent. */
+  usage() {
+    return this.http.request("GET", "/api/usage");
+  }
+  /** Waits for a starting browser to dial in, through this client's own list and session calls. */
+  async waitUntilConnected(id, timeoutMs) {
+    const checks = { list: () => this.browser.list(), session: (sid) => this.control.session(sid) };
+    await waitUntilConnected(checks, id, timeoutMs);
+  }
+};
+
+// src/context.ts
 function client(flags2) {
   const saved = resolved();
   const apiKey = flagStr(flags2, "key") || saved.apiKey;
@@ -1551,8 +2065,9 @@ function client(flags2) {
   }
   return new Oya({ apiKey, baseUrl });
 }
+var printJson = (value) => console.log(JSON.stringify(value, null, JSON_INDENT2));
 var out = (flags2, value, human) => {
-  if (flags2.json) console.log(JSON.stringify(value, null, 2));
+  if (flags2.json) printJson(value);
   else human();
 };
 async function targetBrowser(oya, flags2) {
@@ -1565,399 +2080,474 @@ async function targetBrowser(oya, flags2) {
   }
   return oya.browser.get(all[all.length - 1].id);
 }
-async function cmdLogin(flags2) {
-  const current = resolved();
-  let apiKey = flagStr(flags2, "key") || "";
-  const baseUrl = (flagStr(flags2, "url") || (apiKey ? current.baseUrl : await ask("Control plane URL:", current.baseUrl))).replace(/\/+$/, "");
-  const how = apiKey ? "paste" : await choose("How do you want to authenticate?", [
-    { id: "paste", label: "Paste an API key", note: "from the dashboard, or a self-hosted key" },
-    { id: "password", label: "Sign in with email and password", note: "mints a new key for this machine" }
-  ]);
-  if (!apiKey && how === "paste") apiKey = await askSecret("API key:");
-  if (!apiKey && how === "password") {
-    const email = await ask("Email:");
-    const password = await askSecret("Password:");
-    const res = await fetch(`${baseUrl}/api/auth/login`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ email, password })
-    });
-    const session = await res.json();
-    if (!res.ok || !session.access_token) throw new Error(session.error || "Sign-in failed");
-    const minted = await fetch(`${baseUrl}/api/auth/keys`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${session.access_token}`, "Content-Type": "application/json" },
-      body: JSON.stringify({ label: "CLI" })
-    });
-    const created = await minted.json();
-    if (!minted.ok || !created.key) throw new Error(created.error || "Could not create an API key");
-    apiKey = created.key;
-    console.log('  Created a new API key labelled "CLI".');
-  }
-  if (!apiKey) throw new Error("No API key given");
-  const check = await fetch(`${baseUrl}/api/config`, { headers: { Authorization: `Bearer ${apiKey}` } });
-  if (!check.ok) throw new Error(`That key was rejected by ${baseUrl} (${check.status})`);
-  save({ apiKey, baseUrl });
-  console.log(`
-\u2705 Signed in to ${baseUrl}. Saved to ${configPath}`);
-  console.log("   Next: `oya init` to pick your model and browser provider.");
-}
-async function cmdInit(flags2) {
-  const oya = client(flags2);
-  const current = await oya.config.get();
+
+// src/commands/init.ts
+var PRESETS = {
+  anthropic: { name: "Anthropic", model: "claude-sonnet-4-5" },
+  openai: { name: "OpenAI", model: "gpt-4o-mini" },
+  gemini: { name: "Gemini", model: "gemini-3.8-flash" },
+  vertex: { name: "Gemini Enterprise", model: "gemini-2.5-flash" }
+};
+var modelOptions = (current) => [
+  { id: "anthropic", label: "Claude (Anthropic)" },
+  { id: "openai", label: "OpenAI" },
+  { id: "gemini", label: "Gemini (Google)" },
+  { id: "vertex", label: "Gemini Enterprise (Vertex AI)" },
+  { id: "skip", label: "Skip", note: current.has_openai_key ? "keep what is configured" : "no agent control" }
+];
+async function askModel(current, updates) {
   console.log("\n\u2500\u2500 1. Your model \u2500\u2500");
-  const llm = await choose("Which LLM should agents use?", [
-    { id: "anthropic", label: "Claude (Anthropic)" },
-    { id: "openai", label: "OpenAI" },
-    { id: "gemini", label: "Gemini (Google)" },
-    { id: "vertex", label: "Gemini Enterprise (Vertex AI)" },
-    { id: "skip", label: "Skip", note: current.has_openai_key ? "keep what is configured" : "no agent control" }
-  ]);
-  const presets = {
-    anthropic: { name: "Anthropic", model: "claude-sonnet-4-5" },
-    openai: { name: "OpenAI", model: "gpt-4o-mini" },
-    gemini: { name: "Gemini", model: "gemini-3.8-flash" },
-    vertex: { name: "Gemini Enterprise", model: "gemini-2.5-flash" }
-  };
-  const updates = {};
-  if (llm !== "skip") {
-    updates.llm_provider = llm;
-    const key = await askSecret(`${presets[llm].name} API key:`);
-    if (key) updates.openai_api_key = key;
-    const model = await ask("Default model:", presets[llm].model);
-    if (model) updates.chat_model = model;
-  }
+  const llm = await choose("Which LLM should agents use?", modelOptions(current));
+  if (llm !== "skip") await askModelDetails(llm, updates);
+}
+async function askModelDetails(llm, updates) {
+  updates.llm_provider = llm;
+  const key = await askSecret(`${PRESETS[llm].name} API key:`);
+  if (key) updates.openai_api_key = key;
+  const model = await ask("Default model:", PRESETS[llm].model);
+  if (model) updates.chat_model = model;
+}
+function providerOptions(current) {
+  const note2 = (p) => p.needs.length ? p.configured ? "configured" : "needs an API key" : void 0;
+  return current.providers.map((p) => ({ id: p.id, label: p.label, note: note2(p) }));
+}
+async function askProvider(current, updates) {
   console.log("\n\u2500\u2500 2. Where your browsers run \u2500\u2500");
-  const provider = await choose("Browser provider:", current.providers.map((p) => ({
-    id: p.id,
-    label: p.label,
-    note: p.needs.length ? p.configured ? "configured" : "needs an API key" : void 0
-  })));
+  const provider = await choose("Browser provider:", providerOptions(current));
   updates.browser_provider = provider;
-  const needs = current.providers.find((p) => p.id === provider)?.needs || [];
-  for (const field of needs) {
+  for (const field of current.providers.find((p) => p.id === provider)?.needs || []) {
     const value = await askSecret(`${field.replace(/_/g, " ")}:`);
     if (value) updates[field] = value;
   }
+  return provider;
+}
+var CAPTCHA_OPTIONS2 = [
+  { id: "", label: "No", note: "providers that solve natively still will" },
+  { id: "capsolver", label: "Yes, via CapSolver" }
+];
+async function askCaptcha(updates) {
   console.log("\n\u2500\u2500 3. CAPTCHAs \u2500\u2500");
-  const solver = await choose("Solve CAPTCHAs automatically?", [
-    { id: "", label: "No", note: "providers that solve natively still will" },
-    { id: "capsolver", label: "Yes, via CapSolver" }
-  ]);
+  const solver = await choose("Solve CAPTCHAs automatically?", CAPTCHA_OPTIONS2);
   updates.captcha_solver = solver;
-  if (solver) {
-    const key = await askSecret("Solver API key:");
-    if (key) updates.captcha_api_key = key;
-  }
+  if (!solver) return;
+  const key = await askSecret("Solver API key:");
+  if (key) updates.captcha_api_key = key;
+}
+function signInHint(provider) {
+  if (provider !== "oya-cloud" && provider !== "oya-selfhosted") return;
+  console.log("\n\u2500\u2500 4. Sign in once, on your own machine \u2500\u2500");
+  console.log("   Your remote browsers reuse the cookies from a desktop sign-in, so agents");
+  console.log("   arrive already logged in \u2014 as the same identity, from the same fingerprint.");
+  console.log(`   Download the desktop browser: ${resolved().baseUrl}/downloads`);
+}
+async function interview2(oya) {
+  const current = await oya.config.get();
+  const updates = {};
+  await askModel(current, updates);
+  const provider = await askProvider(current, updates);
+  await askCaptcha(updates);
   updates.onboarded = "true";
   await oya.config.set(updates);
+  return provider;
+}
+async function cmdInit(flags2) {
+  const provider = await interview2(client(flags2));
   console.log("\n\u2705 Saved against your API key.");
-  if (provider === "oya-cloud" || provider === "oya-selfhosted") {
-    console.log("\n\u2500\u2500 4. Sign in once, on your own machine \u2500\u2500");
-    console.log("   Your remote browsers reuse the cookies from a desktop sign-in, so agents");
-    console.log("   arrive already logged in \u2014 as the same identity, from the same fingerprint.");
-    console.log(`   Download the desktop browser: ${resolved().baseUrl}/downloads`);
-  }
+  signInHint(provider);
   console.log("\n   Then:  oya start && oya goto https://example.com");
 }
-async function cmdStart(flags2) {
-  const oya = client(flags2);
-  const browser = await oya.browser.start({
+
+// src/commands/browsers.ts
+import { spawn as spawn3 } from "child_process";
+function identityOptions(flags2) {
+  return {
     persona: flagStr(flags2, "persona") || "default",
     captcha: flags2.captcha === false ? "off" : "auto",
     provider: flagStr(flags2, "provider"),
     wsUrl: flagStr(flags2, "ws-url"),
     name: flagStr(flags2, "name"),
-    idempotencyKey: flagStr(flags2, "idempotency-key"),
-    queueMs: flagStr(flags2, "queue-ms") === void 0 ? void 0 : Number(flagStr(flags2, "queue-ms")),
-    budgetUsd: flagStr(flags2, "budget-usd") === void 0 ? void 0 : Number(flagStr(flags2, "budget-usd")),
+    idempotencyKey: flagStr(flags2, "idempotency-key")
+  };
+}
+function governanceOptions(flags2) {
+  return {
+    queueMs: flagNum(flags2, "queue-ms"),
+    budgetUsd: flagNum(flags2, "budget-usd"),
     governed: flags2.governed === true,
     priority: flagStr(flags2, "priority"),
     policy: flagStr(flags2, "policy") ? JSON.parse(flagStr(flags2, "policy")) : void 0
-  });
-  out(flags2, { id: browser.id, provider: browser.provider, persona: browser.persona, cdpUrl: browser.cdpUrl }, () => {
-    console.log(`\u2705 ${browser.id}`);
-    console.log(`   provider: ${browser.provider}   persona: ${browser.persona}`);
-    if (browser.cdpUrl) console.log(`   cdp:      ${browser.cdpUrl}`);
+  };
+}
+var startOptions = (flags2) => ({ ...identityOptions(flags2), ...governanceOptions(flags2) });
+async function cmdStart(flags2) {
+  const browser = await client(flags2).browser.start(startOptions(flags2));
+  const { id, provider, persona, cdpUrl } = browser;
+  out(flags2, { id, provider, persona, cdpUrl }, () => {
+    console.log(`\u2705 ${id}`);
+    console.log(`   provider: ${provider}   persona: ${persona}`);
+    if (cdpUrl) console.log(`   cdp:      ${cdpUrl}`);
   });
 }
 async function cmdGoto(args2, flags2) {
   const url = args2[0];
   if (!url) throw new Error("Usage: oya goto <url>");
-  const oya = client(flags2);
-  const browser = await targetBrowser(oya, flags2);
+  const browser = await targetBrowser(client(flags2), flags2);
   await browser.goto(url);
   console.log(`\u2705 ${browser.id} \u2192 ${url}`);
 }
 async function cmdAsk(args2, flags2) {
   const prompt = args2.join(" ");
   if (!prompt) throw new Error('Usage: oya ask "find the pricing page"');
-  const oya = client(flags2);
-  const browser = await targetBrowser(oya, flags2);
+  const browser = await targetBrowser(client(flags2), flags2);
   console.log(await browser.ask(prompt));
 }
+var DOT = { ok: "\u25CF", stale: "\u25D0", errors: "\u2717", dead: "\u25CB" };
+function lsRow(b) {
+  const provider = (b.provider || "oya").padEnd(LsColumns.PROVIDER);
+  const persona = (b.personaName || b.persona || "default").padEnd(LsColumns.PERSONA);
+  const url = b.currentUrl.replace(/^https?:\/\//, "").slice(0, LsColumns.URL);
+  return `${DOT[b.health] || "\xB7"} ${b.id}  ${provider} ${persona} ${b.name.padEnd(LsColumns.NAME)} ${b.commands}\xB7${b.errors}  ${url}`;
+}
 async function cmdLs(flags2) {
   const all = await client(flags2).browser.list();
   out(flags2, all, () => {
     if (!all.length) return console.log("No browsers running.");
-    const dot = { ok: "\u25CF", stale: "\u25D0", errors: "\u2717", dead: "\u25CB" };
-    for (const b of all) {
-      console.log(`${dot[b.health] || "\xB7"} ${b.id}  ${(b.provider || "oya").padEnd(14)} ${(b.personaName || b.persona || "default").padEnd(14)} ${b.name.padEnd(18)} ${b.commands}\xB7${b.errors}  ${b.currentUrl.replace(/^https?:\/\//, "").slice(0, 40)}`);
-    }
+    for (const b of all) console.log(lsRow(b));
     console.log(`
 ${all.length} running.`);
   });
 }
+function rmLine(x) {
+  const removed = x.sandboxRemoved === true ? " (sandbox destroyed)" : "";
+  const note2 = x.sandboxRemoved === false ? " \u2014 sandbox NOT removed, check Oya Cloud" : removed;
+  return `${x.ok ? "\u2705" : "\u2717"} ${x.id}${note2}${x.error ? ` ${x.error}` : ""}`;
+}
 async function cmdRm(args2, flags2) {
   const oya = client(flags2);
   if (!flags2.all && !args2.length) throw new Error("Usage: oya rm <id>\u2026 | oya rm --all");
   const r = await oya.browser.stop(flags2.all ? "all" : args2);
-  for (const x of r.results) {
-    const note2 = x.sandboxRemoved === true ? " (sandbox destroyed)" : x.sandboxRemoved === false ? " \u2014 sandbox NOT removed, check Oya Cloud" : "";
-    console.log(`${x.ok ? "\u2705" : "\u2717"} ${x.id}${note2}${x.error ? ` ${x.error}` : ""}`);
-  }
+  for (const x of r.results) console.log(rmLine(x));
   console.log(`stopped ${r.stopped}`);
 }
+function activityLine(a) {
+  const error = a.error ? ` \u2014 ${a.error}` : "";
+  return `    ${a.ok ? "\xB7" : "\u2717"} ${a.action.padEnd(StatusColumns.ACTION)} ${a.summary}${error}  ${a.ms}ms`;
+}
+function printStatus(s) {
+  console.log(`${s.name}  ${s.id}`);
+  console.log(`  ${s.health} \xB7 ${s.provider || "oya"} \xB7 persona ${s.personaName || s.persona || "default"}`);
+  console.log(`  ${s.commands} commands \xB7 ${s.errors} errors \xB7 ${s.pending} in flight \xB7 at ${s.currentUrl || "\u2014"}`);
+  if (s.lastError) console.log(`  last error: ${s.lastError}`);
+  if (!s.activity.length) return;
+  console.log("  recent:");
+  for (const a of s.activity.slice(0, StatusColumns.RECENT)) console.log(activityLine(a));
+}
 async function cmdStatus(flags2) {
-  const oya = client(flags2);
-  const browser = await targetBrowser(oya, flags2);
+  const browser = await targetBrowser(client(flags2), flags2);
   const s = await browser.status();
-  out(flags2, s, () => {
-    console.log(`${s.name}  ${s.id}`);
-    console.log(`  ${s.health} \xB7 ${s.provider || "oya"} \xB7 persona ${s.personaName || s.persona || "default"}`);
-    console.log(`  ${s.commands} commands \xB7 ${s.errors} errors \xB7 ${s.pending} in flight \xB7 at ${s.currentUrl || "\u2014"}`);
-    if (s.lastError) console.log(`  last error: ${s.lastError}`);
-    if (s.activity.length) {
-      console.log("  recent:");
-      for (const a of s.activity.slice(0, 10)) console.log(`    ${a.ok ? "\xB7" : "\u2717"} ${a.action.padEnd(18)} ${a.summary}${a.error ? ` \u2014 ${a.error}` : ""}  ${a.ms}ms`);
-    }
-  });
+  out(flags2, s, () => printStatus(s));
 }
-async function cmdPersonas(args2, flags2) {
-  const oya = client(flags2);
-  const [sub, ...rest] = args2;
-  if (sub === "new" || sub === "create") {
-    const platformAlias = {
-      win32: "Win32",
-      windows: "Win32",
-      win: "Win32",
-      macintel: "MacIntel",
-      mac: "MacIntel",
-      macos: "MacIntel",
-      linux: "Linux x86_64",
-      "linux x86_64": "Linux x86_64"
-    };
-    const platformFlag = flagStr(flags2, "platform");
-    const prefs = {
-      ...platformFlag ? { platform: platformAlias[platformFlag.toLowerCase()] || platformFlag } : {},
-      ...flagStr(flags2, "tz") ? { timezone: flagStr(flags2, "tz") } : {},
-      ...flagStr(flags2, "locale") ? { locale: flagStr(flags2, "locale") } : {}
-    };
-    if (flags2.preview) {
-      const fp = await oya.personas.preview(prefs);
-      return out(flags2, fp, () => console.log(`${fp.platform} \xB7 ${fp.timezone} \xB7 ${fp.locale} \xB7 ${fp.screen} \xB7 ${fp.webgl}`));
-    }
-    const created = await oya.personas.create({
-      name: flagStr(flags2, "name") || rest[0],
-      prefs,
-      proxy: flagStr(flags2, "geo") ? { geo: flagStr(flags2, "geo") } : void 0,
-      maxConcurrent: flagStr(flags2, "max") ? Number(flagStr(flags2, "max")) : void 0
-    });
-    return out(flags2, created, () => console.log(`\u2705 ${created.id}  ${created.name}  ${created.fingerprint.platform} \xB7 ${created.fingerprint.timezone}`));
-  }
-  if (sub === "edit") {
-    if (!rest[0]) throw new Error("Usage: oya personas edit <id> --name <n> --max <n> --geo <cc>");
-    const updated = await oya.personas.update(rest[0], {
-      ...flagStr(flags2, "name") ? { name: flagStr(flags2, "name") } : {},
-      ...flagStr(flags2, "max") ? { maxConcurrent: flagStr(flags2, "max") === "none" ? null : Number(flagStr(flags2, "max")) } : {},
-      ...flagStr(flags2, "geo") ? { proxy: { geo: flagStr(flags2, "geo") } } : {}
-    });
-    return out(flags2, updated, () => console.log(`\u2705 ${updated.id}  ${updated.name}  cap ${updated.maxConcurrent ?? "\u221E"}`));
-  }
-  if (sub === "clone") {
-    if (!rest[0]) throw new Error("Usage: oya personas clone <id> [--name <n>]");
-    const c = await oya.personas.clone(rest[0], { name: flagStr(flags2, "name") });
-    return out(flags2, c, () => console.log(`\u2705 ${c.id}  ${c.name}  ${c.fingerprint.platform} \xB7 ${c.fingerprint.timezone}  (new identity, same kind of device)`));
-  }
-  if (sub === "rm" || sub === "delete") {
-    if (!rest[0]) throw new Error("Usage: oya personas rm <id>");
-    await oya.personas.remove(rest[0]);
-    return console.log(`\u2705 removed ${rest[0]}`);
-  }
-  const all = await oya.personas.list();
-  out(flags2, all, () => {
-    if (!all.length) return console.log("No personas yet \u2014 `oya personas new`.");
-    for (const p of all) {
-      const cap = p.maxConcurrent === null ? "\u221E" : String(p.maxConcurrent);
-      console.log(`${p.id}  ${p.name.padEnd(20)} ${p.activeBrowsers}/${cap} running  ${p.fingerprint.platform} \xB7 ${p.fingerprint.timezone}${p.exit ? `  via ${p.exit.label}` : p.proxy?.geo ? `  geo ${p.proxy.geo}` : ""}${p.mfa?.configured ? `  mfa:${p.mfa.type}` : ""}${p.isDefault ? "  (default)" : ""}`);
-    }
-  });
+function opener(url) {
+  if (process.platform === "darwin") return ["open", [url]];
+  if (process.platform === "win32") return ["cmd", ["/c", "start", "", url]];
+  return ["xdg-open", [url]];
 }
 async function cmdOpen(flags2) {
   const browser = await targetBrowser(client(flags2), flags2);
-  const url = browser.liveViewUrl();
-  const [opener, args2] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  spawn2(opener, args2, { detached: true, stdio: "ignore" }).unref();
+  const [command2, args2] = opener(browser.liveViewUrl());
+  spawn3(command2, args2, { detached: true, stdio: "ignore" }).unref();
   console.log(`Opening ${browser.id}`);
 }
-async function cmdConfig(args2, flags2) {
+
+// src/commands/personas.ts
+var PLATFORM_ALIAS = {
+  win32: "Win32",
+  windows: "Win32",
+  win: "Win32",
+  macintel: "MacIntel",
+  mac: "MacIntel",
+  macos: "MacIntel",
+  linux: "Linux x86_64",
+  "linux x86_64": "Linux x86_64"
+};
+function prefsFrom(flags2) {
+  const platformFlag = flagStr(flags2, "platform");
+  return {
+    ...platformFlag ? { platform: PLATFORM_ALIAS[platformFlag.toLowerCase()] || platformFlag } : {},
+    ...flagStr(flags2, "tz") ? { timezone: flagStr(flags2, "tz") } : {},
+    ...flagStr(flags2, "locale") ? { locale: flagStr(flags2, "locale") } : {}
+  };
+}
+function createOptions(flags2, rest, prefs) {
+  return {
+    name: flagStr(flags2, "name") || rest[0],
+    prefs,
+    proxy: flagStr(flags2, "geo") ? { geo: flagStr(flags2, "geo") } : void 0,
+    maxConcurrent: flagStr(flags2, "max") ? Number(flagStr(flags2, "max")) : void 0
+  };
+}
+var create = async (oya, rest, flags2) => {
+  const prefs = prefsFrom(flags2);
+  if (flags2.preview) return preview(oya, prefs, flags2);
+  const created = await oya.personas.create(createOptions(flags2, rest, prefs));
+  const fp = created.fingerprint;
+  out(flags2, created, () => console.log(`\u2705 ${created.id}  ${created.name}  ${fp.platform} \xB7 ${fp.timezone}`));
+};
+async function preview(oya, prefs, flags2) {
+  const fp = await oya.personas.preview(prefs);
+  out(flags2, fp, () => console.log(`${fp.platform} \xB7 ${fp.timezone} \xB7 ${fp.locale} \xB7 ${fp.screen} \xB7 ${fp.webgl}`));
+}
+function editChanges(flags2) {
+  const max = flagStr(flags2, "max");
+  return {
+    ...flagStr(flags2, "name") ? { name: flagStr(flags2, "name") } : {},
+    ...max ? { maxConcurrent: max === "none" ? null : Number(max) } : {},
+    ...flagStr(flags2, "geo") ? { proxy: { geo: flagStr(flags2, "geo") } } : {}
+  };
+}
+var edit = async (oya, rest, flags2) => {
+  if (!rest[0]) throw new Error("Usage: oya personas edit <id> --name <n> --max <n> --geo <cc>");
+  const updated = await oya.personas.update(rest[0], editChanges(flags2));
+  out(flags2, updated, () => console.log(`\u2705 ${updated.id}  ${updated.name}  cap ${updated.maxConcurrent ?? "\u221E"}`));
+};
+var clone = async (oya, rest, flags2) => {
+  if (!rest[0]) throw new Error("Usage: oya personas clone <id> [--name <n>]");
+  const c = await oya.personas.clone(rest[0], { name: flagStr(flags2, "name") });
+  const fp = c.fingerprint;
+  out(
+    flags2,
+    c,
+    () => console.log(`\u2705 ${c.id}  ${c.name}  ${fp.platform} \xB7 ${fp.timezone}  (new identity, same kind of device)`)
+  );
+};
+var remove = async (oya, rest) => {
+  if (!rest[0]) throw new Error("Usage: oya personas rm <id>");
+  await oya.personas.remove(rest[0]);
+  console.log(`\u2705 removed ${rest[0]}`);
+};
+function personaLine(p) {
+  const cap = p.maxConcurrent === null ? "\u221E" : String(p.maxConcurrent);
+  const where = p.exit ? `  via ${p.exit.label}` : p.proxy?.geo ? `  geo ${p.proxy.geo}` : "";
+  const extras = `${where}${p.mfa?.configured ? `  mfa:${p.mfa.type}` : ""}${p.isDefault ? "  (default)" : ""}`;
+  const device = `${p.fingerprint.platform} \xB7 ${p.fingerprint.timezone}`;
+  return `${p.id}  ${p.name.padEnd(PERSONA_NAME_WIDTH)} ${p.activeBrowsers}/${cap} running  ${device}${extras}`;
+}
+var list = async (oya, _rest, flags2) => {
+  const all = await oya.personas.list();
+  out(flags2, all, () => {
+    if (!all.length) return console.log("No personas yet \u2014 `oya personas new`.");
+    for (const p of all) console.log(personaLine(p));
+  });
+};
+var SUBCOMMANDS = { new: create, create, edit, clone, rm: remove, delete: remove };
+async function cmdPersonas(args2, flags2) {
   const oya = client(flags2);
-  if (!args2.length) {
-    const current = await oya.config.get();
-    return out(flags2, current, () => console.log(JSON.stringify(current, null, 2)));
-  }
+  const [sub, ...rest] = args2;
+  const run2 = sub !== void 0 && Object.hasOwn(SUBCOMMANDS, sub) ? SUBCOMMANDS[sub] : list;
+  await run2(oya, rest, flags2);
+}
+
+// src/commands/settings.ts
+function parsePairs(args2) {
   const updates = {};
   for (const pair of args2) {
     const index = pair.indexOf("=");
     if (index < 1) throw new Error(`Expected key=value, got "${pair}"`);
     updates[pair.slice(0, index)] = pair.slice(index + 1);
   }
+  return updates;
+}
+async function cmdConfig(args2, flags2) {
+  const oya = client(flags2);
+  if (!args2.length) {
+    const current = await oya.config.get();
+    return out(flags2, current, () => printJson(current));
+  }
+  const updates = parsePairs(args2);
   await oya.config.set(updates);
   console.log(`\u2705 updated ${Object.keys(updates).join(", ")}`);
 }
 async function cmdUsage(flags2) {
-  const usage = await client(flags2).usage();
-  console.log(JSON.stringify(usage, null, 2));
+  printJson(await client(flags2).usage());
 }
+async function cmdWhoami() {
+  printJson({ ...resolved(), apiKey: load().apiKey ? "saved" : "none" });
+}
+
+// src/commands/stealth.ts
+import { spawn as spawn4 } from "child_process";
+var spawnHarness = (flags2) => spawn4("node", ["test-stealth.js", ...flags2.live ? ["--live"] : []], {
+  cwd: process.env.OYA_SERVER_DIR || "server",
+  stdio: "inherit"
+});
 function cmdStealthTest(flags2) {
   return new Promise((resolve, reject) => {
-    const child = spawn2("node", ["test-stealth.js", ...flags2.live ? ["--live"] : []], {
-      cwd: process.env.OYA_SERVER_DIR || "server",
-      stdio: "inherit"
-    });
-    child.on("error", () => reject(new Error(
-      "Could not find the stealth harness. Run it from a checkout, or set OYA_SERVER_DIR."
-    )));
+    const child = spawnHarness(flags2);
+    const missing = "Could not find the stealth harness. Run it from a checkout, or set OYA_SERVER_DIR.";
+    child.on("error", () => reject(new Error(missing)));
     child.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`stealth test exited ${code}`)));
   });
 }
-var { command, args, flags } = parse(process.argv.slice(2));
-try {
-  if (["control", "sessions", "takeover", "release", "resume", "events", "project", "credential", "webhook", "cancel", "recover", "members"].includes(command) || command === "stop" && flags.force === true) {
-    const c = client(flags).control;
-    const required = (i = 0) => {
-      if (!args[i]) throw new Error("Missing argument; run oya help");
-      return args[i];
-    };
-    let result;
-    switch (command) {
-      case "control":
-        result = await c.overview();
-        break;
-      case "sessions":
-        result = args[0] ? await c.session(args[0]) : await c.sessions();
-        break;
-      case "cancel":
-        result = await c.cancel(required());
-        break;
-      case "recover":
-        result = await c.recover(required(), flags.replace === true);
-        break;
-      case "members":
-        if (!args[0]) result = await c.members();
-        else if (args[0] === "remove") result = await c.removeMember(required(1));
-        else if (args[0] === "invite") {
-          const role = flagStr(flags, "role") || "operator";
-          if (!["viewer", "operator", "administrator"].includes(role)) throw new Error("Invalid role");
-          result = await c.inviteMember(role);
-        } else throw new Error("Use members, members invite, or members remove");
-        break;
-      case "stop":
-        result = await c.stop(required(), flags.force === true);
-        break;
-      case "takeover":
-      case "release":
-      case "resume":
-        result = await c.takeover(required(), command === "takeover" ? "acquire" : command);
-        break;
-      case "events":
-        result = await c.events(Number(flagStr(flags, "after") || 0));
-        break;
-      case "project":
-        result = await c.settings(JSON.parse(required()));
-        break;
-      case "credential":
-        if (required() === "revoke") result = await c.revokeCredential(required(1));
-        else if (args[0] === "new") {
-          const role = flagStr(flags, "role") || "operator";
-          if (!["viewer", "operator", "administrator"].includes(role)) throw new Error("Invalid role");
-          result = await c.createCredential({ role, label: flagStr(flags, "label") });
-        } else throw new Error("Use credential new or credential revoke");
-        break;
-      case "webhook":
-        if (required() === "new") result = await c.createWebhook(required(1));
-        else if (args[0] === "remove") result = await c.removeWebhook(required(1));
-        else if (args[0] === "replay") result = await c.replayDelivery(required(1));
-        else throw new Error("Use webhook new, remove, or replay");
-        break;
-    }
-    console.log(JSON.stringify(result, null, 2));
-  } else switch (command) {
-    case "install":
-      await cmdInstall(flags);
-      break;
-    case "login":
-      await cmdLogin(flags);
-      break;
-    case "init":
-      await cmdInit(flags);
-      break;
-    case "start":
-      await cmdStart(flags);
-      break;
-    case "goto":
-      await cmdGoto(args, flags);
-      break;
-    case "ask":
-      await cmdAsk(args, flags);
-      break;
-    case "ls":
-    case "list":
-      await cmdLs(flags);
-      break;
-    case "status":
-      await cmdStatus(flags);
-      break;
-    case "rm":
-    case "stop":
-      await cmdRm(args, flags);
-      break;
-    case "personas":
-      await cmdPersonas(args, flags);
-      break;
-    case "open":
-      await cmdOpen(flags);
-      break;
-    case "config":
-      await cmdConfig(args, flags);
-      break;
-    case "usage":
-      await cmdUsage(flags);
-      break;
-    case "stealth-test":
-      await cmdStealthTest(flags);
-      break;
-    case "whoami":
-      console.log(JSON.stringify({ ...resolved(), apiKey: load().apiKey ? "saved" : "none" }, null, 2));
-      break;
-    case "help":
-    case "--help":
-    case "-h":
-      console.log(HELP);
-      break;
-    default:
-      console.error(`Unknown command: ${command}
+
+// src/commands/control.ts
+var ROLES = ["viewer", "operator", "administrator"];
+function required(args2, i = 0) {
+  if (!args2[i]) throw new Error("Missing argument; run oya help");
+  return args2[i];
+}
+function roleFlag(flags2) {
+  const role = flagStr(flags2, "role") || "operator";
+  if (!ROLES.includes(role)) throw new Error("Invalid role");
+  return role;
+}
+function subcommand(table, sub, call2, usage) {
+  if (!Object.hasOwn(table, sub)) throw new Error(usage);
+  return table[sub](call2);
+}
+var members = (call2) => {
+  if (!call2.args[0]) return call2.c.members();
+  const table = {
+    remove: ({ c, args: args2 }) => c.removeMember(required(args2, 1)),
+    invite: ({ c, flags: flags2 }) => c.inviteMember(roleFlag(flags2))
+  };
+  return subcommand(table, call2.args[0], call2, "Use members, members invite, or members remove");
+};
+var credential = (call2) => {
+  const table = {
+    revoke: ({ c, args: args2 }) => c.revokeCredential(required(args2, 1)),
+    new: ({ c, flags: flags2 }) => c.createCredential({ role: roleFlag(flags2), label: flagStr(flags2, "label") })
+  };
+  return subcommand(table, required(call2.args), call2, "Use credential new or credential revoke");
+};
+var webhook = (call2) => {
+  const table = {
+    new: ({ c, args: args2 }) => c.createWebhook(required(args2, 1)),
+    remove: ({ c, args: args2 }) => c.removeWebhook(required(args2, 1)),
+    replay: ({ c, args: args2 }) => c.replayDelivery(required(args2, 1))
+  };
+  return subcommand(table, required(call2.args), call2, "Use webhook new, remove, or replay");
+};
+var takeover = ({ c, command: command2, args: args2 }) => c.takeover(required(args2), command2 === "takeover" ? "acquire" : command2);
+var COMMANDS = {
+  control: ({ c }) => c.overview(),
+  sessions: ({ c, args: args2 }) => args2[0] ? c.session(args2[0]) : c.sessions(),
+  cancel: ({ c, args: args2 }) => c.cancel(required(args2)),
+  recover: ({ c, args: args2, flags: flags2 }) => c.recover(required(args2), flags2.replace === true),
+  members,
+  stop: ({ c, args: args2, flags: flags2 }) => c.stop(required(args2), flags2.force === true),
+  takeover,
+  release: takeover,
+  resume: takeover,
+  events: ({ c, flags: flags2 }) => c.events(Number(flagStr(flags2, "after") || 0)),
+  project: ({ c, args: args2 }) => c.settings(JSON.parse(required(args2))),
+  credential,
+  webhook
+};
+function isControlCommand(command2, flags2) {
+  if (command2 === "stop") return flags2.force === true;
+  return Object.hasOwn(COMMANDS, command2);
+}
+async function runControl(command2, args2, flags2) {
+  const c = client(flags2).control;
+  printJson(await COMMANDS[command2]({ c, command: command2, args: args2, flags: flags2 }));
+}
+
+// src/help.ts
+var HELP = `oya \u2014 thousands of browsers, one API
+
+  oya install                     Stand up a self-hosted control plane
+            [--dry-run] [--config oya-install.json]
+  oya login                       Save an API key for this machine
+  oya init                        Set your model, browser provider and sign-ins
+  oya start [--persona auto]      Start a browser and print its id
+  oya goto <url> [--id <id>]      Navigate (defaults to the newest browser)
+  oya ask "<prompt>" [--id <id>]  Drive it in plain language
+  oya ls                          List running browsers
+  oya rm <id> | --all             Stop browsers
+  oya personas                    Identities: fingerprint + cookies + proxy
+  oya personas new [name]         --platform Win32|MacIntel|Linux --tz <zone> --locale <l> --max <n>
+  oya personas edit <id>          --name <n> --max <n> --geo <cc>
+  oya personas clone|rm <id>      A new device of the same kind \xB7 delete
+  oya status [--id <id>]          Health, counters and what it has been doing
+  oya open [--id <id>]            Open the live view in your browser
+  oya config [key=value ...]      Show or change this key's settings
+  oya control                     Durable project overview
+  oya sessions [id]               All sessions, including pending cleanup
+  oya stop <id> --force           Stop despite a profile-save error, or reconcile
+  oya takeover <id>               Acquire human control
+  oya release <id>                Release human control, leaving the agent paused
+  oya resume <id>                 Acknowledge agent resume
+  oya events [--after <cursor>]   Read durable lifecycle events
+  oya project <settings-json>     Update limits, rate cards and retention
+  oya start --governed --provider oya-selfhosted [--queue-ms 30000]
+            [--budget-usd 5] [--policy JSON] [--idempotency-key ID]
+  oya cancel <id>               Cancel queued or provisioning work
+  oya recover <id> [--replace]   Explicitly recover or replace a session
+  oya members [invite|remove]   List members, invite, or remove a user
+  oya credential new [--role viewer|operator|administrator]
+  oya credential revoke <id>     Revoke a service credential
+  oya webhook new <https-url>    Register a signed event webhook
+  oya webhook remove <id>        Disable a webhook
+  oya webhook replay <id>        Replay a delivery
+  oya usage                       What this key has spent
+  oya stealth-test [--live]       Score this deployment against bot detectors
+
+Options: --url <control plane>   --key <api key>   --json
+Config:  ${configPath}
+`;
+
+// src/commands/index.ts
+var help = async () => console.log(HELP);
+var COMMANDS2 = {
+  install: (_args, flags2) => cmdInstall(flags2),
+  login: (_args, flags2) => cmdLogin(flags2),
+  init: (_args, flags2) => cmdInit(flags2),
+  start: (_args, flags2) => cmdStart(flags2),
+  goto: cmdGoto,
+  ask: cmdAsk,
+  ls: (_args, flags2) => cmdLs(flags2),
+  list: (_args, flags2) => cmdLs(flags2),
+  status: (_args, flags2) => cmdStatus(flags2),
+  rm: cmdRm,
+  stop: cmdRm,
+  personas: cmdPersonas,
+  open: (_args, flags2) => cmdOpen(flags2),
+  config: cmdConfig,
+  usage: (_args, flags2) => cmdUsage(flags2),
+  "stealth-test": (_args, flags2) => cmdStealthTest(flags2),
+  whoami: () => cmdWhoami(),
+  help,
+  "--help": help,
+  "-h": help
+};
+function unknown(command2) {
+  console.error(`Unknown command: ${command2}
 `);
-      console.log(HELP);
-      process.exit(1);
-  }
-} catch (err) {
+  console.log(HELP);
+  process.exit(1);
+}
+async function dispatch(command2, args2, flags2) {
+  if (isControlCommand(command2, flags2)) return runControl(command2, args2, flags2);
+  if (!Object.hasOwn(COMMANDS2, command2)) unknown(command2);
+  await COMMANDS2[command2](args2, flags2);
+}
+
+// src/index.ts
+function fail2(err) {
   const error = err;
   console.error(`
 \u2717 ${error.message}`);
-  if (error.status === 401) console.error("  The API key was rejected. Run `oya login`.");
-  if (error.status === 429) console.error("  A quota or a persona concurrency cap. `oya personas` shows what is running.");
+  if (error.status === Status2.UNAUTHORIZED) console.error("  The API key was rejected. Run `oya login`.");
+  if (error.status === Status2.TOO_MANY_REQUESTS) {
+    console.error("  A quota or a persona concurrency cap. `oya personas` shows what is running.");
+  }
   process.exit(1);
+}
+var { command, args, flags } = parse(process.argv.slice(ARGV_SKIP));
+try {
+  await dispatch(command, args, flags);
+} catch (err) {
+  fail2(err);
 } finally {
   closePrompts();
 }