lopata 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# bunflare
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.2. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "lopata",
+  "version": "0.0.1",
+  "module": "index.ts",
+  "type": "module",
+  "bin": {
+    "lopata": "runtime/cli.ts"
+  },
+  "exports": {
+    "./vite-plugin": "./runtime/vite-plugin/index.ts"
+  },
+  "files": [
+    "runtime/",
+    "!runtime/tests/",
+    "index.ts"
+  ],
+  "scripts": {
+    "wrangler:dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "types": "wrangler types",
+    "cli": "bun runtime/cli.ts",
+    "dev": "bun runtime/cli.ts dev",
+    "lint": "biome lint .",
+    "lint:fix": "biome lint . --write",
+    "format": "dprint fmt",
+    "format:check": "dprint check"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@types/bun": "latest",
+    "dprint": "^0.51.1",
+    "bun-plugin-tailwind": "^0.1.2",
+    "vite": "^7.3.1",
+    "wrangler": "^4.65.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "optionalDependencies": {
+    "puppeteer": "*",
+    "puppeteer-core": "*"
+  },
+  "dependencies": {
+    "@cloudflare/sandbox": "^0.7.4",
+    "html-rewriter-wasm": "^0.4.1",
+    "preact": "^10.28.3",
+    "sharp": "^0.34.5",
+    "smol-toml": "^1.6.0",
+    "tailwindcss": "^4.1.18"
+  }
+}

package/runtime/bindings/ai.ts

