@bbloker/sdk 0.1.0

package/dist/adapters/fastify.js

@@ -0,0 +1,64 @@
+import {
+  Bbloker
+} from "../chunk-6P6B2RO7.js";
+
+// src/adapters/fastify.ts
+function createPlugin(config) {
+  const bbloker = new Bbloker(config);
+  return function bblokerPlugin(fastify, _opts, done) {
+    fastify.addHook("onRequest", (request, reply, hookDone) => {
+      const normalized = normalizeFastifyRequest(request);
+      const decision = bbloker.analyze(normalized);
+      if (decision.action === "block") {
+        if (config.onBlock) {
+          const result = config.onBlock({
+            fingerprint: {
+              ip: normalized.ip,
+              userAgent: normalized.userAgent,
+              headerOrder: normalized.headerNames,
+              headers: normalized.headers,
+              path: normalized.path,
+              method: normalized.method,
+              ts: Date.now()
+            },
+            decision
+          });
+          if (result instanceof Promise) {
+            result.then(() => {
+              reply.status(403).send();
+            });
+            return;
+          }
+        }
+        reply.status(403).send();
+        return;
+      }
+      hookDone();
+    });
+    done();
+  };
+}
+function normalizeFastifyRequest(req) {
+  const rawHeaders = req.headers;
+  const headers = {};
+  const headerNames = [];
+  for (const [key, value] of Object.entries(rawHeaders)) {
+    const lower = key.toLowerCase();
+    headers[lower] = Array.isArray(value) ? value.join(", ") : value ?? "";
+    headerNames.push(lower);
+  }
+  const forwarded = headers["x-forwarded-for"]?.split(",")[0]?.trim();
+  const ip = req.ip ?? forwarded ?? "0.0.0.0";
+  return {
+    ip,
+    userAgent: headers["user-agent"] ?? "",
+    headers,
+    headerNames,
+    path: req.url ?? "/",
+    method: req.method ?? "GET"
+  };
+}
+export {
+  Bbloker,
+  createPlugin
+};

package/dist/adapters/hono.cjs

@@ -0,0 +1,55 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkKT5GDIXHcjs = require('../chunk-KT5GDIXH.cjs');
+
+// src/adapters/hono.ts
+function createMiddleware(config) {
+  const bbloker = new (0, _chunkKT5GDIXHcjs.Bbloker)(config);
+  return async function middleware(c, next) {
+    const normalized = normalizeHonoRequest(c);
+    const decision = bbloker.analyze(normalized);
+    if (decision.action === "block") {
+      if (config.onBlock) {
+        const result = await config.onBlock({
+          fingerprint: {
+            ip: normalized.ip,
+            userAgent: normalized.userAgent,
+            headerOrder: normalized.headerNames,
+            headers: normalized.headers,
+            path: normalized.path,
+            method: normalized.method,
+            ts: Date.now()
+          },
+          decision
+        });
+        if (result instanceof Response) return result;
+      }
+      return c.text("Forbidden", 403);
+    }
+    await next();
+  };
+}
+function normalizeHonoRequest(c) {
+  const headers = {};
+  const headerNames = [];
+  c.req.raw.headers.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    headers[lower] = value;
+    headerNames.push(lower);
+  });
+  const forwarded = _optionalChain([headers, 'access', _ => _["x-forwarded-for"], 'optionalAccess', _2 => _2.split, 'call', _3 => _3(","), 'access', _4 => _4[0], 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+  const cfIp = headers["cf-connecting-ip"];
+  const ip = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(cfIp, () => ( forwarded)), () => ( headers["x-real-ip"])), () => ( "0.0.0.0"));
+  return {
+    ip,
+    userAgent: _nullishCoalesce(headers["user-agent"], () => ( "")),
+    headers,
+    headerNames,
+    path: c.req.path,
+    method: c.req.method
+  };
+}
+
+
+
+exports.Bbloker = _chunkKT5GDIXHcjs.Bbloker; exports.createMiddleware = createMiddleware;

