lopata 0.0.1

package/runtime/bunflare-config.ts

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+
+export interface BunflareConfig {
+  /** Path to the main worker's wrangler config (HTTP entrypoint) */
+  main: string;
+  /** Auxiliary workers, each with a service name and wrangler config path */
+  workers?: Array<{
+    name: string;
+    config: string;
+  }>;
+  /** Enable real cron scheduling based on wrangler triggers.crons (default: false) */
+  cron?: boolean;
+  /**
+   * DO isolation mode:
+   * - "dev" (default) — all DO instances run in-process (fast, shared memory, hot reload)
+   * - "isolated" — each DO instance runs in a separate Bun Worker thread (faithful to CF production)
+   */
+  isolation?: "dev" | "isolated";
+  /** Browser Rendering binding config for local dev */
+  browser?: {
+    /** WS endpoint of an existing Chrome instance. If set, uses puppeteer-core connect(). */
+    wsEndpoint?: string;
+    /** Path to Chrome executable (only used when spawning without wsEndpoint). */
+    executablePath?: string;
+    /** Headless mode (default: true, only used when spawning). */
+    headless?: boolean;
+  };
+}
+
+export function defineConfig(config: BunflareConfig): BunflareConfig {
+  return config;
+}
+
+/**
+ * Try to load `bunflare.config.ts` from the given directory.
+ * Returns null if the file doesn't exist.
+ * All paths in the returned config are resolved relative to baseDir.
+ */
+export async function loadBunflareConfig(baseDir: string): Promise<BunflareConfig | null> {
+  const configPath = join(baseDir, "bunflare.config.ts");
+  if (!existsSync(configPath)) return null;
+
+  const mod = await import(configPath);
+  const config: BunflareConfig = mod.default ?? mod;
+
+  // Resolve all paths relative to baseDir
+  config.main = resolve(baseDir, config.main);
+  if (config.workers) {
+    for (const worker of config.workers) {
+      worker.config = resolve(baseDir, worker.config);
+    }
+  }
+
+  return config;
+}

package/runtime/cli/cache.ts

@@ -0,0 +1,39 @@
+import type { CliContext } from "./context";
+import { parseFlag } from "./context";
+
+export async function run(ctx: CliContext, args: string[]) {
+	const action = args[0];
+
+	switch (action) {
+		case "list": {
+			const db = ctx.db();
+			const rows = db.query<{ cache_name: string; cnt: number }, []>(
+				"SELECT cache_name, COUNT(*) as cnt FROM cache_entries GROUP BY cache_name ORDER BY cache_name",
+			).all();
+			if (rows.length === 0) {
+				console.log("(no cache entries)");
+				return;
+			}
+			for (const row of rows) {
+				console.log(`${row.cache_name}  ${row.cnt} entries`);
+			}
+			break;
+		}
+		case "purge": {
+			const cacheName = parseFlag(ctx.args, "--name");
+			const db = ctx.db();
+			let result;
+			if (cacheName) {
+				result = db.run("DELETE FROM cache_entries WHERE cache_name = ?", [cacheName]);
+				console.log(`Purged ${result.changes} entries from cache "${cacheName}"`);
+			} else {
+				result = db.run("DELETE FROM cache_entries");
+				console.log(`Purged ${result.changes} cache entries (all caches)`);
+			}
+			break;
+		}
+		default:
+			console.error("Usage: bunflare cache <list|purge> [options]");
+			process.exit(1);
+	}
+}

package/runtime/cli/context.ts

