lopata 0.0.1

package/runtime/dashboard/rpc/handlers/do.ts

@@ -0,0 +1,117 @@
+import type { HandlerContext, DoNamespace, DoInstance, DoDetail, OkResponse, D1Table, QueryResult } from "../types";
+import { getAllConfigs, getDoNamespace } from "../types";
+import { getDatabase, getDataDir } from "../../../db";
+import { Database } from "bun:sqlite";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+
+export const handlers = {
+  "do.listNamespaces"(_input: {}, ctx: HandlerContext): DoNamespace[] {
+    const db = getDatabase();
+    const rows = db.query<{ namespace: string; count: number }, []>(
+      "SELECT namespace, COUNT(*) as count FROM do_instances GROUP BY namespace ORDER BY namespace"
+    ).all();
+    const rowMap = new Map(rows.map(r => [r.namespace, r]));
+    for (const config of getAllConfigs(ctx)) {
+      for (const b of config.durable_objects?.bindings ?? []) {
+        if (!rowMap.has(b.class_name)) {
+          rows.push({ namespace: b.class_name, count: 0 });
+        }
+      }
+    }
+    rows.sort((a, b) => a.namespace.localeCompare(b.namespace));
+    return rows;
+  },
+
+  "do.listInstances"({ ns }: { ns: string }): DoInstance[] {
+    const db = getDatabase();
+    const instances = db.query<{ id: string; name: string | null }, [string]>(
+      "SELECT id, name FROM do_instances WHERE namespace = ? ORDER BY id"
+    ).all(ns);
+
+    const kvCounts = db.query<{ id: string; key_count: number }, [string]>(
+      "SELECT id, COUNT(*) as key_count FROM do_storage WHERE namespace = ? GROUP BY id"
+    ).all(ns);
+    const kvMap = new Map(kvCounts.map(r => [r.id, r.key_count]));
+
+    const alarms = db.query<{ id: string; alarm_time: number }, [string]>(
+      "SELECT id, alarm_time FROM do_alarms WHERE namespace = ?"
+    ).all(ns);
+    const alarmMap = new Map(alarms.map(a => [a.id, a.alarm_time]));
+
+    return instances.map(inst => ({
+      id: inst.id,
+      name: inst.name,
+      key_count: kvMap.get(inst.id) ?? 0,
+      alarm: alarmMap.get(inst.id) ?? null,
+    }));
+  },
+
+  "do.getInstance"({ ns, id }: { ns: string; id: string }, ctx: HandlerContext): DoDetail {
+    const db = getDatabase();
+    const entries = db.query<{ key: string; value: string }, [string, string]>(
+      "SELECT key, value FROM do_storage WHERE namespace = ? AND id = ? ORDER BY key"
+    ).all(ns, id);
+
+    const alarm = db.query<{ alarm_time: number }, [string, string]>(
+      "SELECT alarm_time FROM do_alarms WHERE namespace = ? AND id = ?"
+    ).get(ns, id);
+
+    const namespace = getDoNamespace(ctx, ns);
+    return { entries, alarm: alarm?.alarm_time ?? null, hasAlarmHandler: namespace?.hasAlarmHandler() ?? false };
+  },
+
+  "do.deleteEntry"({ ns, id, key }: { ns: string; id: string; key: string }): OkResponse {
+    const db = getDatabase();
+    db.prepare("DELETE FROM do_storage WHERE namespace = ? AND id = ? AND key = ?").run(ns, id, key);
+    return { ok: true };
+  },
+
+  "do.listSqlTables"({ ns, id }: { ns: string; id: string }): D1Table[] {
+    const dbPath = join(getDataDir(), "do-sql", ns, `${id}.sqlite`);
+    if (!existsSync(dbPath)) return [];
+
+    const dodb = new Database(dbPath);
+    try {
+      const tables = dodb.query<{ name: string; sql: string }, []>(
+        "SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+      ).all();
+
+      return tables.map(t => {
+        const row = dodb.query<{ count: number }, []>(`SELECT COUNT(*) as count FROM "${t.name}"`).get();
+        return { name: t.name, sql: t.sql, rows: row?.count ?? 0 };
+      });
+    } finally {
+      dodb.close();
+    }
+  },
+
+  async "do.triggerAlarm"({ ns, id }: { ns: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const namespace = getDoNamespace(ctx, ns);
+    if (!namespace) throw new Error(`Durable Object namespace "${ns}" not found (worker not loaded?)`);
+    await namespace.triggerAlarm(id);
+    return { ok: true };
+  },
+
+  "do.sqlQuery"({ ns, id, sql }: { ns: string; id: string; sql: string }): QueryResult {
+    if (!sql) throw new Error("Missing sql field");
+
+    const dbPath = join(getDataDir(), "do-sql", ns, `${id}.sqlite`);
+    if (!existsSync(dbPath)) throw new Error("SQL database not found for this instance");
+
+    const dodb = new Database(dbPath);
+    try {
+      const stmt = dodb.prepare(sql);
+      if (stmt.columnNames.length > 0) {
+        const rows = stmt.all() as Record<string, unknown>[];
+        return { columns: stmt.columnNames, rows, count: rows.length };
+      } else {
+        stmt.run();
+        const changes = dodb.query<{ c: number }, []>("SELECT changes() as c").get()?.c ?? 0;
+        return { columns: [], rows: [], count: changes, message: `${changes} row(s) affected` };
+      }
+    } finally {
+      dodb.close();
+    }
+  },
+};

package/runtime/dashboard/rpc/handlers/email.ts

@@ -0,0 +1,82 @@
+import type { HandlerContext, EmailRecord, OkResponse } from "../types";
+import { getDatabase } from "../../../db";
+import type { SQLQueryBindings } from "bun:sqlite";
+
+export const handlers = {
+	"email.list"({ status, limit = 50 }: { status?: string; limit?: number }): EmailRecord[] {
+		const db = getDatabase();
+		let query = "SELECT id, binding, from_addr, to_addr, raw_size, status, reject_reason, created_at FROM email_messages";
+		const params: SQLQueryBindings[] = [];
+
+		if (status) {
+			query += " WHERE status = ?";
+			params.push(status);
+		}
+		query += " ORDER BY created_at DESC LIMIT ?";
+		params.push(limit);
+
+		return db.prepare(query).all(...params) as EmailRecord[];
+	},
+
+	"email.get"({ id }: { id: string }): { record: EmailRecord; raw: string } | null {
+		const db = getDatabase();
+		const row = db.query<Record<string, unknown>, [string]>(
+			"SELECT id, binding, from_addr, to_addr, raw, raw_size, status, reject_reason, created_at FROM email_messages WHERE id = ?",
+		).get(id);
+		if (!row) return null;
+
+		let rawStr: string;
+		try {
+			rawStr = new TextDecoder().decode(row.raw as BufferSource);
+		} catch {
+			rawStr = "<binary content>";
+		}
+
+		const { raw: _raw, ...record } = row;
+		return { record: record as unknown as EmailRecord, raw: rawStr };
+	},
+
+	"email.delete"({ id }: { id: string }): OkResponse {
+		const db = getDatabase();
+		db.prepare("DELETE FROM email_messages WHERE id = ?").run(id);
+		return { ok: true };
+	},
+
+	async "email.trigger"(
+		{ from, to, subject, body }: { from: string; to: string; subject?: string; body?: string },
+		ctx: HandlerContext,
+	): Promise<OkResponse> {
+		// Build raw MIME content
+		const lines: string[] = [];
+		lines.push(`From: ${from}`);
+		lines.push(`To: ${to}`);
+		if (subject) lines.push(`Subject: ${subject}`);
+		lines.push(`Date: ${new Date().toUTCString()}`);
+		lines.push("MIME-Version: 1.0");
+		lines.push("Content-Type: text/plain; charset=utf-8");
+		lines.push("");
+		lines.push(body ?? "");
+		const rawContent = lines.join("\r\n");
+		const rawBytes = new TextEncoder().encode(rawContent);
+
+		const gen = ctx.manager?.active;
+		if (!gen) throw new Error("No active generation");
+		const res = await gen.callEmail(rawBytes, from, to);
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(text || `Email handler failed with status ${res.status}`);
+		}
+		return { ok: true };
+	},
+
+	"email.stats"(_input: {}, _ctx: HandlerContext): { total: number; byStatus: Record<string, number> } {
+		const db = getDatabase();
+		const total = db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM email_messages").get()?.count ?? 0;
+		const rows = db.query<{ status: string; count: number }, []>(
+			"SELECT status, COUNT(*) as count FROM email_messages GROUP BY status",
+		).all();
+		const byStatus: Record<string, number> = {};
+		for (const r of rows) byStatus[r.status] = r.count;
+		return { total, byStatus };
+	},
+};

package/runtime/dashboard/rpc/handlers/errors.ts

@@ -0,0 +1,32 @@
+import { getTraceStore } from "../../../tracing/store";
+
+export const handlers = {
+  "errors.list"(input: { limit?: number; cursor?: string }) {
+    if (input.limit !== undefined && (typeof input.limit !== "number" || input.limit < 1)) {
+      throw new Error("limit must be a positive number");
+    }
+    return getTraceStore().listErrors({ limit: input.limit ?? 50, cursor: input.cursor });
+  },
+
+  "errors.get"(input: { id: string }) {
+    if (!input.id || typeof input.id !== "string") {
+      throw new Error("id is required and must be a string");
+    }
+    const error = getTraceStore().getError(input.id);
+    if (!error) throw new Error("Error not found");
+    return error;
+  },
+
+  "errors.delete"(input: { id: string }): { ok: true } {
+    if (!input.id || typeof input.id !== "string") {
+      throw new Error("id is required and must be a string");
+    }
+    getTraceStore().deleteError(input.id);
+    return { ok: true };
+  },
+
+  "errors.clear"(_input: {}): { ok: true } {
+    getTraceStore().clearErrors();
+    return { ok: true };
+  },
+};

package/runtime/dashboard/rpc/handlers/generations.ts

@@ -0,0 +1,60 @@
+import type { HandlerContext, GenerationsData, GenerationInfo, OkResponse } from "../types";
+
+export const handlers = {
+  "generations.list"(_input: {}, ctx: HandlerContext): GenerationsData {
+    if (!ctx.manager) throw new Error("Generation manager not available");
+
+    const result: GenerationsData = {
+      generations: ctx.manager.list(),
+      gracePeriodMs: ctx.manager.gracePeriodMs,
+    };
+
+    // Include per-worker data when registry is available (multi-worker mode)
+    if (ctx.registry) {
+      result.workers = [];
+      for (const [name, mgr] of ctx.registry.listManagers()) {
+        result.workers.push({
+          workerName: name,
+          generations: mgr.list(),
+          gracePeriodMs: mgr.gracePeriodMs,
+        });
+      }
+    }
+
+    return result;
+  },
+
+  async "generations.reload"(input: { workerName?: string }, ctx: HandlerContext): Promise<{ ok: true; generation: GenerationInfo }> {
+    let manager = ctx.manager;
+    if (input.workerName && ctx.registry) {
+      manager = ctx.registry.getManager(input.workerName) ?? null;
+    }
+    if (!manager) throw new Error("Generation manager not available");
+    const gen = await manager.reload();
+    return { ok: true, generation: gen.getInfo() };
+  },
+
+  "generations.drain"(input: { workerName?: string }, ctx: HandlerContext): { ok: true; stoppedGeneration: number } {
+    let manager = ctx.manager;
+    if (input.workerName && ctx.registry) {
+      manager = ctx.registry.getManager(input.workerName) ?? null;
+    }
+    if (!manager) throw new Error("Generation manager not available");
+    const gens = manager.list().filter(g => g.state === "draining");
+    if (gens.length === 0) throw new Error("No draining generations");
+    const oldest = gens.reduce((a, b) => a.createdAt < b.createdAt ? a : b);
+    manager.stop(oldest.id);
+    return { ok: true, stoppedGeneration: oldest.id };
+  },
+
+  "generations.config"({ gracePeriodMs, workerName }: { gracePeriodMs: number; workerName?: string }, ctx: HandlerContext): { ok: true; gracePeriodMs: number } {
+    let manager = ctx.manager;
+    if (workerName && ctx.registry) {
+      manager = ctx.registry.getManager(workerName) ?? null;
+    }
+    if (!manager) throw new Error("Generation manager not available");
+    if (typeof gracePeriodMs !== "number" || gracePeriodMs < 0) throw new Error("Invalid gracePeriodMs");
+    manager.setGracePeriod(gracePeriodMs);
+    return { ok: true, gracePeriodMs: manager.gracePeriodMs };
+  },
+};

package/runtime/dashboard/rpc/handlers/kv.ts

@@ -0,0 +1,76 @@
+import type { HandlerContext, KvNamespace, Paginated, KvKey, KvValue, OkResponse } from "../types";
+import { getAllConfigs } from "../types";
+import { getDatabase } from "../../../db";
+import type { SQLQueryBindings } from "bun:sqlite";
+
+export const handlers = {
+  "kv.listNamespaces"(_input: {}, ctx: HandlerContext): KvNamespace[] {
+    const db = getDatabase();
+    const rows = db.query<{ namespace: string; count: number }, []>(
+      "SELECT namespace, COUNT(*) as count FROM kv GROUP BY namespace ORDER BY namespace"
+    ).all();
+    const rowMap = new Map(rows.map(r => [r.namespace, r]));
+    for (const config of getAllConfigs(ctx)) {
+      for (const ns of config.kv_namespaces ?? []) {
+        if (!rowMap.has(ns.id)) {
+          rows.push({ namespace: ns.id, count: 0 });
+        }
+      }
+    }
+    rows.sort((a, b) => a.namespace.localeCompare(b.namespace));
+    return rows;
+  },
+
+  "kv.listKeys"({ ns, limit = 50, cursor = "", prefix = "" }: { ns: string; limit?: number; cursor?: string; prefix?: string }): Paginated<KvKey> {
+    const db = getDatabase();
+    let query = "SELECT key, LENGTH(value) as size, metadata, expiration FROM kv WHERE namespace = ?";
+    const params: SQLQueryBindings[] = [ns];
+
+    if (prefix) { query += " AND key LIKE ?"; params.push(prefix + "%"); }
+    if (cursor) { query += " AND key > ?"; params.push(cursor); }
+    query += " ORDER BY key LIMIT ?";
+    params.push(limit + 1);
+
+    const rows = db.prepare(query).all(...params) as KvKey[];
+    const hasMore = rows.length > limit;
+    const items = rows.slice(0, limit);
+    const last = items[items.length - 1];
+    return { items, cursor: hasMore && last ? last.key : null };
+  },
+
+  "kv.getKey"({ ns, key }: { ns: string; key: string }): KvValue {
+    const db = getDatabase();
+    const row = db.query<{ value: Buffer; metadata: string | null; expiration: number | null }, [string, string]>(
+      "SELECT value, metadata, expiration FROM kv WHERE namespace = ? AND key = ?"
+    ).get(ns, key);
+    if (!row) throw new Error("Key not found");
+
+    let valueStr: string;
+    try { valueStr = new TextDecoder().decode(row.value); }
+    catch { valueStr = `<binary: ${row.value.length} bytes>`; }
+
+    return {
+      key,
+      value: valueStr,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null,
+      expiration: row.expiration,
+    };
+  },
+
+  "kv.putKey"({ ns, key, value, metadata, expirationTtl }: { ns: string; key: string; value: string; metadata?: string; expirationTtl?: number }): OkResponse {
+    const db = getDatabase();
+    const encoded = new TextEncoder().encode(value);
+    const exp = expirationTtl ? Math.floor(Date.now() / 1000) + expirationTtl : null;
+    const meta = metadata?.trim() || null;
+    db.prepare(
+      "INSERT OR REPLACE INTO kv (namespace, key, value, metadata, expiration) VALUES (?, ?, ?, ?, ?)"
+    ).run(ns, key, encoded, meta, exp);
+    return { ok: true };
+  },
+
+  "kv.deleteKey"({ ns, key }: { ns: string; key: string }): OkResponse {
+    const db = getDatabase();
+    db.prepare("DELETE FROM kv WHERE namespace = ? AND key = ?").run(ns, key);
+    return { ok: true };
+  },
+};

package/runtime/dashboard/rpc/handlers/overview.ts

@@ -0,0 +1,94 @@
+import type { HandlerContext, OverviewData } from "../types";
+import { getAllConfigs } from "../types";
+import { getDatabase, getDataDir } from "../../../db";
+import { getTraceStore } from "../../../tracing/store";
+import { join } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+
+export const handlers = {
+  "overview.get"(_input: {}, ctx: HandlerContext): OverviewData {
+    const db = getDatabase();
+
+    const d1Dir = join(getDataDir(), "d1");
+    let d1Count = 0;
+    if (existsSync(d1Dir)) {
+      d1Count = readdirSync(d1Dir).filter(f => f.endsWith(".sqlite")).length;
+    }
+
+    const dbContainers = new Set<string>();
+    const dbKv = new Set(db.query<{ namespace: string }, []>("SELECT DISTINCT namespace FROM kv").all().map(r => r.namespace));
+    const dbR2 = new Set(db.query<{ bucket: string }, []>("SELECT DISTINCT bucket FROM r2_objects").all().map(r => r.bucket));
+    const dbQueue = new Set(db.query<{ queue: string }, []>("SELECT DISTINCT queue FROM queue_messages").all().map(r => r.queue));
+    const dbDo = new Set(db.query<{ namespace: string }, []>("SELECT DISTINCT namespace FROM do_storage").all().map(r => r.namespace));
+    const dbWorkflows = new Set(db.query<{ workflow_name: string }, []>("SELECT DISTINCT workflow_name FROM workflow_instances").all().map(r => r.workflow_name));
+
+    for (const config of getAllConfigs(ctx)) {
+      for (const ns of config.kv_namespaces ?? []) dbKv.add(ns.id);
+      for (const b of config.r2_buckets ?? []) dbR2.add(b.bucket_name);
+      for (const p of config.queues?.producers ?? []) dbQueue.add(p.queue);
+      for (const b of config.durable_objects?.bindings ?? []) dbDo.add(b.class_name);
+      for (const w of config.workflows ?? []) dbWorkflows.add(w.binding);
+      for (const c of config.containers ?? []) dbContainers.add(c.class_name);
+      d1Count = Math.max(d1Count, (config.d1_databases ?? []).length);
+    }
+
+    const emailCount = db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM email_messages").get()?.count ?? 0;
+    const aiCount = db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM ai_requests").get()?.count ?? 0;
+    const analyticsEngineCount = db.query<{ count: number }, []>("SELECT COUNT(DISTINCT dataset) as count FROM analytics_engine").get()?.count ?? 0;
+
+    return {
+      kv: dbKv.size,
+      r2: dbR2.size,
+      queue: dbQueue.size,
+      do: dbDo.size,
+      workflows: dbWorkflows.size,
+      containers: dbContainers.size,
+      d1: d1Count,
+      cache: db.query<{ count: number }, []>("SELECT COUNT(DISTINCT cache_name) as count FROM cache_entries").get()?.count ?? 0,
+      errors: getTraceStore().getErrorCount(),
+      workerErrors: getTraceStore().getErrorCountsByWorker(),
+      scheduled: getAllConfigs(ctx).reduce((sum, cfg) => sum + (cfg.triggers?.crons?.length ?? 0), 0),
+      email: emailCount,
+      ai: aiCount,
+      analyticsEngine: analyticsEngineCount,
+      generations: ctx.manager ? ctx.manager.list() : [],
+      runtime: (() => {
+        const mem = process.memoryUsage();
+        const cpu = process.cpuUsage();
+        const envPassthrough: Record<string, string> = {};
+        for (const key of [
+          "NODE_ENV", "BUN_ENV", "SHELL", "TERM", "LANG", "HOME", "USER",
+          "PATH", "EDITOR", "TZ",
+        ]) {
+          if (process.env[key]) envPassthrough[key] = process.env[key]!;
+        }
+        return {
+          bunVersion: Bun.version,
+          platform: process.platform,
+          arch: process.arch,
+          pid: process.pid,
+          cwd: process.cwd(),
+          uptime: process.uptime(),
+          startedAt: Date.now() - process.uptime() * 1000,
+          memory: {
+            rss: mem.rss,
+            heapUsed: mem.heapUsed,
+            heapTotal: mem.heapTotal,
+            external: mem.external,
+          },
+          cpuUsage: {
+            user: cpu.user,
+            system: cpu.system,
+          },
+          env: envPassthrough,
+        };
+      })(),
+      ...(ctx.registry ? {
+        workers: Array.from(ctx.registry.listManagers()).map(([name, mgr]) => ({
+          workerName: name,
+          generations: mgr.list(),
+        })),
+      } : {}),
+    };
+  },
+};

package/runtime/dashboard/rpc/handlers/queue.ts

@@ -0,0 +1,79 @@
+import type { HandlerContext, QueueInfo, QueueMessage, OkResponse } from "../types";
+import { getAllConfigs } from "../types";
+import { getDatabase } from "../../../db";
+import { randomUUIDv7 } from "bun";
+import type { SQLQueryBindings } from "bun:sqlite";
+
+export const handlers = {
+  "queue.listQueues"(_input: {}, ctx: HandlerContext): QueueInfo[] {
+    const db = getDatabase();
+    const rows = db.query<{ queue: string; pending: number; acked: number; failed: number }, []>(
+      `SELECT queue,
+        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+        SUM(CASE WHEN status = 'acked' THEN 1 ELSE 0 END) as acked,
+        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed
+      FROM queue_messages GROUP BY queue ORDER BY queue`
+    ).all();
+    const rowMap = new Map(rows.map(r => [r.queue, r]));
+    for (const config of getAllConfigs(ctx)) {
+      for (const p of config.queues?.producers ?? []) {
+        if (!rowMap.has(p.queue)) {
+          rows.push({ queue: p.queue, pending: 0, acked: 0, failed: 0 });
+        }
+      }
+    }
+    rows.sort((a, b) => a.queue.localeCompare(b.queue));
+    return rows;
+  },
+
+  "queue.listMessages"({ queue, limit = 50, status }: { queue: string; limit?: number; status?: string }): QueueMessage[] {
+    const db = getDatabase();
+    let query = "SELECT id, body, content_type, status, attempts, visible_at, created_at, completed_at FROM queue_messages WHERE queue = ?";
+    const params: SQLQueryBindings[] = [queue];
+
+    if (status) { query += " AND status = ?"; params.push(status); }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit);
+
+    const rows = db.prepare(query).all(...params) as Record<string, unknown>[];
+    return rows.map(row => {
+      let bodyStr: string;
+      try { bodyStr = new TextDecoder().decode(row.body as BufferSource); }
+      catch { bodyStr = `<binary>`; }
+      return { ...row, body: bodyStr } as QueueMessage;
+    });
+  },
+
+  "queue.deleteMessage"({ queue, id }: { queue: string; id: string }): OkResponse {
+    const db = getDatabase();
+    db.prepare("DELETE FROM queue_messages WHERE queue = ? AND id = ?").run(queue, id);
+    return { ok: true };
+  },
+
+  "queue.publishMessage"({ queue, body, contentType = "json" }: { queue: string; body: string; contentType?: string }): OkResponse {
+    const db = getDatabase();
+    const now = Date.now();
+    let encoded: Uint8Array;
+    if (contentType === "json") {
+      // Validate JSON
+      JSON.parse(body);
+      encoded = new TextEncoder().encode(body);
+    } else {
+      encoded = new TextEncoder().encode(body);
+    }
+    db.run(
+      "INSERT INTO queue_messages (id, queue, body, content_type, attempts, status, visible_at, created_at) VALUES (?, ?, ?, ?, 0, 'pending', ?, ?)",
+      [randomUUIDv7(), queue, encoded, contentType, now, now],
+    );
+    return { ok: true };
+  },
+
+  "queue.requeueMessage"({ queue, id }: { queue: string; id: string }): OkResponse {
+    const db = getDatabase();
+    const now = Date.now();
+    db.prepare(
+      "UPDATE queue_messages SET status = 'pending', attempts = 0, visible_at = ?, completed_at = NULL WHERE queue = ? AND id = ?",
+    ).run(now, queue, id);
+    return { ok: true };
+  },
+};