package/dist/adapters/hono.d.cts

@@ -0,0 +1,32 @@
+import { BblokerConfig } from '../index.cjs';
+export { Bbloker } from '../index.cjs';
+
+type HonoContext = {
+    req: {
+        raw: Request;
+        header(name: string): string | undefined;
+        path: string;
+        method: string;
+    };
+    header(name: string): string | undefined;
+    text(body: string, status?: number): Response;
+};
+type HonoNext = () => Promise<void>;
+/**
+ * Create Hono middleware that blocks AI crawlers.
+ * Works on Cloudflare Workers, Deno, Bun, Node.
+ *
+ * Usage:
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { createMiddleware } from '@bbloker/sdk/hono';
+ *
+ * const app = new Hono();
+ * app.use('*', createMiddleware({
+ *   apiKey: process.env.BBLOKER_API_KEY!,
+ * }));
+ * ```
+ */
+declare function createMiddleware(config: BblokerConfig): (c: HonoContext, next: HonoNext) => Promise<Response | undefined>;
+
+export { BblokerConfig, createMiddleware };

package/dist/adapters/hono.d.ts

@@ -0,0 +1,32 @@
+import { BblokerConfig } from '../index.js';
+export { Bbloker } from '../index.js';
+
+type HonoContext = {
+    req: {
+        raw: Request;
+        header(name: string): string | undefined;
+        path: string;
+        method: string;
+    };
+    header(name: string): string | undefined;
+    text(body: string, status?: number): Response;
+};
+type HonoNext = () => Promise<void>;
+/**
+ * Create Hono middleware that blocks AI crawlers.
+ * Works on Cloudflare Workers, Deno, Bun, Node.
+ *
+ * Usage:
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { createMiddleware } from '@bbloker/sdk/hono';
+ *
+ * const app = new Hono();
+ * app.use('*', createMiddleware({
+ *   apiKey: process.env.BBLOKER_API_KEY!,
+ * }));
+ * ```
+ */
+declare function createMiddleware(config: BblokerConfig): (c: HonoContext, next: HonoNext) => Promise<Response | undefined>;
+
+export { BblokerConfig, createMiddleware };

package/dist/adapters/hono.js

@@ -0,0 +1,55 @@
+import {
+  Bbloker
+} from "../chunk-6P6B2RO7.js";
+
+// src/adapters/hono.ts
+function createMiddleware(config) {
+  const bbloker = new Bbloker(config);
+  return async function middleware(c, next) {
+    const normalized = normalizeHonoRequest(c);
+    const decision = bbloker.analyze(normalized);
+    if (decision.action === "block") {
+      if (config.onBlock) {
+        const result = await config.onBlock({
+          fingerprint: {
+            ip: normalized.ip,
+            userAgent: normalized.userAgent,
+            headerOrder: normalized.headerNames,
+            headers: normalized.headers,
+            path: normalized.path,
+            method: normalized.method,
+            ts: Date.now()
+          },
+          decision
+        });
+        if (result instanceof Response) return result;
+      }
+      return c.text("Forbidden", 403);
+    }
+    await next();
+  };
+}
+function normalizeHonoRequest(c) {
+  const headers = {};
+  const headerNames = [];
+  c.req.raw.headers.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    headers[lower] = value;
+    headerNames.push(lower);
+  });
+  const forwarded = headers["x-forwarded-for"]?.split(",")[0]?.trim();
+  const cfIp = headers["cf-connecting-ip"];
+  const ip = cfIp ?? forwarded ?? headers["x-real-ip"] ?? "0.0.0.0";
+  return {
+    ip,
+    userAgent: headers["user-agent"] ?? "",
+    headers,
+    headerNames,
+    path: c.req.path,
+    method: c.req.method
+  };
+}
+export {
+  Bbloker,
+  createMiddleware
+};

