lopata 0.0.1

package/runtime/cli/r2.ts

@@ -0,0 +1,140 @@
+import type { CliContext } from "./context";
+import { parseFlag } from "./context";
+import { FileR2Bucket } from "../bindings/r2";
+
+/**
+ * Parse wrangler-compatible objectPath in the form {bucket}/{key}.
+ * If there's no slash, the whole string is the bucket name (for list).
+ */
+function parseObjectPath(objectPath: string): { bucketName: string; key: string } {
+	const idx = objectPath.indexOf("/");
+	if (idx === -1) return { bucketName: objectPath, key: "" };
+	return { bucketName: objectPath.slice(0, idx), key: objectPath.slice(idx + 1) };
+}
+
+/**
+ * Resolve bucket name: check it exists in config, return the config entry's bucket_name.
+ */
+function resolveBucket(
+	buckets: { binding: string; bucket_name: string }[] | undefined,
+	bucketName: string,
+): string {
+	if (!buckets || buckets.length === 0) {
+		console.error("No R2 buckets configured.");
+		process.exit(1);
+	}
+	// Match by bucket_name or binding name
+	const match = buckets.find(b => b.bucket_name === bucketName || b.binding === bucketName);
+	if (!match) {
+		const names = buckets.map(b => b.bucket_name).join(", ");
+		console.error(`R2 bucket "${bucketName}" not found. Available: ${names}`);
+		process.exit(1);
+	}
+	return match.bucket_name;
+}
+
+export async function run(ctx: CliContext, args: string[]) {
+	const sub = args[0];
+	if (sub !== "object") {
+		console.error(`Usage: bunflare r2 object <list|get|put|delete> <bucket/key>`);
+		process.exit(1);
+	}
+
+	const action = args[1];
+	const objectPath = args[2];
+	const config = await ctx.config();
+
+	switch (action) {
+		case "list": {
+			if (!objectPath) {
+				// No path — list all buckets if no path given
+				const buckets = config.r2_buckets ?? [];
+				if (buckets.length === 0) {
+					console.log("No R2 buckets configured.");
+					return;
+				}
+				for (const b of buckets) {
+					console.log(`${b.bucket_name}  binding=${b.binding}`);
+				}
+				return;
+			}
+			const { bucketName, key: prefix } = parseObjectPath(objectPath);
+			const resolved = resolveBucket(config.r2_buckets, bucketName);
+			const bucket = new FileR2Bucket(ctx.db(), resolved, ctx.dataDir());
+			const listPrefix = parseFlag(ctx.args, "--prefix") ?? prefix;
+			let cursor = "";
+			let total = 0;
+			do {
+				const result = await bucket.list({ prefix: listPrefix, cursor: cursor || undefined });
+				for (const obj of result.objects) {
+					const size = formatSize(obj.size);
+					const date = obj.uploaded.toISOString().slice(0, 19).replace("T", " ");
+					console.log(`${date}  ${size.padStart(10)}  ${obj.key}`);
+				}
+				total += result.objects.length;
+				cursor = result.cursor;
+			} while (cursor);
+			if (total === 0) console.log("(no objects)");
+			break;
+		}
+		case "get": {
+			if (!objectPath || !objectPath.includes("/")) {
+				console.error("Usage: bunflare r2 object get <bucket/key>");
+				process.exit(1);
+			}
+			const { bucketName, key } = parseObjectPath(objectPath);
+			const resolved = resolveBucket(config.r2_buckets, bucketName);
+			const bucket = new FileR2Bucket(ctx.db(), resolved, ctx.dataDir());
+			const obj = await bucket.get(key);
+			if (!obj) {
+				console.error(`Object not found: ${key}`);
+				process.exit(1);
+			}
+			if ("arrayBuffer" in obj) {
+				const data = await obj.arrayBuffer();
+				process.stdout.write(new Uint8Array(data));
+			}
+			break;
+		}
+		case "put": {
+			if (!objectPath || !objectPath.includes("/")) {
+				console.error("Usage: bunflare r2 object put <bucket/key> --file <path>");
+				process.exit(1);
+			}
+			const filePath = parseFlag(ctx.args, "--file") ?? parseFlag(ctx.args, "-f");
+			if (!filePath) {
+				console.error("Usage: bunflare r2 object put <bucket/key> --file <path>");
+				process.exit(1);
+			}
+			const { bucketName, key } = parseObjectPath(objectPath);
+			const resolved = resolveBucket(config.r2_buckets, bucketName);
+			const bucket = new FileR2Bucket(ctx.db(), resolved, ctx.dataDir());
+			const data = await Bun.file(filePath).arrayBuffer();
+			await bucket.put(key, data);
+			console.log(`Uploaded ${key} (${formatSize(data.byteLength)})`);
+			break;
+		}
+		case "delete": {
+			if (!objectPath || !objectPath.includes("/")) {
+				console.error("Usage: bunflare r2 object delete <bucket/key>");
+				process.exit(1);
+			}
+			const { bucketName, key } = parseObjectPath(objectPath);
+			const resolved = resolveBucket(config.r2_buckets, bucketName);
+			const bucket = new FileR2Bucket(ctx.db(), resolved, ctx.dataDir());
+			await bucket.delete(key);
+			console.log(`Deleted ${key}`);
+			break;
+		}
+		default:
+			console.error(`Usage: bunflare r2 object <list|get|put|delete> <bucket/key>`);
+			process.exit(1);
+	}
+}
+
+function formatSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}