@@ -0,0 +1,132 @@
+/**
+ * Local implementation of the Cloudflare Workers AI binding.
+ * Proxies requests to the Cloudflare AI API and logs them to SQLite.
+ */
+import type { Database } from "bun:sqlite";
+
+const MAX_LOG_SIZE = 1024;
+
+function truncate(value: unknown): string {
+	const str = typeof value === "string" ? value : JSON.stringify(value);
+	if (!str) return "";
+	return str.length > MAX_LOG_SIZE ? str.slice(0, MAX_LOG_SIZE) + "…" : str;
+}
+
+export class AiBinding {
+	private readonly db: Database;
+	private readonly accountId?: string;
+	private readonly apiToken?: string;
+	aiGatewayLogId: string | null = null;
+
+	constructor(db: Database, accountId?: string, apiToken?: string) {
+		this.db = db;
+		this.accountId = accountId;
+		this.apiToken = apiToken;
+	}
+
+	private ensureCredentials(): { accountId: string; apiToken: string } {
+		if (!this.accountId || !this.apiToken) {
+			throw new Error(
+				"Workers AI requires CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN in .dev.vars",
+			);
+		}
+		return { accountId: this.accountId, apiToken: this.apiToken };
+	}
+
+	async run(model: string, inputs: Record<string, unknown>, options?: { returnRawResponse?: boolean }): Promise<unknown> {
+		const { accountId, apiToken } = this.ensureCredentials();
+		const isStreaming = !!inputs.stream;
+		const id = crypto.randomUUID();
+		const start = Date.now();
+
+		let status = "ok";
+		let error: string | undefined;
+		let outputSummary = "";
+
+		try {
+			const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}`;
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${apiToken}`,
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify(inputs),
+			});
+
+			if (!response.ok) {
+				const text = await response.text();
+				status = "error";
+				error = `HTTP ${response.status}: ${text}`;
+				throw new Error(error);
+			}
+
+			if (isStreaming) {
+				outputSummary = "<streaming>";
+				return response.body;
+			}
+
+			if (options?.returnRawResponse) {
+				outputSummary = "<raw response>";
+				return response;
+			}
+
+			const json = await response.json() as { result?: unknown };
+			outputSummary = truncate(json.result);
+			return json.result;
+		} catch (err) {
+			if (status !== "error") {
+				status = "error";
+				error = err instanceof Error ? err.message : String(err);
+			}
+			throw err;
+		} finally {
+			const duration = Date.now() - start;
+			this.db.prepare(
+				`INSERT INTO ai_requests (id, model, input_summary, output_summary, duration_ms, status, error, is_streaming, created_at)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			).run(
+				id,
+				model,
+				truncate(inputs),
+				outputSummary,
+				duration,
+				status,
+				error ?? null,
+				isStreaming ? 1 : 0,
+				start,
+			);
+		}
+	}
+
+	async models(params?: Record<string, string>): Promise<unknown[]> {
+		const { accountId, apiToken } = this.ensureCredentials();
+		const url = new URL(`https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/models/search`);
+		if (params) {
+			for (const [key, value] of Object.entries(params)) {
+				url.searchParams.set(key, value);
+			}
+		}
+		const response = await fetch(url.toString(), {
+			headers: { Authorization: `Bearer ${apiToken}` },
+		});
+		if (!response.ok) {
+			const text = await response.text();
+			throw new Error(`Workers AI models() failed: HTTP ${response.status}: ${text}`);
+		}
+		const json = await response.json() as { result?: unknown[] };
+		return json.result ?? [];
+	}
+
+	gateway(_id: string): never {
+		throw new Error("ai.gateway() is not supported in local dev mode");
+	}
+
+	autorag(_id: string): never {
+		throw new Error("ai.autorag() is not supported in local dev mode");
+	}
+
+	toMarkdown(): never {
+		throw new Error("ai.toMarkdown() is not supported in local dev mode");
+	}
+}

package/runtime/bindings/analytics-engine.ts

@@ -0,0 +1,96 @@
+import type { Database } from "bun:sqlite";
+import { randomUUIDv7 } from "bun";
+
+export interface AnalyticsEngineDataPoint {
+	indexes?: ((ArrayBuffer | string) | null)[];
+	doubles?: number[];
+	blobs?: ((ArrayBuffer | string) | null)[];
+}
+
+const MAX_INDEXES = 1;
+const MAX_INDEX_BYTES = 96;
+const MAX_DOUBLES = 20;
+const MAX_BLOBS = 20;
+const MAX_BLOBS_TOTAL_BYTES = 16 * 1024; // 16 KB
+
+function toText(value: ArrayBuffer | string | null | undefined): string | null {
+	if (value == null) return null;
+	if (typeof value === "string") return value;
+	return new TextDecoder().decode(value);
+}
+
+function byteLength(value: ArrayBuffer | string | null | undefined): number {
+	if (value == null) return 0;
+	if (typeof value === "string") return new TextEncoder().encode(value).byteLength;
+	return value.byteLength;
+}
+
+/**
+ * SqliteAnalyticsEngine — local implementation of the Cloudflare Analytics Engine
+ * `writeDataPoint()` binding. Stores data points in SQLite.
+ */
+export class SqliteAnalyticsEngine {
+	private db: Database;
+	private dataset: string;
+	private insertStmt: ReturnType<Database["query"]>;
+
+	constructor(db: Database, dataset: string) {
+		this.db = db;
+		this.dataset = dataset;
+
+		const blobCols = Array.from({ length: MAX_BLOBS }, (_, i) => `blob${i + 1}`);
+		const doubleCols = Array.from({ length: MAX_DOUBLES }, (_, i) => `double${i + 1}`);
+		const allCols = ["id", "dataset", "timestamp", "_sample_interval", "index1", ...blobCols, ...doubleCols];
+		const placeholders = allCols.map(() => "?").join(", ");
+		this.insertStmt = db.query(`INSERT INTO analytics_engine (${allCols.join(", ")}) VALUES (${placeholders})`);
+	}
+
+	writeDataPoint(event?: AnalyticsEngineDataPoint): void {
+		const indexes = event?.indexes ?? [];
+		const doubles = event?.doubles ?? [];
+		const blobs = event?.blobs ?? [];
+
+		// Validate indexes
+		if (indexes.length > MAX_INDEXES) {
+			throw new Error(`Analytics Engine: indexes array exceeds maximum length of ${MAX_INDEXES}`);
+		}
+		for (const idx of indexes) {
+			if (idx != null && byteLength(idx) > MAX_INDEX_BYTES) {
+				throw new Error(`Analytics Engine: index value exceeds maximum size of ${MAX_INDEX_BYTES} bytes`);
+			}
+		}
+
+		// Validate doubles
+		if (doubles.length > MAX_DOUBLES) {
+			throw new Error(`Analytics Engine: doubles array exceeds maximum length of ${MAX_DOUBLES}`);
+		}
+
+		// Validate blobs
+		if (blobs.length > MAX_BLOBS) {
+			throw new Error(`Analytics Engine: blobs array exceeds maximum length of ${MAX_BLOBS}`);
+		}
+		let totalBlobBytes = 0;
+		for (const blob of blobs) {
+			totalBlobBytes += byteLength(blob);
+		}
+		if (totalBlobBytes > MAX_BLOBS_TOTAL_BYTES) {
+			throw new Error(`Analytics Engine: total blob size exceeds maximum of ${MAX_BLOBS_TOTAL_BYTES} bytes`);
+		}
+
+		const id = randomUUIDv7();
+		const timestamp = Date.now();
+		const index1 = toText(indexes[0]);
+
+		const blobValues: (string | null)[] = [];
+		for (let i = 0; i < MAX_BLOBS; i++) {
+			blobValues.push(i < blobs.length ? toText(blobs[i]) : null);
+		}
+
+		const doubleValues: (number | null)[] = [];
+		for (let i = 0; i < MAX_DOUBLES; i++) {
+			doubleValues.push(i < doubles.length ? doubles[i]! : null);
+		}
+
+		this.insertStmt.run(id, this.dataset, timestamp, 1, index1, ...blobValues, ...doubleValues);
+	}
+}

package/runtime/bindings/browser.ts

@@ -0,0 +1,64 @@
+/**
+ * Local shim for Cloudflare's Browser Rendering binding.
+ *
+ * On Cloudflare, env.BROWSER is a Fetcher ({ fetch }) that proxies to
+ * the Browser Rendering API. @cloudflare/puppeteer calls
+ * endpoint.fetch("/v1/acquire") etc. under the hood.
+ *
+ * For local dev we skip the Fetcher layer entirely — the plugin shim
+ * for @cloudflare/puppeteer delegates directly to this class which
+ * uses real puppeteer / puppeteer-core.
+ */
+
+export interface ActiveSession {
+  sessionId: string;
+  startTime: number;
+  connectionId?: string;
+  connectionStartTime?: number;
+}
+
+export class BrowserBinding {
+  /** Managed browser instance (when launched locally, not via wsEndpoint). */
+  private _browser: any = null;
+
+  constructor(private config: { wsEndpoint?: string; executablePath?: string; headless?: boolean }) {}
+
+  /** Launch a new browser and return a puppeteer Browser instance. */
+  async launch(opts?: { keep_alive?: number }): Promise<any> {
+    if (this.config.wsEndpoint) {
+      // @ts-ignore — puppeteer-core is an optional dependency
+      const puppeteer = await import("puppeteer-core");
+      this._browser = await puppeteer.default.connect({ browserWSEndpoint: this.config.wsEndpoint });
+      return this._browser;
+    }
+    // @ts-ignore — puppeteer is an optional dependency
+    const puppeteer = await import("puppeteer");
+    this._browser = await puppeteer.default.launch({
+      headless: this.config.headless ?? true,
+      executablePath: this.config.executablePath,
+    });
+    return this._browser;
+  }
+
+  /** Connect to an existing browser session by sessionId. */
+  async connect(sessionId: string): Promise<any> {
+    if (this.config.wsEndpoint) {
+      // @ts-ignore — puppeteer-core is an optional dependency
+      const puppeteer = await import("puppeteer-core");
+      return puppeteer.default.connect({ browserWSEndpoint: this.config.wsEndpoint });
+    }
+    // In local dev without wsEndpoint, return the existing managed browser if available
+    if (this._browser && this._browser.isConnected()) {
+      return this._browser;
+    }
+    throw new Error("connect() requires wsEndpoint in browser config, or launch() first");
+  }
+
+  /** List active sessions (stub — local dev has at most one). */
+  async sessions(): Promise<ActiveSession[]> {
+    if (this._browser && this._browser.isConnected()) {
+      return [{ sessionId: "local", startTime: Date.now() }];
+    }
+    return [];
+  }
+}

package/runtime/bindings/cache.ts

@@ -0,0 +1,179 @@
+import type { Database } from "bun:sqlite";
+
+export interface CacheLimits {
+	maxBodySize?: number; // default 512 MiB (CF limit)
+	maxHeaderSize?: number; // default 32 KiB per header pair
+}
+
+const CACHE_DEFAULTS: Required<CacheLimits> = {
+	maxBodySize: 512 * 1024 * 1024,
+	maxHeaderSize: 32 * 1024,
+};
+
+/**
+ * Parse Cache-Control header and return the effective max-age in seconds,
+ * or null if no cacheable directive found.
+ * Returns -1 for no-store (should not be cached at all).
+ */
+function parseCacheControlMaxAge(header: string | null): number | null {
+	if (!header) return null;
+
+	const directives = header.toLowerCase().split(",").map((d) => d.trim());
+
+	for (const d of directives) {
+		if (d === "no-store") return -1;
+	}
+
+	// s-maxage takes precedence over max-age for shared caches (CF behavior)
+	for (const d of directives) {
+		const sMaxAgeMatch = d.match(/^s-maxage\s*=\s*(\d+)$/);
+		if (sMaxAgeMatch?.[1]) return parseInt(sMaxAgeMatch[1], 10);
+	}
+
+	for (const d of directives) {
+		const maxAgeMatch = d.match(/^max-age\s*=\s*(\d+)$/);
+		if (maxAgeMatch?.[1]) return parseInt(maxAgeMatch[1], 10);
+	}
+
+	return null;
+}
+
+/**
+ * Compute the expiration timestamp (ms since epoch) from response headers.
+ * Returns null if no expiration info is present (cache indefinitely).
+ */
+function computeExpiresAt(headers: Headers): number | null {
+	const cacheControl = headers.get("cache-control");
+	const maxAge = parseCacheControlMaxAge(cacheControl);
+
+	if (maxAge === -1) return -1; // signal: no-store
+	if (maxAge !== null) return Date.now() + maxAge * 1000;
+
+	// Fallback to Expires header
+	const expires = headers.get("expires");
+	if (expires) {
+		const expiresTime = Date.parse(expires);
+		if (!isNaN(expiresTime)) return expiresTime;
+	}
+
+	return null;
+}
+
+export class SqliteCache {
+	private db: Database;
+	private cacheName: string;
+	private limits: Required<CacheLimits>;
+
+	constructor(db: Database, cacheName: string, limits?: CacheLimits) {
+		this.db = db;
+		this.cacheName = cacheName;
+		this.limits = { ...CACHE_DEFAULTS, ...limits };
+	}
+
+	async match(request: Request | string, options?: { ignoreMethod?: boolean }): Promise<Response | undefined> {
+		const req = typeof request === "string" ? new Request(request) : request;
+
+		// Only GET requests are cacheable unless ignoreMethod is true
+		if (req.method !== "GET" && !options?.ignoreMethod) {
+			return undefined;
+		}
+
+		const url = req.url;
+		const row = this.db.query<{ status: number; headers: string; body: Uint8Array; expires_at: number | null }, [string, string]>(
+			"SELECT status, headers, body, expires_at FROM cache_entries WHERE cache_name = ? AND url = ?"
+		).get(this.cacheName, url);
+
+		if (!row) return undefined;
+
+		// Check expiration — lazily delete expired entries
+		if (row.expires_at !== null && row.expires_at <= Date.now()) {
+			this.db.query(
+				"DELETE FROM cache_entries WHERE cache_name = ? AND url = ?"
+			).run(this.cacheName, url);
+			return undefined;
+		}
+
+		const headers = new Headers(JSON.parse(row.headers));
+		headers.set("cf-cache-status", "HIT");
+		return new Response(row.body, { status: row.status, headers });
+	}
+
+	async put(request: Request | string, response: Response): Promise<void> {
+		const req = typeof request === "string" ? new Request(request) : request;
+
+		// Only GET requests are cacheable
+		if (req.method !== "GET") {
+			throw new Error("Cache API only supports caching GET requests");
+		}
+
+		// Reject 206 Partial Content
+		if (response.status === 206) {
+			throw new Error("Cache API does not support caching 206 Partial Content responses");
+		}
+
+		// Reject Vary: *
+		const vary = response.headers.get("vary");
+		if (vary && vary.trim() === "*") {
+			throw new Error("Cache API does not support caching responses with Vary: *");
+		}
+
+		// Responses with Set-Cookie header should not be cached (Cloudflare behavior)
+		if (response.headers.has("Set-Cookie")) {
+			return;
+		}
+
+		// Parse expiration from Cache-Control / Expires
+		const expiresAt = computeExpiresAt(response.headers);
+
+		// no-store — don't cache at all
+		if (expiresAt === -1) {
+			return;
+		}
+
+		const url = req.url;
+		const status = response.status;
+		const headers = JSON.stringify([...response.headers.entries()]);
+		const body = new Uint8Array(await response.arrayBuffer());
+
+		// Validate body size
+		if (body.byteLength > this.limits.maxBodySize) {
+			throw new Error(`Response body exceeds max size of ${this.limits.maxBodySize} bytes`);
+		}
+
+		this.db.query(
+			"INSERT OR REPLACE INTO cache_entries (cache_name, url, status, headers, body, expires_at) VALUES (?, ?, ?, ?, ?, ?)"
+		).run(this.cacheName, url, status, headers, body, expiresAt);
+	}
+
+	async delete(request: Request | string, options?: { ignoreMethod?: boolean }): Promise<boolean> {
+		const req = typeof request === "string" ? new Request(request) : request;
+
+		// Only GET requests are cacheable unless ignoreMethod is true
+		if (req.method !== "GET" && !options?.ignoreMethod) {
+			return false;
+		}
+
+		const url = req.url;
+		const result = this.db.query(
+			"DELETE FROM cache_entries WHERE cache_name = ? AND url = ?"
+		).run(this.cacheName, url);
+
+		return result.changes > 0;
+	}
+}
+
+export class SqliteCacheStorage {
+	private db: Database;
+	private limits?: CacheLimits;
+	public default: SqliteCache;
+
+	constructor(db: Database, limits?: CacheLimits) {
+		this.db = db;
+		this.limits = limits;
+		this.default = new SqliteCache(db, "default", limits);
+	}
+
+	async open(cacheName: string): Promise<SqliteCache> {
+		return new SqliteCache(this.db, cacheName, this.limits);
+	}
+}

package/runtime/bindings/cf-streams.ts

@@ -0,0 +1,56 @@
+/**
+ * Cloudflare-specific stream classes: IdentityTransformStream and FixedLengthStream.
+ */
+
+/**
+ * IdentityTransformStream — passes bytes through unchanged.
+ * Functionally equivalent to `new TransformStream()` but semantically indicates byte stream passthrough.
+ */
+export class IdentityTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+  constructor() {
+    super();
+  }
+}
+
+/**
+ * FixedLengthStream — enforces exact byte count.
+ * Errors if total bytes written exceed `expectedLength` or if closed before reaching it.
+ */
+export class FixedLengthStream extends TransformStream<Uint8Array, Uint8Array> {
+  readonly expectedLength: number;
+
+  constructor(expectedLength: number | bigint) {
+    const length = Number(expectedLength);
+    if (!Number.isFinite(length) || length < 0) {
+      throw new TypeError("FixedLengthStream requires a non-negative length");
+    }
+
+    let bytesWritten = 0;
+
+    super({
+      transform(chunk, controller) {
+        bytesWritten += chunk.byteLength;
+        if (bytesWritten > length) {
+          controller.error(
+            new TypeError(
+              `FixedLengthStream: exceeded expected length of ${length} bytes (got ${bytesWritten})`
+            )
+          );
+          return;
+        }
+        controller.enqueue(chunk);
+      },
+      flush(controller) {
+        if (bytesWritten < length) {
+          controller.error(
+            new TypeError(
+              `FixedLengthStream: stream closed with ${bytesWritten} bytes, expected ${length}`
+            )
+          );
+        }
+      },
+    });
+
+    this.expectedLength = length;
+  }
+}