package/dist/adapters/nextjs.cjs

@@ -0,0 +1,53 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkKT5GDIXHcjs = require('../chunk-KT5GDIXH.cjs');
+
+// src/adapters/nextjs.ts
+function createMiddleware(config) {
+  const bbloker = new (0, _chunkKT5GDIXHcjs.Bbloker)(config);
+  return async function middleware(request) {
+    const { NextResponse } = await Promise.resolve().then(() => _interopRequireWildcard(require("next/server")));
+    const normalized = normalizeNextRequest(request);
+    const decision = bbloker.analyze(normalized);
+    if (decision.action === "block") {
+      if (config.onBlock) {
+        const result = await config.onBlock({
+          fingerprint: {
+            ip: normalized.ip,
+            userAgent: normalized.userAgent,
+            headerOrder: normalized.headerNames,
+            headers: normalized.headers,
+            path: normalized.path,
+            method: normalized.method,
+            ts: Date.now()
+          },
+          decision
+        });
+        if (result instanceof Response) return result;
+      }
+      return new NextResponse(null, { status: 403 });
+    }
+    return NextResponse.next();
+  };
+}
+function normalizeNextRequest(req) {
+  const headers = {};
+  const headerNames = [];
+  req.headers.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    headers[lower] = value;
+    headerNames.push(lower);
+  });
+  return {
+    ip: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(req.ip, () => ( _optionalChain([headers, 'access', _ => _["x-forwarded-for"], 'optionalAccess', _2 => _2.split, 'call', _3 => _3(","), 'access', _4 => _4[0], 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]))), () => ( headers["x-real-ip"])), () => ( "0.0.0.0")),
+    userAgent: _nullishCoalesce(headers["user-agent"], () => ( "")),
+    headers,
+    headerNames,
+    path: req.nextUrl.pathname,
+    method: req.method
+  };
+}
+
+
+
+exports.Bbloker = _chunkKT5GDIXHcjs.Bbloker; exports.createMiddleware = createMiddleware;

package/dist/adapters/nextjs.d.cts

@@ -0,0 +1,34 @@
+import { BblokerConfig } from '../index.cjs';
+export { Bbloker } from '../index.cjs';
+
+type NextRequest = {
+    ip?: string | null;
+    headers: {
+        get(name: string): string | null;
+        forEach(cb: (value: string, key: string) => void): void;
+    };
+    nextUrl: {
+        pathname: string;
+    };
+    method: string;
+    geo?: {
+        country?: string;
+    };
+};
+/**
+ * Create a Next.js middleware that blocks AI crawlers.
+ *
+ * Usage in middleware.ts:
+ * ```ts
+ * import { createMiddleware } from '@bbloker/sdk/nextjs';
+ *
+ * export default createMiddleware({
+ *   apiKey: process.env.BBLOKER_API_KEY!,
+ * });
+ *
+ * export const config = { matcher: '/((?!_next/static|favicon.ico).*)' };
+ * ```
+ */
+declare function createMiddleware(config: BblokerConfig): (request: NextRequest) => Promise<Response>;
+
+export { BblokerConfig, createMiddleware };

package/dist/adapters/nextjs.d.ts

@@ -0,0 +1,34 @@
+import { BblokerConfig } from '../index.js';
+export { Bbloker } from '../index.js';
+
+type NextRequest = {
+    ip?: string | null;
+    headers: {
+        get(name: string): string | null;
+        forEach(cb: (value: string, key: string) => void): void;
+    };
+    nextUrl: {
+        pathname: string;
+    };
+    method: string;
+    geo?: {
+        country?: string;
+    };
+};
+/**
+ * Create a Next.js middleware that blocks AI crawlers.
+ *
+ * Usage in middleware.ts:
+ * ```ts
+ * import { createMiddleware } from '@bbloker/sdk/nextjs';
+ *
+ * export default createMiddleware({
+ *   apiKey: process.env.BBLOKER_API_KEY!,
+ * });
+ *
+ * export const config = { matcher: '/((?!_next/static|favicon.ico).*)' };
+ * ```
+ */
+declare function createMiddleware(config: BblokerConfig): (request: NextRequest) => Promise<Response>;
+
+export { BblokerConfig, createMiddleware };