package/runtime/cli/traces.ts

@@ -0,0 +1,251 @@
+import type { CliContext } from "./context";
+import { parseFlag, hasFlag } from "./context";
+import { getTracingDatabase } from "../tracing/db";
+import { TraceStore } from "../tracing/store";
+import type { SpanData, SpanEventData } from "../tracing/types";
+
+const USAGE = `Usage:
+  bunflare trace list [options]   List traces
+  bunflare trace get <traceId>    Get trace detail
+
+Options:
+  --json              Output as JSON
+  --limit <n>         Max results (default 50)
+  --since <dur>       Show traces since duration ago (e.g. 5m, 1h, 2d)
+  --search <query>    Filter traces by text search
+  --cursor <cursor>   Pagination cursor from previous result`;
+
+export async function run(ctx: CliContext, args: string[]) {
+	const action = args[0];
+	const db = getTracingDatabase();
+	const store = new TraceStore(db);
+	const json = hasFlag(ctx.args, "--json");
+
+	switch (action) {
+		case "list": {
+			const limitStr = parseFlag(ctx.args, "--limit");
+			const limit = limitStr ? parseInt(limitStr, 10) : 50;
+			const since = parseFlag(ctx.args, "--since");
+			const search = parseFlag(ctx.args, "--search");
+			const cursor = parseFlag(ctx.args, "--cursor");
+
+			let items: Array<{ traceId: string; rootSpanName: string; workerName: string | null; status: string; statusMessage: string | null; startTime: number; durationMs: number | null; spanCount: number; errorCount: number }>;
+			let nextCursor: string | null;
+
+			if (search) {
+				const result = store.searchTraces(search, limit);
+				items = result.items;
+				nextCursor = result.cursor;
+			} else if (since) {
+				const sinceMs = Date.now() - parseDuration(since);
+				items = store.getRecentTraces(sinceMs, limit);
+				nextCursor = null;
+			} else {
+				const result = store.listTraces({ limit, cursor });
+				items = result.items;
+				nextCursor = result.cursor;
+			}
+
+			if (json) {
+				console.log(JSON.stringify({ items, cursor: nextCursor }, null, 2));
+			} else {
+				printTraceList(items, nextCursor);
+			}
+			break;
+		}
+		case "get": {
+			const traceId = args[1];
+			if (!traceId) {
+				console.error("Usage: bunflare trace get <traceId>");
+				process.exit(1);
+			}
+
+			const { spans, events } = store.getTrace(traceId);
+			if (spans.length === 0) {
+				console.error(`Trace not found: ${traceId}`);
+				process.exit(1);
+			}
+
+			const errors = store.getErrorsForTrace(traceId);
+
+			if (json) {
+				console.log(JSON.stringify({ traceId, spans, events, errors }, null, 2));
+			} else {
+				printTraceDetail(traceId, spans, events, errors);
+			}
+			break;
+		}
+		default:
+			console.error(USAGE);
+			process.exit(1);
+	}
+}
+
+// ─── Text output: list ───────────────────────────────────────────────
+
+function printTraceList(
+	items: Array<{ traceId: string; rootSpanName: string; status: string; startTime: number; durationMs: number | null; spanCount: number; errorCount: number }>,
+	cursor: string | null,
+) {
+	if (items.length === 0) {
+		console.log("(no traces)");
+		return;
+	}
+
+	const header = "TIME                STATUS  DURATION  SPANS  ERRORS  NAME";
+	const sep = "─".repeat(header.length);
+	console.log(header);
+	console.log(sep);
+
+	for (const t of items) {
+		const time = fmtTime(t.startTime);
+		const status = statusIcon(t.status) + " " + t.status.padEnd(5);
+		const dur = t.durationMs !== null ? `${t.durationMs.toFixed(0)}ms`.padStart(6) : "   ...";
+		const spans = String(t.spanCount).padStart(5);
+		const errs = t.errorCount > 0 ? String(t.errorCount).padStart(6) : "     -";
+		console.log(`${time}  ${status}  ${dur}  ${spans}  ${errs}  ${t.rootSpanName}`);
+	}
+
+	console.log(sep);
+	console.log(`${items.length} trace(s)` + (items.length > 0 ? `  oldest id: ${items[items.length - 1]!.traceId}` : ""));
+
+	if (cursor) {
+		console.log(`\nMore results available. Use --cursor ${cursor}`);
+	}
+}
+
+// ─── Text output: get ────────────────────────────────────────────────
+
+function printTraceDetail(
+	traceId: string,
+	spans: SpanData[],
+	events: SpanEventData[],
+	errors: Array<{ id: string; timestamp: number; errorName: string; errorMessage: string; source: string | null; data: unknown }>,
+) {
+	const root = spans.find(s => !s.parentSpanId);
+	const totalDuration = root?.durationMs;
+	const startTime = root?.startTime ?? spans[0]!.startTime;
+
+	// Header
+	console.log(`Trace ${traceId}`);
+	console.log(`Status: ${statusIcon(root?.status ?? "unset")} ${root?.status ?? "unset"}  |  Duration: ${fmtDuration(totalDuration)}  |  Spans: ${spans.length}  |  Started: ${fmtTime(startTime)}`);
+	if (root?.workerName) console.log(`Worker: ${root.workerName}`);
+
+	// Span tree
+	console.log("\nSpans");
+	const spanMap = new Map(spans.map(s => [s.spanId, s]));
+	const children = new Map<string | null, SpanData[]>();
+	for (const s of spans) {
+		const pid = s.parentSpanId ?? null;
+		if (!children.has(pid)) children.set(pid, []);
+		children.get(pid)!.push(s);
+	}
+	const rootSpans = children.get(null) ?? [];
+	for (let i = 0; i < rootSpans.length; i++) {
+		printSpanTree(rootSpans[i]!, children, "", i === rootSpans.length - 1);
+	}
+
+	// Events
+	if (events.length > 0) {
+		console.log("\nEvents");
+		for (const e of events) {
+			const ts = fmtTimestamp(e.timestamp);
+			const level = e.level ? `[${e.level}]`.padEnd(8) : "        ";
+			const msg = e.message ?? e.name;
+			const spanName = spanMap.get(e.spanId)?.name;
+			const spanRef = spanName ? `  (${spanName})` : "";
+			console.log(`  ${ts}  ${level} ${msg}${spanRef}`);
+		}
+	}
+
+	// Errors
+	if (errors.length > 0) {
+		console.log("\nErrors");
+		for (const e of errors) {
+			const ts = fmtTimestamp(e.timestamp);
+			console.log(`  ${ts}  \x1b[31m${e.errorName}: ${e.errorMessage}\x1b[0m` + (e.source ? `  [${e.source}]` : ""));
+			const stack = extractStack(e.data);
+			if (stack) {
+				for (const line of stack) {
+					console.log(`           \x1b[2m${line}\x1b[0m`);
+				}
+			}
+		}
+	}
+}
+
+function printSpanTree(span: SpanData, children: Map<string | null, SpanData[]>, prefix: string, isLast: boolean) {
+	const connector = isLast ? "└─ " : "├─ ";
+	const status = statusIcon(span.status);
+	const dur = fmtDuration(span.durationMs);
+	const kind = span.kind !== "internal" ? ` [${span.kind}]` : "";
+	const errMsg = span.status === "error" && span.statusMessage ? `: ${span.statusMessage}` : "";
+	console.log(`${prefix}${connector}${status} ${span.name}${kind}  ${span.status} ${dur}${errMsg}`);
+
+	const attrs = span.attributes;
+	if (attrs && Object.keys(attrs).length > 0) {
+		const attrPrefix = prefix + (isLast ? "   " : "│  ");
+		for (const [k, v] of Object.entries(attrs)) {
+			console.log(`${attrPrefix}  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`);
+		}
+	}
+
+	const kids = children.get(span.spanId) ?? [];
+	const childPrefix = prefix + (isLast ? "   " : "│  ");
+	for (let i = 0; i < kids.length; i++) {
+		printSpanTree(kids[i]!, children, childPrefix, i === kids.length - 1);
+	}
+}
+
+// ─── Formatting helpers ──────────────────────────────────────────────
+
+function statusIcon(status: string): string {
+	switch (status) {
+		case "ok": return "\x1b[32m✓\x1b[0m";
+		case "error": return "\x1b[31m✗\x1b[0m";
+		default: return "\x1b[33m●\x1b[0m";
+	}
+}
+
+function fmtTime(ms: number): string {
+	return new Date(ms).toISOString().slice(0, 19).replace("T", " ");
+}
+
+function fmtTimestamp(ms: number): string {
+	return new Date(ms).toISOString().slice(11, 23);
+}
+
+function fmtDuration(ms: number | null | undefined): string {
+	if (ms == null) return "...";
+	if (ms < 1) return `${(ms * 1000).toFixed(0)}µs`;
+	if (ms < 1000) return `${ms.toFixed(0)}ms`;
+	return `${(ms / 1000).toFixed(2)}s`;
+}
+
+function extractStack(data: unknown): string[] | null {
+	if (!data || typeof data !== "object") return null;
+	const d = data as Record<string, unknown>;
+	const error = d.error as Record<string, unknown> | undefined;
+	const stack = error?.stack;
+	if (typeof stack !== "string") return null;
+	// Stack lines start with "    at " — skip the first line (error name: message, already printed)
+	const lines = stack.split("\n");
+	const frameLines = lines.filter(l => l.trimStart().startsWith("at "));
+	return frameLines.length > 0 ? frameLines.map(l => l.trim()) : null;
+}
+
+function parseDuration(s: string): number {
+	const match = s.match(/^(\d+)(s|m|h|d)$/);
+	if (!match) {
+		console.error(`Invalid duration: ${s} (use e.g. 5m, 1h, 2d)`);
+		process.exit(1);
+	}
+	const n = parseInt(match[1]!, 10);
+	switch (match[2]) {
+		case "s": return n * 1000;
+		case "m": return n * 60_000;
+		case "h": return n * 3_600_000;
+		case "d": return n * 86_400_000;
+		default: return n * 60_000;
+	}
+}

