1import { launch, type LaunchedChrome } from "chrome-launcher";
2import WebSocket from "ws";
3import type { Logger } from "../utils/logger";
4import {
5  cleanChromeLockArtifacts,
6  ensureChromeProfileDir,
7  findChromeProcessUsingProfile,
8  findExistingChromeDebugPort,
9  hasChromeLockArtifacts,
10  listChromeProfileEntries,
11  resolveChromeProfileDir,
12  shouldRetryChromeLaunchRecovery,
13} from "./profile";
14 
15interface ChromeVersionResponse {
16  webSocketDebuggerUrl: string;
17}
18 
19export interface ChromeConnectOptions {
20  cdpUrl?: string;
21  browserPath?: string;
22  headless?: boolean;
23  logger?: Logger;
24  profileDir?: string;
25}
26 
27export interface ChromeConnection {
28  browserWsUrl: string;
29  origin?: string;
30  port?: number;
31  profileDir?: string;
32  launched: boolean;
33  close(): Promise<void>;
34}
35 
36async function fetchJson<T>(url: string): Promise<T> {
37  const response = await fetch(url);
38  if (!response.ok) {
39    throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
40  }
41  return (await response.json()) as T;
42}
43 
44async function connectToHttpEndpoint(origin: string): Promise<ChromeConnection> {
45  const normalizedOrigin = origin.replace(/\/$/, "");
46  const version = await fetchJson<ChromeVersionResponse>(`${normalizedOrigin}/json/version`);
47  return {
48    browserWsUrl: version.webSocketDebuggerUrl,
49    origin: normalizedOrigin,
50    port: Number(new URL(normalizedOrigin).port || 80),
51    launched: false,
52    async close() {
53      // Reused external Chrome, nothing to close here.
54    },
55  };
56}
57 
58async function tryReuseChrome(profileDir: string, logger?: Logger): Promise<ChromeConnection | null> {
59  const port = await findExistingChromeDebugPort({ profileDir });
60  if (!port) {
61    return null;
62  }
63 
64  const origin = `http://127.0.0.1:${port}`;
65  try {
66    const connection = await connectToHttpEndpoint(origin);
67    logger?.info(`Reusing Chrome debugger at ${origin} for profile ${profileDir}`);
68    return {
69      ...connection,
70      profileDir,
71    };
72  } catch {
73    // Debugger disappeared between detection and connect.
74  }
75  return null;
76}
77 
78async function launchFreshChrome(
79  profileDir: string,
80  options: Pick<ChromeConnectOptions, "browserPath" | "headless">,
81): Promise<ChromeConnection> {
82  let launchedChrome: LaunchedChrome | null = null;
83  try {
84    launchedChrome = await launch({
85      chromePath: options.browserPath,
86      userDataDir: profileDir,
87      chromeFlags: [
88        "--disable-background-networking",
89        "--disable-default-apps",
90        "--disable-popup-blocking",
91        "--disable-sync",
92        "--no-first-run",
93        "--no-default-browser-check",
94        "--remote-allow-origins=*",
95        ...(!options.headless ? ["--no-startup-window"] : []),
96        ...(options.headless ? ["--headless=new"] : []),
97      ],
98    });
99 
100    const origin = `http://127.0.0.1:${launchedChrome.port}`;
101    const version = await fetchJson<ChromeVersionResponse>(`${origin}/json/version`);
102 
103    const chrome = launchedChrome;
104    return {
105      browserWsUrl: version.webSocketDebuggerUrl,
106      origin,
107      port: launchedChrome.port,
108      profileDir,
109      launched: true,
110      async close() {
111        if (!chrome) return;
112        await gracefulCloseChrome(chrome, origin);
113      },
114    };
115  } catch (error) {
116    launchedChrome?.kill();
117    throw error;
118  }
119}
120 
121async function gracefulCloseChrome(chrome: LaunchedChrome, origin: string): Promise<void> {
122  try {
123    const resp = await fetch(`${origin}/json/version`);
124    const { webSocketDebuggerUrl } = (await resp.json()) as ChromeVersionResponse;
125    if (webSocketDebuggerUrl) {
126      const ws = await new Promise<WebSocket>((resolve, reject) => {
127        const socket = new WebSocket(webSocketDebuggerUrl);
128        socket.once("open", () => resolve(socket));
129        socket.once("error", reject);
130      });
131      const id = 1;
132      ws.send(JSON.stringify({ id, method: "Browser.close" }));
133      await new Promise<void>((resolve) => {
134        const timer = setTimeout(() => { ws.close(); resolve(); }, 5_000);
135        ws.once("close", () => { clearTimeout(timer); resolve(); });
136      });
137      const exited = await new Promise<boolean>((resolve) => {
138        if (chrome.pid && !isProcessAlive(chrome.pid)) { resolve(true); return; }
139        const timer = setTimeout(() => resolve(false), 3_000);
140        chrome.process.once("exit", () => { clearTimeout(timer); resolve(true); });
141      });
142      if (exited) return;
143    }
144  } catch {}
145  chrome.kill();
146}
147 
148function isProcessAlive(pid: number): boolean {
149  try { process.kill(pid, 0); return true; } catch { return false; }
150}
151 
152export async function connectChrome(options: ChromeConnectOptions): Promise<ChromeConnection> {
153  if (options.cdpUrl) {
154    if (options.cdpUrl.startsWith("ws://") || options.cdpUrl.startsWith("wss://")) {
155      return {
156        browserWsUrl: options.cdpUrl,
157        launched: false,
158        async close() {},
159      };
160    }
161    return connectToHttpEndpoint(options.cdpUrl);
162  }
163 
164  const profileDir = ensureChromeProfileDir(resolveChromeProfileDir(options.profileDir));
165  const reused = await tryReuseChrome(profileDir, options.logger);
166  if (reused) {
167    return reused;
168  }
169 
170  options.logger?.warn(`No running Chrome debugger found for profile ${profileDir}. Launching Chrome with that profile.`);
171  try {
172    return await launchFreshChrome(profileDir, options);
173  } catch (error) {
174    const entries = await listChromeProfileEntries(profileDir);
175    const shouldRetry = shouldRetryChromeLaunchRecovery({
176      hasLockArtifacts: hasChromeLockArtifacts(entries),
177      hasLiveOwner: findChromeProcessUsingProfile(profileDir),
178    });
179    if (!shouldRetry) {
180      throw error;
181    }
182 
183    options.logger?.warn(`Chrome launch failed with stale profile locks. Cleaning ${profileDir} and retrying once.`);
184    cleanChromeLockArtifacts(profileDir);
185    return await launchFreshChrome(profileDir, options);
186  }
187}
188