package/dist/adapters/nextjs.js

@@ -0,0 +1,53 @@
+import {
+  Bbloker
+} from "../chunk-6P6B2RO7.js";
+
+// src/adapters/nextjs.ts
+function createMiddleware(config) {
+  const bbloker = new Bbloker(config);
+  return async function middleware(request) {
+    const { NextResponse } = await import("next/server");
+    const normalized = normalizeNextRequest(request);
+    const decision = bbloker.analyze(normalized);
+    if (decision.action === "block") {
+      if (config.onBlock) {
+        const result = await config.onBlock({
+          fingerprint: {
+            ip: normalized.ip,
+            userAgent: normalized.userAgent,
+            headerOrder: normalized.headerNames,
+            headers: normalized.headers,
+            path: normalized.path,
+            method: normalized.method,
+            ts: Date.now()
+          },
+          decision
+        });
+        if (result instanceof Response) return result;
+      }
+      return new NextResponse(null, { status: 403 });
+    }
+    return NextResponse.next();
+  };
+}
+function normalizeNextRequest(req) {
+  const headers = {};
+  const headerNames = [];
+  req.headers.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    headers[lower] = value;
+    headerNames.push(lower);
+  });
+  return {
+    ip: req.ip ?? headers["x-forwarded-for"]?.split(",")[0]?.trim() ?? headers["x-real-ip"] ?? "0.0.0.0",
+    userAgent: headers["user-agent"] ?? "",
+    headers,
+    headerNames,
+    path: req.nextUrl.pathname,
+    method: req.method
+  };
+}
+export {
+  Bbloker,
+  createMiddleware
+};

package/dist/adapters/node.cjs

