@firekid/scraper 1.0.1

package/dist/index.cjs

@@ -0,0 +1,2145 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/config.ts
+function getConfig() {
+  return config;
+}
+function updateConfig(updates) {
+  Object.assign(config, updates);
+}
+var import_dotenv, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_dotenv = __toESM(require("dotenv"));
+    import_dotenv.default.config();
+    config = {
+      browser: {
+        headless: process.env.HEADLESS === "true",
+        timeout: parseInt(process.env.BROWSER_TIMEOUT || "30000", 10),
+        maxWorkers: parseInt(process.env.MAX_QUEUE_WORKERS || "5", 10)
+      },
+      cloudflare: {
+        bypass: process.env.CF_BYPASS || "auto",
+        turnstileSolver: process.env.TURNSTILE_SOLVER || "manual"
+      },
+      captcha: {
+        apiKey: process.env.CAPTCHA_API_KEY || ""
+      },
+      server: {
+        enabled: process.env.API_ENABLED === "true",
+        port: parseInt(process.env.API_PORT || "3000", 10),
+        apiKey: process.env.API_KEY || ""
+      },
+      proxy: {
+        enabled: process.env.PROXY_ENABLED === "true",
+        url: process.env.PROXY_URL || ""
+      },
+      storage: {
+        dataDir: process.env.DATA_DIR || "./data",
+        patternsDb: process.env.PATTERNS_DB || "./data/patterns.db",
+        sessionsDb: process.env.SESSIONS_DB || "./data/sessions.db"
+      },
+      logging: {
+        level: process.env.LOG_LEVEL || "info"
+      },
+      recording: {
+        autoHideAfterSolve: process.env.AUTO_HIDE_AFTER_SOLVE !== "false",
+        recordScreenshots: process.env.RECORD_SCREENSHOTS === "true"
+      },
+      rateLimit: {
+        enabled: process.env.RATE_LIMIT_ENABLED !== "false",
+        max: parseInt(process.env.RATE_LIMIT_MAX || "100", 10),
+        window: parseInt(process.env.RATE_LIMIT_WINDOW || "3600000", 10)
+      },
+      advanced: {
+        enableTelemetry: process.env.ENABLE_TELEMETRY === "true",
+        enableAnalytics: process.env.ENABLE_ANALYTICS === "true"
+      }
+    };
+  }
+});
+
+// src/logger/logger.ts
+function setLogLevel(level) {
+  logger.level = level;
+}
+function step(url, action, meta) {
+  logger.info(`[${url}] ${action}`, meta);
+}
+function highlight(url, data) {
+  logger.info(`[${url}] EXTRACTED:`, data);
+}
+var import_winston, logger;
+var init_logger = __esm({
+  "src/logger/logger.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_winston = __toESM(require("winston"));
+    init_config();
+    logger = import_winston.default.createLogger({
+      level: config.logging.level,
+      format: import_winston.default.format.combine(
+        import_winston.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        import_winston.default.format.errors({ stack: true }),
+        import_winston.default.format.splat(),
+        import_winston.default.format.printf(({ level, message, timestamp, ...meta }) => {
+          let msg = `${timestamp} [${level.toUpperCase()}] ${message}`;
+          if (Object.keys(meta).length > 0) {
+            msg += ` ${JSON.stringify(meta)}`;
+          }
+          return msg;
+        })
+      ),
+      transports: [
+        new import_winston.default.transports.Console({
+          format: import_winston.default.format.combine(
+            import_winston.default.format.colorize(),
+            import_winston.default.format.printf(({ level, message, timestamp }) => {
+              return `${timestamp} ${level}: ${message}`;
+            })
+          )
+        }),
+        new import_winston.default.transports.File({
+          filename: "logs/error.log",
+          level: "error"
+        }),
+        new import_winston.default.transports.File({
+          filename: "logs/combined.log"
+        })
+      ]
+    });
+  }
+});
+
+// src/network/smart-fetch.ts
+var import_fs2, import_path2, SmartFetch;
+var init_smart_fetch = __esm({
+  "src/network/smart-fetch.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    import_fs2 = __toESM(require("fs"));
+    import_path2 = __toESM(require("path"));
+    SmartFetch = class {
+      pageContext = null;
+      lastReferer = "";
+      setPageContext(page) {
+        this.pageContext = page;
+      }
+      async fetch(options) {
+        const {
+          url,
+          referer,
+          autoReferer = true,
+          method = "GET",
+          headers = {},
+          cookies = {},
+          body,
+          followRedirects = true,
+          timeout = 3e4
+        } = options;
+        const finalReferer = referer || (autoReferer && this.pageContext ? this.pageContext.url() : this.lastReferer);
+        const finalHeaders = {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+          "Accept": "*/*",
+          ...headers
+        };
+        if (finalReferer) {
+          finalHeaders["Referer"] = finalReferer;
+          logger.info(`[smart-fetch] Auto-Referer: ${finalReferer}`);
+        }
+        if (Object.keys(cookies).length > 0) {
+          const cookieString = Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join("; ");
+          finalHeaders["Cookie"] = cookieString;
+        }
+        logger.info(`[smart-fetch] ${method} ${url}`);
+        try {
+          const response = await fetch(url, {
+            method,
+            headers: finalHeaders,
+            body: body ? JSON.stringify(body) : void 0,
+            redirect: followRedirects ? "follow" : "manual",
+            signal: AbortSignal.timeout(timeout)
+          });
+          const contentType = response.headers.get("content-type") || "";
+          let data;
+          if (contentType.includes("application/json")) {
+            data = await response.json();
+          } else if (contentType.includes("text")) {
+            data = await response.text();
+          } else {
+            data = await response.arrayBuffer();
+          }
+          this.lastReferer = url;
+          const headersObj = {};
+          response.headers.forEach((value, key) => {
+            headersObj[key] = value;
+          });
+          return {
+            status: response.status,
+            headers: headersObj,
+            data
+          };
+        } catch (err) {
+          logger.error(`[smart-fetch] Failed: ${err.message}`);
+          throw err;
+        }
+      }
+      async download(url, outputPath, referer) {
+        logger.info(`[smart-fetch] Downloading ${url} to ${outputPath}`);
+        const response = await this.fetch({
+          url,
+          referer,
+          autoReferer: true
+        });
+        const dir = import_path2.default.dirname(outputPath);
+        if (!import_fs2.default.existsSync(dir)) {
+          import_fs2.default.mkdirSync(dir, { recursive: true });
+        }
+        if (response.data instanceof ArrayBuffer) {
+          import_fs2.default.writeFileSync(outputPath, Buffer.from(response.data));
+        } else if (typeof response.data === "string") {
+          import_fs2.default.writeFileSync(outputPath, response.data);
+        } else {
+          import_fs2.default.writeFileSync(outputPath, JSON.stringify(response.data));
+        }
+        logger.info(`[smart-fetch] Downloaded to ${outputPath}`);
+      }
+      getLastReferer() {
+        return this.lastReferer;
+      }
+    };
+  }
+});
+
+// src/modes/downloader.ts
+var DownloaderMode;
+var init_downloader = __esm({
+  "src/modes/downloader.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    init_smart_fetch();
+    DownloaderMode = class {
+      page;
+      smartFetch;
+      constructor(page) {
+        this.page = page;
+        this.smartFetch = new SmartFetch();
+        this.smartFetch.setPageContext(page);
+      }
+      async execute(url) {
+        logger.info("[downloader-mode] Analyzing download flow...");
+        const flow = await this.detectDownloadFlow();
+        if (!flow) {
+          return {
+            success: false,
+            data: {},
+            errors: ["No download flow detected"],
+            timestamp: Date.now()
+          };
+        }
+        logger.info(`[downloader-mode] Flow type: ${flow.type}`);
+        try {
+          let downloadedFiles = [];
+          if (flow.type === "DIRECT" && flow.links) {
+            downloadedFiles = await this.downloadDirectLinks(flow.links);
+          } else if (flow.type === "BUTTON_CLICK" && flow.button) {
+            downloadedFiles = await this.downloadViaButton(flow.button);
+          }
+          return {
+            success: true,
+            data: {
+              flow: flow.type,
+              files: downloadedFiles
+            },
+            errors: [],
+            timestamp: Date.now()
+          };
+        } catch (err) {
+          return {
+            success: false,
+            data: {},
+            errors: [err.message],
+            timestamp: Date.now()
+          };
+        }
+      }
+      async detectDownloadFlow() {
+        const directLinks = await this.findDirectLinks();
+        if (directLinks.length > 0) {
+          return {
+            type: "DIRECT",
+            steps: ["Found direct download links"],
+            links: directLinks
+          };
+        }
+        const downloadButton = await this.findDownloadButton();
+        if (downloadButton) {
+          return {
+            type: "BUTTON_CLICK",
+            steps: ["Click download button", "Wait for file"],
+            button: downloadButton
+          };
+        }
+        return null;
+      }
+      async findDirectLinks() {
+        return await this.page.evaluate(() => {
+          const links = Array.from(document.querySelectorAll("a[href]"));
+          const fileLinks = [];
+          const fileExtensions = /\.(mp4|mp3|pdf|zip|rar|exe|dmg|apk|avi|mkv|mov|wav|flac)$/i;
+          for (const link of links) {
+            const href = link.href;
+            if (href && fileExtensions.test(href)) {
+              const selector = link.id ? `#${link.id}` : `a[href="${href}"]`;
+              const ext = href.match(fileExtensions)?.[1];
+              fileLinks.push({
+                url: href,
+                selector,
+                extension: ext
+              });
+            }
+          }
+          return fileLinks;
+        });
+      }
+      async findDownloadButton() {
+        const buttons = await this.page.evaluate(() => {
+          const candidates = Array.from(document.querySelectorAll('button, a, [class*="download"]'));
+          const scored = [];
+          for (const el of candidates) {
+            const text = (el.textContent || "").toLowerCase();
+            const className = (el.className || "").toLowerCase();
+            const href = el.href;
+            let score = 0;
+            if (text.includes("download")) score += 10;
+            if (className.includes("download")) score += 10;
+            if (el.hasAttribute("download")) score += 20;
+            if (href && href.includes("download")) score += 5;
+            if (text.includes("get")) score += 3;
+            if (text.includes("save")) score += 3;
+            if (score > 0) {
+              const selector = el.id ? `#${el.id}` : el.tagName.toLowerCase();
+              scored.push({ selector, score, text, href });
+            }
+          }
+          return scored.sort((a, b) => b.score - a.score);
+        });
+        return buttons.length > 0 ? buttons[0] : null;
+      }
+      async downloadDirectLinks(links) {
+        const downloaded = [];
+        for (const link of links) {
+          const filename = `download-${Date.now()}.${link.extension || "bin"}`;
+          const outputPath = `./downloads/${filename}`;
+          logger.info(`[downloader-mode] Downloading ${link.url}`);
+          await this.smartFetch.download(link.url, outputPath);
+          downloaded.push(outputPath);
+        }
+        return downloaded;
+      }
+      async downloadViaButton(button) {
+        logger.info(`[downloader-mode] Clicking download button: ${button.selector}`);
+        const [download] = await Promise.all([
+          this.page.waitForEvent("download"),
+          this.page.click(button.selector)
+        ]);
+        const filename = download.suggestedFilename();
+        const outputPath = `./downloads/${filename}`;
+        await download.saveAs(outputPath);
+        logger.info(`[downloader-mode] Saved to ${outputPath}`);
+        return [outputPath];
+      }
+    };
+  }
+});
+
+// src/modes/scrape.ts
+var ScrapeMode;
+var init_scrape = __esm({
+  "src/modes/scrape.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    ScrapeMode = class {
+      page;
+      constructor(page) {
+        this.page = page;
+      }
+      async execute(url) {
+        logger.info("[scrape-mode] Extracting content...");
+        try {
+          const data = await this.extractContent();
+          return {
+            success: true,
+            data,
+            errors: [],
+            timestamp: Date.now()
+          };
+        } catch (err) {
+          return {
+            success: false,
+            data: {},
+            errors: [err.message],
+            timestamp: Date.now()
+          };
+        }
+      }
+      async extractContent() {
+        return await this.page.evaluate(() => {
+          const result = {};
+          const title = document.querySelector("h1")?.textContent?.trim();
+          if (title) result.title = title;
+          const description = document.querySelector('meta[name="description"]')?.getAttribute("content");
+          if (description) result.description = description;
+          const images = Array.from(document.querySelectorAll("img[src]")).map((img) => img.src).filter(Boolean);
+          if (images.length > 0) result.images = images;
+          const links = Array.from(document.querySelectorAll("a[href]")).map((a) => ({
+            text: a.textContent?.trim(),
+            href: a.href
+          })).filter((l) => l.text && l.href);
+          if (links.length > 0) result.links = links;
+          const paragraphs = Array.from(document.querySelectorAll("p")).map((p) => p.textContent?.trim()).filter(Boolean);
+          if (paragraphs.length > 0) result.content = paragraphs;
+          return result;
+        });
+      }
+    };
+  }
+});
+
+// src/modes/navigator.ts
+var NavigatorMode;
+var init_navigator = __esm({
+  "src/modes/navigator.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    NavigatorMode = class {
+      page;
+      constructor(page) {
+        this.page = page;
+      }
+      async execute(url) {
+        logger.info("[navigator-mode] Mapping site structure...");
+        try {
+          const siteMap = await this.buildSiteMap();
+          return {
+            success: true,
+            data: siteMap,
+            errors: [],
+            timestamp: Date.now()
+          };
+        } catch (err) {
+          return {
+            success: false,
+            data: {},
+            errors: [err.message],
+            timestamp: Date.now()
+          };
+        }
+      }
+      async buildSiteMap() {
+        const currentUrl = this.page.url();
+        const structure = await this.page.evaluate(() => {
+          const nav = document.querySelector("nav");
+          const menu = document.querySelector('[class*="menu"]');
+          const header = document.querySelector("header");
+          const navLinks = nav || menu || header;
+          const links = [];
+          if (navLinks) {
+            const anchors = navLinks.querySelectorAll("a[href]");
+            for (const a of anchors) {
+              const text = a.textContent?.trim();
+              const href = a.href;
+              if (text && href) {
+                links.push({ text, href });
+              }
+            }
+          }
+          return {
+            title: document.title,
+            url: window.location.href,
+            navigation: links,
+            sections: Array.from(document.querySelectorAll("section, article")).length
+          };
+        });
+        return structure;
+      }
+    };
+  }
+});
+
+// src/modes/auto.ts
+var auto_exports = {};
+__export(auto_exports, {
+  AutoMode: () => AutoMode
+});
+var AutoMode;
+var init_auto = __esm({
+  "src/modes/auto.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    init_downloader();
+    init_scrape();
+    init_navigator();
+    AutoMode = class {
+      page;
+      constructor(page) {
+        this.page = page;
+      }
+      async execute(url) {
+        logger.info("[auto-mode] Analyzing site...");
+        const mode = await this.detectBestMode();
+        logger.info(`[auto-mode] Selected mode: ${mode}`);
+        let result;
+        switch (mode) {
+          case "downloader":
+            const downloader = new DownloaderMode(this.page);
+            result = await downloader.execute(url);
+            break;
+          case "scrape":
+            const scraper = new ScrapeMode(this.page);
+            result = await scraper.execute(url);
+            break;
+          case "navigator":
+            const navigator2 = new NavigatorMode(this.page);
+            result = await navigator2.execute(url);
+            break;
+          default:
+            result = {
+              success: false,
+              data: {},
+              errors: ["Unknown mode"],
+              timestamp: Date.now()
+            };
+        }
+        return result;
+      }
+      async detectBestMode() {
+        const indicators = await this.page.evaluate(() => {
+          const hasDownloadButton = !!document.querySelector('a[download], button:has-text("Download")');
+          const hasVideoPlayer = !!document.querySelector('video, iframe[src*="youtube"], iframe[src*="vimeo"]');
+          const hasFileLinks = !!document.querySelector('a[href$=".mp4"], a[href$=".pdf"], a[href$=".zip"]');
+          const hasPagination = !!document.querySelector('.pagination, .next, [class*="page-"]');
+          const hasInfiniteScroll = document.body.scrollHeight > window.innerHeight * 3;
+          const hasForm = !!document.querySelector("form");
+          const hasSearch = !!document.querySelector('input[type="search"], input[placeholder*="search"]');
+          return {
+            hasDownloadButton,
+            hasVideoPlayer,
+            hasFileLinks,
+            hasPagination,
+            hasInfiniteScroll,
+            hasForm,
+            hasSearch
+          };
+        });
+        if (indicators.hasDownloadButton || indicators.hasVideoPlayer || indicators.hasFileLinks) {
+          return "downloader";
+        }
+        if (indicators.hasPagination || indicators.hasInfiniteScroll) {
+          return "scrape";
+        }
+        return "navigator";
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ActionRecorder: () => ActionRecorder,
+  CloudflareManager: () => CloudflareManager,
+  CommandExecutor: () => CommandExecutor,
+  CommandParser: () => CommandParser,
+  FirekidScraper: () => FirekidScraper,
+  PatternCache: () => PatternCache,
+  SmartFetch: () => SmartFetch,
+  applyGhost: () => applyGhost,
+  config: () => config,
+  getConfig: () => getConfig,
+  getNewSeed: () => getNewSeed,
+  getSeedForSite: () => getSeedForSite,
+  logger: () => logger,
+  setLogLevel: () => setLogLevel,
+  updateConfig: () => updateConfig
+});
+module.exports = __toCommonJS(src_exports);
+init_cjs_shims();
+
+// src/core/scraper.ts
+init_cjs_shims();
+var import_playwright = require("playwright");
+
+// src/ghost/index.ts
+init_cjs_shims();
+
+// src/ghost/seed.ts
+init_cjs_shims();
+var import_crypto = __toESM(require("crypto"));
+var seedCache = /* @__PURE__ */ new Map();
+var chromeVersions = [
+  "131.0.6778.85",
+  "131.0.6778.86",
+  "130.0.6723.116",
+  "129.0.6668.100"
+];
+var resolutions = [
+  { width: 1920, height: 1080 },
+  { width: 1366, height: 768 },
+  { width: 1536, height: 864 },
+  { width: 1440, height: 900 },
+  { width: 2560, height: 1440 }
+];
+var languages = ["en-US", "en-GB", "en", "es-ES", "fr-FR", "de-DE"];
+var timezones = ["America/New_York", "America/Los_Angeles", "Europe/London", "Europe/Paris"];
+var webglVendors = [
+  "Google Inc. (NVIDIA)",
+  "Google Inc. (Intel)",
+  "Google Inc. (AMD)",
+  "Google Inc. (Apple)"
+];
+var webglRenderers = [
+  "ANGLE (NVIDIA, NVIDIA GeForce RTX 3070 Direct3D11 vs_5_0 ps_5_0, D3D11)",
+  "ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)",
+  "ANGLE (AMD, AMD Radeon RX 580 Direct3D11 vs_5_0 ps_5_0, D3D11)"
+];
+var fontSets = [
+  ["Arial", "Calibri", "Cambria", "Consolas", "Georgia", "Times New Roman", "Verdana"],
+  ["Arial", "Helvetica", "Georgia", "Courier New", "Times", "Comic Sans MS"],
+  ["Arial", "Tahoma", "Trebuchet MS", "Verdana", "Georgia", "Palatino Linotype"]
+];
+function random(array) {
+  return array[Math.floor(Math.random() * array.length)];
+}
+function randomRange(min, max) {
+  return Math.random() * (max - min) + min;
+}
+function getNewSeed() {
+  const resolution = random(resolutions);
+  return {
+    id: import_crypto.default.randomUUID(),
+    chromeVersion: random(chromeVersions),
+    screenWidth: resolution.width,
+    screenHeight: resolution.height,
+    language: random(languages),
+    timezone: random(timezones),
+    canvasNoise: randomRange(1e-4, 1e-3),
+    webglVendor: random(webglVendors),
+    webglRenderer: random(webglRenderers),
+    audioNoise: randomRange(1e-5, 1e-4),
+    fonts: random(fontSets)
+  };
+}
+function getSeedForSite(siteHost) {
+  if (seedCache.has(siteHost)) {
+    return seedCache.get(siteHost);
+  }
+  const seed = getNewSeed();
+  seedCache.set(siteHost, seed);
+  return seed;
+}
+
+// src/ghost/canvas.ts
+init_cjs_shims();
+async function applyCanvasSpoof(context, seed) {
+  await context.addInitScript((noise) => {
+    const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
+    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+    const originalToBlob = HTMLCanvasElement.prototype.toBlob;
+    CanvasRenderingContext2D.prototype.getImageData = function(...args) {
+      const imageData = originalGetImageData.apply(this, args);
+      for (let i = 0; i < imageData.data.length; i += 4) {
+        imageData.data[i] += Math.floor(noise * 255 * (Math.random() - 0.5));
+        imageData.data[i + 1] += Math.floor(noise * 255 * (Math.random() - 0.5));
+        imageData.data[i + 2] += Math.floor(noise * 255 * (Math.random() - 0.5));
+      }
+      return imageData;
+    };
+    HTMLCanvasElement.prototype.toDataURL = function(...args) {
+      const context2 = this.getContext("2d");
+      if (context2) {
+        const imageData = context2.getImageData(0, 0, this.width, this.height);
+        context2.putImageData(imageData, 0, 0);
+      }
+      return originalToDataURL.apply(this, args);
+    };
+    HTMLCanvasElement.prototype.toBlob = function(...args) {
+      const context2 = this.getContext("2d");
+      if (context2) {
+        const imageData = context2.getImageData(0, 0, this.width, this.height);
+        context2.putImageData(imageData, 0, 0);
+      }
+      return originalToBlob.apply(this, args);
+    };
+  }, seed.canvasNoise);
+}
+
+// src/ghost/webgl.ts
+init_cjs_shims();
+async function applyWebGLSpoof(context, seed) {
+  await context.addInitScript((params) => {
+    const { vendor, renderer } = params;
+    const getParameterProxyHandler = {
+      apply(target, thisArg, args) {
+        const param = args[0];
+        if (param === 37445) {
+          return vendor;
+        }
+        if (param === 37446) {
+          return renderer;
+        }
+        return Reflect.apply(target, thisArg, args);
+      }
+    };
+    const getExtensionProxyHandler = {
+      apply(target, thisArg, args) {
+        const result = Reflect.apply(target, thisArg, args);
+        if (!result) {
+          return result;
+        }
+        if (args[0] === "WEBGL_debug_renderer_info") {
+          const getParameterProxy = new Proxy(result.getParameter, getParameterProxyHandler);
+          result.getParameter = getParameterProxy;
+        }
+        return result;
+      }
+    };
+    WebGLRenderingContext.prototype.getParameter = new Proxy(
+      WebGLRenderingContext.prototype.getParameter,
+      getParameterProxyHandler
+    );
+    WebGL2RenderingContext.prototype.getParameter = new Proxy(
+      WebGL2RenderingContext.prototype.getParameter,
+      getParameterProxyHandler
+    );
+    WebGLRenderingContext.prototype.getExtension = new Proxy(
+      WebGLRenderingContext.prototype.getExtension,
+      getExtensionProxyHandler
+    );
+    WebGL2RenderingContext.prototype.getExtension = new Proxy(
+      WebGL2RenderingContext.prototype.getExtension,
+      getExtensionProxyHandler
+    );
+  }, { vendor: seed.webglVendor, renderer: seed.webglRenderer });
+}
+
+// src/ghost/audio.ts
+init_cjs_shims();
+async function applyAudioSpoof(context, seed) {
+  await context.addInitScript((noise) => {
+    const context2 = window.AudioContext || window.webkitAudioContext;
+    if (context2) {
+      const originalCreateDynamicsCompressor = context2.prototype.createDynamicsCompressor;
+      const originalCreateOscillator = context2.prototype.createOscillator;
+      context2.prototype.createDynamicsCompressor = function() {
+        const compressor = originalCreateDynamicsCompressor.apply(this, arguments);
+        if (compressor.reduction) {
+          Object.defineProperty(compressor.reduction, "value", {
+            get() {
+              return this._value + noise * (Math.random() - 0.5);
+            },
+            set(v) {
+              this._value = v;
+            }
+          });
+        }
+        return compressor;
+      };
+      context2.prototype.createOscillator = function() {
+        const oscillator = originalCreateOscillator.apply(this, arguments);
+        const originalStart = oscillator.start;
+        oscillator.start = function() {
+          if (oscillator.frequency) {
+            oscillator.frequency.value += noise * (Math.random() - 0.5);
+          }
+          return originalStart.apply(this, arguments);
+        };
+        return oscillator;
+      };
+    }
+  }, seed.audioNoise);
+}
+
+// src/ghost/fonts.ts
+init_cjs_shims();
+async function applyFontSpoof(context, seed) {
+  await context.addInitScript((fonts) => {
+    const originalGetComputedStyle = window.getComputedStyle;
+    window.getComputedStyle = function(element, pseudoElt) {
+      const styles = originalGetComputedStyle.call(this, element, pseudoElt);
+      const originalGetPropertyValue = styles.getPropertyValue;
+      styles.getPropertyValue = function(property) {
+        if (property === "font-family") {
+          const value = originalGetPropertyValue.call(this, property);
+          const families = value.split(",").map((f) => f.trim());
+          const filtered = families.filter((family) => {
+            const cleanFamily = family.replace(/['"]/g, "");
+            return fonts.some((f) => cleanFamily.includes(f));
+          });
+          return filtered.length > 0 ? filtered.join(", ") : value;
+        }
+        return originalGetPropertyValue.call(this, property);
+      };
+      return styles;
+    };
+  }, seed.fonts);
+}
+
+// src/ghost/navigator.ts
+init_cjs_shims();
+async function applyNavigatorSpoof(context, seed) {
+  await context.addInitScript((seedData) => {
+    Object.defineProperty(navigator, "webdriver", {
+      get: () => void 0
+    });
+    Object.defineProperty(navigator, "plugins", {
+      get: () => [1, 2, 3, 4, 5]
+    });
+    Object.defineProperty(navigator, "languages", {
+      get: () => [seedData.language, "en"]
+    });
+    Object.defineProperty(navigator, "platform", {
+      get: () => "Win32"
+    });
+    Object.defineProperty(navigator, "hardwareConcurrency", {
+      get: () => 8
+    });
+    Object.defineProperty(navigator, "deviceMemory", {
+      get: () => 8
+    });
+    const originalQuery = window.navigator.permissions.query;
+    window.navigator.permissions.query = (parameters) => parameters.name === "notifications" ? Promise.resolve({ state: Notification.permission }) : originalQuery(parameters);
+    if (window.chrome) {
+      delete window.chrome.runtime;
+    }
+    Object.defineProperty(screen, "width", {
+      get: () => seedData.screenWidth
+    });
+    Object.defineProperty(screen, "height", {
+      get: () => seedData.screenHeight
+    });
+    Object.defineProperty(screen, "availWidth", {
+      get: () => seedData.screenWidth
+    });
+    Object.defineProperty(screen, "availHeight", {
+      get: () => seedData.screenHeight - 40
+    });
+  }, seed);
+}
+
+// src/ghost/consistency.ts
+init_cjs_shims();
+function validateConsistency(seed) {
+  if (!seed.id || !seed.chromeVersion) {
+    throw new Error("Invalid seed: missing required fields");
+  }
+  if (seed.screenWidth < 800 || seed.screenHeight < 600) {
+    throw new Error("Invalid seed: screen resolution too small");
+  }
+  if (seed.canvasNoise < 0 || seed.canvasNoise > 1) {
+    throw new Error("Invalid seed: canvas noise out of range");
+  }
+  if (seed.audioNoise < 0 || seed.audioNoise > 1) {
+    throw new Error("Invalid seed: audio noise out of range");
+  }
+  if (!seed.fonts || seed.fonts.length === 0) {
+    throw new Error("Invalid seed: no fonts specified");
+  }
+}
+
+// src/ghost/behavior.ts
+init_cjs_shims();
+var HumanBehavior = class {
+  seed;
+  profile;
+  constructor(seed) {
+    this.seed = seed;
+    this.profile = this.generateProfile();
+  }
+  generateProfile() {
+    return {
+      typingSpeed: { min: 50, max: 150 },
+      mouseMovements: [],
+      scrollPatterns: [],
+      pauseDistribution: [],
+      clickTiming: []
+    };
+  }
+  async randomDelay(min = 500, max = 2e3) {
+    const delay = Math.random() * (max - min) + min;
+    await new Promise((r) => setTimeout(r, delay));
+  }
+  async humanClick(page, selector) {
+    const element = await page.locator(selector);
+    const box = await element.boundingBox();
+    if (box) {
+      const x = box.x + Math.random() * box.width;
+      const y = box.y + Math.random() * box.height;
+      await page.mouse.move(x, y, { steps: 10 });
+      await this.randomDelay(100, 300);
+      await page.mouse.click(x, y);
+    }
+  }
+  async humanType(page, selector, text) {
+    await page.focus(selector);
+    for (const char of text) {
+      await page.keyboard.type(char);
+      await this.randomDelay(
+        this.profile.typingSpeed.min,
+        this.profile.typingSpeed.max
+      );
+    }
+  }
+  async randomScroll(page) {
+    const scrolls = Math.floor(Math.random() * 3) + 1;
+    for (let i = 0; i < scrolls; i++) {
+      const scrollY = Math.random() * 500;
+      await page.evaluate((y) => window.scrollBy(0, y), scrollY);
+      await this.randomDelay(500, 1e3);
+    }
+  }
+  async randomMouseMovement(page) {
+    const x = Math.random() * 1920;
+    const y = Math.random() * 1080;
+    await page.mouse.move(x, y, { steps: 20 });
+    await this.randomDelay(200, 500);
+  }
+  getProfile() {
+    return this.profile;
+  }
+};
+
+// src/ghost/index.ts
+init_logger();
+async function applyGhost(context, options = {}) {
+  const seed = options.fresh || !options.siteHost ? getNewSeed() : getSeedForSite(options.siteHost);
+  validateConsistency(seed);
+  logger.info(`[ghost] Applying identity seed: ${seed.id.slice(0, 8)}... | Chrome ${seed.chromeVersion} | ${seed.screenWidth}x${seed.screenHeight}`);
+  await applyCanvasSpoof(context, seed);
+  await applyWebGLSpoof(context, seed);
+  await applyAudioSpoof(context, seed);
+  await applyFontSpoof(context, seed);
+  await applyNavigatorSpoof(context, seed);
+  await context.setExtraHTTPHeaders({
+    "Accept-Language": `${seed.language},en;q=0.9`,
+    "sec-ch-ua": `"Chromium";v="${seed.chromeVersion.split(".")[0]}", "Google Chrome";v="${seed.chromeVersion.split(".")[0]}", "Not-A.Brand";v="99"`,
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"'
+  });
+  logger.info("[ghost] All fingerprint spoofs applied");
+  return new HumanBehavior(seed);
+}
+
+// src/cloudflare/cloudflare.ts
+init_cjs_shims();
+init_logger();
+var CloudflareManager = class {
+  async detect(page) {
+    const url = page.url();
+    try {
+      const title = await page.title();
+      const content = await page.content();
+      const cfIndicators = [
+        title.includes("Just a moment"),
+        title.includes("Attention Required"),
+        content.includes("cf-browser-verification"),
+        content.includes("cloudflare"),
+        content.includes("cf_chl_opt"),
+        content.includes("__cf_bm"),
+        content.includes("Ray ID")
+      ];
+      const detected = cfIndicators.some(Boolean);
+      if (detected) {
+        logger.warn(`[cloudflare] CF protection detected on ${url}`);
+      }
+      return detected;
+    } catch {
+      return false;
+    }
+  }
+  async waitForClearance(page, timeoutMs = 3e4) {
+    logger.info("[cloudflare] Waiting for CF challenge to resolve...");
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const title = await page.title().catch(() => "");
+      const isCFPage = title.includes("Just a moment") || title.includes("Attention Required");
+      if (!isCFPage) {
+        logger.info("[cloudflare] CF challenge cleared");
+        return true;
+      }
+      await page.waitForTimeout(1e3);
+    }
+    logger.error("[cloudflare] CF challenge timeout - could not clear in time");
+    return false;
+  }
+  async extractTokens(context) {
+    const cookies = await context.cookies();
+    const tokens = {};
+    for (const cookie of cookies) {
+      if (cookie.name === "cf_clearance") tokens.cfClearance = cookie.value;
+      if (cookie.name === "__cf_bm") tokens.cfBm = cookie.value;
+    }
+    if (tokens.cfClearance) {
+      logger.info(`[cloudflare] Captured cf_clearance: ${tokens.cfClearance.slice(0, 20)}...`);
+    }
+    return tokens;
+  }
+  async detectWAF(page) {
+    const content = await page.content().catch(() => "");
+    if (content.includes("cloudflare") || content.includes("cf-ray")) return "Cloudflare";
+    if (content.includes("akamai") || content.includes("ak_bmsc")) return "Akamai";
+    if (content.includes("sucuri")) return "Sucuri";
+    if (content.includes("incapsula")) return "Imperva/Incapsula";
+    if (content.includes("distil")) return "Distil Networks";
+    return null;
+  }
+  async handleCloudflare(page, url) {
+    const isProtected = await this.detect(page);
+    if (!isProtected) return true;
+    logger.info("[cloudflare] Cloudflare detected");
+    const cleared = await this.waitForClearance(page);
+    if (cleared) {
+      logger.info("[cloudflare] JS challenge auto-cleared");
+      return true;
+    }
+    const hasTurnstile = await this.detectTurnstile(page);
+    if (hasTurnstile) {
+      logger.info("[cloudflare] Turnstile CAPTCHA detected - opening browser for manual solve");
+      return await this.handleTurnstile(page, url);
+    }
+    logger.warn("[cloudflare] Unknown Cloudflare challenge");
+    return false;
+  }
+  async detectTurnstile(page) {
+    const turnstileFrame = await page.locator('iframe[src*="challenges.cloudflare.com"]').count();
+    const turnstileDiv = await page.locator('[id*="turnstile"]').count();
+    return turnstileFrame > 0 || turnstileDiv > 0;
+  }
+  async handleTurnstile(page, url) {
+    logger.info("[cloudflare] Waiting for manual Turnstile solve...");
+    console.log("\n===========================================");
+    console.log("  PLEASE SOLVE THE CAPTCHA");
+    console.log("  Waiting for you to complete it...");
+    console.log("===========================================\n");
+    await this.waitForTurnstileSolved(page);
+    logger.info("[cloudflare] CAPTCHA solved! Continuing...");
+    return true;
+  }
+  async isTurnstileSolved(page) {
+    try {
+      const turnstileExists = await page.locator('iframe[src*="challenges.cloudflare.com"]').count();
+      if (turnstileExists === 0) return true;
+      const hasToken = await page.evaluate(() => {
+        const input = document.querySelector('input[name="cf-turnstile-response"]');
+        return input && input.value !== "";
+      });
+      if (hasToken) return true;
+      const contentVisible = await page.evaluate(() => {
+        const body = document.body;
+        return body && !body.classList.contains("no-scroll");
+      });
+      return contentVisible;
+    } catch {
+      return false;
+    }
+  }
+  async waitForTurnstileSolved(page) {
+    while (true) {
+      const solved = await this.isTurnstileSolved(page);
+      if (solved) {
+        await page.waitForTimeout(2e3);
+        return;
+      }
+      await page.waitForTimeout(1e3);
+    }
+  }
+};
+
+// src/engine/cmd-parser.ts
+init_cjs_shims();
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+init_logger();
+var CommandParser = class {
+  variables = {};
+  setVariable(key, value) {
+    this.variables[key] = value;
+  }
+  resolve(text) {
+    return text.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+      return this.variables[key] ?? `{{${key}}}`;
+    });
+  }
+  parseLine(line, lineNum) {
+    if (line.trim().startsWith("//")) return null;
+    const parts = line.trim().split(/\s+/);
+    const action = parts[0].toUpperCase();
+    const args = parts.slice(1).map((a) => this.resolve(a));
+    const validActions = [
+      "GOTO",
+      "BACK",
+      "FORWARD",
+      "REFRESH",
+      "CLICK",
+      "TYPE",
+      "PRESS",
+      "SELECT",
+      "CHECK",
+      "UPLOAD",
+      "WAIT",
+      "WAITLOAD",
+      "SCROLL",
+      "SCROLLDOWN",
+      "SCAN",
+      "EXTRACT",
+      "SCREENSHOT",
+      "PAGINATE",
+      "INFINITESCROLL",
+      "FETCH",
+      "DOWNLOAD",
+      "REFERER",
+      "BYPASS_CLOUDFLARE",
+      "REPEAT",
+      "IF",
+      "LOOP"
+    ];
+    if (!validActions.includes(action)) {
+      logger.warn(`Unknown action "${action}" at line ${lineNum} - skipping`);
+      return null;
+    }
+    return { action, args, line: lineNum };
+  }
+  parse(content, filePath = "unknown") {
+    const lines = content.split("\n");
+    const steps = [];
+    let i = 0;
+    while (i < lines.length) {
+      const raw = lines[i];
+      const lineNum = i + 1;
+      if (raw.trim().startsWith("//")) {
+        i++;
+        continue;
+      }
+      const trimmed = raw.trimEnd();
+      if (!trimmed.trim()) {
+        i++;
+        continue;
+      }
+      const indent = raw.match(/^(\s*)/)?.[1].length ?? 0;
+      if (indent === 0) {
+        const step2 = this.parseLine(trimmed, lineNum);
+        if (step2) {
+          if (step2.action === "REPEAT" || step2.action === "IF" || step2.action === "LOOP") {
+            step2.children = [];
+            i++;
+            while (i < lines.length) {
+              const childRaw = lines[i];
+              const childIndent = childRaw.match(/^(\s*)/)?.[1].length ?? 0;
+              if (childIndent === 0) break;
+              const childStep = this.parseLine(childRaw.trim(), i + 1);
+              if (childStep) step2.children.push(childStep);
+              i++;
+            }
+          } else {
+            i++;
+          }
+          steps.push(step2);
+        } else {
+          i++;
+        }
+      } else {
+        i++;
+      }
+    }
+    const site = import_path.default.basename(filePath, ".cmd");
+    logger.info(`Parsed ${steps.length} steps from ${filePath}`);
+    return { site, steps, raw: content };
+  }
+  load(filePath) {
+    if (!import_fs.default.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const content = import_fs.default.readFileSync(filePath, "utf8");
+    return this.parse(content, filePath);
+  }
+  findAll(dir = "./commands") {
+    if (!import_fs.default.existsSync(dir)) return [];
+    return import_fs.default.readdirSync(dir).filter((f) => f.endsWith(".cmd")).map((f) => import_path.default.join(dir, f));
+  }
+};
+
+// src/engine/cmd-executor.ts
+init_cjs_shims();
+init_logger();
+init_config();
+init_smart_fetch();
+var CommandExecutor = class {
+  page;
+  url;
+  result = {
+    success: false,
+    skipped: [],
+    extracted: [],
+    errors: []
+  };
+  smartFetch;
+  cfManager;
+  variables = {};
+  constructor(page, url) {
+    this.page = page;
+    this.url = url;
+    this.smartFetch = new SmartFetch();
+    this.smartFetch.setPageContext(page);
+    this.cfManager = new CloudflareManager();
+  }
+  async execute(cmd) {
+    logger.info(`Executing ${cmd.site}.cmd - ${cmd.steps.length} steps`);
+    for (const step2 of cmd.steps) {
+      await this.runStep(step2);
+    }
+    if (this.result.errors.length > 0) {
+      logger.warn(`Completed with ${this.result.errors.length} skipped steps`);
+      for (const err of this.result.errors) {
+        logger.warn(`  Line ${err.line} - ${err.action}: ${err.error}`);
+      }
+    }
+    this.result.success = true;
+    return this.result;
+  }
+  async runStep(cmdStep) {
+    const { action, args, line } = cmdStep;
+    step(this.url, `${action} ${args.join(" ")}`, { mode: "cmd", step: action });
+    try {
+      switch (action) {
+        case "GOTO":
+          await this.goto(args);
+          break;
+        case "BACK":
+          await this.page.goBack();
+          break;
+        case "FORWARD":
+          await this.page.goForward();
+          break;
+        case "REFRESH":
+          await this.page.reload();
+          break;
+        case "CLICK":
+          await this.click(args);
+          break;
+        case "TYPE":
+          await this.type(args);
+          break;
+        case "PRESS":
+          await this.press(args);
+          break;
+        case "SELECT":
+          await this.select(args);
+          break;
+        case "CHECK":
+          await this.check(args);
+          break;
+        case "UPLOAD":
+          await this.upload(args);
+          break;
+        case "WAIT":
+          await this.wait(args);
+          break;
+        case "WAITLOAD":
+          await this.page.waitForLoadState("networkidle");
+          break;
+        case "SCROLL":
+          await this.scroll(args);
+          break;
+        case "SCROLLDOWN":
+          await this.scrollDown(args);
+          break;
+        case "SCAN":
+          await this.scan(args);
+          break;
+        case "EXTRACT":
+          await this.extract(args);
+          break;
+        case "SCREENSHOT":
+          await this.screenshot(args);
+          break;
+        case "PAGINATE":
+          await this.paginate(args);
+          break;
+        case "INFINITESCROLL":
+          await this.infiniteScroll();
+          break;
+        case "FETCH":
+          await this.fetch(args);
+          break;
+        case "DOWNLOAD":
+          await this.download(args);
+          break;
+        case "REFERER":
+          await this.setReferer(args);
+          break;
+        case "BYPASS_CLOUDFLARE":
+          await this.bypassCloudflare(args);
+          break;
+        case "REPEAT":
+          await this.repeat(cmdStep);
+          break;
+        case "IF":
+          await this.conditional(cmdStep);
+          break;
+        case "LOOP":
+          await this.loop(cmdStep);
+          break;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Line ${line} SKIPPED - ${action}: ${msg}`);
+      this.result.errors.push({ line, action, error: msg });
+      this.result.skipped.push(`Line ${line}: ${action} ${args.join(" ")}`);
+    }
+  }
+  async goto(args) {
+    const url = args[0];
+    if (!url) throw new Error("GOTO requires a URL");
+    await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: config.browser.timeout });
+    step(this.url, `GOTO ${url}`, { mode: "cmd", step: "GOTO", url });
+  }
+  async click(args) {
+    const selector = args[0];
+    if (!selector) throw new Error("CLICK requires a selector");
+    await this.page.waitForSelector(selector, { timeout: 1e4 });
+    await this.page.click(selector);
+  }
+  async type(args) {
+    const selector = args[0];
+    const text = args.slice(1).join(" ");
+    if (!selector) throw new Error("TYPE requires a selector");
+    if (!text) throw new Error("TYPE requires text");
+    await this.page.waitForSelector(selector, { timeout: 1e4 });
+    await this.page.fill(selector, text);
+  }
+  async press(args) {
+    const key = args[0];
+    if (!key) throw new Error("PRESS requires a key");
+    await this.page.keyboard.press(key);
+  }
+  async select(args) {
+    const selector = args[0];
+    const value = args[1];
+    if (!selector) throw new Error("SELECT requires a selector");
+    if (!value) throw new Error("SELECT requires a value");
+    await this.page.selectOption(selector, value);
+  }
+  async check(args) {
+    const selector = args[0];
+    if (!selector) throw new Error("CHECK requires a selector");
+    await this.page.check(selector);
+  }
+  async upload(args) {
+    const selector = args[0];
+    const filePath = args[1];
+    if (!selector) throw new Error("UPLOAD requires a selector");
+    if (!filePath) throw new Error("UPLOAD requires a file path");
+    await this.page.setInputFiles(selector, filePath);
+  }
+  async wait(args) {
+    const target = args[0];
+    if (!target) throw new Error("WAIT requires a selector or ms value");
+    if (/^\d+$/.test(target)) {
+      await this.page.waitForTimeout(parseInt(target, 10));
+    } else {
+      await this.page.waitForSelector(target, { timeout: config.browser.timeout });
+    }
+  }
+  async scroll(args) {
+    const selector = args[0];
+    if (!selector) throw new Error("SCROLL requires a selector");
+    await this.page.locator(selector).scrollIntoViewIfNeeded();
+  }
+  async scrollDown(args) {
+    const pixels = parseInt(args[0] || "500", 10);
+    await this.page.evaluate((px) => window.scrollBy(0, px), pixels);
+  }
+  async scan(args) {
+    const selector = args[0];
+    if (!selector) throw new Error("SCAN requires a selector");
+    const elements = await this.page.$$(selector);
+    const found = [];
+    for (const el of elements) {
+      const tag = await el.evaluate((e) => e.tagName.toLowerCase());
+      const text = await el.textContent();
+      const href = await el.getAttribute("href");
+      const src = await el.getAttribute("src");
+      const id = await el.getAttribute("id");
+      const cls = await el.getAttribute("class");
+      found.push({ tag, text: text?.trim().slice(0, 100), href, src, id, class: cls });
+    }
+    this.result.extracted.push({ type: "scan", selector, count: found.length, found });
+    highlight(this.url, { type: "scan", selector, count: found.length });
+    step(this.url, `SCAN found ${found.length} elements matching "${selector}"`, { mode: "cmd", step: "SCAN" });
+  }
+  async extract(args) {
+    const selector = args[0];
+    const attr = args[1] || "text";
+    if (!selector) throw new Error("EXTRACT requires a selector");
+    const elements = await this.page.$$(selector);
+    const data = [];
+    for (const el of elements) {
+      if (attr === "text") {
+        const text = await el.textContent();
+        data.push(text?.trim());
+      } else {
+        const value = await el.getAttribute(attr);
+        data.push(value);
+      }
+    }
+    this.result.extracted.push({ selector, attr, count: data.length, data });
+    highlight(this.url, { selector, attr, count: data.length });
+  }
+  async screenshot(args) {
+    const path5 = args[0] || `screenshot-${Date.now()}.png`;
+    await this.page.screenshot({ path: path5, fullPage: true });
+    logger.info(`Screenshot saved: ${path5}`);
+  }
+  async paginate(args) {
+    const selector = args[0];
+    if (!selector) throw new Error("PAGINATE requires a selector");
+    let page = 1;
+    while (true) {
+      try {
+        await this.page.waitForSelector(selector, { timeout: 5e3 });
+        logger.info(`Clicking next page (${page})`);
+        await this.page.click(selector);
+        await this.page.waitForLoadState("networkidle");
+        page++;
+      } catch {
+        logger.info(`Pagination complete - ${page} pages`);
+        break;
+      }
+    }
+  }
+  async infiniteScroll() {
+    let previousHeight = 0;
+    let attempts = 0;
+    const maxAttempts = 50;
+    while (attempts < maxAttempts) {
+      const currentHeight = await this.page.evaluate(() => document.body.scrollHeight);
+      if (currentHeight === previousHeight) {
+        break;
+      }
+      await this.page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+      await this.page.waitForTimeout(1e3);
+      previousHeight = currentHeight;
+      attempts++;
+    }
+    logger.info(`Infinite scroll complete - ${attempts} scrolls`);
+  }
+  async fetch(args) {
+    const url = args[0];
+    const varName = args[1];
+    if (!url) throw new Error("FETCH requires a URL");
+    const response = await this.smartFetch.fetch({
+      url,
+      autoReferer: true
+    });
+    if (varName) {
+      this.variables[varName] = response.data;
+      logger.info(`Saved response to variable: ${varName}`);
+    }
+    this.result.extracted.push({
+      type: "fetch",
+      url,
+      status: response.status,
+      data: response.data
+    });
+  }
+  async download(args) {
+    const url = args[0];
+    const outputPath = args[1] || `./downloads/${Date.now()}.bin`;
+    const referer = args[2];
+    if (!url) throw new Error("DOWNLOAD requires a URL");
+    logger.info(`Downloading: ${url}`);
+    await this.smartFetch.download(url, outputPath, referer);
+    this.result.extracted.push({
+      type: "download",
+      url,
+      path: outputPath
+    });
+  }
+  async setReferer(args) {
+    const referer = args[0];
+    if (!referer) throw new Error("REFERER requires a URL");
+    logger.info(`Set manual Referer: ${referer}`);
+  }
+  async bypassCloudflare(args) {
+    const mode = args[0] || "auto";
+    await this.cfManager.handleCloudflare(this.page, this.url);
+  }
+  async repeat(stepCmd) {
+    const selector = stepCmd.args[0];
+    if (!selector) throw new Error("REPEAT requires a selector");
+    if (!stepCmd.children?.length) throw new Error("REPEAT has no child commands");
+    const elements = await this.page.$$(selector);
+    step(this.url, `REPEAT ${elements.length}x over "${selector}"`, { mode: "cmd", step: "REPEAT" });
+    for (let i = 0; i < elements.length; i++) {
+      step(this.url, `  REPEAT iteration ${i + 1}/${elements.length}`, { mode: "cmd" });
+      for (const child of stepCmd.children) {
+        await this.runStep(child);
+      }
+    }
+  }
+  async conditional(stepCmd) {
+    const selector = stepCmd.args[0];
+    if (!selector) throw new Error("IF requires a selector");
+    if (!stepCmd.children?.length) throw new Error("IF has no child commands");
+    const exists = await this.page.locator(selector).count() > 0;
+    if (exists && stepCmd.children) {
+      for (const child of stepCmd.children) {
+        await this.runStep(child);
+      }
+    }
+  }
+  async loop(stepCmd) {
+    const count = parseInt(stepCmd.args[0] || "1", 10);
+    if (!stepCmd.children?.length) throw new Error("LOOP has no child commands");
+    for (let i = 0; i < count; i++) {
+      step(this.url, `  LOOP iteration ${i + 1}/${count}`, { mode: "cmd" });
+      for (const child of stepCmd.children) {
+        await this.runStep(child);
+      }
+    }
+  }
+};
+
+// src/core/scraper.ts
+init_logger();
+init_config();
+var FirekidScraper = class {
+  config;
+  browser = null;
+  context = null;
+  page = null;
+  cfManager;
+  constructor(userConfig = {}) {
+    this.config = {
+      headless: userConfig.headless ?? config.browser.headless,
+      bypassCloudflare: userConfig.bypassCloudflare ?? true,
+      maxWorkers: userConfig.maxWorkers ?? config.browser.maxWorkers,
+      timeout: userConfig.timeout ?? config.browser.timeout,
+      dataDir: userConfig.dataDir ?? config.storage.dataDir,
+      logLevel: userConfig.logLevel ?? config.logging.level
+    };
+    this.cfManager = new CloudflareManager();
+  }
+  async init() {
+    if (this.browser) return;
+    logger.info("Initializing Firekid Scraper...");
+    this.browser = await import_playwright.chromium.launch({
+      headless: this.config.headless,
+      args: [
+        "--disable-blink-features=AutomationControlled",
+        "--no-sandbox"
+      ]
+    });
+    this.context = await this.browser.newContext({
+      viewport: { width: 1920, height: 1080 },
+      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+    });
+    await applyGhost(this.context);
+    this.page = await this.context.newPage();
+    logger.info("Firekid Scraper initialized");
+  }
+  async goto(url) {
+    await this.init();
+    if (!this.page) throw new Error("Page not initialized");
+    logger.info(`Navigating to ${url}`);
+    await this.page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: this.config.timeout
+    });
+    if (this.config.bypassCloudflare) {
+      await this.cfManager.handleCloudflare(this.page, url);
+    }
+  }
+  async extract(url, selectors) {
+    await this.goto(url);
+    if (!this.page) throw new Error("Page not initialized");
+    const data = {};
+    for (const [key, selector] of Object.entries(selectors)) {
+      try {
+        const element = await this.page.locator(selector).first();
+        const text = await element.textContent();
+        data[key] = text?.trim() || null;
+      } catch (err) {
+        logger.warn(`Failed to extract ${key} with selector ${selector}`);
+        data[key] = null;
+      }
+    }
+    return data;
+  }
+  async auto(url) {
+    await this.goto(url);
+    if (!this.page) throw new Error("Page not initialized");
+    logger.info("Running auto mode...");
+    const { AutoMode: AutoMode2 } = await Promise.resolve().then(() => (init_auto(), auto_exports));
+    const autoMode = new AutoMode2(this.page);
+    return await autoMode.execute(url);
+  }
+  async runCommandFile(filePath) {
+    await this.init();
+    if (!this.page) throw new Error("Page not initialized");
+    const parser = new CommandParser();
+    const cmdFile = parser.load(filePath);
+    logger.info(`Executing command file: ${cmdFile.site}`);
+    const executor = new CommandExecutor(this.page, cmdFile.steps[0]?.args[0] || "");
+    const result = await executor.execute(cmdFile);
+    return {
+      success: result.success,
+      data: result.extracted,
+      errors: result.errors.map((e) => e.error),
+      timestamp: Date.now()
+    };
+  }
+  async close() {
+    if (this.page) await this.page.close();
+    if (this.context) await this.context.close();
+    if (this.browser) await this.browser.close();
+    this.page = null;
+    this.context = null;
+    this.browser = null;
+    logger.info("Firekid Scraper closed");
+  }
+  getPage() {
+    return this.page;
+  }
+  getBrowser() {
+    return this.browser;
+  }
+  getContext() {
+    return this.context;
+  }
+};
+
+// src/index.ts
+init_smart_fetch();
+
+// src/recorder/recorder.ts
+init_cjs_shims();
+var import_playwright2 = require("playwright");
+
+// src/recorder/selector-generator.ts
+init_cjs_shims();
+var SelectorGenerator = class {
+  async generate(page, element) {
+    const selectors = [];
+    if (element.id) {
+      selectors.push(`#${element.id}`);
+    }
+    if (element.className && typeof element.className === "string") {
+      const classes = element.className.split(" ").filter(Boolean);
+      if (classes.length > 0) {
+        selectors.push(`.${classes.join(".")}`);
+      }
+    }
+    if (element.tagName) {
+      const tag = element.tagName.toLowerCase();
+      if (element.type) {
+        selectors.push(`${tag}[type="${element.type}"]`);
+      }
+      if (element.href) {
+        selectors.push(`${tag}[href*="${this.simplifyUrl(element.href)}"]`);
+      }
+      if (element.textContent) {
+        const text = element.textContent.trim().slice(0, 30);
+        if (text) {
+          selectors.push(`${tag}:has-text("${text}")`);
+        }
+      }
+    }
+    const primary = selectors[0] || "body";
+    const fallbacks = selectors.slice(1);
+    return { primary, fallbacks };
+  }
+  simplifyUrl(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.pathname;
+    } catch {
+      return url;
+    }
+  }
+  async generateCssPath(page, element) {
+    return await page.evaluate((el) => {
+      const path5 = [];
+      let current = el;
+      while (current && current.nodeType === Node.ELEMENT_NODE) {
+        let selector = current.nodeName.toLowerCase();
+        if (current.id) {
+          selector += `#${current.id}`;
+          path5.unshift(selector);
+          break;
+        } else {
+          let sibling = current;
+          let nth = 1;
+          while (sibling.previousElementSibling) {
+            sibling = sibling.previousElementSibling;
+            if (sibling.nodeName === current.nodeName) {
+              nth++;
+            }
+          }
+          if (nth > 1) {
+            selector += `:nth-of-type(${nth})`;
+          }
+        }
+        path5.unshift(selector);
+        current = current.parentNode;
+      }
+      return path5.join(" > ");
+    }, element);
+  }
+};
+
+// src/recorder/pattern-detector.ts
+init_cjs_shims();
+init_logger();
+var PatternDetector = class {
+  analyze(actions) {
+    const patterns = {};
+    patterns.hasFormSubmission = this.detectFormSubmission(actions);
+    patterns.hasPagination = this.detectPagination(actions);
+    patterns.hasInfiniteScroll = this.detectInfiniteScroll(actions);
+    patterns.hasDownloadFlow = this.detectDownloadFlow(actions);
+    patterns.hasLogin = this.detectLogin(actions);
+    patterns.hasSearch = this.detectSearch(actions);
+    logger.info("[pattern-detector] Detected patterns:", patterns);
+    return patterns;
+  }
+  detectFormSubmission(actions) {
+    const typeActions = actions.filter((a) => a.type === "type");
+    const clickActions = actions.filter((a) => a.type === "click");
+    if (typeActions.length < 2) return null;
+    const fields = typeActions.map((action) => ({
+      selector: action.selectors.primary,
+      type: action.fieldType || "text",
+      placeholder: action.element?.placeholder || ""
+    }));
+    const submitButton = clickActions.find(
+      (a) => a.element?.textContent?.toLowerCase().includes("submit") || a.element?.textContent?.toLowerCase().includes("login") || a.element?.type === "submit"
+    );
+    if (!submitButton) return null;
+    return {
+      type: "FORM_SUBMISSION",
+      fields,
+      submitButton: submitButton.selectors.primary
+    };
+  }
+  detectPagination(actions) {
+    const clickActions = actions.filter((a) => a.type === "click");
+    const nextClicks = clickActions.filter(
+      (a) => a.element?.textContent?.toLowerCase().includes("next") || a.element?.className?.toLowerCase().includes("next") || a.element?.href?.includes("page")
+    );
+    if (nextClicks.length < 2) return null;
+    const firstNext = nextClicks[0];
+    const sameSelector = nextClicks.every(
+      (a) => a.selectors.primary === firstNext.selectors.primary
+    );
+    if (sameSelector) {
+      return {
+        type: "PAGINATION",
+        nextButton: firstNext.selectors.primary,
+        timesClicked: nextClicks.length
+      };
+    }
+    return null;
+  }
+  detectInfiniteScroll(actions) {
+    const scrollActions = actions.filter((a) => a.type === "scroll");
+    if (scrollActions.length > 5) {
+      return {
+        type: "INFINITE_SCROLL",
+        totalScrolls: scrollActions.length
+      };
+    }
+    return null;
+  }
+  detectDownloadFlow(actions) {
+    return actions.some(
+      (a) => a.element?.textContent?.toLowerCase().includes("download") || a.element?.href?.includes("download") || a.element?.href?.match(/\.(mp4|mp3|pdf|zip|rar)$/i)
+    );
+  }
+  detectLogin(actions) {
+    const typeActions = actions.filter((a) => a.type === "type");
+    const hasPassword = typeActions.some(
+      (a) => a.fieldType === "password" || a.selectors.primary.includes("password")
+    );
+    const hasUsername = typeActions.some(
+      (a) => a.fieldType === "email" || a.fieldType === "text" || a.selectors.primary.includes("email") || a.selectors.primary.includes("username")
+    );
+    return hasPassword && hasUsername;
+  }
+  detectSearch(actions) {
+    return actions.some(
+      (a) => a.type === "type" && (a.selectors.primary.includes("search") || a.element?.placeholder?.toLowerCase().includes("search"))
+    );
+  }
+};
+
+// src/recorder/cmd-generator.ts
+init_cjs_shims();
+var CmdGenerator = class {
+  generate(url, actions, patterns) {
+    const lines = [];
+    lines.push(`GOTO ${url}`);
+    lines.push(`WAITLOAD`);
+    lines.push("");
+    if (patterns.hasLogin) {
+      lines.push("LOGIN DETECTED");
+    }
+    if (patterns.hasSearch) {
+      lines.push("SEARCH DETECTED");
+    }
+    if (patterns.hasFormSubmission) {
+      const form = patterns.hasFormSubmission;
+      lines.push("");
+      form.fields.forEach((field) => {
+        lines.push(`WAIT ${field.selector}`);
+        lines.push(`TYPE ${field.selector} YOUR_${field.type.toUpperCase()}_HERE`);
+      });
+      lines.push(`CLICK ${form.submitButton}`);
+      lines.push("WAITLOAD");
+    }
+    const uniqueActions = this.deduplicateActions(actions);
+    uniqueActions.forEach((action) => {
+      if (action.type === "click") {
+        lines.push(`CLICK ${action.selectors.primary}`);
+      } else if (action.type === "type" && action.value) {
+        lines.push(`TYPE ${action.selectors.primary} ${action.value}`);
+      }
+    });
+    if (patterns.hasPagination) {
+      const pagination = patterns.hasPagination;
+      lines.push("");
+      lines.push(`PAGINATE ${pagination.nextButton}`);
+    }
+    if (patterns.hasInfiniteScroll) {
+      lines.push("");
+      lines.push("INFINITESCROLL");
+    }
+    if (patterns.hasDownloadFlow) {
+      lines.push("");
+      lines.push("DOWNLOAD DETECTED");
+    }
+    return lines.join("\n");
+  }
+  deduplicateActions(actions) {
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const action of actions) {
+      const key = `${action.type}:${action.selectors.primary}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(action);
+      }
+    }
+    return unique;
+  }
+};
+
+// src/recorder/recorder.ts
+init_logger();
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var ActionRecorder = class {
+  browser = null;
+  page = null;
+  actions = [];
+  isRecording = false;
+  selectorGen;
+  patternDetector;
+  cmdGenerator;
+  startUrl = "";
+  constructor() {
+    this.selectorGen = new SelectorGenerator();
+    this.patternDetector = new PatternDetector();
+    this.cmdGenerator = new CmdGenerator();
+  }
+  async startRecording(url) {
+    this.startUrl = url;
+    this.actions = [];
+    this.isRecording = true;
+    logger.info("[recorder] Starting recording session...");
+    console.log("\n===========================================");
+    console.log("  RECORDING MODE ACTIVATED");
+    console.log(`  URL: ${url}`);
+    console.log("  Perform your actions in the browser...");
+    console.log("  Close the browser when done");
+    console.log("===========================================\n");
+    this.browser = await import_playwright2.chromium.launch({ headless: false });
+    const context = await this.browser.newContext();
+    this.page = await context.newPage();
+    await this.attachListeners(this.page);
+    await this.page.goto(url);
+    await this.page.waitForEvent("close");
+    await this.stopRecording();
+  }
+  async attachListeners(page) {
+    await page.exposeFunction("__recordClick", async (x, y) => {
+      if (!this.isRecording) return;
+      const element = await page.evaluate((coords) => {
+        const el = document.elementFromPoint(coords.x, coords.y);
+        if (!el) return null;
+        return {
+          tagName: el.tagName.toLowerCase(),
+          id: el.id,
+          className: el.className,
+          textContent: el.textContent?.slice(0, 50),
+          href: el.href,
+          type: el.type
+        };
+      }, { x, y });
+      if (element) {
+        const selectors = await this.selectorGen.generate(page, element);
+        this.actions.push({
+          type: "click",
+          selectors,
+          timestamp: Date.now(),
+          element
+        });
+        logger.info(`[recorder] Recorded CLICK on ${selectors.primary}`);
+      }
+    });
+    await page.exposeFunction("__recordType", async (selector, value) => {
+      if (!this.isRecording) return;
+      const element = await page.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        if (!el) return null;
+        return {
+          tagName: el.tagName.toLowerCase(),
+          id: el.id,
+          type: el.type,
+          placeholder: el.placeholder
+        };
+      }, selector);
+      if (element) {
+        const selectors = await this.selectorGen.generate(page, element);
+        this.actions.push({
+          type: "type",
+          selectors,
+          value,
+          timestamp: Date.now(),
+          element,
+          fieldType: element.type
+        });
+        logger.info(`[recorder] Recorded TYPE in ${selectors.primary}: "${value.slice(0, 20)}..."`);
+      }
+    });
+    await page.addInitScript(() => {
+      document.addEventListener("click", (e) => {
+        const target = e.target;
+        if (target) {
+          window.__recordClick(e.clientX, e.clientY);
+        }
+      });
+      document.addEventListener("input", (e) => {
+        const target = e.target;
+        if (target && target.tagName === "INPUT") {
+          setTimeout(() => {
+            window.__recordType(target.id || target.name, target.value);
+          }, 500);
+        }
+      });
+    });
+  }
+  async stopRecording() {
+    this.isRecording = false;
+    logger.info(`[recorder] Recording stopped - ${this.actions.length} actions captured`);
+    const patterns = this.patternDetector.analyze(this.actions);
+    const cmdFile = this.cmdGenerator.generate(this.startUrl, this.actions, patterns);
+    const outputDir = "./commands";
+    if (!import_fs3.default.existsSync(outputDir)) {
+      import_fs3.default.mkdirSync(outputDir, { recursive: true });
+    }
+    const filename = `recorded-${Date.now()}.cmd`;
+    const filepath = import_path3.default.join(outputDir, filename);
+    import_fs3.default.writeFileSync(filepath, cmdFile);
+    console.log("\n===========================================");
+    console.log("  RECORDING COMPLETE");
+    console.log(`  Saved to: ${filepath}`);
+    console.log(`  Actions: ${this.actions.length}`);
+    console.log("===========================================\n");
+    if (this.browser) {
+      await this.browser.close();
+    }
+  }
+  getActions() {
+    return this.actions;
+  }
+};
+
+// src/intelligence/pattern-cache.ts
+init_cjs_shims();
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+init_logger();
+init_config();
+var import_path4 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"));
+var PatternCache = class {
+  db;
+  constructor() {
+    const dbPath = config.storage.patternsDb;
+    const dir = import_path4.default.dirname(dbPath);
+    if (!import_fs4.default.existsSync(dir)) {
+      import_fs4.default.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS patterns (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        site TEXT NOT NULL,
+        type TEXT NOT NULL,
+        selectors TEXT NOT NULL,
+        flow TEXT NOT NULL,
+        success_rate REAL DEFAULT 1.0,
+        created_at INTEGER DEFAULT (strftime('%s', 'now')),
+        updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_site ON patterns(site)
+    `);
+    logger.info("[pattern-cache] Database initialized");
+  }
+  save(site, pattern) {
+    const stmt = this.db.prepare(`
+      INSERT INTO patterns (site, type, selectors, flow, success_rate)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      site,
+      pattern.type,
+      JSON.stringify(pattern.selectors),
+      JSON.stringify(pattern.flow),
+      pattern.successRate
+    );
+    logger.info(`[pattern-cache] Saved pattern for ${site}`);
+  }
+  load(site) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM patterns 
+      WHERE site = ? 
+      ORDER BY success_rate DESC, updated_at DESC 
+      LIMIT 1
+    `);
+    const row = stmt.get(site);
+    if (!row) return null;
+    return {
+      type: row.type,
+      selectors: JSON.parse(row.selectors),
+      flow: JSON.parse(row.flow),
+      successRate: row.success_rate
+    };
+  }
+  updateSuccessRate(site, success) {
+    const current = this.load(site);
+    if (!current) return;
+    const newRate = success ? Math.min(1, current.successRate + 0.1) : Math.max(0.1, current.successRate - 0.1);
+    const stmt = this.db.prepare(`
+      UPDATE patterns 
+      SET success_rate = ?, updated_at = strftime('%s', 'now')
+      WHERE site = ?
+    `);
+    stmt.run(newRate, site);
+    logger.info(`[pattern-cache] Updated success rate for ${site}: ${newRate}`);
+  }
+  listAll() {
+    const stmt = this.db.prepare(`
+      SELECT * FROM patterns 
+      ORDER BY success_rate DESC
+    `);
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      site: row.site,
+      pattern: {
+        type: row.type,
+        selectors: JSON.parse(row.selectors),
+        flow: JSON.parse(row.flow),
+        successRate: row.success_rate
+      }
+    }));
+  }
+  clear() {
+    this.db.exec("DELETE FROM patterns");
+    logger.info("[pattern-cache] Cleared all patterns");
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/index.ts
+init_config();
+init_logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionRecorder,
+  CloudflareManager,
+  CommandExecutor,
+  CommandParser,
+  FirekidScraper,
+  PatternCache,
+  SmartFetch,
+  applyGhost,
+  config,
+  getConfig,
+  getNewSeed,
+  getSeedForSite,
+  logger,
+  setLogLevel,
+  updateConfig
+});