@detiq/crawler 0.1.3

package/src/test-executor.test.ts

@@ -0,0 +1,72 @@
+import http from 'node:http';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { executeTestPlan } from './test-executor.js';
+import type { ExecutionStep } from '@detiq/agents';
+
+async function startFixtureServer(html: string): Promise<{ url: string; close: () => Promise<void> }> {
+  const server = http.createServer((_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(html);
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : 0;
+  return {
+    url: `http://127.0.0.1:${port}`,
+    close: () => new Promise<void>((resolve) => server.close(() => resolve())),
+  };
+}
+
+// No AI healing context is passed in these tests (healCtx omitted), so the AI tier
+// (which needs a real LLM call) never engages — this is regression coverage for the
+// pre-existing mechanical strategy-fallback tier that self-healing wiring must not break.
+
+test('resolveLocator: primary strategy succeeds when the selector/strategy pair is correct', async () => {
+  const fixture = await startFixtureServer('<html><body><button>Submit</button></body></html>');
+  try {
+    const plan: ExecutionStep[] = [
+      { stepNumber: 1, description: 'navigate', action: 'navigate', url: fixture.url },
+      { stepNumber: 2, description: 'click Submit', action: 'click', selector: 'Submit', selectorStrategy: 'text' },
+    ];
+    const result = await executeTestPlan(plan, { screenshotDir: '/tmp', testRunId: 'test-primary-ok' });
+    assert.equal(result.status, 'PASSED');
+    assert.equal(result.stepResults[1].healed, false);
+  } finally {
+    await fixture.close();
+  }
+});
+
+test('resolveLocator: mechanical tier heals when the strategy is wrong but the text still matches', async () => {
+  // "label" strategy looks for a form control associated with a <label> — a bare
+  // <button> has no such association, so the primary lookup must fail and fall
+  // through to the "text" strategy, which does find it.
+  const fixture = await startFixtureServer('<html><body><button>Submit</button></body></html>');
+  try {
+    const plan: ExecutionStep[] = [
+      { stepNumber: 1, description: 'navigate', action: 'navigate', url: fixture.url },
+      { stepNumber: 2, description: 'click Submit', action: 'click', selector: 'Submit', selectorStrategy: 'label' },
+    ];
+    const result = await executeTestPlan(plan, { screenshotDir: '/tmp', testRunId: 'test-mechanical-heal' });
+    assert.equal(result.status, 'PASSED');
+    assert.equal(result.stepResults[1].healed, true);
+    assert.equal(result.stepResults[1].healedVia, 'mechanical');
+  } finally {
+    await fixture.close();
+  }
+});
+
+test('resolveLocator: fails cleanly (no healCtx configured) when no strategy matches at all', async () => {
+  const fixture = await startFixtureServer('<html><body><button>Submit</button></body></html>');
+  try {
+    const plan: ExecutionStep[] = [
+      { stepNumber: 1, description: 'navigate', action: 'navigate', url: fixture.url },
+      { stepNumber: 2, description: 'click Nonexistent', action: 'click', selector: 'Nonexistent Button', selectorStrategy: 'text' },
+    ];
+    const result = await executeTestPlan(plan, { screenshotDir: '/tmp', testRunId: 'test-no-match' });
+    assert.equal(result.status, 'FAILED');
+    assert.equal(result.stepResults[1].healed, undefined);
+  } finally {
+    await fixture.close();
+  }
+});

package/src/test-executor.ts

@@ -0,0 +1,424 @@
+import { chromium, firefox, webkit, type Page, type Locator } from 'playwright';
+import type { ExecutionStep } from '@detiq/agents';
+import { analyzeFailure } from './failure-analysis-agent.js';
+
+export interface StepResult {
+  stepNumber: number;
+  description: string;
+  status: 'PASSED' | 'FAILED' | 'SKIPPED';
+  duration: number;
+  error?: string;
+  screenshotPath?: string;
+  healed?: boolean;
+  /** 'mechanical' = same selector text, different Playwright locator strategy.
+   *  'ai' = AI Self-Healing Agent matched a semantically different element
+   *  (the app's selector text itself changed, e.g. "Sign In" -> "Log In"). */
+  healedVia?: 'mechanical' | 'ai';
+  healReasoning?: string;
+  healConfidence?: number;
+}
+
+export interface ExecutionResult {
+  stepResults: StepResult[];
+  status: 'PASSED' | 'FAILED' | 'ERROR' | 'FLAKY';
+  errorStep?: number;
+  totalDuration: number;
+  finalScreenshotPath?: string;
+  retryCount?: number;
+  consoleLogs?: Array<{ type: string; text: string; timestamp: number }>;
+  networkErrors?: Array<{ url: string; status: number; method: string; timestamp: number }>;
+  rootCauseSummary?: string;
+  networkTimings?: Array<{ url: string; method: string; status: number; duration: number }>;
+}
+
+const LOCATOR_STRATEGIES: ExecutionStep['selectorStrategy'][] = ['text', 'label', 'role', 'css'];
+
+function buildLocator(page: Page, selector: string, strategy: ExecutionStep['selectorStrategy'] = 'text'): Locator {
+  switch (strategy) {
+    case 'css':   return page.locator(selector);
+    case 'text':  return page.getByText(selector, { exact: false });
+    case 'role':  return page.getByRole(selector as any);
+    case 'label': return page.getByLabel(selector);
+    default:      return page.locator(selector);
+  }
+}
+
+/** Scans the live page for visible interactive elements — the "current page elements"
+ *  fed to the AI Self-Healing Agent when mechanical locator strategies fail. */
+async function extractCurrentPageElements(page: Page): Promise<Array<{ meaning: string; role: string; ariaLabel?: string; textContent?: string }>> {
+  return page.evaluate(() => {
+    const els = Array.from(document.querySelectorAll<HTMLElement>(
+      'a, button, input, select, textarea, [role="button"], [role="link"], [role="tab"], [role="menuitem"], [aria-label]'
+    ));
+    return els
+      .filter((el) => {
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      })
+      .slice(0, 200)
+      .map((el) => {
+        const ariaLabel = el.getAttribute('aria-label') ?? undefined;
+        const textContent = (el.textContent ?? '').replace(/\s+/g, ' ').trim().slice(0, 100) || undefined;
+        const role = el.getAttribute('role') ?? el.tagName.toLowerCase();
+        return { meaning: ariaLabel || textContent || role, role, ariaLabel, textContent };
+      });
+  });
+}
+
+/**
+ * Resolves a step's target element in three tiers:
+ *  1. Exact selector + strategy as generated.
+ *  2. Mechanical: same selector text, other Playwright locator strategies
+ *     (handles a strategy mismatch, not an actual UI change).
+ *  3. AI: when tenantId/projectId are supplied, asks the Self-Healing Agent to find
+ *     the current page's best semantic match for the failed step description — the
+ *     tier that actually survives the app's selector text changing.
+ */
+async function resolveLocator(
+  page: Page,
+  step: ExecutionStep,
+  healCtx?: { tenantId: string; projectId: string },
+): Promise<{ loc: Locator; healed: boolean; healedVia?: 'mechanical' | 'ai'; healReasoning?: string; healConfidence?: number } | null> {
+  const { selector, selectorStrategy = 'text' } = step;
+  if (!selector) return null;
+
+  const primary = buildLocator(page, selector, selectorStrategy);
+  const attached = await primary.first().isVisible({ timeout: 1500 }).catch(() => false);
+  if (attached) return { loc: primary, healed: false };
+
+  // Tier 2 — mechanical: try other strategies before giving up
+  for (const strategy of LOCATOR_STRATEGIES) {
+    if (strategy === selectorStrategy) continue;
+    const loc = buildLocator(page, selector, strategy);
+    const visible = await loc.first().isVisible({ timeout: 800 }).catch(() => false);
+    if (visible) return { loc, healed: true, healedVia: 'mechanical' };
+  }
+
+  // Tier 3 — AI: the selector text itself may no longer match anything on the page.
+  if (healCtx) {
+    try {
+      const { healElement } = await import('@detiq/agents');
+      const currentPageElements = await extractCurrentPageElements(page);
+      const result = await healElement({
+        tenantId: healCtx.tenantId,
+        projectId: healCtx.projectId,
+        failedElementMeaning: step.description || selector,
+        currentPageElements,
+      });
+      if (result.healed && result.updatedTest) {
+        const healedLoc = page.getByText(result.updatedTest.elementMeaning, { exact: false });
+        const visible = await healedLoc.first().isVisible({ timeout: 1500 }).catch(() => false);
+        if (visible) {
+          return {
+            loc: healedLoc,
+            healed: true,
+            healedVia: 'ai',
+            healReasoning: result.reasoning,
+            healConfidence: result.confidence,
+          };
+        }
+      }
+    } catch {
+      // AI healing is a best-effort last resort — any failure here (LLM error, bad
+      // JSON, etc.) just falls through to the caller's normal Playwright error below.
+    }
+  }
+
+  // Return primary — caller will fail with a meaningful Playwright error
+  return { loc: primary, healed: false };
+}
+
+function applyHealInfo(result: StepResult, r: { healed: boolean; healedVia?: 'mechanical' | 'ai'; healReasoning?: string; healConfidence?: number }): void {
+  result.healed = r.healed;
+  result.healedVia = r.healedVia;
+  result.healReasoning = r.healReasoning;
+  result.healConfidence = r.healConfidence;
+}
+
+async function runPlan(
+  page: Page,
+  plan: ExecutionStep[],
+  options: { screenshotDir: string; testRunId: string; onStepComplete?: (result: StepResult) => void; healCtx?: { tenantId: string; projectId: string } },
+  consoleLogs: Array<{ type: string; text: string; timestamp: number }>,
+  networkErrors: Array<{ url: string; status: number; method: string; timestamp: number }>,
+): Promise<{ stepResults: StepResult[]; errorStep?: number; finalScreenshotPath?: string; consoleLogs: typeof consoleLogs; networkErrors: typeof networkErrors }> {
+  const stepResults: StepResult[] = [];
+  let errorStep: number | undefined;
+  let finalScreenshotPath: string | undefined;
+
+  for (const step of plan) {
+    const stepStart = Date.now();
+    const result: StepResult = {
+      stepNumber: step.stepNumber,
+      description: step.description,
+      status: 'FAILED',
+      duration: 0,
+    };
+
+    try {
+      const timeout = step.timeout ?? 8000;
+
+      switch (step.action) {
+        case 'navigate':
+          await page.goto(step.url!, { waitUntil: 'domcontentloaded', timeout });
+          break;
+
+        case 'click': {
+          const r = await resolveLocator(page, step, options.healCtx);
+          if (!r) throw new Error('Could not resolve locator');
+          await r.loc.first().click({ timeout });
+          applyHealInfo(result, r);
+          break;
+        }
+
+        case 'fill': {
+          const r = await resolveLocator(page, step, options.healCtx);
+          if (!r) throw new Error('Could not resolve locator');
+          await r.loc.first().fill(step.value ?? '', { timeout });
+          applyHealInfo(result, r);
+          break;
+        }
+
+        case 'select': {
+          const r = await resolveLocator(page, step, options.healCtx);
+          if (!r) throw new Error('Could not resolve locator');
+          await r.loc.first().selectOption(step.value ?? '', { timeout });
+          applyHealInfo(result, r);
+          break;
+        }
+
+        case 'hover': {
+          const r = await resolveLocator(page, step, options.healCtx);
+          if (!r) throw new Error('Could not resolve locator');
+          await r.loc.first().hover({ timeout });
+          applyHealInfo(result, r);
+          break;
+        }
+
+        case 'press_key':
+          await page.keyboard.press(step.value ?? 'Enter');
+          break;
+
+        case 'assert_visible': {
+          const r = await resolveLocator(page, step, options.healCtx);
+          if (!r) throw new Error('Could not resolve locator');
+          await r.loc.first().waitFor({ state: 'visible', timeout });
+          applyHealInfo(result, r);
+          break;
+        }
+
+        case 'assert_text': {
+          const r = await resolveLocator(page, step, options.healCtx);
+          if (!r) throw new Error('Could not resolve locator');
+          const text = await r.loc.first().textContent({ timeout });
+          if (!text?.includes(step.value ?? '')) {
+            throw new Error(`Expected text "${step.value}" not found. Got: "${text?.slice(0, 100)}"`);
+          }
+          applyHealInfo(result, r);
+          break;
+        }
+
+        case 'assert_url': {
+          const url = page.url();
+          if (!url.includes(step.value ?? '')) {
+            throw new Error(`Expected URL to contain "${step.value}". Got: "${url}"`);
+          }
+          break;
+        }
+
+        case 'wait':
+          await page.waitForTimeout(step.timeout ?? 2000);
+          break;
+
+        case 'screenshot': {
+          const ssPath = `${options.screenshotDir}/${options.testRunId}-step-${step.stepNumber}.png`;
+          await page.screenshot({ path: ssPath, fullPage: true });
+          result.screenshotPath = ssPath;
+          break;
+        }
+      }
+
+      result.status = 'PASSED';
+    } catch (err: any) {
+      result.status = step.optional ? 'SKIPPED' : 'FAILED';
+      result.error = err.message;
+      if (!step.optional) {
+        errorStep = step.stepNumber;
+      }
+    }
+
+    try {
+      await page.waitForLoadState('networkidle', { timeout: 1500 }).catch(() => {});
+      if (!result.screenshotPath) {
+        const ssPath = `${options.screenshotDir}/${options.testRunId}-step-${step.stepNumber}.png`;
+        await page.screenshot({ path: ssPath, fullPage: true });
+        result.screenshotPath = ssPath;
+      }
+    } catch { /* Screenshot evidence is best-effort and should not fail the run. */ }
+
+    result.duration = Date.now() - stepStart;
+    stepResults.push(result);
+    options.onStepComplete?.(result);
+
+    if (result.status === 'FAILED') break;
+  }
+
+  try {
+    const finalPath = `${options.screenshotDir}/${options.testRunId}-final.png`;
+    await page.screenshot({ path: finalPath, fullPage: true });
+    finalScreenshotPath = finalPath;
+  } catch { /* non-fatal */ }
+
+  return { stepResults, errorStep, finalScreenshotPath, consoleLogs, networkErrors };
+}
+
+function interpolate(template: string | undefined, data: Record<string, string>): string | undefined {
+  if (!template) return template;
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] ?? `{{${key}}}`);
+}
+
+export async function executeTestPlan(
+  plan: ExecutionStep[],
+  options: {
+    screenshotDir: string;
+    testRunId: string;
+    viewport?: { width: number; height: number };
+    onStepComplete?: (result: StepResult) => void;
+    /** Run the test up to this many times to detect flakiness (default 1). */
+    maxRuns?: number;
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    /** Data row for parameterized execution: substitutes {{varname}} in step fields. */
+    dataRow?: Record<string, string>;
+    /** Enables the AI Self-Healing Agent tier when a step's selector can't be resolved
+     *  even after trying alternate locator strategies. Omit to keep mechanical-only
+     *  healing (no LLM calls during execution). */
+    healCtx?: { tenantId: string; projectId: string };
+    /** Decrypted Playwright storageState JSON — restores a logged-in session so
+     *  steps don't have to re-authenticate. Without this, any test case behind a
+     *  login wall fails at the first authenticated step. */
+    storageState?: string;
+  },
+): Promise<ExecutionResult> {
+  if (options.dataRow && Object.keys(options.dataRow).length > 0) {
+    const data = options.dataRow;
+    plan = plan.map((step) => ({
+      ...step,
+      url: interpolate(step.url, data),
+      selector: interpolate(step.selector, data),
+      value: interpolate(step.value, data),
+      description: interpolate(step.description, data) ?? step.description,
+    }));
+  }
+  const maxRuns = options.maxRuns ?? 1;
+  const browserEngine = { chromium, firefox, webkit }[options.browser ?? 'chromium'] ?? chromium;
+  const start = Date.now();
+
+  const outcomes: ('PASSED' | 'FAILED')[] = [];
+  let lastResult: Awaited<ReturnType<typeof runPlan>> | null = null;
+  let lastNetworkTimings: Array<{ url: string; method: string; status: number; duration: number }> = [];
+
+  for (let run = 0; run < maxRuns; run++) {
+    const browser = await browserEngine.launch({
+      headless: true,
+      // Optional override for environments with a non-standard/pre-provisioned
+      // browser install (e.g. a custom base image with only system Chromium).
+      ...(process.env.PLAYWRIGHT_EXECUTABLE_PATH ? { executablePath: process.env.PLAYWRIGHT_EXECUTABLE_PATH } : {}),
+    });
+    let parsedStorageState: any;
+    try {
+      parsedStorageState = options.storageState ? JSON.parse(options.storageState) : undefined;
+    } catch {
+      parsedStorageState = undefined;
+    }
+    const context = await browser.newContext({
+      viewport: options.viewport ?? { width: 1440, height: 900 },
+      ...(parsedStorageState ? { storageState: parsedStorageState } : {}),
+    });
+    const page = await context.newPage();
+
+    await page
+      .addStyleTag({ content: '*, *::before, *::after { animation-duration: 0s !important; transition-duration: 0s !important; }' })
+      .catch(() => {});
+
+    const consoleLogs: Array<{ type: string; text: string; timestamp: number }> = [];
+    const networkErrors: Array<{ url: string; status: number; method: string; timestamp: number }> = [];
+    const networkTimings: Array<{ url: string; method: string; status: number; duration: number }> = [];
+    const requestStartTimes = new Map<string, number>();
+
+    page.on('console', msg => {
+      if (consoleLogs.length < 100) {
+        consoleLogs.push({ type: msg.type(), text: msg.text().slice(0, 500), timestamp: Date.now() });
+      }
+    });
+    page.on('request', request => {
+      const url = request.url();
+      if (url.includes('/api/') || url.match(/\/(graphql|rest|v\d)\//)) {
+        requestStartTimes.set(request.url(), Date.now());
+      }
+    });
+    page.on('response', response => {
+      const url = response.url();
+      const start = requestStartTimes.get(url);
+      if (start && networkTimings.length < 200) {
+        networkTimings.push({ url: url.slice(0, 300), method: response.request().method(), status: response.status(), duration: Date.now() - start });
+        requestStartTimes.delete(url);
+      }
+      if (!response.ok() && !url.includes('favicon') && networkErrors.length < 50) {
+        networkErrors.push({
+          url: url.slice(0, 300),
+          status: response.status(),
+          method: response.request().method(),
+          timestamp: Date.now(),
+        });
+      }
+    });
+
+    lastResult = await runPlan(page, plan, options, consoleLogs, networkErrors);
+    lastNetworkTimings = networkTimings;
+    await browser.close();
+
+    const passed = !lastResult.stepResults.some((r) => r.status === 'FAILED');
+    outcomes.push(passed ? 'PASSED' : 'FAILED');
+
+    // If all subsequent runs are consistent with first, no need to keep going
+    if (run > 0 && outcomes.every((o) => o === outcomes[0])) break;
+  }
+
+  const passCount = outcomes.filter((o) => o === 'PASSED').length;
+  const failCount = outcomes.filter((o) => o === 'FAILED').length;
+
+  let status: ExecutionResult['status'];
+  if (maxRuns > 1 && passCount > 0 && failCount > 0) {
+    status = 'FLAKY';
+  } else if (passCount === outcomes.length) {
+    status = 'PASSED';
+  } else {
+    status = 'FAILED';
+  }
+
+  let rootCauseSummary: string | undefined;
+  if (status === 'FAILED' || status === 'FLAKY') {
+    const failedStep = lastResult!.stepResults.find(s => s.status === 'FAILED');
+    rootCauseSummary = await analyzeFailure({
+      tenantId: options.healCtx?.tenantId,
+      error: failedStep?.error ?? 'Unknown error',
+      stepDescription: failedStep?.description,
+      consoleLogs: lastResult!.consoleLogs,
+      networkErrors: lastResult!.networkErrors,
+      screenshotPath: lastResult!.finalScreenshotPath,
+    }).catch(() => undefined) ?? undefined;
+  }
+
+  return {
+    stepResults: lastResult!.stepResults,
+    status,
+    errorStep: lastResult!.errorStep,
+    totalDuration: Date.now() - start,
+    finalScreenshotPath: lastResult!.finalScreenshotPath,
+    retryCount: outcomes.length - 1,
+    consoleLogs: lastResult!.consoleLogs,
+    networkErrors: lastResult!.networkErrors,
+    rootCauseSummary,
+    networkTimings: lastNetworkTimings,
+  };
+}

package/src/tls-fingerprint.ts

@@ -0,0 +1,111 @@
+/**
+ * TLS fingerprint spoofing — Chrome JA3 cipher suite ordering.
+ *
+ * Node.js TLS doesn't expose JA3 hash control directly, but ordering
+ * cipher suites to match Chrome's TLS ClientHello reduces fingerprint
+ * detectability vs the default OpenSSL order.
+ *
+ * For full JA3 bypass, pair with the browser-stealth engine (Camoufox).
+ */
+
+import { Agent as HttpsAgent } from 'node:https';
+import { connect as tlsConnect } from 'node:tls';
+
+// Chrome 120+ TLS 1.3 + 1.2 cipher suite order
+export const CHROME_CIPHERS = [
+  'TLS_AES_128_GCM_SHA256',
+  'TLS_AES_256_GCM_SHA384',
+  'TLS_CHACHA20_POLY1305_SHA256',
+  'ECDHE-ECDSA-AES128-GCM-SHA256',
+  'ECDHE-RSA-AES128-GCM-SHA256',
+  'ECDHE-ECDSA-AES256-GCM-SHA384',
+  'ECDHE-RSA-AES256-GCM-SHA384',
+  'ECDHE-ECDSA-CHACHA20-POLY1305',
+  'ECDHE-RSA-CHACHA20-POLY1305',
+  'ECDHE-RSA-AES128-SHA',
+  'ECDHE-RSA-AES256-SHA',
+  'AES128-GCM-SHA256',
+  'AES256-GCM-SHA384',
+  'AES128-SHA',
+  'AES256-SHA',
+].join(':');
+
+// Chrome's ECDH curve preference order
+export const CHROME_CURVES = 'X25519:P-256:P-384';
+
+export interface TlsFingerprintOptions {
+  rejectUnauthorized?: boolean;
+  keepAlive?: boolean;
+  keepAliveMsecs?: number;
+  maxSockets?: number;
+}
+
+/**
+ * Returns an HTTPS agent configured with Chrome-like TLS settings.
+ * Drop-in replacement for the default agent in fetch/got/axios.
+ */
+export function createChromeTlsAgent(opts: TlsFingerprintOptions = {}): HttpsAgent {
+  return new HttpsAgent({
+    ciphers: CHROME_CIPHERS,
+    ecdhCurve: CHROME_CURVES,
+    minVersion: 'TLSv1.2',
+    maxVersion: 'TLSv1.3',
+    rejectUnauthorized: opts.rejectUnauthorized ?? true,
+    keepAlive: opts.keepAlive ?? true,
+    keepAliveMsecs: opts.keepAliveMsecs ?? 10_000,
+    maxSockets: opts.maxSockets ?? 50,
+  });
+}
+
+/**
+ * Probe a host and return its JA3-relevant TLS parameters.
+ * Useful for verifying that the fingerprint changed vs default.
+ */
+export async function probeTlsFingerprint(host: string, port = 443): Promise<{
+  protocol: string;
+  cipher: string;
+  authorized: boolean;
+  subjectCN: string | null;
+}> {
+  return new Promise((resolve, reject) => {
+    const socket = tlsConnect({
+      host,
+      port,
+      servername: host,
+      ciphers: CHROME_CIPHERS,
+      ecdhCurve: CHROME_CURVES,
+      minVersion: 'TLSv1.2',
+      rejectUnauthorized: false,
+    }, () => {
+      const cert = socket.getPeerCertificate();
+      resolve({
+        protocol: socket.getProtocol() ?? 'unknown',
+        cipher: socket.getCipher()?.name ?? 'unknown',
+        authorized: socket.authorized,
+        subjectCN: cert?.subject?.CN ?? null,
+      });
+      socket.destroy();
+    });
+    socket.on('error', reject);
+    setTimeout(() => { socket.destroy(); reject(new Error('TLS probe timeout')); }, 5_000);
+  });
+}
+
+/**
+ * Node.js fetch dispatcher options with Chrome TLS agent.
+ * Pass as the `dispatcher` option to undici or as `agent` to node-fetch.
+ */
+export const chromeTlsAgent = createChromeTlsAgent();
+
+export const CHROME_TLS_HEADERS = {
+  'Accept-Encoding': 'gzip, deflate, br, zstd',
+  'Accept-Language': 'en-US,en;q=0.9',
+  'sec-ch-ua': '"Google Chrome";v="120", "Chromium";v="120", "Not-A.Brand";v="99"',
+  'sec-ch-ua-mobile': '?0',
+  'sec-ch-ua-platform': '"Windows"',
+  'Sec-Fetch-Dest': 'document',
+  'Sec-Fetch-Mode': 'navigate',
+  'Sec-Fetch-Site': 'none',
+  'Sec-Fetch-User': '?1',
+  'Upgrade-Insecure-Requests': '1',
+};