@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkKT5GDIXHcjs = require('../chunk-KT5GDIXH.cjs');
+
+// src/adapters/node.ts
+function createHandler(config) {
+  const bbloker = new (0, _chunkKT5GDIXHcjs.Bbloker)(config);
+  return function handler(req, res) {
+    const normalized = normalizeNodeRequest(req);
+    const decision = bbloker.analyze(normalized);
+    if (decision.action === "block") {
+      if (config.onBlock) {
+        const result = config.onBlock({
+          fingerprint: {
+            ip: normalized.ip,
+            userAgent: normalized.userAgent,
+            headerOrder: normalized.headerNames,
+            headers: normalized.headers,
+            path: normalized.path,
+            method: normalized.method,
+            ts: Date.now()
+          },
+          decision
+        });
+        if (result instanceof Promise) {
+          result.catch(() => {
+          });
+        }
+      }
+      res.writeHead(403);
+      res.end();
+      return true;
+    }
+    return false;
+  };
+}
+function normalizeNodeRequest(req) {
+  const rawHeaders = req.headers;
+  const headers = {};
+  const headerNames = [];
+  for (const [key, value] of Object.entries(rawHeaders)) {
+    const lower = key.toLowerCase();
+    headers[lower] = Array.isArray(value) ? value.join(", ") : _nullishCoalesce(value, () => ( ""));
+    headerNames.push(lower);
+  }
+  const forwarded = _optionalChain([headers, 'access', _ => _["x-forwarded-for"], 'optionalAccess', _2 => _2.split, 'call', _3 => _3(","), 'access', _4 => _4[0], 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+  const ip = _nullishCoalesce(_nullishCoalesce(forwarded, () => ( _optionalChain([req, 'access', _7 => _7.socket, 'optionalAccess', _8 => _8.remoteAddress]))), () => ( "0.0.0.0"));
+  return {
+    ip,
+    userAgent: _nullishCoalesce(headers["user-agent"], () => ( "")),
+    headers,
+    headerNames,
+    path: _nullishCoalesce(req.url, () => ( "/")),
+    method: _nullishCoalesce(req.method, () => ( "GET"))
+  };
+}
+
+
+
+exports.Bbloker = _chunkKT5GDIXHcjs.Bbloker; exports.createHandler = createHandler;

package/dist/adapters/node.d.cts

@@ -0,0 +1,25 @@
+import { BblokerConfig } from '../index.cjs';
+export { Bbloker } from '../index.cjs';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Create a raw Node.js HTTP handler wrapper that blocks AI crawlers.
+ *
+ * Usage:
+ * ```ts
+ * import http from 'node:http';
+ * import { createHandler } from '@bbloker/sdk/node';
+ *
+ * const bbloker = createHandler({
+ *   apiKey: process.env.BBLOKER_API_KEY!,
+ * });
+ *
+ * const server = http.createServer((req, res) => {
+ *   if (bbloker(req, res)) return; // blocked
+ *   res.end('Hello');
+ * });
+ * ```
+ */
+declare function createHandler(config: BblokerConfig): (req: IncomingMessage, res: ServerResponse) => boolean;
+
+export { BblokerConfig, createHandler };

package/dist/adapters/node.d.ts

@@ -0,0 +1,25 @@
+import { BblokerConfig } from '../index.js';
+export { Bbloker } from '../index.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Create a raw Node.js HTTP handler wrapper that blocks AI crawlers.
+ *
+ * Usage:
+ * ```ts
+ * import http from 'node:http';
+ * import { createHandler } from '@bbloker/sdk/node';
+ *
+ * const bbloker = createHandler({
+ *   apiKey: process.env.BBLOKER_API_KEY!,
+ * });
+ *
+ * const server = http.createServer((req, res) => {
+ *   if (bbloker(req, res)) return; // blocked
+ *   res.end('Hello');
+ * });
+ * ```
+ */
+declare function createHandler(config: BblokerConfig): (req: IncomingMessage, res: ServerResponse) => boolean;
+
+export { BblokerConfig, createHandler };

package/dist/adapters/node.js

@@ -0,0 +1,60 @@
+import {
+  Bbloker
+} from "../chunk-6P6B2RO7.js";
+
+// src/adapters/node.ts
+function createHandler(config) {
+  const bbloker = new Bbloker(config);
+  return function handler(req, res) {
+    const normalized = normalizeNodeRequest(req);
+    const decision = bbloker.analyze(normalized);
+    if (decision.action === "block") {
+      if (config.onBlock) {
+        const result = config.onBlock({
+          fingerprint: {
+            ip: normalized.ip,
+            userAgent: normalized.userAgent,
+            headerOrder: normalized.headerNames,
+            headers: normalized.headers,
+            path: normalized.path,
+            method: normalized.method,
+            ts: Date.now()
+          },
+          decision
+        });
+        if (result instanceof Promise) {
+          result.catch(() => {
+          });
+        }
+      }
+      res.writeHead(403);
+      res.end();
+      return true;
+    }
+    return false;
+  };
+}
+function normalizeNodeRequest(req) {
+  const rawHeaders = req.headers;
+  const headers = {};
+  const headerNames = [];
+  for (const [key, value] of Object.entries(rawHeaders)) {
+    const lower = key.toLowerCase();
+    headers[lower] = Array.isArray(value) ? value.join(", ") : value ?? "";
+    headerNames.push(lower);
+  }
+  const forwarded = headers["x-forwarded-for"]?.split(",")[0]?.trim();
+  const ip = forwarded ?? req.socket?.remoteAddress ?? "0.0.0.0";
+  return {
+    ip,
+    userAgent: headers["user-agent"] ?? "",
+    headers,
+    headerNames,
+    path: req.url ?? "/",
+    method: req.method ?? "GET"
+  };
+}
+export {
+  Bbloker,
+  createHandler
+};