@@ -0,0 +1,105 @@
+import type { Database } from "bun:sqlite";
+import type { WranglerConfig } from "../config";
+import { autoLoadConfig, loadConfig } from "../config";
+import { resolve, join } from "node:path";
+
+export interface CliContext {
+	args: string[];
+	config: () => Promise<WranglerConfig>;
+	db: () => Database;
+	dataDir: () => string;
+}
+
+/** Parse a flag value from argv. Returns the value after the flag, or undefined. */
+export function parseFlag(args: string[], name: string): string | undefined {
+	const idx = args.indexOf(name);
+	return idx !== -1 ? args[idx + 1] : undefined;
+}
+
+/** Check if a boolean flag is present. */
+export function hasFlag(args: string[], name: string): boolean {
+	return args.includes(name);
+}
+
+/** Get positional args (everything that's not a flag or flag value). */
+export function positionalArgs(args: string[], flags: string[]): string[] {
+	const result: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		if (flags.includes(args[i]!)) {
+			i++; // skip flag value
+			continue;
+		}
+		if (args[i]!.startsWith("-")) continue;
+		result.push(args[i]!);
+	}
+	return result;
+}
+
+/**
+ * Resolve a single binding from config when multiple bindings of the same type exist.
+ * If there's exactly one, auto-select it. If multiple, require the flag.
+ */
+export function resolveBinding<T extends { binding?: string; bucket_name?: string; queue?: string }>(
+	bindings: T[] | undefined,
+	flagValue: string | undefined,
+	typeName: string,
+	matchField: keyof T = "binding" as keyof T,
+): T {
+	if (!bindings || bindings.length === 0) {
+		console.error(`No ${typeName} bindings configured.`);
+		process.exit(1);
+	}
+	if (bindings.length === 1) return bindings[0]!;
+	if (!flagValue) {
+		const names = bindings.map(b => String(b[matchField])).join(", ");
+		console.error(`Multiple ${typeName} bindings found: ${names}. Use the appropriate flag to select one.`);
+		process.exit(1);
+	}
+	const match = bindings.find(b => String(b[matchField]) === flagValue);
+	if (!match) {
+		const names = bindings.map(b => String(b[matchField])).join(", ");
+		console.error(`${typeName} binding "${flagValue}" not found. Available: ${names}`);
+		process.exit(1);
+	}
+	return match;
+}
+
+export function createContext(argv: string[]): CliContext {
+	// Strip "bun runtime/cli.ts" or similar prefix — find first non-file arg
+	const args = argv.slice(2);
+
+	const configPath = parseFlag(args, "--config") ?? parseFlag(args, "-c");
+	const envName = parseFlag(args, "--env") ?? parseFlag(args, "-e");
+	const baseDir = process.cwd();
+
+	let _config: WranglerConfig | null = null;
+	let _db: Database | null = null;
+
+	return {
+		args,
+		config: async () => {
+			if (_config) return _config;
+			_config = configPath
+				? await loadConfig(resolve(baseDir, configPath), envName)
+				: await autoLoadConfig(baseDir, envName);
+			return _config;
+		},
+		db: () => {
+			if (_db) return _db;
+			const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+			const { mkdirSync } = require("node:fs") as typeof import("node:fs");
+			const dataDir = join(baseDir, ".bunflare");
+			mkdirSync(dataDir, { recursive: true });
+			mkdirSync(join(dataDir, "r2"), { recursive: true });
+			mkdirSync(join(dataDir, "d1"), { recursive: true });
+			const dbPath = join(dataDir, "data.sqlite");
+			_db = new Database(dbPath, { create: true });
+			_db.run("PRAGMA journal_mode=WAL");
+			// Run schema migrations
+			const { runMigrations } = require("../db") as typeof import("../db");
+			runMigrations(_db);
+			return _db;
+		},
+		dataDir: () => join(baseDir, ".bunflare"),
+	};
+}

package/runtime/cli/d1.ts

