@govtechsg/oobee 0.10.61 → 0.10.65

package/src/index.ts

@@ -7,6 +7,8 @@ import {
   cleanUp,
   getUserDataTxt,
   writeToUserDataTxt,
+  listenForCleanUp,
+  cleanUpAndExit,
 } from './utils.js';
 import {
   prepareData,
@@ -106,19 +108,19 @@ const runScan = async (answers: Answers) => {
   answers.metadata = '{}';
 
   const data: Data = await prepareData(answers);
+  
+  // Executes cleanUp script if error encountered
+  listenForCleanUp(data.randomToken);
+  
   data.userDataDirectory = getClonedProfilesWithRandomToken(data.browser, data.randomToken);
 
   printMessage(['Scanning website...'], messageOptions);
 
   await combineRun(data, screenToScan);
 
-  // Delete cloned directory
-  deleteClonedProfiles(data.browser, data.randomToken);
-
   // Delete dataset and request queues
-  cleanUp(data.randomToken);
+  cleanUpAndExit(0, data.randomToken);
 
-  process.exit(0);
 };
 
 if (userData) {

package/src/logs.ts

@@ -2,6 +2,8 @@
 /* eslint-disable no-shadow */
 import { createLogger, format, transports } from 'winston';
 import { guiInfoStatusTypes } from './constants/constants.js';
+import path from 'path';
+import { randomUUID } from 'crypto';
 
 const { combine, timestamp, printf } = format;
 
@@ -20,12 +22,32 @@ const logFormat = printf(({ timestamp, level, message }) => {
 // transport: storage device for logs
 // Enabled for console and storing into files; Files are overwritten each time
 // All logs in combined.txt, error in errors.txt
+const uuid = randomUUID();
+let basePath: string;
+
+if (process.env.OOBEE_LOGS_PATH) {
+  basePath = process.env.OOBEE_LOGS_PATH;
+} else if (process.platform === 'win32') {
+  basePath = path.join(process.env.APPDATA, 'Oobee');
+} else if (process.platform === 'darwin') {
+  basePath = path.join(process.env.HOME, 'Library', 'Application Support', 'Oobee');
+} else {
+  basePath = path.join(process.cwd());
+}
+
+export const errorsTxtPath = path.join(basePath, `${uuid}.txt`);
 
 const consoleLogger = createLogger({
   silent: !(process.env.RUNNING_FROM_PH_GUI || process.env.OOBEE_VERBOSE),
   format: combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), logFormat),
-  transports:
-    process.env.RUNNING_FROM_PH_GUI || process.env.OOBEE_VERBOSE ? [new transports.Console()] : [],
+  transports: [
+    new transports.Console({ level: 'info' }),
+    new transports.File({
+      filename: errorsTxtPath,
+      level: 'info',
+      handleExceptions: true,
+    }),
+  ],
 });
 
 // No display in consoles, this will mostly be used within the interactive script to avoid disrupting the flow
@@ -34,9 +56,10 @@ const consoleLogger = createLogger({
 const silentLogger = createLogger({
   format: combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), logFormat),
   transports: [
-    process.env.OOBEE_VERBOSE || process.env.RUNNING_FROM_PH_GUI
-      ? new transports.Console({ handleExceptions: true })
-      : new transports.File({ filename: 'errors.txt', level: 'warn', handleExceptions: true }),
+    new transports.File({ 
+      filename: errorsTxtPath,
+      level: 'warn', 
+      handleExceptions: true }),
   ].filter(Boolean),
 });
 
@@ -46,16 +69,17 @@ export const guiInfoLog = (status: string, data: { numScanned?: number; urlScann
     switch (status) {
       case guiInfoStatusTypes.COMPLETED:
         console.log('Scan completed');
+        silentLogger.info('Scan completed');
         break;
       case guiInfoStatusTypes.SCANNED:
       case guiInfoStatusTypes.SKIPPED:
       case guiInfoStatusTypes.ERROR:
       case guiInfoStatusTypes.DUPLICATE:
-        console.log(
-          `crawling::${data.numScanned || 0}::${status}::${
+        const msg = `crawling::${data.numScanned || 0}::${status}::${
             data.urlScanned || 'no url provided'
-          }`,
-        );
+          }`;
+        console.log(msg);
+        silentLogger.info(msg);
         break;
       default:
         console.log(`Status provided to gui info log not recognized: ${status}`);
@@ -64,4 +88,6 @@ export const guiInfoLog = (status: string, data: { numScanned?: number; urlScann
   }
 };
 
+consoleLogger.info(`Logger writing to: ${errorsTxtPath}`);
+
 export { logFormat, consoleLogger, silentLogger };

package/src/mergeAxeResults.ts

@@ -14,7 +14,7 @@ import { Base64Encode } from 'base64-stream';
 import { pipeline } from 'stream/promises';
 // @ts-ignore
 import * as Sentry from '@sentry/node';
-import constants, { ScannerTypes, sentryConfig, setSentryUser } from './constants/constants.js';
+import constants, { BrowserTypes, ScannerTypes, sentryConfig, setSentryUser } from './constants/constants.js';
 import { getBrowserToRun, getPlaywrightLaunchOptions } from './constants/common.js';
 
 import {
@@ -29,6 +29,7 @@ import {
   getWcagCriteriaMap,
   categorizeWcagCriteria,
   getUserDataTxt,
+  register
 } from './utils.js';
 import { consoleLogger, silentLogger } from './logs.js';
 import itemTypeDescription from './constants/itemTypeDescription.js';
@@ -961,8 +962,6 @@ const writeScanDetailsCsv = async (
   });
 };
 
-let browserChannel = getBrowserToRun().browserToRun;
-
 const writeSummaryPdf = async (storagePath: string, pagesScanned: number, filename = 'summary', browser: string, userDataDirectory: string) => {
   const htmlFilePath = `${storagePath}/${filename}.html`;
   const fileDestinationPath = `${storagePath}/${filename}.pdf`;
@@ -975,6 +974,8 @@ const writeSummaryPdf = async (storagePath: string, pagesScanned: number, filena
         ...getPlaywrightLaunchOptions(browser),
       });
 
+  register(context);
+
   const page = await context.newPage();
 
   const data = fs.readFileSync(htmlFilePath, { encoding: 'utf-8' });
@@ -1710,9 +1711,9 @@ const generateArtifacts = async (
   zip: string = undefined, // optional
   generateJsonFiles = false,
 ) => {
-  const intermediateDatasetsPath = `${getStoragePath(randomToken)}/crawlee`;
-  const oobeeAppVersion = getVersion();
   const storagePath = getStoragePath(randomToken);
+  const intermediateDatasetsPath = `${storagePath}/crawlee`;
+  const oobeeAppVersion = getVersion();
 
   const formatAboutStartTime = (dateString: string) => {
     const utcStartTimeDate = new Date(dateString);
@@ -1982,15 +1983,21 @@ const generateArtifacts = async (
     ]);
   }
 
+  let browserChannel = getBrowserToRun(randomToken, BrowserTypes.CHROME, false).browserToRun;
+
   // Should consider refactor constants.userDataDirectory to be a parameter in future
   await retryFunction(() => writeSummaryPdf(storagePath, pagesScanned.length, 'summary', browserChannel, constants.userDataDirectory), 1);
 
-  const foldersToRemove = ['crawlee', 'logs'];
-  for (const folder of foldersToRemove) {
-    const folderPath = path.join(storagePath, folder);
-    if (await fs.pathExists(folderPath)) {
-      await fs.remove(folderPath);
-    }
+  try {
+    fs.rmSync(path.join(storagePath, 'crawlee'), { recursive: true, force: true });
+  } catch (error) {
+    consoleLogger.warn(`Unable to force remove crawlee folder: ${error.message}`);
+  }
+
+  try {
+    fs.rmSync(path.join(storagePath, 'pdfs'), { recursive: true, force: true });
+  } catch (error) {
+    consoleLogger.warn(`Unable to force remove pdfs folder: ${error.message}`);
   }
 
   // Take option if set
@@ -2000,6 +2007,11 @@ const generateArtifacts = async (
     if (!zip.endsWith('.zip')) {
       constants.cliZipFileName += '.zip';
     }
+
+  }
+
+  if (!path.isAbsolute(constants.cliZipFileName) || path.dirname(constants.cliZipFileName) === '.') {
+    constants.cliZipFileName = path.join(storagePath, constants.cliZipFileName);
   }
 
   await fs

package/src/npmIndex.ts

@@ -12,7 +12,7 @@ import {
   submitForm,
 } from './constants/common.js';
 import { createCrawleeSubFolders, filterAxeResults } from './crawlers/commonCrawlerFunc.js';
-import { createAndUpdateResultsFolders, createDetailsAndLogs } from './utils.js';
+import { createAndUpdateResultsFolders } from './utils.js';
 import generateArtifacts from './mergeAxeResults.js';
 import { takeScreenshotForHTMLElements } from './screenshotFunc/htmlScreenshotFunc.js';
 import { consoleLogger, silentLogger } from './logs.js';
@@ -205,7 +205,7 @@ export const init = async ({
     throwErrorIfTerminated();
     if (includeScreenshots) {
       // use chrome by default
-      const { browserToRun, clonedBrowserDataDir } = getBrowserToRun(BrowserTypes.CHROME, false, randomToken);
+      const { browserToRun, clonedBrowserDataDir } = getBrowserToRun(randomToken, BrowserTypes.CHROME, false);
       const browserContext = await constants.launcher.launchPersistentContext(
         clonedBrowserDataDir,
         { viewport: viewportSettings, ...getPlaywrightLaunchOptions(browserToRun) },
@@ -271,7 +271,6 @@ export const init = async ({
     if (urlsCrawled.scanned.length === 0) {
       printMessage([`No pages were scanned.`], alertMessageOptions);
     } else {
-      await createDetailsAndLogs(randomToken);
       await createAndUpdateResultsFolders(randomToken);
       const pagesNotScanned = [
         ...scanDetails.urlsCrawled.error,

package/src/proxyService.ts

@@ -0,0 +1,405 @@
+// getProxyInfo.ts
+// Cross-platform proxy detector for Playwright/Chromium with PAC + credentials + macOS Keychain support.
+//
+// Windows: WinINET registry (HKCU → HKLM)
+// macOS: env vars first, then `scutil --proxy` (reads per-protocol usernames/passwords;
+//         if password is missing, fetch it from Keychain via `/usr/bin/security`)
+// Linux/others: env vars only
+//
+// Output precedence in proxyInfoToArgs():
+//   1) pacUrl → ["--proxy-pac-url=<url>", ...bypass]
+//   2) manual proxies → ["--proxy-server=...", ...bypass] (embeds creds if provided/available)
+//   3) autoDetect → ["--proxy-auto-detect", ...bypass]
+
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+
+export interface ProxyInfo {
+  // host:port OR user:pass@host:port (no scheme)
+  http?: string;
+  https?: string;
+  socks?: string;
+  // PAC + autodetect
+  pacUrl?: string;
+  autoDetect?: boolean;
+  // optional bypass list (semicolon-separated)
+  bypassList?: string;
+  // optional global credentials to embed (URL-encoded)
+  username?: string;
+  password?: string;
+}
+
+export interface ProxySettings {
+  server: string;
+  username?: string;
+  password?: string;
+  bypass?: string;
+}
+
+// New discriminated union that the launcher can switch on
+export type ProxyResolution =
+  | { kind: 'manual'; settings: ProxySettings }   // Playwright proxy option
+  | { kind: 'pac'; pacUrl: string; bypass?: string } // Use --proxy-pac-url
+  | { kind: 'none' };    
+
+/* ============================ helpers ============================ */
+
+function stripScheme(u: string): string {
+  return u.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, '');
+}
+function semiJoin(arr?: string[]): string | undefined {
+  if (!arr) return undefined;
+  const cleaned = arr.map(s => s.trim()).filter(Boolean);
+  return cleaned.length ? cleaned.join(';') : undefined;
+}
+function readCredsFromEnv(): { username?: string; password?: string } {
+  const username = process.env.PROXY_USERNAME || process.env.HTTP_PROXY_USERNAME || undefined;
+  const password = process.env.PROXY_PASSWORD || process.env.HTTP_PROXY_PASSWORD || undefined;
+  return { username, password };
+}
+function hasUserinfo(v: string | undefined): boolean {
+  return !!(v && /@/.test(v.split('/')[0]));
+}
+function pick(map: Record<string, string>, keys: string[]): string | undefined {
+  for (const k of keys) {
+    const v = map[k];
+    if (v && String(v).trim().length) return String(v).trim();
+  }
+  return undefined;
+}
+function extractHost(valueHostPort: string): string {
+  // valueHostPort may be "user:pass@host:port" or "host:port"
+  const noUser = valueHostPort.includes('@') ? valueHostPort.split('@', 2)[1] : valueHostPort;
+  return noUser.split(':', 2)[0];
+}
+
+/* ============================ env (macOS + Linux) ============================ */
+
+function parseEnvProxyCommon(): ProxyInfo | null {
+  const http = process.env.HTTP_PROXY || process.env.http_proxy || '';
+  const https = process.env.HTTPS_PROXY || process.env.https_proxy || '';
+  const socks = process.env.ALL_PROXY || process.env.all_proxy || '';
+  const noProxy = process.env.NO_PROXY || process.env.no_proxy || '';
+
+  const info: ProxyInfo = {};
+  if (http) info.http = stripScheme(http);
+  if (https) info.https = stripScheme(https);
+  if (socks) info.socks = stripScheme(socks);
+  if (noProxy) info.bypassList = semiJoin(noProxy.split(/[,;]/));
+
+  const { username, password } = readCredsFromEnv();
+  if (username && password) { info.username = username; info.password = password; }
+
+  return (info.http || info.https || info.socks || info.bypassList) ? info : null;
+}
+
+/* ============================ macOS Keychain ============================ */
+/**
+ * Try to read an Internet Password from macOS Keychain for a given host/account.
+ * We intentionally avoid passing any user-controlled strings; host/account come from scutil.
+ * Returns the password (raw) or undefined.
+ */
+export function keychainFindInternetPassword(host: string, account?: string): string | undefined {
+  console.log("Attempting to find internet proxy password in macOS keychain...");
+
+  // Only attempt on macOS, in an interactive session, or when explicitly allowed.
+  if (process.platform !== 'darwin') return undefined;
+  const allow = process.stdin.isTTY || process.env.ENABLE_KEYCHAIN_LOOKUP === '1';
+  if (!allow) return undefined;
+
+  const SECURITY_BIN = '/usr/bin/security';
+  const OUTPUT_LIMIT = 64 * 1024; // 64 KiB
+
+  // Verify absolute binary and realpath
+  try {
+    if (!fs.existsSync(SECURITY_BIN)) return undefined;
+    const real = fs.realpathSync(SECURITY_BIN);
+    if (real !== SECURITY_BIN) return undefined;
+  } catch {
+    return undefined;
+  }
+
+  // Minimal sanitized env (avoid proxy/env influence)
+  const env = {
+    PATH: '/usr/bin:/bin',
+    http_proxy: '', https_proxy: '', all_proxy: '', no_proxy: '',
+    HTTP_PROXY: '', HTTPS_PROXY: '', ALL_PROXY: '', NO_PROXY: '',
+    NODE_OPTIONS: '', NODE_PATH: '', DYLD_LIBRARY_PATH: '', LD_LIBRARY_PATH: '',
+  } as NodeJS.ProcessEnv;
+
+  const baseArgs = ['find-internet-password', '-s', host, '-w'];
+  const args = account ? [...baseArgs, '-a', account] : baseArgs;
+
+  // No timeout: allow user to respond to Keychain prompt
+  const res = spawnSync(SECURITY_BIN, args, {
+    encoding: 'utf8',
+    windowsHide: true,
+    shell: false,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (!res.error && res.status === 0 && res.stdout) {
+    const out = res.stdout.slice(0, OUTPUT_LIMIT).replace(/\r?\n$/, '');
+    return out || undefined;
+  }
+
+  // Retry without account if first try used one
+  if (account) {
+    const retry = spawnSync(SECURITY_BIN, baseArgs, {
+      encoding: 'utf8',
+      windowsHide: true,
+      shell: false,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (!retry.error && retry.status === 0 && retry.stdout) {
+      const out = retry.stdout.slice(0, OUTPUT_LIMIT).replace(/\r?\n$/, '');
+      return out || undefined;
+    }
+  }
+
+  // Common Keychain errors you may see in retry.stderr:
+  // - "User interaction is not allowed." (Keychain locked / non-interactive / no UI permission)
+  // - "The specified item could not be found in the keychain."
+  return undefined;
+}
+
+/* ============================ macOS fallback (scutil) ============================ */
+
+function parseMacScutil(): ProxyInfo | null {
+  const out = spawnSync('/usr/sbin/scutil', ['--proxy'], {
+    encoding: 'utf8',
+    windowsHide: true,
+    shell: false,
+  });
+  if (out.error || !out.stdout) return null;
+
+  const map: Record<string, string> = {};
+  for (const line of out.stdout.split(/\r?\n/)) {
+    const m = line.match(/^\s*([A-Za-z0-9]+)\s*:\s*(.+?)\s*$/);
+    if (m) map[m[1]] = m[2];
+  }
+
+  const info: ProxyInfo = {};
+
+  // PAC + autodetect
+  if (map['ProxyAutoConfigEnable'] === '1' && map['ProxyAutoConfigURLString']) {
+    info.pacUrl = map['ProxyAutoConfigURLString'].trim();
+  }
+  if (map['ProxyAutoDiscoveryEnable'] === '1') info.autoDetect = true;
+
+  // Collect per-protocol creds (Apple keys vary by macOS version)
+  const httpUser = pick(map, ['HTTPProxyUsername', 'HTTPUser', 'HTTPUsername']);
+  let   httpPass = pick(map, ['HTTPProxyPassword', 'HTTPPassword']);
+  const httpsUser = pick(map, ['HTTPSProxyUsername', 'HTTPSUser', 'HTTPSUsername']);
+  let   httpsPass = pick(map, ['HTTPSProxyPassword', 'HTTPSPassword']);
+  const socksUser = pick(map, ['SOCKSProxyUsername', 'SOCKSUser', 'SOCKSUsername']);
+  let   socksPass = pick(map, ['SOCKSProxyPassword', 'SOCKSPassword']);
+
+  // Manual proxies (always set host:port only; never include creds)
+  if (map['HTTPEnable'] === '1' && map['HTTPProxy'] && map['HTTPPort']) {
+    const hostPort = `${map['HTTPProxy']}:${map['HTTPPort']}`;
+    info.http = hostPort;
+    // If macOS has username but no password, try Keychain for this host/account
+    if (httpUser && !httpPass) httpPass = keychainFindInternetPassword(extractHost(hostPort), httpUser);
+  }
+
+  if (map['HTTPSEnable'] === '1' && map['HTTPSProxy'] && map['HTTPSPort']) {
+    const hostPort = `${map['HTTPSProxy']}:${map['HTTPSPort']}`;
+    info.https = hostPort;
+    if (httpsUser && !httpsPass) httpsPass = keychainFindInternetPassword(extractHost(hostPort), httpsUser);
+  }
+
+  if (map['SOCKSEnable'] === '1' && map['SOCKSProxy'] && map['SOCKSPort']) {
+    const hostPort = `${map['SOCKSProxy']}:${map['SOCKSPort']}`;
+    info.socks = hostPort;
+    if (socksUser && !socksPass) socksPass = keychainFindInternetPassword(extractHost(hostPort), socksUser);
+  }
+
+  // Choose one set of creds to expose globally: prefer HTTP, else HTTPS, else SOCKS
+  // (Do not overwrite if env already provided username/password.)
+  if (!info.username && !info.password) {
+    if (httpUser && httpPass) {
+      info.username = httpUser;
+      info.password = httpPass;
+    } else if (httpsUser && httpsPass) {
+      info.username = httpsUser;
+      info.password = httpsPass;
+    } else if (socksUser && socksPass) {
+      info.username = socksUser;
+      info.password = socksPass;
+    }
+  }
+
+  // Bypass list
+  let exceptions: string[] = [];
+  if (map['ExceptionsList']) {
+    const quoted = [...map['ExceptionsList'].matchAll(/"([^"]+)"/g)].map(m => m[1]);
+    exceptions = quoted.length
+      ? quoted
+      : map['ExceptionsList'].replace(/[<>{}()]/g, ' ')
+          .split(/[,\s]+/).map(s => s.trim()).filter(Boolean);
+  }
+  if (map['ExcludeSimpleHostnames'] === '1' && !exceptions.includes('<local>')) exceptions.unshift('<local>');
+  const bypassList = semiJoin(exceptions);
+  if (bypassList) info.bypassList = bypassList;
+
+  // If scutil did not provide creds anywhere, still allow env creds as global fallback
+  if ((!info.username || !info.password)) {
+    const envCreds = readCredsFromEnv();
+    if (envCreds.username && envCreds.password) {
+      info.username = info.username || envCreds.username;
+      info.password = info.password || envCreds.password;
+    }
+  }
+
+  return (info.pacUrl || info.http || info.https || info.socks || info.autoDetect || info.bypassList) ? info : null;
+}
+
+/* ============================ Windows (Registry only) ============================ */
+
+function regExeCandidates(): string[] {
+  const root = process.env.SystemRoot || 'C:\\Windows';
+  const sys32 = path.join(root, 'System32', 'reg.exe');
+  const syswow64 = path.join(root, 'SysWOW64', 'reg.exe');
+  const sysnative = path.join(root, 'Sysnative', 'reg.exe'); // for 32-bit node on 64-bit OS
+  const set = new Set([sysnative, sys32, syswow64]);
+  return [...set].filter(p => p && fs.existsSync(p));
+}
+function execReg(args: string[]): string | null {
+  for (const exe of regExeCandidates()) {
+    const out = spawnSync(exe, args, {
+      encoding: 'utf8',
+      windowsHide: true,
+      shell: false,
+    });
+    if (!out.error && out.stdout) return out.stdout;
+  }
+  return null;
+}
+
+type WinVals = {
+  ProxyEnable?: string;
+  ProxyServer?: string;
+  ProxyOverride?: string;
+  AutoConfigURL?: string;
+  AutoDetect?: string;
+};
+
+function readRegVals(hiveKey: string): WinVals | null {
+  const stdout = execReg(['query', hiveKey]);
+  if (!stdout) return null;
+
+  const take = (name: string) => {
+    const m = stdout.match(new RegExp(`\\s${name}\\s+REG_\\w+\\s+(.+)$`, 'mi'));
+    return m ? m[1].trim() : '';
+  };
+
+  return {
+    ProxyEnable:   take('ProxyEnable'),
+    ProxyServer:   take('ProxyServer'),
+    ProxyOverride: take('ProxyOverride'),
+    AutoConfigURL: take('AutoConfigURL'),
+    AutoDetect:    take('AutoDetect'),
+  };
+}
+
+function parseWindowsRegistry(): ProxyInfo | null {
+  const HKCU = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings';
+  const HKLM = 'HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings';
+
+  const cu = readRegVals(HKCU);
+  const lm = readRegVals(HKLM);
+  const v = cu || lm;
+  if (!v) return null;
+
+  const info: ProxyInfo = {};
+  const enabledManual = !!v.ProxyEnable && v.ProxyEnable !== '0' && v.ProxyEnable.toLowerCase() !== '0x0';
+  const enabledAuto   = !!v.AutoDetect && v.AutoDetect !== '0' && v.AutoDetect.toLowerCase() !== '0x0';
+  const anyEnabled    = enabledManual || enabledAuto || !!v.AutoConfigURL;
+
+  // PAC + autodetect (only when something is actually enabled)
+  if (v.AutoConfigURL) info.pacUrl = v.AutoConfigURL.trim(); // PAC stands on its own
+  if (enabledAuto) info.autoDetect = true;                    // autodetect still gated
+
+  // Manual proxies
+  if (enabledManual && v.ProxyServer) {
+    const s = v.ProxyServer.trim();
+    if (s.includes('=')) {
+      for (const part of s.split(';')) {
+        const [proto, addr] = part.split('=');
+        if (!proto || !addr) continue;
+        const p = proto.trim().toLowerCase();
+        const a = stripScheme(addr.trim());
+        if (p === 'http') info.http = a;
+        else if (p === 'https') info.https = a;
+        else if (p === 'socks' || p === 'socks5') info.socks = a;
+      }
+    } else {
+      const a = stripScheme(s);
+      info.http = a;
+      info.https = a;
+    }
+  }
+
+  // Bypass list
+  if (anyEnabled && v.ProxyOverride) info.bypassList = semiJoin(v.ProxyOverride.split(/[,;]/));
+
+  // Env creds as global fallback (Windows does not store proxy creds in ProxyServer)
+  const { username, password } = readCredsFromEnv();
+  if (username && password) { info.username = username; info.password = password; }
+
+  return (info.pacUrl || info.http || info.https || info.socks || info.autoDetect || info.bypassList) ? info : null;
+}
+
+/* ============================ Public API ============================ */
+
+export function getProxyInfo(): ProxyInfo | null {
+  const plat = os.platform();
+  if (plat === 'win32') return parseEnvProxyCommon() || parseWindowsRegistry();
+  if (plat === 'darwin') return parseEnvProxyCommon() || parseMacScutil();
+  return parseEnvProxyCommon(); // Linux/others
+}
+
+export function proxyInfoToResolution(info: ProxyInfo | null): ProxyResolution {
+  if (!info) return { kind: 'none' };
+
+  // Prefer manual proxies first (these work with Playwright's proxy option)
+  if (info.http) {
+    return { kind: 'manual', settings: {
+      server: `http://${info.http}`,
+      username: info.username,
+      password: info.password,
+      bypass: info.bypassList,
+    }};
+  }
+  if (info.https) {
+    return { kind: 'manual', settings: {
+      server: `http://${info.https}`,
+      username: info.username,
+      password: info.password,
+      bypass: info.bypassList,
+    }};
+  }
+  if (info.socks) {
+    return { kind: 'manual', settings: {
+      server: `socks5://${info.socks}`,
+      username: info.username,
+      password: info.password,
+      bypass: info.bypassList,
+    }};
+  }
+
+  // PAC → handle via Chromium args; do NOT try proxy.server = 'pac+...'
+  if (info.pacUrl) {
+    // Minor hardening: prefer 127.0.0.1 over localhost for loopback PAC
+    const pacUrl = info.pacUrl.replace('://localhost', '://127.0.0.1');
+    return { kind: 'pac', pacUrl, bypass: info.bypassList };
+  }
+
+  // Auto-detect not supported directly
+  return { kind: 'none' };
+}

package/src/screenshotFunc/htmlScreenshotFunc.ts

@@ -22,7 +22,7 @@ export const takeScreenshotForHTMLElements = async (
   for (const violation of violations) {
     if (screenshotCount >= maxScreenshots) {
       /*
-      silentLogger.warn(
+      consoleLogger.warn(
         `Skipping screenshots for ${violation.id} as maxScreenshots (${maxScreenshots}) exceeded. You can increase it by specifying a higher value when calling takeScreenshotForHTMLElements.`,
       );
       */
@@ -34,7 +34,7 @@ export const takeScreenshotForHTMLElements = async (
 
     // Check if rule ID is 'oobee-grading-text-contents' and skip screenshot logic
     if (rule === 'oobee-grading-text-contents') {
-      // silentLogger.info('Skipping screenshot for rule oobee-grading-text-contents');
+      // consoleLogger.info('Skipping screenshot for rule oobee-grading-text-contents');
       newViolations.push(violation); // Make sure it gets added
       continue;
     }
@@ -59,13 +59,13 @@ export const takeScreenshotForHTMLElements = async (
               nodeWithScreenshotPath.screenshotPath = screenshotPath;
               screenshotCount++;
             } else {
-              // silentLogger.info(`Element at ${currLocator} is not visible`);
+              // consoleLogger.info(`Element at ${currLocator} is not visible`);
             }
 
             break; // Stop looping after finding the first visible locator
           }
         } catch (e) {
-          // silentLogger.info(`Unable to take element screenshot at ${selector}`);
+          // consoleLogger.info(`Unable to take element screenshot at ${selector}`);
         }
       }
       newViolationNodes.push(nodeWithScreenshotPath);