diff options
Diffstat (limited to 'src/cdp/target-factory.ts')
| -rw-r--r-- | src/cdp/target-factory.ts | 223 |
1 files changed, 223 insertions, 0 deletions
diff --git a/src/cdp/target-factory.ts b/src/cdp/target-factory.ts new file mode 100644 index 0000000..25c43a6 --- /dev/null +++ b/src/cdp/target-factory.ts @@ -0,0 +1,223 @@ +/** + * The single place harness tabs and windows are created. + * + * Every tab the harness opens must land in the pinned profile, so all creation + * paths (client.newTab, browser_open_urls, isolated tabs for web_search / + * read_page) funnel through here. A missed call site would silently act in + * another profile — with that profile's cookies and logins. + * + * Two mechanisms, chosen by whether a profile is pinned: + * + * unpinned — `Target.createTarget`, exactly as before: `newWindow: true` for + * a fresh dedicated window, `openerId` for siblings inside it. + * + * pinned — the window comes from a command-line launch into the profile + * (see profile/launch.ts), and further tabs come from + * `window.open(..., '_blank')` evaluated in an owned page with + * `userGesture: true`. That is the only CDP-reachable way to place + * a tab in a non-default browser context: createTarget rejects a + * foreign browserContextId outright, and `openerId` does NOT + * inherit the opener's context (verified — it lands in the + * focus-derived default context, in a different window). + * window.open keeps both the context and the window, recursively. + * + * Correlation: window.open returns no target id, so each spawn carries a unique + * `about:blank#pi-<uuid>` token and the new target is found by that token. + * Set-difference polling would be wrong here — isolated tabs run concurrently + * (browser_read_page is registered unserialized). + */ + +import { randomUUID } from "node:crypto"; +import type { BrowserClient } from "../client"; +import { type Result, err, ok } from "../util/result"; +import { type CdpError, cdpError } from "./errors"; + +/** How long to wait for a window.open-spawned target to appear. */ +const SPAWN_DEADLINE_MS = 8_000; +const SPAWN_POLL_MS = 100; + +export type HarnessWindow = { + /** Target id of the window's seed tab. */ + readonly targetId: string; + /** + * True when this call created the window. The seed tab is then a blank tab + * the caller may use directly, instead of opening a second one. + */ + readonly freshlyCreated: boolean; +}; + +type PageTarget = { + readonly targetId: string; + readonly type: string; + readonly url: string; + readonly browserContextId?: string; +}; + +const listPageTargets = async (client: BrowserClient): Promise<Result<ReadonlyArray<PageTarget>, CdpError>> => { + const r = await client.session().callBrowser("Target.getTargets"); + if (!r.success) return r; + const data = r.data as { targetInfos: ReadonlyArray<PageTarget> }; + return ok(data.targetInfos.filter((t) => t.type === "page")); +}; + +/** A CDP session id for driving `targetId`, reusing the active one when possible. */ +const sessionForTarget = async (client: BrowserClient, targetId: string): Promise<Result<string, CdpError>> => { + const current = client.current(); + if (current?.targetId === targetId) return ok(current.sessionId); + const attached = await client.session().callBrowser("Target.attachToTarget", { targetId, flatten: true }); + if (!attached.success) return attached; + return ok((attached.data as { sessionId: string }).sessionId); +}; + +/** + * Spawn a tab from `openerTargetId` via window.open, so it inherits the + * opener's profile and window, and return its target id. + */ +const spawnTabViaOpener = async ( + client: BrowserClient, + openerTargetId: string, +): Promise<Result<string, CdpError>> => { + const session = await sessionForTarget(client, openerTargetId); + if (!session.success) return session; + + const token = `pi-${randomUUID()}`; + // userGesture: true is what gets this past the popup blocker. + const opened = await client.session().callOnTarget( + "Runtime.evaluate", + { + expression: `!!window.open('about:blank#${token}', '_blank')`, + returnByValue: true, + userGesture: true, + }, + session.data, + ); + if (!opened.success) return opened; + const result = opened.data as { result?: { value?: unknown } }; + if (result.result?.value !== true) { + return err(cdpError( + "invalid_response", + "the browser blocked window.open in the pinned profile's window — the page may have navigated away; retry, or run /browser-profile to re-seed", + "Runtime.evaluate", + )); + } + + const deadline = Date.now() + SPAWN_DEADLINE_MS; + while (Date.now() < deadline) { + const targets = await listPageTargets(client); + if (targets.success) { + const spawned = targets.data.find((t) => t.url.includes(token)); + if (spawned) return ok(spawned.targetId); + } + await new Promise((r) => setTimeout(r, SPAWN_POLL_MS)); + } + return err(cdpError("timeout", `the tab opened in the pinned profile did not report back within ${SPAWN_DEADLINE_MS}ms`)); +}; + +/** + * In-flight window creation, per client. Isolated tabs run concurrently + * (browser_read_page is registered unserialized), so two of them starting at + * once would otherwise each find "no harness window" and create one — two blank + * windows before, and two launched profile windows now. Callers share the first + * call's result instead. + */ +const inFlight = new WeakMap<BrowserClient, Promise<Result<HarnessWindow, CdpError>>>(); + +/** + * The harness window for this session, creating it when absent. + * + * Reuses a live owned tab when one exists — including after the user closed the + * original seed — so reconnects don't scatter windows. + */ +export const ensureHarnessWindow = async (client: BrowserClient): Promise<Result<HarnessWindow, CdpError>> => { + const pending = inFlight.get(client); + if (pending) { + const shared = await pending; + // `freshlyCreated` is a claim on the seed tab, and only the caller that + // started the creation may hold it. Everyone waiting on the same window + // must open a tab of their own beside it, or two callers would drive the + // very same tab. + return shared.success ? ok({ targetId: shared.data.targetId, freshlyCreated: false }) : shared; + } + const attempt = ensureHarnessWindowUncoordinated(client).finally(() => inFlight.delete(client)); + inFlight.set(client, attempt); + return attempt; +}; + +const ensureHarnessWindowUncoordinated = async ( + client: BrowserClient, +): Promise<Result<HarnessWindow, CdpError>> => { + const targets = await listPageTargets(client); + if (!targets.success) return targets; + const live = new Set(targets.data.map((t) => t.targetId)); + + const ownership = client.ownership(); + const pinnedCtx = client.profileContextId(); + // A tab may only be reused when we can prove which profile it is in. With a + // pin set but no context resolved yet — a fresh connection, or a browser that + // restarted — the recorded tabs cannot be verified, so we seed a new window + // rather than risk adopting one from the wrong profile. (Sessions close their + // owned tabs on shutdown, so this is the normal, no-cost case.) + const canReuse = client.profilePin() === null || pinnedCtx !== undefined; + const inPinnedProfile = (targetId: string): boolean => { + if (!pinnedCtx) return true; + const info = targets.data.find((t) => t.targetId === targetId); + return info?.browserContextId === pinnedCtx; + }; + + if (canReuse) { + const harnessWindow = ownership.harnessWindow(); + if (harnessWindow && live.has(harnessWindow) && inPinnedProfile(harnessWindow)) { + return ok({ targetId: harnessWindow, freshlyCreated: false }); + } + const survivor = ownership.list().find((id) => live.has(id) && inPinnedProfile(id)); + if (survivor) { + ownership.setHarnessWindow(survivor); + return ok({ targetId: survivor, freshlyCreated: false }); + } + } + + const seeded = client.profilePin() + ? await client.seedPinnedProfileWindow() + : await createDedicatedWindow(client); + if (!seeded.success) return seeded; + return ok({ targetId: seeded.data, freshlyCreated: true }); +}; + +/** Unpinned path: a fresh dedicated window, exactly as the harness always did. */ +const createDedicatedWindow = async (client: BrowserClient): Promise<Result<string, CdpError>> => { + const created = await client.session().callBrowser("Target.createTarget", { url: "about:blank", newWindow: true }); + if (!created.success) return created; + const { targetId } = created.data as { targetId: string }; + const ownership = client.ownership(); + ownership.setHarnessWindow(targetId); + ownership.add(targetId); + const win = await client.session().callBrowser("Browser.getWindowForTarget", { targetId }); + if (win.success) { + const windowId = (win.data as { windowId?: number }).windowId; + if (typeof windowId === "number") ownership.setHarnessWindowId(windowId); + } + return ok(targetId); +}; + +/** + * Open a harness-owned tab beside `openerTargetId`, in the same window and — + * when a profile is pinned — the same profile. The tab is registered as owned. + */ +export const openHarnessTab = async ( + client: BrowserClient, + openerTargetId: string, +): Promise<Result<string, CdpError>> => { + const spawned = client.profileContextId() + ? await spawnTabViaOpener(client, openerTargetId) + : await (async (): Promise<Result<string, CdpError>> => { + const created = await client.session().callBrowser("Target.createTarget", { + url: "about:blank", + openerId: openerTargetId, + }); + if (!created.success) return created; + return ok((created.data as { targetId: string }).targetId); + })(); + if (!spawned.success) return spawned; + client.ownership().add(spawned.data); + return ok(spawned.data); +}; |
