1import { execFile } from "node:child_process";
2import { promisify } from "node:util";
3import { CdpClient, TargetSession, evaluateRuntime } from "./cdp-client";
4 
5interface NavigationResult {
6  errorText?: string;
7}
8 
9const execFileAsync = promisify(execFile);
10const MACOS_BROWSER_APP_IDS = [
11  "com.google.Chrome",
12  "org.chromium.Chromium",
13  "com.brave.Browser",
14  "com.microsoft.edgemac",
15];
16 
17function sleep(ms: number): Promise<void> {
18  return new Promise((resolve) => setTimeout(resolve, ms));
19}
20 
21async function activateBrowserApp(): Promise<void> {
22  if (process.platform !== "darwin") {
23    return;
24  }
25 
26  for (const appId of MACOS_BROWSER_APP_IDS) {
27    try {
28      await execFileAsync("osascript", ["-e", `tell application id "${appId}" to activate`]);
29      return;
30    } catch {
31      // Try the next installed browser bundle id.
32    }
33  }
34}
35 
36export class BrowserSession {
37  private constructor(
38    private readonly cdp: CdpClient,
39    public readonly targetSession: TargetSession,
40    public readonly interactive: boolean,
41  ) {}
42 
43  static async open(
44    cdp: CdpClient,
45    options: {
46      initialUrl?: string;
47      interactive?: boolean;
48    } = {},
49  ): Promise<BrowserSession> {
50    const targetSession = await cdp.createPageSession({
51      initialUrl: options.initialUrl,
52      visible: options.interactive,
53    });
54    const browser = new BrowserSession(cdp, targetSession, Boolean(options.interactive));
55    if (browser.interactive) {
56      await browser.bringToFront().catch(() => {});
57    }
58    return browser;
59  }
60 
61  async goto(url: string, timeoutMs = 30_000): Promise<void> {
62    const loadPromise = this.targetSession.waitForEvent("Page.loadEventFired", undefined, timeoutMs).catch(() => null);
63    const result = await this.targetSession.send<NavigationResult>("Page.navigate", { url });
64    if (result.errorText) {
65      throw new Error(`Navigation failed: ${result.errorText}`);
66    }
67    await loadPromise;
68    await this.waitForReadyState(timeoutMs);
69  }
70 
71  async waitForReadyState(timeoutMs = 30_000): Promise<void> {
72    const startedAt = Date.now();
73    while (Date.now() - startedAt < timeoutMs) {
74      const state = await this.evaluate<string>("document.readyState");
75      if (state === "interactive" || state === "complete") {
76        return;
77      }
78      await sleep(150);
79    }
80    throw new Error("Timed out waiting for document.readyState");
81  }
82 
83  async evaluate<T>(expression: string): Promise<T> {
84    return evaluateRuntime<T>(this.targetSession, expression);
85  }
86 
87  async getHTML(): Promise<string> {
88    return this.evaluate<string>("document.documentElement.outerHTML");
89  }
90 
91  async getTitle(): Promise<string> {
92    return this.evaluate<string>("document.title");
93  }
94 
95  async getURL(): Promise<string> {
96    return this.evaluate<string>("window.location.href");
97  }
98 
99  async bringToFront(): Promise<void> {
100    await this.targetSession.send("Page.bringToFront").catch(async () => {
101      await this.cdp.sendBrowserCommand("Target.activateTarget", {
102        targetId: this.targetSession.targetId,
103      });
104    });
105    if (this.interactive) {
106      await activateBrowserApp().catch(() => {});
107    }
108  }
109 
110  async click(selector: string): Promise<void> {
111    const result = await this.evaluate<{ ok: boolean; error?: string }>(`
112      (() => {
113        const element = document.querySelector(${JSON.stringify(selector)});
114        if (!element) {
115          return { ok: false, error: "Element not found" };
116        }
117        element.scrollIntoView({ block: "center", inline: "center" });
118        if (element instanceof HTMLElement) {
119          element.click();
120          return { ok: true };
121        }
122        return { ok: false, error: "Element is not clickable" };
123      })()
124    `);
125 
126    if (!result.ok) {
127      throw new Error(result.error ?? `Failed to click ${selector}`);
128    }
129  }
130 
131  async scrollToEnd(options: { stepPx?: number; delayMs?: number; maxSteps?: number } = {}): Promise<void> {
132    const stepPx = options.stepPx ?? 1_400;
133    const delayMs = options.delayMs ?? 250;
134    const maxSteps = options.maxSteps ?? 6;
135 
136    for (let step = 0; step < maxSteps; step += 1) {
137      const done = await this.evaluate<boolean>(`
138        (() => {
139          const before = window.scrollY;
140          window.scrollBy(0, ${stepPx});
141          const atBottom = window.innerHeight + window.scrollY >= document.body.scrollHeight - 4;
142          return atBottom || window.scrollY === before;
143        })()
144      `);
145      if (done) {
146        break;
147      }
148      await sleep(delayMs);
149    }
150  }
151 
152  async close(): Promise<void> {
153    await this.cdp.closeTarget(this.targetSession.targetId);
154  }
155}
156