package/runtime/cli.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+
+import { createContext, hasFlag } from "./cli/context";
+
+const ctx = createContext(process.argv);
+const args = ctx.args;
+
+// Strip global flags to find the command
+const globalFlags = ["--config", "-c", "--env", "-e"];
+const commandArgs: string[] = [];
+for (let i = 0; i < args.length; i++) {
+	if (globalFlags.includes(args[i]!)) {
+		i++; // skip flag value
+		continue;
+	}
+	commandArgs.push(args[i]!);
+}
+
+const command = commandArgs[0];
+const subcommand = commandArgs[1];
+
+if (!command || hasFlag(args, "--help") || hasFlag(args, "-h")) {
+	printHelp();
+	process.exit(0);
+}
+
+switch (command) {
+	case "dev": {
+		const mod = await import("./cli/dev");
+		await mod.run(ctx);
+		break;
+	}
+	case "d1": {
+		const mod = await import("./cli/d1");
+		await mod.run(ctx, commandArgs.slice(1));
+		break;
+	}
+	case "r2": {
+		const mod = await import("./cli/r2");
+		await mod.run(ctx, commandArgs.slice(1));
+		break;
+	}
+	case "kv": {
+		const mod = await import("./cli/kv");
+		await mod.run(ctx, commandArgs.slice(1));
+		break;
+	}
+	case "queues": {
+		const mod = await import("./cli/queues");
+		await mod.run(ctx, commandArgs.slice(1));
+		break;
+	}
+	case "cache": {
+		const mod = await import("./cli/cache");
+		await mod.run(ctx, commandArgs.slice(1));
+		break;
+	}
+	case "trace": {
+		const mod = await import("./cli/traces");
+		await mod.run(ctx, commandArgs.slice(1));
+		break;
+	}
+	default:
+		console.error(`Unknown command: ${command}`);
+		printHelp();
+		process.exit(1);
+}
+
+function printHelp() {
+	console.log(`
+bunflare — local Cloudflare Worker dev tools
+
+Usage: bunflare <command> [options]
+
+Commands:
+  dev                         Start local dev server
+  d1 list                     List D1 databases
+  d1 execute <db> --command   Execute SQL on a D1 database
+  d1 migrations apply [db]    Apply D1 migrations
+  r2 object list [bucket]          List R2 objects (bucket/prefix)
+  r2 object get <bucket/key>      Get an R2 object
+  r2 object put <bucket/key> -f   Upload a file to R2
+  r2 object delete <bucket/key>   Delete an R2 object
+  kv key list                 List KV keys
+  kv key get <key>            Get a KV value
+  kv key put <key> <value>    Put a KV value
+  kv key delete <key>         Delete a KV key
+  queues list                 List queues
+  queues message list <queue> List queue messages
+  queues message send <queue> Send a message to a queue
+  queues message purge <queue> Purge queue messages
+  cache list                  List cache names
+  cache purge [--name CACHE]  Purge cache entries
+  trace list [options]        List traces (--limit, --since, --search, --cursor)
+  trace get <traceId>         Get trace detail as JSON
+
+Global flags:
+  --config, -c <path>   Path to wrangler config file
+  --env, -e <name>      Environment name
+  --help, -h            Show this help
+`.trim());
+}