@@ -0,0 +1,163 @@
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { CliContext } from "./context";
+import { parseFlag, resolveBinding } from "./context";
+import { openD1Database } from "../bindings/d1";
+
+export async function run(ctx: CliContext, args: string[]) {
+	const action = args[0];
+
+	switch (action) {
+		case "list": {
+			const config = await ctx.config();
+			const databases = config.d1_databases ?? [];
+			if (databases.length === 0) {
+				console.log("No D1 databases configured.");
+				return;
+			}
+			for (const db of databases) {
+				console.log(`${db.binding}  ${db.database_name}  ${db.database_id}`);
+			}
+			break;
+		}
+		case "execute": {
+			const dbName = args[1];
+			if (!dbName) {
+				console.error("Usage: bunflare d1 execute <database> --command 'SQL' | --file <path>");
+				process.exit(1);
+			}
+			const config = await ctx.config();
+			const databases = config.d1_databases ?? [];
+			const dbConfig = databases.find(
+				d => d.binding === dbName || d.database_name === dbName,
+			);
+			if (!dbConfig) {
+				const names = databases.map(d => `${d.binding}/${d.database_name}`).join(", ");
+				console.error(`Database "${dbName}" not found. Available: ${names || "(none)"}`);
+				process.exit(1);
+			}
+
+			const command = parseFlag(ctx.args, "--command");
+			const filePath = parseFlag(ctx.args, "--file");
+			if (!command && !filePath) {
+				console.error("Usage: bunflare d1 execute <database> --command 'SQL' | --file <path>");
+				process.exit(1);
+			}
+
+			const sql = command ?? readFileSync(resolve(filePath!), "utf-8");
+			const d1 = openD1Database(ctx.dataDir(), dbConfig.database_name);
+			const result = await d1.exec(sql);
+			console.log(`Executed ${result.count} statement(s) in ${result.duration.toFixed(1)}ms`);
+			break;
+		}
+		case "migrations": {
+			const subAction = args[1];
+			if (subAction !== "apply") {
+				console.error("Usage: bunflare d1 migrations apply [database]");
+				process.exit(1);
+			}
+			const targetDb = args[2];
+			const config = await ctx.config();
+			await applyMigrations(config.d1_databases ?? [], ctx.dataDir(), targetDb);
+			break;
+		}
+		default:
+			console.error(`Usage: bunflare d1 <list|execute|migrations> [options]`);
+			process.exit(1);
+	}
+}
+
+/**
+ * Apply D1 migrations. Extracted from runtime/d1-migrate.ts for CLI reuse.
+ */
+export async function applyMigrations(
+	databases: { binding: string; database_name: string; database_id: string; migrations_dir?: string }[],
+	dataDir: string,
+	targetDb?: string,
+): Promise<number> {
+	const filtered = targetDb
+		? databases.filter(d => d.binding === targetDb || d.database_name === targetDb)
+		: databases;
+
+	if (filtered.length === 0) {
+		if (targetDb) {
+			console.error(`Database "${targetDb}" not found.`);
+			process.exit(1);
+		}
+		console.log("No D1 databases configured.");
+		return 0;
+	}
+
+	const d1Dir = join(dataDir, "d1");
+	mkdirSync(d1Dir, { recursive: true });
+	const baseDir = process.cwd();
+	let totalApplied = 0;
+
+	for (const dbConfig of filtered) {
+		const { database_name, binding, migrations_dir } = dbConfig;
+
+		if (!migrations_dir) {
+			console.log(`${binding} (${database_name}): no migrations_dir, skipping`);
+			continue;
+		}
+
+		const migrationsPath = resolve(baseDir, migrations_dir);
+		if (!existsSync(migrationsPath)) {
+			console.log(`${binding} (${database_name}): migrations_dir not found: ${migrationsPath}`);
+			continue;
+		}
+
+		const dbPath = join(d1Dir, `${database_name}.sqlite`);
+		const db = new Database(dbPath, { create: true });
+		db.run("PRAGMA journal_mode=WAL");
+
+		db.run(`
+			CREATE TABLE IF NOT EXISTS d1_migrations (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				name TEXT NOT NULL UNIQUE,
+				applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+			)
+		`);
+
+		const applied = new Set(
+			db.query<{ name: string }, []>("SELECT name FROM d1_migrations ORDER BY id").all().map(r => r.name),
+		);
+
+		const files = readdirSync(migrationsPath)
+			.filter(f => f.endsWith(".sql"))
+			.sort();
+
+		const pending = files.filter(f => !applied.has(f));
+
+		if (pending.length === 0) {
+			console.log(`${binding} (${database_name}): up to date (${applied.size} migrations)`);
+			db.close();
+			continue;
+		}
+
+		console.log(`${binding} (${database_name}): applying ${pending.length} migration(s)...`);
+
+		for (const file of pending) {
+			const sql = readFileSync(join(migrationsPath, file), "utf-8");
+			try {
+				db.run("BEGIN");
+				db.run(sql);
+				db.run("INSERT INTO d1_migrations (name) VALUES (?)", [file]);
+				db.run("COMMIT");
+				console.log(`  + ${file}`);
+				totalApplied++;
+			} catch (err) {
+				db.run("ROLLBACK");
+				console.error(`  x ${file}: ${err}`);
+				db.close();
+				process.exit(1);
+			}
+		}
+
+		db.close();
+	}
+
+	console.log(`Done. Applied ${totalApplied} migration(s).`);
+	return totalApplied;
+}