1import {
2  CdpConnection,
3  findChromeExecutable as findChromeExecutableBase,
4  findExistingChromeDebugPort,
5  gracefulKillChrome,
6  getFreePort,
7  launchChrome as launchChromeBase,
8  openPageSession,
9  sleep,
10  waitForChromeDebugPort,
11  type PlatformCandidates,
12} from "baoyu-chrome-cdp";
13 
14import process from "node:process";
15 
16import { read_cookie_file, write_cookie_file } from "./cookie-file.js";
17import { resolveXToMarkdownCookiePath } from "./paths.js";
18import { X_COOKIE_NAMES, X_REQUIRED_COOKIES, X_LOGIN_URL, X_USER_DATA_DIR } from "./constants.js";
19import type { CookieLike } from "./types.js";
20 
21const CHROME_CANDIDATES_FULL: PlatformCandidates = {
22  darwin: [
23    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
24    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
25    "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
26    "/Applications/Chromium.app/Contents/MacOS/Chromium",
27    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
28  ],
29  win32: [
30    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
31    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
32    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
33    "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
34  ],
35  default: [
36    "/usr/bin/google-chrome",
37    "/usr/bin/google-chrome-stable",
38    "/usr/bin/chromium",
39    "/usr/bin/chromium-browser",
40    "/snap/bin/chromium",
41    "/usr/bin/microsoft-edge",
42  ],
43};
44 
45function findChromeExecutable(): string | null {
46  return findChromeExecutableBase({
47    candidates: CHROME_CANDIDATES_FULL,
48    envNames: ["X_CHROME_PATH"],
49  }) ?? null;
50}
51 
52async function launchChrome(profileDir: string, port: number) {
53  const chromePath = findChromeExecutable();
54  if (!chromePath) throw new Error("Chrome executable not found.");
55  return await launchChromeBase({
56    chromePath,
57    profileDir,
58    port,
59    url: X_LOGIN_URL,
60    extraArgs: ["--disable-popup-blocking"],
61  });
62}
63 
64async function fetchXCookiesViaCdp(
65  profileDir: string,
66  timeoutMs: number,
67  verbose: boolean,
68  log?: (message: string) => void
69): Promise<Record<string, string>> {
70  const existingPort = await findExistingChromeDebugPort({ profileDir });
71  const reusing = existingPort !== null;
72  const port = existingPort ?? await getFreePort("X_DEBUG_PORT");
73  const chrome = reusing ? null : await launchChrome(profileDir, port);
74 
75  let cdp: CdpConnection | null = null;
76  let targetId: string | null = null;
77  try {
78    const wsUrl = await waitForChromeDebugPort(port, 30_000, { includeLastError: true });
79    cdp = await CdpConnection.connect(wsUrl, 15_000);
80 
81    const page = await openPageSession({
82      cdp,
83      reusing,
84      url: X_LOGIN_URL,
85      matchTarget: (target) => target.type === "page" && (
86        target.url.includes("x.com") || target.url.includes("twitter.com")
87      ),
88      enableNetwork: true,
89    });
90    const { sessionId } = page;
91    targetId = page.targetId;
92 
93    if (verbose) {
94      log?.(reusing
95        ? `[x-cookies] Reusing existing Chrome on port ${port}. Waiting for cookies...`
96        : "[x-cookies] Chrome opened. If needed, complete X login in the window. Waiting for cookies...");
97    }
98 
99    const start = Date.now();
100    let last: Record<string, string> = {};
101 
102    while (Date.now() - start < timeoutMs) {
103      const { cookies } = await cdp.send<{ cookies: CookieLike[] }>(
104        "Network.getCookies",
105        { urls: ["https://x.com/", "https://twitter.com/"] },
106        { sessionId, timeoutMs: 10_000 }
107      );
108 
109      const m = buildXCookieMap((cookies ?? []).filter(Boolean));
110      last = m;
111      if (hasRequiredXCookies(m)) {
112        return m;
113      }
114 
115      await sleep(1000);
116    }
117 
118    throw new Error(`Timed out waiting for X cookies. Last keys: ${Object.keys(last).join(", ")}`);
119  } finally {
120    if (cdp) {
121      if (reusing && targetId) {
122        try {
123          await cdp.send("Target.closeTarget", { targetId }, { timeoutMs: 5_000 });
124        } catch {}
125      }
126      cdp.close();
127    }
128 
129    if (chrome) await gracefulKillChrome(chrome, port);
130  }
131}
132 
133function resolveCookieDomain(cookie: CookieLike): string | null {
134  const rawDomain = cookie.domain?.trim();
135  if (rawDomain) {
136    return rawDomain.startsWith(".") ? rawDomain.slice(1) : rawDomain;
137  }
138  const rawUrl = cookie.url?.trim();
139  if (rawUrl) {
140    try {
141      return new URL(rawUrl).hostname;
142    } catch {
143      return null;
144    }
145  }
146  return null;
147}
148 
149function pickCookieValue<T extends CookieLike>(cookies: T[], name: string): string | undefined {
150  const matches = cookies.filter((cookie) => cookie.name === name && typeof cookie.value === "string");
151  if (matches.length === 0) return undefined;
152 
153  const preferred = matches.find((cookie) => {
154    const domain = resolveCookieDomain(cookie);
155    return domain === "x.com" && (cookie.path ?? "/") === "/";
156  });
157  const xDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? "").endsWith("x.com"));
158  const twitterDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? "").endsWith("twitter.com"));
159  return (preferred ?? xDomain ?? twitterDomain ?? matches[0])?.value;
160}
161 
162function buildXCookieMap<T extends CookieLike>(cookies: T[]): Record<string, string> {
163  const cookieMap: Record<string, string> = {};
164  for (const name of X_COOKIE_NAMES) {
165    const value = pickCookieValue(cookies, name);
166    if (value) cookieMap[name] = value;
167  }
168  return cookieMap;
169}
170 
171export function hasRequiredXCookies(cookieMap: Record<string, string>): boolean {
172  return X_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
173}
174 
175function filterXCookieMap(cookieMap: Record<string, string>): Record<string, string> {
176  const filtered: Record<string, string> = {};
177  for (const name of X_COOKIE_NAMES) {
178    const value = cookieMap[name];
179    if (value) filtered[name] = value;
180  }
181  return filtered;
182}
183 
184function buildInlineCookiesFromEnv(): CookieLike[] {
185  const cookies: CookieLike[] = [];
186  const authToken = process.env.X_AUTH_TOKEN?.trim();
187  const ct0 = process.env.X_CT0?.trim();
188  const gt = process.env.X_GUEST_TOKEN?.trim();
189  const twid = process.env.X_TWID?.trim();
190 
191  if (authToken) {
192    cookies.push({ name: "auth_token", value: authToken, domain: "x.com", path: "/" });
193  }
194  if (ct0) {
195    cookies.push({ name: "ct0", value: ct0, domain: "x.com", path: "/" });
196  }
197  if (gt) {
198    cookies.push({ name: "gt", value: gt, domain: "x.com", path: "/" });
199  }
200  if (twid) {
201    cookies.push({ name: "twid", value: twid, domain: "x.com", path: "/" });
202  }
203 
204  return cookies;
205}
206 
207async function loadXCookiesFromInline(log?: (message: string) => void): Promise<Record<string, string>> {
208  const inline = buildInlineCookiesFromEnv();
209  if (inline.length === 0) return {};
210 
211  const cookieMap = buildXCookieMap(
212    inline.filter((cookie): cookie is CookieLike => Boolean(cookie?.name && typeof cookie.value === "string"))
213  );
214 
215  if (Object.keys(cookieMap).length > 0) {
216    log?.(`[x-cookies] Loaded X cookies from env: ${Object.keys(cookieMap).length} cookie(s).`);
217  } else {
218    log?.("[x-cookies] Env cookies provided but no X cookies matched.");
219  }
220 
221  return cookieMap;
222}
223 
224async function loadXCookiesFromFile(log?: (message: string) => void): Promise<Record<string, string>> {
225  const cookiePath = resolveXToMarkdownCookiePath();
226  const fileMap = filterXCookieMap((await read_cookie_file(cookiePath)) ?? {});
227  if (Object.keys(fileMap).length > 0) {
228    log?.(`[x-cookies] Loaded X cookies from file: ${cookiePath} (${Object.keys(fileMap).length} cookie(s))`);
229  }
230  return fileMap;
231}
232 
233async function loadXCookiesFromCdp(log?: (message: string) => void): Promise<Record<string, string>> {
234  try {
235    const cookieMap = await fetchXCookiesViaCdp(X_USER_DATA_DIR, 5 * 60 * 1000, true, log);
236    if (!hasRequiredXCookies(cookieMap)) return cookieMap;
237 
238    const cookiePath = resolveXToMarkdownCookiePath();
239    try {
240      await write_cookie_file(cookieMap, cookiePath, "cdp");
241      log?.(`[x-cookies] Cookies saved to ${cookiePath}`);
242    } catch (error) {
243      log?.(
244        `[x-cookies] Failed to write cookie file (${cookiePath}): ${
245          error instanceof Error ? error.message : String(error ?? "")
246        }`
247      );
248    }
249    if (cookieMap.auth_token) log?.(`[x-cookies] auth_token: ${cookieMap.auth_token.slice(0, 20)}...`);
250    if (cookieMap.ct0) log?.(`[x-cookies] ct0: ${cookieMap.ct0.slice(0, 20)}...`);
251    return cookieMap;
252  } catch (error) {
253    log?.(
254      `[x-cookies] Failed to load cookies via Chrome DevTools Protocol: ${
255        error instanceof Error ? error.message : String(error ?? "")
256      }`
257    );
258    return {};
259  }
260}
261 
262export async function loadXCookies(log?: (message: string) => void): Promise<Record<string, string>> {
263  const inlineMap = await loadXCookiesFromInline(log);
264  const fileMap = await loadXCookiesFromFile(log);
265  const combined = { ...fileMap, ...inlineMap };
266 
267  if (hasRequiredXCookies(combined)) return combined;
268 
269  const cdpMap = await loadXCookiesFromCdp(log);
270  return { ...fileMap, ...cdpMap, ...inlineMap };
271}
272 
273export async function refreshXCookies(log?: (message: string) => void): Promise<Record<string, string>> {
274  return loadXCookiesFromCdp(log);
275}
276 
277export function buildCookieHeader(cookieMap: Record<string, string>): string | undefined {
278  const entries = Object.entries(cookieMap).filter(([, value]) => value);
279  if (entries.length === 0) return undefined;
280  return entries.map(([key, value]) => `${key}=${value}`).join("; ");
281}
282