package/runtime/dashboard/rpc/handlers/r2.ts

@@ -0,0 +1,72 @@
+import type { HandlerContext, R2Bucket, R2Object, Paginated, OkResponse } from "../types";
+import { getAllConfigs } from "../types";
+import { getDatabase, getDataDir } from "../../../db";
+import type { SQLQueryBindings } from "bun:sqlite";
+import { join, dirname } from "node:path";
+import { existsSync, unlinkSync, mkdirSync } from "node:fs";
+
+export const handlers = {
+  "r2.listBuckets"(_input: {}, ctx: HandlerContext): R2Bucket[] {
+    const db = getDatabase();
+    const rows = db.query<{ bucket: string; count: number; total_size: number }, []>(
+      "SELECT bucket, COUNT(*) as count, COALESCE(SUM(size),0) as total_size FROM r2_objects GROUP BY bucket ORDER BY bucket"
+    ).all();
+    const rowMap = new Map(rows.map(r => [r.bucket, r]));
+    for (const config of getAllConfigs(ctx)) {
+      for (const b of config.r2_buckets ?? []) {
+        if (!rowMap.has(b.bucket_name)) {
+          rows.push({ bucket: b.bucket_name, count: 0, total_size: 0 });
+        }
+      }
+    }
+    rows.sort((a, b) => a.bucket.localeCompare(b.bucket));
+    return rows;
+  },
+
+  "r2.listObjects"({ bucket, limit = 50, cursor = "", prefix = "" }: { bucket: string; limit?: number; cursor?: string; prefix?: string }): Paginated<R2Object> {
+    const db = getDatabase();
+    let query = "SELECT key, size, etag, uploaded, http_metadata, custom_metadata FROM r2_objects WHERE bucket = ?";
+    const params: SQLQueryBindings[] = [bucket];
+
+    if (prefix) { query += " AND key LIKE ?"; params.push(prefix + "%"); }
+    if (cursor) { query += " AND key > ?"; params.push(cursor); }
+    query += " ORDER BY key LIMIT ?";
+    params.push(limit + 1);
+
+    const rows = db.prepare(query).all(...params) as R2Object[];
+    const hasMore = rows.length > limit;
+    const items = rows.slice(0, limit);
+    const last = items[items.length - 1];
+    return { items, cursor: hasMore && last ? last.key : null };
+  },
+
+  "r2.deleteObject"({ bucket, key }: { bucket: string; key: string }): OkResponse {
+    const db = getDatabase();
+    db.prepare("DELETE FROM r2_objects WHERE bucket = ? AND key = ?").run(bucket, key);
+    const filePath = join(getDataDir(), "r2", bucket, key);
+    if (existsSync(filePath)) unlinkSync(filePath);
+    return { ok: true };
+  },
+
+  async "r2.renameObject"({ bucket, oldKey, newKey }: { bucket: string; oldKey: string; newKey: string }): Promise<OkResponse> {
+    const db = getDatabase();
+    const oldPath = join(getDataDir(), "r2", bucket, oldKey);
+    const newPath = join(getDataDir(), "r2", bucket, newKey);
+
+    if (!existsSync(oldPath)) {
+      throw new Error(`Object "${oldKey}" not found in bucket "${bucket}"`);
+    }
+
+    mkdirSync(dirname(newPath), { recursive: true });
+    const data = await Bun.file(oldPath).arrayBuffer();
+    await Bun.write(newPath, data);
+
+    db.run(
+      "UPDATE r2_objects SET key = ? WHERE bucket = ? AND key = ?",
+      [newKey, bucket, oldKey],
+    );
+
+    unlinkSync(oldPath);
+    return { ok: true };
+  },
+};