@bbloker/sdk 0.1.0

package/dist/chunk-6P6B2RO7.js

@@ -0,0 +1,422 @@
+// src/data/default-rules.json
+var default_rules_default = {
+  version: 1,
+  updatedAt: "2026-02-06",
+  blockedUAs: [
+    "GPTBot",
+    "ChatGPT-User",
+    "OAI-SearchBot",
+    "CCBot",
+    "anthropic-ai",
+    "ClaudeBot",
+    "Claude-Web",
+    "Meta-ExternalAgent",
+    "Meta-ExternalFetcher",
+    "FacebookBot",
+    "facebookexternalhit",
+    "PerplexityBot",
+    "Bytespider",
+    "Google-Extended",
+    "Applebot-Extended",
+    "cohere-ai",
+    "Diffbot",
+    "ImagesiftBot",
+    "Omgilibot",
+    "Omgili",
+    "YouBot",
+    "Amazonbot",
+    "AI2Bot",
+    "Ai2Bot-Dolma",
+    "Scrapy",
+    "PetalBot",
+    "Semrushbot",
+    "AhrefsBot",
+    "MJ12bot",
+    "DotBot",
+    "Seekport",
+    "BLEXBot",
+    "DataForSeoBot",
+    "magpie-crawler",
+    "Timpibot",
+    "Velenpublicwebcrawler",
+    "Webzio-Extended",
+    "iaskspider",
+    "Kangaroo Bot",
+    "img2dataset"
+  ],
+  blockedIPs: [
+    "20.15.240.0/20",
+    "20.171.206.0/23",
+    "40.83.2.0/23",
+    "52.230.152.0/21",
+    "20.171.207.0/24"
+  ],
+  headerPatterns: [
+    {
+      name: "accept",
+      pattern: "^\\*\\/\\*$",
+      weight: 0.3
+    },
+    {
+      name: "accept-language",
+      pattern: "^$",
+      weight: 0.5
+    },
+    {
+      name: "accept-encoding",
+      pattern: "^$",
+      weight: 0.4
+    }
+  ],
+  anomalyThreshold: 0.7
+};
+
+// src/core/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var Logger = class {
+  level = LEVELS.warn;
+  setLevel(level) {
+    this.level = LEVELS[level];
+  }
+  debug(...args) {
+    if (this.level <= LEVELS.debug) console.debug("[bbloker]", ...args);
+  }
+  info(...args) {
+    if (this.level <= LEVELS.info) console.info("[bbloker]", ...args);
+  }
+  warn(...args) {
+    if (this.level <= LEVELS.warn) console.warn("[bbloker]", ...args);
+  }
+  error(...args) {
+    if (this.level <= LEVELS.error) console.error("[bbloker]", ...args);
+  }
+};
+var logger = new Logger();
+
+// src/core/rules.ts
+var RuleManager = class {
+  rules;
+  apiUrl;
+  apiKey;
+  syncTimer = null;
+  // Pre-compiled UA patterns for fast matching
+  uaPatterns = [];
+  constructor(config) {
+    this.apiUrl = config.apiUrl;
+    this.apiKey = config.apiKey;
+    this.rules = default_rules_default;
+    this.compilePatterns();
+    this.sync();
+    this.syncTimer = setInterval(() => this.sync(), config.syncInterval);
+    if (this.syncTimer?.unref) {
+      this.syncTimer.unref();
+    }
+  }
+  compilePatterns() {
+    this.uaPatterns = this.rules.blockedUAs.map((ua) => ua.toLowerCase());
+  }
+  get current() {
+    return this.rules;
+  }
+  /** Check if a User-Agent matches any blocked pattern */
+  isBlockedUA(ua) {
+    const lower = ua.toLowerCase();
+    return this.uaPatterns.some((pattern) => lower.includes(pattern));
+  }
+  /** Check if an IP is in any blocked CIDR range */
+  isBlockedIP(ip) {
+    return this.rules.blockedIPs.some((cidr) => ipInCidr(ip, cidr));
+  }
+  /** Calculate header anomaly score (0-1) */
+  headerAnomalyScore(headers) {
+    let totalWeight = 0;
+    let matchWeight = 0;
+    for (const pattern of this.rules.headerPatterns) {
+      totalWeight += pattern.weight;
+      const value = headers[pattern.name.toLowerCase()] ?? "";
+      try {
+        if (new RegExp(pattern.pattern).test(value)) {
+          matchWeight += pattern.weight;
+        }
+      } catch {
+      }
+    }
+    return totalWeight > 0 ? matchWeight / totalWeight : 0;
+  }
+  get anomalyThreshold() {
+    return this.rules.anomalyThreshold;
+  }
+  async sync() {
+    try {
+      const res = await fetch(`${this.apiUrl}/v1/rules`, {
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) {
+        logger.warn(`bbloker: rule sync failed: ${res.status}`);
+        return;
+      }
+      const data = await res.json();
+      if (data.version > this.rules.version) {
+        this.rules = data;
+        this.compilePatterns();
+        logger.info(`bbloker: rules updated to v${data.version}`);
+      }
+    } catch {
+      logger.debug("bbloker: rule sync error (using cached rules)");
+    }
+  }
+  destroy() {
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+  }
+};
+function ipToLong(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return 0;
+  return (parseInt(parts[0], 10) << 24 | parseInt(parts[1], 10) << 16 | parseInt(parts[2], 10) << 8 | parseInt(parts[3], 10)) >>> 0;
+}
+function ipInCidr(ip, cidr) {
+  if (ip.includes(":")) return false;
+  const [range, bits] = cidr.split("/");
+  if (!range || !bits) return false;
+  const mask = ~(2 ** (32 - parseInt(bits, 10)) - 1) >>> 0;
+  const ipLong = ipToLong(ip);
+  const rangeLong = ipToLong(range);
+  return (ipLong & mask) === (rangeLong & mask);
+}
+
+// src/core/rate-limiter.ts
+var RateLimiter = class {
+  windows = /* @__PURE__ */ new Map();
+  maxRequests;
+  windowMs;
+  cleanupTimer = null;
+  constructor(maxRequests, windowMs) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.cleanupTimer = setInterval(() => this.cleanup(), 6e4);
+    if (this.cleanupTimer?.unref) {
+      this.cleanupTimer.unref();
+    }
+  }
+  /** Returns true if the IP has exceeded the rate limit */
+  isExceeded(ip) {
+    const now = Date.now();
+    const window = this.windows.get(ip);
+    if (!window || now > window.resetAt) {
+      this.windows.set(ip, { count: 1, resetAt: now + this.windowMs });
+      return false;
+    }
+    window.count++;
+    return window.count > this.maxRequests;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [ip, window] of this.windows) {
+      if (now > window.resetAt) {
+        this.windows.delete(ip);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.windows.clear();
+  }
+};
+
+// src/core/telemetry.ts
+var Telemetry = class {
+  buffer = [];
+  apiUrl;
+  apiKey;
+  maxBuffer;
+  flushTimer = null;
+  enabled;
+  constructor(config) {
+    this.apiUrl = config.apiUrl;
+    this.apiKey = config.apiKey;
+    this.maxBuffer = config.bufferSize;
+    this.enabled = config.enabled;
+    if (!this.enabled) return;
+    this.flushTimer = setInterval(() => this.flush(), config.flushInterval);
+    if (this.flushTimer?.unref) {
+      this.flushTimer.unref();
+    }
+  }
+  push(fp) {
+    if (!this.enabled) return;
+    this.buffer.push(fp);
+    if (this.buffer.length >= this.maxBuffer) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0);
+    try {
+      const res = await fetch(`${this.apiUrl}/v1/fingerprints`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ events: batch }),
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) {
+        logger.warn(`bbloker: telemetry flush failed: ${res.status}`);
+      } else {
+        logger.debug(`bbloker: flushed ${batch.length} fingerprints`);
+      }
+    } catch {
+      logger.debug(`bbloker: telemetry flush error (silent)`);
+    }
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.buffer = [];
+  }
+};
+
+// src/core/engine.ts
+var DEFAULTS = {
+  apiUrl: "https://api.bbloker.com",
+  syncInterval: 3e5,
+  flushInterval: 1e4,
+  bufferSize: 100,
+  telemetry: true,
+  rateLimit: 60,
+  rateLimitWindow: 6e4,
+  logLevel: "warn"
+};
+var Bbloker = class {
+  rules;
+  rateLimiter;
+  telemetry;
+  config;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("bbloker: apiKey is required");
+    }
+    const apiUrl = config.apiUrl ?? DEFAULTS.apiUrl;
+    const syncInterval = config.syncInterval ?? DEFAULTS.syncInterval;
+    const flushInterval = config.flushInterval ?? DEFAULTS.flushInterval;
+    const bufferSize = config.bufferSize ?? DEFAULTS.bufferSize;
+    const telemetryEnabled = config.telemetry ?? DEFAULTS.telemetry;
+    const rateLimit = config.rateLimit ?? DEFAULTS.rateLimit;
+    const rateLimitWindow = config.rateLimitWindow ?? DEFAULTS.rateLimitWindow;
+    const logLevel = config.logLevel ?? DEFAULTS.logLevel;
+    this.config = {
+      apiKey: config.apiKey,
+      apiUrl,
+      rateLimit,
+      rateLimitWindow,
+      logLevel,
+      onBlock: config.onBlock
+    };
+    logger.setLevel(logLevel);
+    this.rules = new RuleManager({
+      apiUrl,
+      apiKey: config.apiKey,
+      syncInterval
+    });
+    this.rateLimiter = new RateLimiter(rateLimit, rateLimitWindow);
+    this.telemetry = new Telemetry({
+      apiUrl,
+      apiKey: config.apiKey,
+      flushInterval,
+      bufferSize,
+      enabled: telemetryEnabled
+    });
+    logger.info("bbloker: initialized");
+  }
+  /**
+   * Analyze a normalized request and return a block/allow decision.
+   * This is the core method — adapters call this.
+   */
+  analyze(req) {
+    if (req.userAgent && this.rules.isBlockedUA(req.userAgent)) {
+      const decision2 = {
+        action: "block",
+        reason: "known_bot_ua",
+        confidence: 0.95
+      };
+      this.report(req, decision2);
+      return decision2;
+    }
+    if (req.ip && this.rules.isBlockedIP(req.ip)) {
+      const decision2 = {
+        action: "block",
+        reason: "known_bot_ip",
+        confidence: 0.9
+      };
+      this.report(req, decision2);
+      return decision2;
+    }
+    if (req.ip && this.rateLimiter.isExceeded(req.ip)) {
+      const decision2 = {
+        action: "block",
+        reason: "rate_limit",
+        confidence: 0.7
+      };
+      this.report(req, decision2);
+      return decision2;
+    }
+    const anomalyScore = this.rules.headerAnomalyScore(req.headers);
+    if (anomalyScore > this.rules.anomalyThreshold) {
+      const decision2 = {
+        action: "block",
+        reason: "header_anomaly",
+        confidence: anomalyScore
+      };
+      this.report(req, decision2);
+      return decision2;
+    }
+    const decision = { action: "allow" };
+    this.report(req, decision);
+    return decision;
+  }
+  report(req, decision) {
+    const fp = {
+      ip: req.ip,
+      userAgent: req.userAgent,
+      headerOrder: req.headerNames,
+      headers: req.headers,
+      path: req.path,
+      method: req.method,
+      ts: Date.now()
+    };
+    this.telemetry.push(fp);
+    if (decision.action === "block") {
+      logger.debug(
+        `bbloker: blocked ${req.ip} [${decision.reason}] UA="${req.userAgent.slice(0, 80)}"`
+      );
+    }
+  }
+  /** Clean up timers. Call when shutting down. */
+  destroy() {
+    this.rules.destroy();
+    this.rateLimiter.destroy();
+    this.telemetry.destroy();
+    logger.info("bbloker: destroyed");
+  }
+};
+
+export {
+  Bbloker
+};