@withbuddi/buddi 0.1.0-pre.37 → 0.1.0-pre.39

package/extension/background.js

@@ -1,8 +1,14 @@
 // src/protocol.ts
 var COMMAND_NAMES = ["navigate", "observe", "click", "fill", "select", "press", "scroll", "tab", "close", "fieldInfo", "secretFill"];
-var HAND_COMMANDS = ["screencast.start", "screencast.stop", "input"];
+var HAND_COMMANDS = ["screencast.start", "screencast.stop", "input", "hold", "unhold"];
 var PreconditionError = class extends Error {
 };
+var OpenedError = class extends Error {
+  constructor(message, page) {
+    super(message);
+    this.page = page;
+  }
+};
 var CancelledError = class extends Error {
 };
 var Cancellation = class {
@@ -148,6 +154,18 @@ var Protocol = class {
       case "command":
         await this.#command(message);
         return;
+      case "loginAck": {
+        const id = message["id"];
+        if (!this.#authenticated || typeof id !== "string" || id.length > 64) return;
+        const ask = message["ask"];
+        if (ask === "save" || ask === "update" || ask === "none") {
+          this.#options.onLoginAck?.(id, { ask });
+          return;
+        }
+        const reason = typeof message["reason"] === "string" ? message["reason"].slice(0, 300) : "";
+        this.#options.onLoginAck?.(id, message["saved"] === true ? { saved: true } : { saved: false, reason: reason || "buddi could not keep that login." });
+        return;
+      }
       default:
         return;
     }
@@ -212,7 +230,14 @@ var Protocol = class {
       if (error instanceof CancelledError) {
         this.#options.send({ type: "result", id, ok: false, error: "cancelled", precondition: !cancel.dispatched });
       } else {
-        this.#options.send({ type: "result", id, ok: false, error: sentence(error), precondition: error instanceof PreconditionError });
+        this.#options.send({
+          type: "result",
+          id,
+          ok: false,
+          error: sentence(error),
+          precondition: error instanceof PreconditionError,
+          ...error instanceof OpenedError ? { page: error.page } : {}
+        });
       }
     } finally {
       this.#running.delete(id);
@@ -229,11 +254,477 @@ function sentence(error) {
   return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
 }
 
+// src/bar.ts
+var OWNER_WAIT_MS = 3e4;
+var BAR_AFTER_MS = 3e3;
+var BAR_POLL_MS = 500;
+async function waitForOwner(probes, limits = {}) {
+  const waitMs = limits.waitMs ?? OWNER_WAIT_MS;
+  const barAfter = limits.barAfterMs ?? BAR_AFTER_MS;
+  const poll = limits.pollMs ?? BAR_POLL_MS;
+  const start = probes.now();
+  let shown = false;
+  const maxPolls = Math.ceil(waitMs / poll);
+  try {
+    for (let polls = 0; ; polls++) {
+      if (!await probes.watched()) return "left";
+      const elapsed = Math.max(probes.now() - start, polls * poll);
+      if (!shown && elapsed >= barAfter) {
+        shown = true;
+        await probes.show().catch(() => void 0);
+      }
+      if (shown) {
+        const choice = await probes.choice().catch(() => void 0);
+        if (choice) return choice;
+      }
+      if (elapsed >= waitMs || polls >= maxPolls) return "timeout";
+      await probes.wait(poll);
+    }
+  } finally {
+    if (shown) await probes.hide().catch(() => void 0);
+  }
+}
+function showBar(agent) {
+  const holder = globalThis;
+  holder["__buddiBar"] = { choice: void 0 };
+  const doc = globalThis.document;
+  if (!doc || doc.getElementById("buddi-working-bar")) return;
+  const host = doc.createElement("div");
+  host.id = "buddi-working-bar";
+  host.setAttribute("style", "position:fixed;top:0;left:0;right:0;z-index:2147483647;all:initial;");
+  const root = host.attachShadow({ mode: "closed" });
+  const bar = doc.createElement("div");
+  bar.setAttribute("role", "status");
+  bar.setAttribute("style", "position:fixed;top:0;left:0;right:0;display:flex;gap:12px;align-items:center;justify-content:flex-end;padding:6px 16px;font:13px/1.4 system-ui,-apple-system,sans-serif;background:#1f2a44;color:#fff;box-shadow:0 1px 4px rgba(0,0,0,.25);");
+  const label = doc.createElement("span");
+  label.textContent = `${agent || "buddi"} is working here`;
+  label.setAttribute("style", "margin-right:auto;");
+  const button = (text2, choice, primary) => {
+    const b = doc.createElement("button");
+    b.type = "button";
+    b.textContent = text2;
+    b.setAttribute("style", `font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;${primary ? "background:#fff;color:#1f2a44;" : "background:transparent;color:#fff;"}`);
+    b.addEventListener("click", () => {
+      holder["__buddiBar"] = { choice };
+    });
+    return b;
+  };
+  bar.append(label, button("Take over", "takeover", false), button("Let it continue", "continue", true));
+  root.append(bar);
+  (doc.documentElement ?? doc.body).append(host);
+}
+function readBar() {
+  const holder = globalThis;
+  const choice = holder["__buddiBar"]?.choice;
+  if (choice) holder["__buddiBar"] = { choice: void 0 };
+  return choice;
+}
+function hideBar() {
+  const doc = globalThis.document;
+  doc?.getElementById("buddi-working-bar")?.remove();
+  const holder = globalThis;
+  delete holder["__buddiBar"];
+}
+var GIVE_BACK_MESSAGE = "buddi-give-back";
+function showHeldBar(session) {
+  const doc = globalThis.document;
+  if (!doc || doc.getElementById("buddi-held-bar")) return;
+  const host = doc.createElement("div");
+  host.id = "buddi-held-bar";
+  host.setAttribute("style", "position:fixed;top:0;left:0;right:0;z-index:2147483647;all:initial;");
+  const root = host.attachShadow({ mode: "closed" });
+  const bar = doc.createElement("div");
+  bar.setAttribute("role", "status");
+  bar.setAttribute("style", "position:fixed;top:0;left:0;right:0;display:flex;gap:12px;align-items:center;justify-content:flex-end;padding:6px 16px;font:13px/1.4 system-ui,-apple-system,sans-serif;background:#1f2a44;color:#fff;box-shadow:0 1px 4px rgba(0,0,0,.25);");
+  const label = doc.createElement("span");
+  label.textContent = "buddi is waiting";
+  label.setAttribute("style", "margin-right:auto;");
+  const give = doc.createElement("button");
+  give.type = "button";
+  give.textContent = "Give it back";
+  give.setAttribute("style", "font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;background:#fff;color:#1f2a44;");
+  give.addEventListener("click", () => {
+    const runtime = globalThis.chrome?.runtime;
+    void runtime?.sendMessage({ type: "buddi-give-back", session })?.catch?.(() => void 0);
+    host.remove();
+  });
+  bar.append(label, give);
+  root.append(bar);
+  (doc.documentElement ?? doc.body).append(host);
+  const asking = [];
+  const restore = () => {
+    for (const button of asking.splice(0)) button.remove();
+    label.textContent = "buddi is waiting";
+    give.style.display = "";
+  };
+  globalThis["__buddiHeldAsk"] = (question, choices) => {
+    restore();
+    label.textContent = question;
+    give.style.display = "none";
+    for (const choice of choices) {
+      const b = doc.createElement("button");
+      b.type = "button";
+      b.textContent = choice.label;
+      b.setAttribute("style", `font:inherit;cursor:pointer;border-radius:6px;padding:3px 10px;border:1px solid #fff;${choice.primary ? "background:#fff;color:#1f2a44;" : "background:transparent;color:#fff;"}`);
+      b.addEventListener("click", () => {
+        restore();
+        choice.pick();
+      });
+      asking.push(b);
+      bar.insertBefore(b, give);
+    }
+    return restore;
+  };
+}
+function hideHeldBar() {
+  const doc = globalThis.document;
+  doc?.getElementById("buddi-held-bar")?.remove();
+  delete globalThis["__buddiHeldAsk"];
+}
+var LOGIN_MESSAGE = "buddi-login";
+var LOGIN_PROMPT_MS = 2 * 6e4;
+function watchHeldLogins(session, facts) {
+  const holder = globalThis;
+  const known = { never: [...facts?.never ?? []], saved: [...facts?.saved ?? []] };
+  const existing = holder["__buddiHeldLogins"];
+  if (existing) {
+    existing.session = session;
+    existing.facts = known;
+    return;
+  }
+  const doc = globalThis.document;
+  if (!doc) return;
+  const state = { session, facts: known, last: "", lastAt: 0, typedAt: 0, cached: void 0, timer: void 0, drop: void 0 };
+  holder["__buddiHeldLogins"] = state;
+  const runtime = () => globalThis.chrome?.runtime;
+  const call = async (message) => {
+    try {
+      return await runtime()?.sendMessage(message);
+    } catch {
+      return void 0;
+    }
+  };
+  const site = () => (globalThis.location?.hostname ?? "").toLowerCase().replace(/^www\./, "");
+  const listed = (where) => state.facts.never.some((entry) => {
+    const bare = entry.toLowerCase().replace(/^www\./, "");
+    return where === bare || where.endsWith(`.${bare}`);
+  });
+  const bar = () => {
+    const question = holder["__buddiHeldAsk"];
+    return typeof question === "function" ? question : void 0;
+  };
+  const prompt = (where, update) => {
+    const question = bar();
+    if (!question) return;
+    if (state.drop) clearTimeout(state.drop);
+    let answered = false;
+    const save = () => {
+      if (answered) return;
+      answered = true;
+      const asking = bar();
+      asking?.(update ? "Updating\u2026" : "Saving\u2026", []);
+      void call({ type: "buddi-login", session: state.session, decision: "save" }).then((reply) => {
+        const answer = reply;
+        const now = bar();
+        if (!now) return;
+        if (answer?.saved === true) {
+          const restore2 = now(update ? `Updated the login for ${where}` : `Saved the login for ${where}`, []);
+          if (state.drop) clearTimeout(state.drop);
+          state.drop = setTimeout(restore2, 2e3);
+          return;
+        }
+        const reason = typeof answer?.reason === "string" && answer.reason !== "" ? answer.reason : "buddi did not answer. Try again.";
+        now(reason, [
+          { label: "Try again", primary: true, pick: () => {
+            answered = false;
+            save();
+          } },
+          { label: "Not now", pick: () => {
+            void call({ type: "buddi-login", session: state.session, decision: "later" });
+          } }
+        ]);
+      });
+    };
+    const restore = question(update ? `Update the login for ${where}?` : `Save this login for ${where}?`, [
+      { label: update ? "Update" : "Save", primary: true, pick: save },
+      { label: "Not now", pick: () => {
+        answered = true;
+        void call({ type: "buddi-login", session: state.session, decision: "later" });
+      } },
+      { label: "Never for this site", pick: () => {
+        answered = true;
+        state.facts.never.push(where);
+        void call({ type: "buddi-login", session: state.session, decision: "never" });
+      } }
+    ]);
+    state.drop = setTimeout(() => {
+      if (!answered) restore();
+    }, 2 * 6e4);
+  };
+  const ask = (found) => {
+    const where = site();
+    if (where === "" || listed(where) || !bar()) return;
+    const update = state.facts.saved.some((login) => login.site === where && login.username === found.username);
+    void call({ type: "buddi-login-seen", session: state.session, username: found.username, password: found.password, update }).then((reply) => {
+      const asked = reply;
+      if (holder["__buddiHeldLogins"] !== state || !asked || typeof asked !== "object") return;
+      prompt(where, asked.update === true);
+    });
+  };
+  void call({ type: "buddi-login-pending", session: state.session }).then((reply) => {
+    const waiting = reply;
+    if (holder["__buddiHeldLogins"] !== state || !waiting || typeof waiting.site !== "string") return;
+    prompt(waiting.site, waiting.update === true);
+  });
+  const NOT_SUBMIT = /\b(show|hide|reveal|toggle|eye|forgot|reset|cancel|back|close|sign ?up|register|create)\b/i;
+  const USER = /user|email|login|account|ident|phone|mail/i;
+  const passwords = (root) => Array.from(root.querySelectorAll('input[type="password" i]'));
+  const usernameFor = (password) => {
+    const scope = password.form ?? doc;
+    const inputs = Array.from(scope.querySelectorAll("input")).filter((input) => ["text", "email", "tel", ""].includes((input.getAttribute("type") ?? "").toLowerCase()) && input.value.trim() !== "");
+    const marked = inputs.find((input) => (input.getAttribute("autocomplete") ?? "").toLowerCase().includes("username") || (input.getAttribute("type") ?? "").toLowerCase() === "email");
+    if (marked) return marked.value.trim();
+    const before = inputs.filter((input) => (input.compareDocumentPosition(password) & 4) !== 0);
+    const pick = before[before.length - 1] ?? inputs.find((input) => USER.test(`${input.name} ${input.id} ${input.getAttribute("autocomplete") ?? ""}`));
+    return pick ? pick.value.trim() : "";
+  };
+  const read = (scope) => {
+    const field = passwords(scope ?? doc).find((input) => input.value !== "");
+    return field ? { username: usernameFor(field), password: field.value } : void 0;
+  };
+  const send2 = (found) => {
+    if (holder["__buddiHeldLogins"] !== state) return;
+    if (!found || found.password === "") return;
+    const key = `${found.username}\0${found.password}`;
+    const now = Date.now();
+    if (key === state.last && now - state.lastAt < 5e3) return;
+    state.last = key;
+    state.lastAt = now;
+    state.cached = void 0;
+    ask(found);
+  };
+  doc.addEventListener("submit", (event) => {
+    send2(read(event.target) ?? state.cached);
+  }, true);
+  doc.addEventListener("keydown", (event) => {
+    if (event.key !== "Enter") return;
+    const target = event.target;
+    if (!target || target.tagName !== "INPUT") return;
+    send2(read(target.form ?? doc));
+  }, true);
+  doc.addEventListener("click", (event) => {
+    const target = event.target;
+    const button = target?.closest?.('button, input[type="submit" i], input[type="image" i], input[type="button" i], [role="button"]');
+    if (!button) return;
+    const words = `${button.textContent ?? ""} ${button.getAttribute("aria-label") ?? ""} ${button.getAttribute("value") ?? ""} ${button.getAttribute("title") ?? ""}`;
+    if (NOT_SUBMIT.test(words)) return;
+    send2(read(button.form ?? doc));
+  }, true);
+  doc.addEventListener("input", (event) => {
+    const target = event.target;
+    if ((target?.getAttribute?.("type") ?? "").toLowerCase() !== "password") return;
+    state.typedAt = Date.now();
+    state.cached = read(target.form ?? doc);
+  }, true);
+  const Observer = globalThis.PerformanceObserver;
+  if (typeof Observer === "function") {
+    try {
+      new Observer((list) => {
+        if (!state.cached || Date.now() - state.typedAt > 1e4) return;
+        const fetched = list.getEntries().some((entry) => ["fetch", "xmlhttprequest"].includes(entry.initiatorType));
+        if (!fetched) return;
+        if (state.timer) clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+          const still = passwords(doc).some((input) => input.isConnected && input.value !== "" && input.getClientRects().length > 0);
+          if (!still) send2(state.cached);
+        }, 1500);
+      }).observe({ type: "resource", buffered: false });
+    } catch {
+    }
+  }
+}
+var LOGIN_SEEN_MESSAGE = "buddi-login-seen";
+var LOGIN_PENDING_MESSAGE = "buddi-login-pending";
+function heldLoginRequest(message, sender, heldTab) {
+  const request = message;
+  if (!request || typeof request.session !== "string" || request.session === "") return void 0;
+  if (heldTab === void 0 || sender?.tab?.id !== heldTab) return void 0;
+  const session = request.session;
+  const url = sender.url ?? "";
+  if (request.type === LOGIN_SEEN_MESSAGE) {
+    if (typeof request.password !== "string" || request.password === "" || request.password.length > 1024) return void 0;
+    const username = typeof request.username === "string" ? request.username.slice(0, 200) : "";
+    return { kind: "seen", session, tabId: heldTab, url, username, password: request.password, update: request.update === true };
+  }
+  if (request.type === LOGIN_PENDING_MESSAGE) return { kind: "pending", session, tabId: heldTab, url };
+  if (request.type === LOGIN_MESSAGE && (request.decision === "save" || request.decision === "later" || request.decision === "never")) {
+    return { kind: "answer", session, tabId: heldTab, decision: request.decision };
+  }
+  return void 0;
+}
+
+// src/held-logins.ts
+var HELD_LOGIN_MS = 2 * 6e4;
+var LOGIN_ACK_MS = 2e4;
+var LOGIN_CHECK_MS = 5e3;
+var NO_ANSWER = "buddi did not answer. Try again.";
+var GONE = "That question is gone; add the login in Settings \u2192 Keys and secrets.";
+function siteName(host) {
+  return host.toLowerCase().replace(/^www\./, "");
+}
+function siteKey(host) {
+  const labels = siteName(host).split(".").filter(Boolean);
+  if (labels.length <= 2) return labels.join(".");
+  const [second, top] = labels.slice(-2);
+  const keep = top.length === 2 && second.length <= 3 ? 3 : 2;
+  return labels.slice(-keep).join(".");
+}
+function webOrigin(url) {
+  try {
+    const parsed = new URL(url ?? "");
+    return parsed.protocol === "https:" || parsed.protocol === "http:" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var HeldLogins = class {
+  constructor(send2, options = {}) {
+    this.send = send2;
+    this.options = options;
+  }
+  #byTab = /* @__PURE__ */ new Map();
+  /** Frames waiting for buddi's answer, by id. */
+  #waiting = /* @__PURE__ */ new Map();
+  #id() {
+    return (this.options.uuid ?? (() => crypto.randomUUID()))();
+  }
+  /** Send a frame and wait for buddi's answer to it; undefined when none comes in time or the tab's pair goes. */
+  #ask(tabId, frame, ms) {
+    const id = this.#id();
+    return new Promise((resolve) => {
+      const timer2 = setTimeout(() => {
+        this.#waiting.delete(id);
+        resolve(void 0);
+      }, ms);
+      this.#waiting.set(id, { tabId, resolve, timer: timer2 });
+      this.send({ ...frame, id });
+    });
+  }
+  /**
+   * A sign-in went out in a held tab: keep the pair, with the origin Chrome
+   * reports for the page (never the page's claim), and ask buddi whether it
+   * is worth a question. Replaces whatever this tab was waiting on. Resolves
+   * to the question to draw, or undefined: a page not on the web, or nothing
+   * to ask (the pair is dropped then). With no word from buddi in time, the
+   * tab asks as the hold's facts said (`pair.update`).
+   */
+  async capture(tabId, session, url, pair) {
+    const where = webOrigin(url);
+    if (!where || pair.password === "" || pair.password.length > 1024) return void 0;
+    this.clearTab(tabId);
+    let settle = () => {
+    };
+    const entry = {
+      tabId,
+      session,
+      origin: where.origin,
+      site: siteName(where.hostname),
+      username: pair.username.slice(0, 200),
+      password: pair.password,
+      update: pair.update === true,
+      timer: setTimeout(() => this.clearTab(tabId), this.options.holdMs ?? HELD_LOGIN_MS),
+      checked: new Promise((resolve) => {
+        settle = resolve;
+      })
+    };
+    this.#byTab.set(tabId, entry);
+    const word = await this.#ask(tabId, { type: "login", session, decision: "check", origin: entry.origin, username: entry.username, password: entry.password }, this.options.checkMs ?? LOGIN_CHECK_MS);
+    if (this.#byTab.get(tabId) !== entry) {
+      settle(false);
+      return void 0;
+    }
+    if (word && "ask" in word) {
+      if (word.ask === "none") {
+        this.clearTab(tabId);
+        settle(false);
+        return void 0;
+      }
+      entry.update = word.ask === "update";
+    }
+    settle(true);
+    return { site: entry.site, username: entry.username, update: entry.update };
+  }
+  /** The question still waiting in this tab, for a page of the same site (once buddi said it is worth asking). */
+  async pending(tabId, session, url) {
+    const entry = this.#byTab.get(tabId);
+    const where = webOrigin(url);
+    if (!entry || entry.session !== session || !where || siteKey(where.hostname) !== siteKey(entry.site)) return void 0;
+    if (!await entry.checked || this.#byTab.get(tabId) !== entry) return void 0;
+    return { site: entry.site, username: entry.username, update: entry.update };
+  }
+  /** Save: the pair goes to buddi with the original origin; the answer is what buddi says became of it. */
+  async save(tabId, session) {
+    const entry = this.#byTab.get(tabId);
+    if (!entry || entry.session !== session) return { saved: false, reason: GONE };
+    const answer = await this.#ask(tabId, { type: "login", session: entry.session, decision: "save", origin: entry.origin, username: entry.username, password: entry.password }, this.options.ackMs ?? LOGIN_ACK_MS);
+    if (!answer || !("saved" in answer)) return { saved: false, reason: NO_ANSWER };
+    if (answer.saved && this.#byTab.get(tabId) === entry) this.clearTab(tabId);
+    return answer;
+  }
+  /** Never for this site: the site alone goes to buddi, and the pair is dropped. */
+  never(tabId, session) {
+    const entry = this.#byTab.get(tabId);
+    if (!entry || entry.session !== session) return false;
+    this.clearTab(tabId);
+    this.send({ type: "login", session: entry.session, decision: "never", origin: entry.origin, username: entry.username });
+    return true;
+  }
+  /** Not now: nothing goes anywhere. */
+  dismiss(tabId, session) {
+    const entry = this.#byTab.get(tabId);
+    if (entry && entry.session === session) this.clearTab(tabId);
+  }
+  /** buddi's answer to a frame this worker sent. */
+  ack(id, answer) {
+    const waiting = this.#waiting.get(id);
+    if (!waiting) return;
+    this.#waiting.delete(id);
+    clearTimeout(waiting.timer);
+    waiting.resolve(answer);
+  }
+  clearTab(tabId) {
+    const entry = this.#byTab.get(tabId);
+    if (entry) {
+      this.#byTab.delete(tabId);
+      clearTimeout(entry.timer);
+      entry.password = "";
+    }
+    for (const [id, waiting] of this.#waiting) {
+      if (waiting.tabId !== tabId) continue;
+      this.#waiting.delete(id);
+      clearTimeout(waiting.timer);
+      waiting.resolve(void 0);
+    }
+  }
+  clearSession(session) {
+    for (const entry of [...this.#byTab.values()]) if (entry.session === session) this.clearTab(entry.tabId);
+  }
+  clear() {
+    for (const tabId of [...this.#byTab.keys()]) this.clearTab(tabId);
+  }
+  get size() {
+    return this.#byTab.size;
+  }
+};
+
 // src/commands.ts
 var TAKEN = "The owner took this tab; observe again to continue in a new one.";
 var MOVED = "This page has changed since that observation. Observe again.";
-var WATCHED = "You are looking at this tab. buddi only acts in background tabs; observe again to continue in a new one.";
+var WATCHED = "You are looking at this tab. buddi waited and asked in the tab; nothing was done.";
+var TAKEN_IN_TAB = "The owner took over this tab from the bar in it.";
 var GROUP_TITLE = "buddi";
+var NEW_WINDOW_NOTE = "Your Chrome couldn't open a tab in that window; opened a new window instead.";
+var NO_WINDOW_NOTE = "Your Chrome had no ordinary window open, so the page opened in a new one, in the background.";
 var MAX_FRAMES = 11;
 var MAX_TREE = 32e3;
 var MAX_TARGETS = 240;
@@ -427,14 +918,28 @@ var BrowserCommands = class {
   #uuid;
   #contentFile;
   #onFrame;
+  #onEvent;
+  /** Sessions the owner let carry on in a tab they are looking at, by tab id. */
+  #inView = /* @__PURE__ */ new Map();
+  /** Sessions whose tab the owner holds (taken over in place), by tab id. */
+  #held = /* @__PURE__ */ new Map();
+  /** What a held tab need not ask about before offering to save a sign-in, as buddi said at the hold. */
+  #heldLogins = /* @__PURE__ */ new Map();
+  /** Sign-ins seen in held tabs, waiting for the owner's answer: one per tab, two minutes, gone on unhold or close. */
+  logins;
   #now;
   #wait;
   /** How many things want the debugger on this tab. A screencast is one of them, and it outlives a command. */
   #attached = /* @__PURE__ */ new Map();
   #casts = /* @__PURE__ */ new Map();
   #castsByTab = /* @__PURE__ */ new Map();
+  #ownerWaitMs;
   constructor(chrome2, options = {}) {
     this.#chrome = chrome2;
+    this.logins = new HeldLogins(options.onLogin ?? (() => void 0));
+    chrome2.tabs.onRemoved?.addListener((tabId) => this.logins.clearTab(tabId));
+    this.#onEvent = options.onEvent ?? (() => void 0);
+    this.#ownerWaitMs = options.ownerWaitMs;
     this.#wait = options.wait ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     this.#onFrame = options.onFrame ?? (() => void 0);
     this.#now = options.now ?? (() => Date.now());
@@ -446,6 +951,11 @@ var BrowserCommands = class {
       const cast = this.#castsByTab.get(tabId);
       if (cast) this.#forgetCast(cast);
     });
+    chrome2.tabs.onUpdated?.addListener((tabId, change) => {
+      if (change.status !== "complete" || ![...this.#held.values()].includes(tabId)) return;
+      const session = [...this.#held].find(([, held]) => held === tabId)?.[0];
+      if (session) void this.#drawHeld(tabId, session);
+    });
     this.#uuid = options.uuid ?? (() => crypto.randomUUID());
     this.#contentFile = options.contentFile ?? "content.js";
   }
@@ -482,6 +992,10 @@ var BrowserCommands = class {
       }
       case "input":
         return this.#input(command, cancel);
+      case "hold":
+        return this.#hold(command, cancel);
+      case "unhold":
+        return this.#unhold(command.session);
       case "close":
         return this.#close(command, cancel);
       default:
@@ -499,12 +1013,96 @@ var BrowserCommands = class {
     for (const session of [...this.#casts.keys()]) void this.#stopScreencast(session).catch(() => void 0);
     this.#sessions.clear();
     this.#refs.clear();
+    this.#inView.clear();
+    this.#held.clear();
+    this.#heldLogins.clear();
+    this.logins.clear();
+  }
+  /* ---- take-over in place ---- */
+  /**
+   * The owner takes the page where it is: the session's tab becomes the
+   * active one, its window comes to the front, and the bar in it says buddi
+   * is waiting, with Give it back. Nothing is streamed; it is their Chrome.
+   */
+  async #hold(command, cancel) {
+    const session = await this.#session(command.session);
+    const tab = await this.#ownTab(session, this.#activeKey(session));
+    const tabId = tab.id;
+    cancel.check();
+    cancel.dispatch();
+    await this.#chrome.tabs.update(tabId, { active: true });
+    if (tab.windowId !== void 0) await this.#chrome.windows.update?.(tab.windowId, { focused: true });
+    this.#held.set(command.session, tabId);
+    const logins = heldLoginFacts(command.args.logins);
+    if (logins) this.#heldLogins.set(command.session, logins);
+    else this.#heldLogins.delete(command.session);
+    await this.#drawHeld(tabId, command.session);
+    return {};
+  }
+  /**
+   * The waiting bar in a held tab, and the watch that offers to save a sign-in
+   * the owner makes there (docs/browser.md, "Saving a sign-in"). Drawn again on
+   * every page the tab loads while it is held.
+   */
+  async #drawHeld(tabId, session) {
+    await this.#chrome.scripting.executeScript({ target: { tabId }, func: showHeldBar, args: [session] }).catch(() => void 0);
+    const facts = this.#heldLogins.get(session) ?? null;
+    await this.#chrome.scripting.executeScript({ target: { tabId }, func: watchHeldLogins, args: [session, facts] }).catch(() => void 0);
+  }
+  /** The tab a session holds, when the owner holds one: where a save-prompt answer may come from. */
+  heldTab(session) {
+    return this.#held.get(session);
+  }
+  /**
+   * A sign-in message from a held tab's page (`heldLoginRequest`): a pair
+   * seen, a page asking whether a question still waits for it, or the
+   * owner's answer. The reply goes back to the page — a Save's is what buddi
+   * said became of it. Undefined for a message this worker does not believe.
+   */
+  loginMessage(message, sender) {
+    const session = message?.session;
+    const request = heldLoginRequest(message, sender, typeof session === "string" ? this.#held.get(session) : void 0);
+    if (!request) return void 0;
+    if (request.kind === "seen") return this.logins.capture(request.tabId, request.session, request.url, request).then((asked) => asked ?? null);
+    if (request.kind === "pending") return this.logins.pending(request.tabId, request.session, request.url).then((asked) => asked ?? null);
+    if (request.decision === "save") return this.logins.save(request.tabId, request.session);
+    if (request.decision === "never") return Promise.resolve({ ok: this.logins.never(request.tabId, request.session) });
+    this.logins.dismiss(request.tabId, request.session);
+    return Promise.resolve({ ok: true });
+  }
+  /**
+   * Given back (from the Canvas, or the bar): the bar goes, and the agent may
+   * act in that tab although the owner is looking at it — they just handed it
+   * over there, so waiting for them to leave it would be asking twice.
+   */
+  async #unhold(session) {
+    const tabId = this.#held.get(session);
+    this.#held.delete(session);
+    this.#heldLogins.delete(session);
+    this.logins.clearSession(session);
+    if (tabId === void 0) return {};
+    this.#inView.set(session, tabId);
+    await this.#chrome.scripting.executeScript({ target: { tabId }, func: hideHeldBar }).catch(() => void 0);
+    return {};
+  }
+  /**
+   * Give it back pressed in a held tab's bar. Refused from any other tab than
+   * the one the session holds; a worker that was restarted since (and so
+   * forgot what it held) passes it on, and the gateway resumes only a page
+   * that is in the owner's hands. It hears it as the Canvas's Give it back.
+   */
+  async giveBack(session, tabId) {
+    const held = this.#held.get(session);
+    if (tabId === void 0 || held !== void 0 && held !== tabId) return false;
+    await this.#unhold(session);
+    this.#onEvent({ type: "event", name: "giveback", session });
+    return true;
   }
   /* ---- sessions and tabs ---- */
   async #session(session) {
     const existing = this.#sessions.get(session);
     if (existing) return existing;
-    const created = { groupId: -1, tabs: /* @__PURE__ */ new Map(), active: null, generation: 0 };
+    const created = { groupId: -1, ungrouped: /* @__PURE__ */ new Set(), tabs: /* @__PURE__ */ new Map(), active: null, generation: 0 };
     this.#sessions.set(session, created);
     return created;
   }
@@ -528,12 +1126,17 @@ var BrowserCommands = class {
       this.#forget(session, key);
       throw new PreconditionError("That tab is gone. Observe again to continue in a new one.");
     }
-    if (session.groupId >= 0 && tab.groupId !== session.groupId) {
+    if (this.#taken(session, tab)) {
       this.#forget(session, key);
       throw new PreconditionError(TAKEN);
     }
     return tab;
   }
+  /** The owner dragged this tab out of the session's group. A tab that never made it into the group cannot have been. */
+  #taken(session, tab) {
+    if (tab.id !== void 0 && session.ungrouped.has(tab.id)) return false;
+    return session.groupId >= 0 && tab.groupId !== session.groupId;
+  }
   #activeKey(session) {
     if (!session.active) throw new PreconditionError("This conversation has no browser tab yet. Navigate to open one.");
     return session.active;
@@ -542,31 +1145,131 @@ var BrowserCommands = class {
    * Reading a tab is harmless; typing into one the owner is reading is not.
    *
    * Unless the typing is theirs: a command marked `owner` came from the hand on
-   * the dashboard, and refusing it would refuse the owner their own browser.
+   * the dashboard. Otherwise, a tab the owner is looking at is waited on: up to
+   * thirty seconds for them to leave it, with the bar in the tab after three
+   * (Take over · Let it continue). Let it continue lets the agent act in view
+   * for as long as that tab stays the one; Take over tells the gateway, which
+   * hands the page to the owner exactly like the Canvas button.
    */
-  async #background(tab, owner = false) {
-    if (owner) return;
-    if (tab.active !== true || tab.windowId === void 0) return;
+  async #background(tab, command) {
+    if (command.owner) return;
+    if (tab.id === void 0 || !await this.#watched(tab.id)) return;
+    if (this.#inView.get(command.session) === tab.id) return;
+    const tabId = tab.id;
+    const outcome = await waitForOwner({
+      watched: () => this.#watched(tabId),
+      show: async () => {
+        await this.#chrome.scripting.executeScript({ target: { tabId }, func: showBar, args: ["buddi"] });
+      },
+      hide: async () => {
+        await this.#chrome.scripting.executeScript({ target: { tabId }, func: hideBar });
+      },
+      choice: async () => {
+        const [frame] = await this.#chrome.scripting.executeScript({ target: { tabId }, func: readBar });
+        const choice = frame?.result;
+        return choice === "continue" || choice === "takeover" ? choice : void 0;
+      },
+      wait: (ms) => this.#wait(ms),
+      now: () => this.#now()
+    }, this.#ownerWaitMs !== void 0 ? { waitMs: this.#ownerWaitMs } : {});
+    if (outcome === "left") return;
+    if (outcome === "continue") {
+      this.#inView.set(command.session, tabId);
+      return;
+    }
+    if (outcome === "takeover") {
+      this.#onEvent({ type: "event", name: "takeover", session: command.session });
+      throw new PreconditionError(TAKEN_IN_TAB);
+    }
+    throw new PreconditionError(WATCHED);
+  }
+  /** Is the owner looking at this tab right now: active, in a focused window? */
+  async #watched(tabId) {
+    const tab = await this.#chrome.tabs.get(tabId).catch(() => void 0);
+    if (!tab || tab.active !== true || tab.windowId === void 0) return false;
     const window = await this.#chrome.windows.get(tab.windowId).catch(() => void 0);
-    if (window?.focused) throw new PreconditionError(WATCHED);
+    return window?.focused === true;
   }
   /** Where the tab actually is now, which a redirect may have changed. */
   #liveUrl(tab) {
     return checkUrl(tab.url ?? "");
   }
+  /**
+   * An ordinary window to open the tab in: the group's own when it has one,
+   * else the one the owner used last, else any. `null` when Chrome has none
+   * (only popups or installed apps' windows), `undefined` when this Chrome
+   * cannot say, in which case Chrome picks as it always did.
+   */
+  async #normalWindow(session) {
+    const windows = this.#chrome.windows;
+    if (!windows.getLastFocused && !windows.getAll) return void 0;
+    const normal = (window) => window?.id !== void 0 && (window.type === void 0 || window.type === "normal");
+    if (session.groupId >= 0) {
+      const group = await this.#chrome.tabGroups.get(session.groupId).catch(() => void 0);
+      if (group?.windowId !== void 0) {
+        const found = await windows.get(group.windowId).catch(() => void 0);
+        if (normal(found)) return found.id;
+      }
+    }
+    const last2 = await windows.getLastFocused?.({ windowTypes: ["normal"] }).catch(() => void 0);
+    if (normal(last2)) return last2.id;
+    const all = await windows.getAll?.({ windowTypes: ["normal"] }).catch(() => void 0);
+    return all?.find(normal)?.id ?? null;
+  }
+  /**
+   * One background tab, in an ordinary window, in the session's group.
+   *
+   * The group is cosmetic: Chrome refuses it in a window without a tab strip,
+   * and that refusal must not undo a page that has already opened. No
+   * ordinary window at all, or one that would not take the tab, and the page
+   * opens in a new window that does not take the focus. Nothing here
+   * activates a tab or focuses a window: the owner keeps working.
+   */
   async #openTab(session, url, cancel) {
+    const windowId = await this.#normalWindow(session);
     cancel.dispatch();
-    const tab = await this.#chrome.tabs.create({ url, active: false });
-    if (tab.id === void 0) throw new Error("Chrome opened a tab without an id.");
-    const groupId = await this.#chrome.tabs.group(session.groupId >= 0 ? { tabIds: [tab.id], groupId: session.groupId } : { tabIds: [tab.id] });
-    if (session.groupId !== groupId) {
-      session.groupId = groupId;
-      await this.#chrome.tabGroups.update(groupId, { title: GROUP_TITLE, collapsed: false }).catch(() => void 0);
+    let tab;
+    let note;
+    let groupable = true;
+    if (windowId === void 0) {
+      tab = await this.#chrome.tabs.create({ url, active: false });
+    } else if (windowId !== null) {
+      tab = await this.#chrome.tabs.create({ url, active: false, windowId }).catch(() => void 0);
+      if (!tab) note = NEW_WINDOW_NOTE;
+    } else {
+      note = NO_WINDOW_NOTE;
+    }
+    if (!tab) {
+      if (!this.#chrome.windows.create) throw new Error("Your Chrome has no ordinary window to open a tab in. Open a Chrome window and try again.");
+      const created = await this.#chrome.windows.create({ url, focused: false, state: "normal" });
+      tab = created.tabs?.[0];
+      groupable = false;
+    }
+    if (tab?.id === void 0) throw new Error("Chrome opened a tab without an id.");
+    const tabId = tab.id;
+    if (groupable) {
+      try {
+        const groupId = await this.#chrome.tabs.group(session.groupId >= 0 ? { tabIds: [tabId], groupId: session.groupId } : { tabIds: [tabId] });
+        if (session.groupId !== groupId) {
+          session.groupId = groupId;
+          await this.#chrome.tabGroups.update(groupId, { title: GROUP_TITLE, collapsed: false }).catch(() => void 0);
+        }
+      } catch {
+        session.ungrouped.add(tabId);
+      }
+    } else {
+      session.ungrouped.add(tabId);
     }
     const key = `tab-${this.#uuid().slice(0, 12)}`;
-    session.tabs.set(key, tab.id);
+    session.tabs.set(key, tabId);
     session.active = key;
-    return tab.id;
+    return { tabId, key, ...note ? { note } : {} };
+  }
+  /** What a failure after the tab opened carries back: the page is there. */
+  async #openedError(error, tabId, key, url) {
+    const tab = await this.#chrome.tabs.get(tabId).catch(() => void 0);
+    const message = error instanceof Error ? error.message : String(error);
+    return new OpenedError(message, { tabId: key, url: tab?.url ?? url, title: tab?.title ?? "" });
   }
   /** The key of this session's current tab, opening one when there is none to reuse. */
   async #reuseOrOpen(session, url, cancel) {
@@ -577,11 +1280,17 @@ var BrowserCommands = class {
         cancel.dispatch();
         await this.#chrome.tabs.update(tab.id, { url });
         await this.#waitForLoad(tab.id);
-        return;
+        return void 0;
       }
     }
     const opened = await this.#openTab(session, url, cancel);
-    await this.#waitForLoad(opened);
+    try {
+      await this.#waitForLoad(opened.tabId);
+    } catch (error) {
+      if (error instanceof CancelledError) throw error;
+      throw await this.#openedError(error, opened.tabId, opened.key, url);
+    }
+    return opened.note;
   }
   /**
    * Wait for what the input may have started, not for what was already there.
@@ -621,8 +1330,8 @@ var BrowserCommands = class {
     session.observed = void 0;
     this.#refs.delete(command.session);
     cancel.check();
-    await this.#reuseOrOpen(session, url, cancel);
-    return {};
+    const note = await this.#reuseOrOpen(session, url, cancel);
+    return note ? { observation: { note } } : {};
   }
   async #tab(command) {
     const session = await this.#session(command.session);
@@ -636,13 +1345,14 @@ var BrowserCommands = class {
   }
   /** Closes this session's own tabs, and only the ones still in its group. */
   async #close(command, cancel) {
+    this.#inView.delete(command.session);
     const session = this.#sessions.get(command.session);
     if (!session) return {};
     const ids = [];
     for (const [key, tabId] of [...session.tabs]) {
       const tab = await this.#chrome.tabs.get(tabId).catch(() => void 0);
       if (!tab) continue;
-      if (session.groupId >= 0 && tab.groupId !== session.groupId) {
+      if (this.#taken(session, tab)) {
         this.#forget(session, key);
         continue;
       }
@@ -662,7 +1372,7 @@ var BrowserCommands = class {
     const live = [];
     for (const [key, tabId] of [...session.tabs]) {
       const tab = await this.#chrome.tabs.get(tabId).catch(() => void 0);
-      if (!tab || session.groupId >= 0 && tab.groupId !== session.groupId) {
+      if (!tab || this.#taken(session, tab)) {
         this.#forget(session, key);
         continue;
       }
@@ -821,7 +1531,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
     const ref = this.#ref(command.session, session, command.args["target"]);
     const tab = await this.#ownTab(session, ref.tabKey);
     if (ref.frameId === 0 && this.#liveUrl(tab) !== ref.docUrl) throw new PreconditionError(MOVED);
-    await this.#background(tab, command.owner);
+    await this.#background(tab, command);
     cancel.check();
     return { ref, tab };
   }
@@ -1002,11 +1712,11 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
       await this.#stopScreencast(command.session);
       throw new PreconditionError("That tab is gone. Observe again to continue in a new one.");
     }
-    if (session.groupId >= 0 && tab.groupId !== session.groupId) {
+    if (this.#taken(session, tab)) {
       await this.#stopScreencast(command.session);
       throw new PreconditionError(TAKEN);
     }
-    await this.#background(tab, command.owner);
+    await this.#background(tab, command);
     const event = inputEvent(command.args);
     cancel.check();
     cancel.dispatch();
@@ -1060,7 +1770,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
     const ref = this.#ref(command.session, session, { ref: str(command.args, "ref") });
     const tab = await this.#ownTab(session, ref.tabKey);
     if (ref.frameId === 0 && this.#liveUrl(tab) !== ref.docUrl) throw new PreconditionError(MOVED);
-    await this.#background(tab, command.owner);
+    await this.#background(tab, command);
     cancel.check();
     const [frame] = await this.#chrome.scripting.executeScript({
       target: { tabId: ref.tabId, frameIds: [ref.frameId] },
@@ -1088,7 +1798,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
     if (value === "") throw new PreconditionError("The fill arrived with nothing in it.");
     const tab = await this.#ownTab(session, ref.tabKey);
     if (ref.frameId === 0 && this.#liveUrl(tab) !== ref.docUrl) throw new PreconditionError(MOVED);
-    await this.#background(tab, command.owner);
+    await this.#background(tab, command);
     cancel.check();
     cancel.dispatch();
     const [frame] = await this.#chrome.scripting.executeScript({
@@ -1148,7 +1858,7 @@ Scroll: ${scroll.x}, ${scroll.y}`.slice(0, MAX_TREE);
     if (!observed || observed.generation !== session.generation) throw new PreconditionError("Stale page observation. Observe again before scrolling.");
     const tab = await this.#ownTab(session, observed.tabKey);
     if (this.#liveUrl(tab) !== observed.url) throw new PreconditionError(MOVED);
-    await this.#background(tab, command.owner);
+    await this.#background(tab, command);
     const tabId = tab.id;
     const direction = str(command.args, "direction") === "up" ? "up" : "down";
     cancel.check();
@@ -1235,6 +1945,13 @@ function pressRef(ref, key, code, keyCode) {
     element.dispatchEvent(new KeyboardEvent(type, { key, code, keyCode, bubbles: true, cancelable: true }));
   }
 }
+function heldLoginFacts(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const { never, saved } = raw;
+  const sites = Array.isArray(never) ? never.filter((site) => typeof site === "string" && site.length <= 253).slice(0, 500) : [];
+  const kept = Array.isArray(saved) ? saved.filter((login) => typeof login?.site === "string" && typeof login?.username === "string").slice(0, 500).map(({ site, username }) => ({ site, username })) : [];
+  return { never: sites, saved: kept };
+}
 
 // src/external.ts
 function isLoopbackOrigin(origin) {
@@ -1310,7 +2027,7 @@ function flush(open) {
     }
   }
 }
-var commands = new BrowserCommands(chrome, { onFrame: send });
+var commands = new BrowserCommands(chrome, { onFrame: send, onEvent: send, onLogin: send });
 var attempt = 0;
 var timer;
 var silence;
@@ -1323,6 +2040,7 @@ var protocol = new Protocol({
   execute: (command, cancel) => commands.run(command, cancel),
   // The socket ended: sessions and refs go with it. The tabs do not.
   onReset: () => commands.reset(),
+  onLoginAck: (id, answer) => commands.logins.ack(id, answer),
   onState: (state) => {
     last = state;
     safely(() => chrome.runtime.sendMessage({ type: "buddi-state", state }).catch(() => void 0));
@@ -1416,9 +2134,23 @@ function schedule() {
     safely(() => connect());
   }, wait);
 }
-chrome.runtime.onMessage.addListener((message, _sender, respond) => {
+chrome.runtime.onMessage.addListener((message, sender, respond) => {
   const request = message;
   if (!request || typeof request.type !== "string") return;
+  if (request.type === GIVE_BACK_MESSAGE) {
+    const tabId = sender?.tab?.id;
+    if (typeof request.session === "string") safely(() => commands.giveBack(request.session, tabId).then(() => void 0));
+    return;
+  }
+  if (request.type === LOGIN_MESSAGE || request.type === LOGIN_SEEN_MESSAGE || request.type === LOGIN_PENDING_MESSAGE) {
+    const reply = commands.loginMessage(message, sender);
+    if (!reply) {
+      respond(null);
+      return;
+    }
+    safely(() => reply.then((answer) => respond(answer), () => respond(null)));
+    return true;
+  }
   if (request.type === "buddi-get-state") {
     respond({ state: last });
     return;