package/runtime/config.ts

@@ -0,0 +1,148 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseTOML } from "smol-toml";
+import type { WorkflowLimits } from "./bindings/workflow";
+
+export interface WranglerConfig {
+  name: string;
+  main: string;
+  compatibility_date?: string;
+  compatibility_flags?: string[];
+  kv_namespaces?: { binding: string; id: string }[];
+  r2_buckets?: { binding: string; bucket_name: string }[];
+  durable_objects?: {
+    bindings: { name: string; class_name: string }[];
+  };
+  workflows?: { name: string; binding: string; class_name: string; limits?: Partial<WorkflowLimits> }[];
+  d1_databases?: { binding: string; database_name: string; database_id: string; migrations_dir?: string }[];
+  queues?: {
+    producers?: { binding: string; queue: string; delivery_delay?: number }[];
+    consumers?: { queue: string; max_batch_size?: number; max_batch_timeout?: number; max_retries?: number; dead_letter_queue?: string }[];
+  };
+  send_email?: {
+    name: string;
+    destination_address?: string;
+    allowed_destination_addresses?: string[];
+  }[];
+  ai?: { binding: string };
+  hyperdrive?: {
+    binding: string;
+    id: string;
+    localConnectionString?: string;
+  }[];
+  services?: { binding: string; service: string; entrypoint?: string }[];
+  triggers?: { crons?: string[] };
+  vars?: Record<string, string>;
+  assets?: {
+    directory: string;
+    binding?: string;
+    html_handling?: "none" | "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash";
+    not_found_handling?: "none" | "404-page" | "single-page-application";
+    run_worker_first?: boolean | string[];
+  };
+  images?: {
+    binding: string;
+  };
+  containers?: {
+    class_name: string;
+    image: string;
+    max_instances?: number;
+    instance_type?: string;
+    name?: string;
+  }[];
+  analytics_engine_datasets?: { binding: string; dataset?: string }[];
+  browser?: { binding: string };
+  version_metadata?: { binding: string };
+  migrations?: { tag: string; new_classes?: string[]; new_sqlite_classes?: string[] }[];
+  env?: Record<string, Partial<Omit<WranglerConfig, "env">>>;
+}
+
+/**
+ * Load config from an explicit path (JSON/JSONC/TOML).
+ */
+export async function loadConfig(path: string, envName?: string): Promise<WranglerConfig> {
+  const raw = await Bun.file(path).text();
+  let config: WranglerConfig;
+  if (path.endsWith(".toml")) {
+    config = parseTOML(raw) as unknown as WranglerConfig;
+  } else {
+    // JSON or JSONC — strip single-line comments (// ...) outside strings
+    config = JSON.parse(stripJsoncComments(raw));
+  }
+  return applyEnvOverrides(config, envName);
+}
+
+/**
+ * Auto-detect config file in a directory. Tries wrangler.jsonc, wrangler.json, wrangler.toml.
+ */
+export async function autoLoadConfig(baseDir: string, envName?: string): Promise<WranglerConfig> {
+  const candidates = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+  for (const name of candidates) {
+    const fullPath = join(baseDir, name);
+    if (existsSync(fullPath)) {
+      return loadConfig(fullPath, envName);
+    }
+  }
+  throw new Error(`No wrangler config found in ${baseDir} (tried: ${candidates.join(", ")})`);
+}
+
+/**
+ * Merge environment-specific overrides into the base config.
+ * Environment sections can override: vars, bindings, routes, triggers, etc.
+ */
+function applyEnvOverrides(config: WranglerConfig, envName?: string): WranglerConfig {
+  if (!envName || !config.env) return config;
+  const envConfig = config.env[envName];
+  if (!envConfig) {
+    throw new Error(`Environment "${envName}" not found in config. Available: ${Object.keys(config.env).join(", ")}`);
+  }
+  // Shallow merge: env-specific values override top-level ones
+  const { env: _env, ...base } = config;
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(envConfig)) {
+    if (value !== undefined) {
+      (merged as Record<string, unknown>)[key] = value;
+    }
+  }
+  return merged;
+}
+
+// ─── JSONC Comment Stripping ───────────────────────────────────────────────
+
+function stripJsoncComments(input: string): string {
+  let result = "";
+  let i = 0;
+  while (i < input.length) {
+    // String literal — copy as-is
+    if (input[i] === '"') {
+      result += '"';
+      i++;
+      while (i < input.length && input[i] !== '"') {
+        if (input[i] === "\\") {
+          result += input[i]! + (input[i + 1] ?? "");
+          i += 2;
+        } else {
+          result += input[i]!;
+          i++;
+        }
+      }
+      if (i < input.length) { result += '"'; i++; }
+      continue;
+    }
+    // Single-line comment
+    if (input[i] === "/" && input[i + 1] === "/") {
+      while (i < input.length && input[i] !== "\n") i++;
+      continue;
+    }
+    // Block comment
+    if (input[i] === "/" && input[i + 1] === "*") {
+      i += 2;
+      while (i < input.length && !(input[i] === "*" && input[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    result += input[i]!;
+    i++;
+  }
+  return result;
+}

package/runtime/d1-migrate.ts

@@ -0,0 +1,37 @@
+/**
+ * Apply D1 migrations for all databases defined in wrangler config.
+ *
+ * Usage: bun runtime/d1-migrate.ts [--config path/to/wrangler.jsonc] [--env envName]
+ *
+ * Equivalent to: wrangler d1 migrations apply <db> --local
+ *
+ * This is a backward-compatible wrapper around the CLI migration logic.
+ */
+
+import { resolve, join } from "node:path";
+import { autoLoadConfig, loadConfig } from "./config";
+import { applyMigrations } from "./cli/d1";
+
+// Parse CLI flags
+function parseFlag(name: string): string | undefined {
+  const idx = process.argv.indexOf(name);
+  return idx !== -1 ? process.argv[idx + 1] : undefined;
+}
+
+const configPath = parseFlag("--config") ?? parseFlag("-c");
+const envName = parseFlag("--env") ?? parseFlag("-e");
+const baseDir = process.cwd();
+
+const config = configPath
+  ? await loadConfig(resolve(baseDir, configPath), envName)
+  : await autoLoadConfig(baseDir, envName);
+
+const databases = config.d1_databases ?? [];
+
+if (databases.length === 0) {
+  console.log("[d1-migrate] No D1 databases configured.");
+  process.exit(0);
+}
+
+const dataDir = join(baseDir, ".bunflare");
+await applyMigrations(databases, dataDir);