@firekid/scraper 1.0.1

package/dist/bin/firekid-scraper.js

@@ -0,0 +1,2251 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
+// src/ghost/seed.ts
+import crypto from "crypto";
+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: crypto.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;
+}
+var seedCache, chromeVersions, resolutions, languages, timezones, webglVendors, webglRenderers, fontSets;
+var init_seed = __esm({
+  "src/ghost/seed.ts"() {
+    "use strict";
+    init_esm_shims();
+    seedCache = /* @__PURE__ */ new Map();
+    chromeVersions = [
+      "131.0.6778.85",
+      "131.0.6778.86",
+      "130.0.6723.116",
+      "129.0.6668.100"
+    ];
+    resolutions = [
+      { width: 1920, height: 1080 },
+      { width: 1366, height: 768 },
+      { width: 1536, height: 864 },
+      { width: 1440, height: 900 },
+      { width: 2560, height: 1440 }
+    ];
+    languages = ["en-US", "en-GB", "en", "es-ES", "fr-FR", "de-DE"];
+    timezones = ["America/New_York", "America/Los_Angeles", "Europe/London", "Europe/Paris"];
+    webglVendors = [
+      "Google Inc. (NVIDIA)",
+      "Google Inc. (Intel)",
+      "Google Inc. (AMD)",
+      "Google Inc. (Apple)"
+    ];
+    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)"
+    ];
+    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"]
+    ];
+  }
+});
+
+// src/ghost/canvas.ts
+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);
+}
+var init_canvas = __esm({
+  "src/ghost/canvas.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/ghost/webgl.ts
+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 });
+}
+var init_webgl = __esm({
+  "src/ghost/webgl.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/ghost/audio.ts
+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);
+}
+var init_audio = __esm({
+  "src/ghost/audio.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/ghost/fonts.ts
+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);
+}
+var init_fonts = __esm({
+  "src/ghost/fonts.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/ghost/navigator.ts
+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);
+}
+var init_navigator = __esm({
+  "src/ghost/navigator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/ghost/consistency.ts
+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");
+  }
+}
+var init_consistency = __esm({
+  "src/ghost/consistency.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/ghost/behavior.ts
+var HumanBehavior;
+var init_behavior = __esm({
+  "src/ghost/behavior.ts"() {
+    "use strict";
+    init_esm_shims();
+    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, text2) {
+        await page.focus(selector);
+        for (const char of text2) {
+          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/config.ts
+import dotenv from "dotenv";
+var config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    dotenv.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
+import winston from "winston";
+function step(url, action, meta) {
+  logger.info(`[${url}] ${action}`, meta);
+}
+function highlight(url, data) {
+  logger.info(`[${url}] EXTRACTED:`, data);
+}
+var logger;
+var init_logger = __esm({
+  "src/logger/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    logger = winston.createLogger({
+      level: config.logging.level,
+      format: winston.format.combine(
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        winston.format.errors({ stack: true }),
+        winston.format.splat(),
+        winston.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 winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.printf(({ level, message, timestamp }) => {
+              return `${timestamp} ${level}: ${message}`;
+            })
+          )
+        }),
+        new winston.transports.File({
+          filename: "logs/error.log",
+          level: "error"
+        }),
+        new winston.transports.File({
+          filename: "logs/combined.log"
+        })
+      ]
+    });
+  }
+});
+
+// src/ghost/index.ts
+async function applyGhost(context, options2 = {}) {
+  const seed = options2.fresh || !options2.siteHost ? getNewSeed() : getSeedForSite(options2.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);
+}
+var init_ghost = __esm({
+  "src/ghost/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_seed();
+    init_canvas();
+    init_webgl();
+    init_audio();
+    init_fonts();
+    init_navigator();
+    init_consistency();
+    init_behavior();
+    init_logger();
+    init_seed();
+    init_behavior();
+  }
+});
+
+// src/cloudflare/cloudflare.ts
+var CloudflareManager;
+var init_cloudflare = __esm({
+  "src/cloudflare/cloudflare.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    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
+import fs from "fs";
+import path2 from "path";
+var CommandParser;
+var init_cmd_parser = __esm({
+  "src/engine/cmd-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    CommandParser = class {
+      variables = {};
+      setVariable(key, value) {
+        this.variables[key] = value;
+      }
+      resolve(text2) {
+        return text2.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 = path2.basename(filePath, ".cmd");
+        logger.info(`Parsed ${steps.length} steps from ${filePath}`);
+        return { site, steps, raw: content };
+      }
+      load(filePath) {
+        if (!fs.existsSync(filePath)) {
+          throw new Error(`File not found: ${filePath}`);
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        return this.parse(content, filePath);
+      }
+      findAll(dir = "./commands") {
+        if (!fs.existsSync(dir)) return [];
+        return fs.readdirSync(dir).filter((f) => f.endsWith(".cmd")).map((f) => path2.join(dir, f));
+      }
+    };
+  }
+});
+
+// src/network/smart-fetch.ts
+import fs2 from "fs";
+import path3 from "path";
+var SmartFetch;
+var init_smart_fetch = __esm({
+  "src/network/smart-fetch.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    SmartFetch = class {
+      pageContext = null;
+      lastReferer = "";
+      setPageContext(page) {
+        this.pageContext = page;
+      }
+      async fetch(options2) {
+        const {
+          url,
+          referer,
+          autoReferer = true,
+          method = "GET",
+          headers = {},
+          cookies = {},
+          body,
+          followRedirects = true,
+          timeout = 3e4
+        } = options2;
+        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 = path3.dirname(outputPath);
+        if (!fs2.existsSync(dir)) {
+          fs2.mkdirSync(dir, { recursive: true });
+        }
+        if (response.data instanceof ArrayBuffer) {
+          fs2.writeFileSync(outputPath, Buffer.from(response.data));
+        } else if (typeof response.data === "string") {
+          fs2.writeFileSync(outputPath, response.data);
+        } else {
+          fs2.writeFileSync(outputPath, JSON.stringify(response.data));
+        }
+        logger.info(`[smart-fetch] Downloaded to ${outputPath}`);
+      }
+      getLastReferer() {
+        return this.lastReferer;
+      }
+    };
+  }
+});
+
+// src/engine/cmd-executor.ts
+var CommandExecutor;
+var init_cmd_executor = __esm({
+  "src/engine/cmd-executor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_config();
+    init_smart_fetch();
+    init_cloudflare();
+    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 text2 = args.slice(1).join(" ");
+        if (!selector) throw new Error("TYPE requires a selector");
+        if (!text2) throw new Error("TYPE requires text");
+        await this.page.waitForSelector(selector, { timeout: 1e4 });
+        await this.page.fill(selector, text2);
+      }
+      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 text2 = 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: text2?.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 text2 = await el.textContent();
+            data.push(text2?.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/modes/downloader.ts
+var DownloaderMode;
+var init_downloader = __esm({
+  "src/modes/downloader.ts"() {
+    "use strict";
+    init_esm_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 text2 = (el.textContent || "").toLowerCase();
+            const className = (el.className || "").toLowerCase();
+            const href = el.href;
+            let score = 0;
+            if (text2.includes("download")) score += 10;
+            if (className.includes("download")) score += 10;
+            if (el.hasAttribute("download")) score += 20;
+            if (href && href.includes("download")) score += 5;
+            if (text2.includes("get")) score += 3;
+            if (text2.includes("save")) score += 3;
+            if (score > 0) {
+              const selector = el.id ? `#${el.id}` : el.tagName.toLowerCase();
+              scored.push({ selector, score, text: text2, 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_esm_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_navigator2 = __esm({
+  "src/modes/navigator.ts"() {
+    "use strict";
+    init_esm_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 text2 = a.textContent?.trim();
+              const href = a.href;
+              if (text2 && href) {
+                links.push({ text: text2, 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_esm_shims();
+    init_logger();
+    init_downloader();
+    init_scrape();
+    init_navigator2();
+    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/core/scraper.ts
+import { chromium } from "playwright";
+var FirekidScraper;
+var init_scraper = __esm({
+  "src/core/scraper.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ghost();
+    init_cloudflare();
+    init_cmd_parser();
+    init_cmd_executor();
+    init_logger();
+    init_config();
+    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 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 text2 = await element.textContent();
+            data[key] = text2?.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/server/app.ts
+var app_exports = {};
+__export(app_exports, {
+  startServer: () => startServer
+});
+import express from "express";
+import { rateLimit } from "express-rate-limit";
+async function startServer(port = 3e3) {
+  app.listen(port, () => {
+    logger.info(`[server] Firekid API server running on port ${port}`);
+    console.log(`
+Firekid Scraper API Server`);
+    console.log(`Port: ${port}`);
+    console.log(`Health: http://localhost:${port}/health
+`);
+  });
+}
+var app, limiter;
+var init_app = __esm({
+  "src/server/app.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_scraper();
+    init_logger();
+    init_config();
+    app = express();
+    app.use(express.json());
+    limiter = rateLimit({
+      windowMs: config.rateLimit.window,
+      max: config.rateLimit.max,
+      message: "Too many requests, please try again later"
+    });
+    if (config.rateLimit.enabled) {
+      app.use(limiter);
+    }
+    app.use((req, res, next) => {
+      const apiKey = req.headers["x-api-key"];
+      if (config.server.apiKey && apiKey !== config.server.apiKey) {
+        return res.status(401).json({ error: "Invalid API key" });
+      }
+      next();
+    });
+    app.post("/scrape", async (req, res) => {
+      const { url, mode = "auto", selectors } = req.body;
+      if (!url) {
+        return res.status(400).json({ error: "URL is required" });
+      }
+      const scraper = new FirekidScraper();
+      try {
+        let result;
+        if (mode === "auto") {
+          result = await scraper.auto(url);
+        } else if (mode === "extract" && selectors) {
+          result = await scraper.extract(url, selectors);
+        } else {
+          return res.status(400).json({ error: "Invalid mode or missing parameters" });
+        }
+        await scraper.close();
+        res.json({ success: true, result });
+      } catch (err) {
+        await scraper.close();
+        logger.error("[api] Scraping error:", err);
+        res.status(500).json({ error: err.message });
+      }
+    });
+    app.post("/command", async (req, res) => {
+      const { filePath } = req.body;
+      if (!filePath) {
+        return res.status(400).json({ error: "File path is required" });
+      }
+      const scraper = new FirekidScraper();
+      try {
+        const result = await scraper.runCommandFile(filePath);
+        await scraper.close();
+        res.json({ success: true, result });
+      } catch (err) {
+        await scraper.close();
+        logger.error("[api] Command execution error:", err);
+        res.status(500).json({ error: err.message });
+      }
+    });
+    app.get("/health", (req, res) => {
+      res.json({ status: "ok", timestamp: Date.now() });
+    });
+  }
+});
+
+// bin/firekid-scraper.ts
+init_esm_shims();
+init_scraper();
+import { Command } from "commander";
+import { intro, outro, text, select, spinner } from "@clack/prompts";
+
+// src/recorder/recorder.ts
+init_esm_shims();
+import { chromium as chromium2 } from "playwright";
+
+// src/recorder/selector-generator.ts
+init_esm_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 text2 = element.textContent.trim().slice(0, 30);
+        if (text2) {
+          selectors.push(`${tag}:has-text("${text2}")`);
+        }
+      }
+    }
+    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_esm_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_esm_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();
+import fs3 from "fs";
+import path4 from "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 chromium2.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 (!fs3.existsSync(outputDir)) {
+      fs3.mkdirSync(outputDir, { recursive: true });
+    }
+    const filename = `recorded-${Date.now()}.cmd`;
+    const filepath = path4.join(outputDir, filename);
+    fs3.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;
+  }
+};
+
+// bin/firekid-scraper.ts
+init_logger();
+import { readFileSync } from "fs";
+import { join } from "path";
+var packageJson = JSON.parse(
+  readFileSync(join(__dirname, "../../package.json"), "utf-8")
+);
+var program = new Command();
+program.name("firekid-scraper").description("The most advanced web scraping machine ever built").version(packageJson.version);
+program.option("-u, --url <url>", "URL to scrape").option("-m, --mode <mode>", "Scraping mode (auto, downloader, scrape, navigator)").option("--cmd <file>", "Run command file").option("--record", "Record browser actions").option("--auto", "Use intelligent auto mode").option("--headless", "Run in headless mode").option("--server", "Start API server").option("-p, --port <port>", "API server port", "3000");
+program.parse();
+var options = program.opts();
+async function main() {
+  intro("Firekid Scraper");
+  if (options.server) {
+    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+    await startServer2(parseInt(options.port, 10));
+    return;
+  }
+  const scraper = new FirekidScraper({
+    headless: options.headless !== false
+  });
+  if (options.record) {
+    const url = options.url || await text({
+      message: "Enter URL to record:",
+      placeholder: "https://example.com"
+    });
+    const s = spinner();
+    s.start("Starting recorder...");
+    const recorder = new ActionRecorder();
+    await recorder.startRecording(url);
+    s.stop("Recording complete!");
+    outro("Command file generated");
+    return;
+  }
+  if (options.cmd) {
+    const s = spinner();
+    s.start(`Running command file: ${options.cmd}`);
+    await scraper.runCommandFile(options.cmd);
+    s.stop("Execution complete!");
+    outro("Done");
+    return;
+  }
+  if (options.auto || options.url) {
+    const url = options.url || await text({
+      message: "Enter URL to scrape:",
+      placeholder: "https://example.com"
+    });
+    const s = spinner();
+    s.start("Scraping...");
+    const result = await scraper.auto(url);
+    s.stop("Scraping complete!");
+    console.log("\nResults:", result);
+    outro("Done");
+    return;
+  }
+  const action = await select({
+    message: "What would you like to do?",
+    options: [
+      { value: "auto", label: "Auto scrape a URL" },
+      { value: "record", label: "Record browser actions" },
+      { value: "command", label: "Run command file" },
+      { value: "server", label: "Start API server" }
+    ]
+  });
+  if (action === "auto") {
+    const url = await text({
+      message: "Enter URL:",
+      placeholder: "https://example.com"
+    });
+    const s = spinner();
+    s.start("Scraping...");
+    const result = await scraper.auto(url);
+    s.stop("Complete!");
+    console.log("\nResults:", result);
+  } else if (action === "record") {
+    const url = await text({
+      message: "Enter URL to record:",
+      placeholder: "https://example.com"
+    });
+    const recorder = new ActionRecorder();
+    await recorder.startRecording(url);
+  } else if (action === "command") {
+    const file = await text({
+      message: "Enter command file path:",
+      placeholder: "commands/mysite.cmd"
+    });
+    await scraper.runCommandFile(file);
+  } else if (action === "server") {
+    const port = await text({
+      message: "Enter port:",
+      placeholder: "3000"
+    });
+    const { startServer: startServer2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+    await startServer2(parseInt(port, 10));
+  }
+  outro("Done");
+}
+main().catch((err) => {
+  logger.error("CLI error:", err);
+  process.exit(1);
+});