npm - lopata - Versions diffs - 0.0.1 - Mend

lopata 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (147) hide show

package/README.md +15 -0
package/package.json +51 -0
package/runtime/bindings/ai.ts +132 -0
package/runtime/bindings/analytics-engine.ts +96 -0
package/runtime/bindings/browser.ts +64 -0
package/runtime/bindings/cache.ts +179 -0
package/runtime/bindings/cf-streams.ts +56 -0
package/runtime/bindings/container-docker.ts +225 -0
package/runtime/bindings/container.ts +662 -0
package/runtime/bindings/crypto-extras.ts +89 -0
package/runtime/bindings/d1.ts +315 -0
package/runtime/bindings/do-executor-inprocess.ts +140 -0
package/runtime/bindings/do-executor-worker.ts +368 -0
package/runtime/bindings/do-executor.ts +45 -0
package/runtime/bindings/do-websocket-bridge.ts +70 -0
package/runtime/bindings/do-worker-entry.ts +220 -0
package/runtime/bindings/do-worker-env.ts +74 -0
package/runtime/bindings/durable-object.ts +992 -0
package/runtime/bindings/email.ts +180 -0
package/runtime/bindings/html-rewriter.ts +84 -0
package/runtime/bindings/hyperdrive.ts +130 -0
package/runtime/bindings/images.ts +381 -0
package/runtime/bindings/kv.ts +359 -0
package/runtime/bindings/queue.ts +507 -0
package/runtime/bindings/r2.ts +759 -0
package/runtime/bindings/rpc-stub.ts +267 -0
package/runtime/bindings/scheduled.ts +172 -0
package/runtime/bindings/service-binding.ts +217 -0
package/runtime/bindings/static-assets.ts +481 -0
package/runtime/bindings/websocket-pair.ts +182 -0
package/runtime/bindings/workflow.ts +858 -0
package/runtime/bunflare-config.ts +56 -0
package/runtime/cli/cache.ts +39 -0
package/runtime/cli/context.ts +105 -0
package/runtime/cli/d1.ts +163 -0
package/runtime/cli/dev.ts +392 -0
package/runtime/cli/kv.ts +84 -0
package/runtime/cli/queues.ts +109 -0
package/runtime/cli/r2.ts +140 -0
package/runtime/cli/traces.ts +251 -0
package/runtime/cli.ts +102 -0
package/runtime/config.ts +148 -0
package/runtime/d1-migrate.ts +37 -0
package/runtime/dashboard/api.ts +174 -0
package/runtime/dashboard/app.tsx +220 -0
package/runtime/dashboard/components/breadcrumb.tsx +16 -0
package/runtime/dashboard/components/buttons.tsx +13 -0
package/runtime/dashboard/components/code-block.tsx +5 -0
package/runtime/dashboard/components/detail-field.tsx +8 -0
package/runtime/dashboard/components/empty-state.tsx +8 -0
package/runtime/dashboard/components/filter-input.tsx +11 -0
package/runtime/dashboard/components/index.ts +16 -0
package/runtime/dashboard/components/key-value-table.tsx +23 -0
package/runtime/dashboard/components/modal.tsx +23 -0
package/runtime/dashboard/components/page-header.tsx +11 -0
package/runtime/dashboard/components/pill-button.tsx +14 -0
package/runtime/dashboard/components/refresh-button.tsx +7 -0
package/runtime/dashboard/components/service-info.tsx +45 -0
package/runtime/dashboard/components/status-badge.tsx +7 -0
package/runtime/dashboard/components/table-link.tsx +5 -0
package/runtime/dashboard/components/table.tsx +26 -0
package/runtime/dashboard/components.tsx +19 -0
package/runtime/dashboard/index.html +23 -0
package/runtime/dashboard/lib.ts +45 -0
package/runtime/dashboard/rpc/client.ts +20 -0
package/runtime/dashboard/rpc/handlers/ai.ts +71 -0
package/runtime/dashboard/rpc/handlers/analytics-engine.ts +53 -0
package/runtime/dashboard/rpc/handlers/cache.ts +24 -0
package/runtime/dashboard/rpc/handlers/config.ts +137 -0
package/runtime/dashboard/rpc/handlers/containers.ts +194 -0
package/runtime/dashboard/rpc/handlers/d1.ts +84 -0
package/runtime/dashboard/rpc/handlers/do.ts +117 -0
package/runtime/dashboard/rpc/handlers/email.ts +82 -0
package/runtime/dashboard/rpc/handlers/errors.ts +32 -0
package/runtime/dashboard/rpc/handlers/generations.ts +60 -0
package/runtime/dashboard/rpc/handlers/kv.ts +76 -0
package/runtime/dashboard/rpc/handlers/overview.ts +94 -0
package/runtime/dashboard/rpc/handlers/queue.ts +79 -0
package/runtime/dashboard/rpc/handlers/r2.ts +72 -0
package/runtime/dashboard/rpc/handlers/scheduled.ts +91 -0
package/runtime/dashboard/rpc/handlers/traces.ts +64 -0
package/runtime/dashboard/rpc/handlers/workers.ts +65 -0
package/runtime/dashboard/rpc/handlers/workflows.ts +171 -0
package/runtime/dashboard/rpc/hooks.ts +132 -0
package/runtime/dashboard/rpc/server.ts +70 -0
package/runtime/dashboard/rpc/types.ts +396 -0
package/runtime/dashboard/sql-browser/data-browser-tab.tsx +122 -0
package/runtime/dashboard/sql-browser/editable-cell.tsx +117 -0
package/runtime/dashboard/sql-browser/filter-row.tsx +99 -0
package/runtime/dashboard/sql-browser/history-panels.tsx +110 -0
package/runtime/dashboard/sql-browser/hooks.ts +137 -0
package/runtime/dashboard/sql-browser/index.ts +4 -0
package/runtime/dashboard/sql-browser/insert-row-form.tsx +85 -0
package/runtime/dashboard/sql-browser/modals.tsx +116 -0
package/runtime/dashboard/sql-browser/schema-browser-tab.tsx +67 -0
package/runtime/dashboard/sql-browser/sql-browser.tsx +52 -0
package/runtime/dashboard/sql-browser/sql-console-tab.tsx +124 -0
package/runtime/dashboard/sql-browser/table-data-view.tsx +566 -0
package/runtime/dashboard/sql-browser/table-sidebar.tsx +38 -0
package/runtime/dashboard/sql-browser/types.ts +61 -0
package/runtime/dashboard/sql-browser/utils.ts +167 -0
package/runtime/dashboard/style.css +177 -0
package/runtime/dashboard/views/ai.tsx +152 -0
package/runtime/dashboard/views/analytics-engine.tsx +169 -0
package/runtime/dashboard/views/cache.tsx +93 -0
package/runtime/dashboard/views/containers.tsx +197 -0
package/runtime/dashboard/views/d1.tsx +81 -0
package/runtime/dashboard/views/do.tsx +168 -0
package/runtime/dashboard/views/email.tsx +235 -0
package/runtime/dashboard/views/errors.tsx +558 -0
package/runtime/dashboard/views/home.tsx +287 -0
package/runtime/dashboard/views/kv.tsx +273 -0
package/runtime/dashboard/views/queue.tsx +193 -0
package/runtime/dashboard/views/r2.tsx +202 -0
package/runtime/dashboard/views/scheduled.tsx +89 -0
package/runtime/dashboard/views/trace-waterfall.tsx +410 -0
package/runtime/dashboard/views/traces.tsx +768 -0
package/runtime/dashboard/views/workers.tsx +55 -0
package/runtime/dashboard/views/workflows.tsx +473 -0
package/runtime/db.ts +258 -0
package/runtime/env.ts +362 -0
package/runtime/error-page/app.tsx +394 -0
package/runtime/error-page/build.ts +269 -0
package/runtime/error-page/index.html +16 -0
package/runtime/error-page/style.css +31 -0
package/runtime/execution-context.ts +18 -0
package/runtime/file-watcher.ts +57 -0
package/runtime/generation-manager.ts +230 -0
package/runtime/generation.ts +411 -0
package/runtime/plugin.ts +292 -0
package/runtime/request-cf.ts +28 -0
package/runtime/rpc-validate.ts +154 -0
package/runtime/tracing/context.ts +40 -0
package/runtime/tracing/db.ts +73 -0
package/runtime/tracing/frames.ts +75 -0
package/runtime/tracing/instrument.ts +186 -0
package/runtime/tracing/span.ts +138 -0
package/runtime/tracing/store.ts +499 -0
package/runtime/tracing/types.ts +47 -0
package/runtime/vite-plugin/config-plugin.ts +68 -0
package/runtime/vite-plugin/dev-server-plugin.ts +493 -0
package/runtime/vite-plugin/dist/index.mjs +52333 -0
package/runtime/vite-plugin/globals-plugin.ts +94 -0
package/runtime/vite-plugin/index.ts +43 -0
package/runtime/vite-plugin/modules-plugin.ts +88 -0
package/runtime/vite-plugin/react-router-plugin.ts +95 -0
package/runtime/worker-registry.ts +52 -0

package/runtime/dashboard/components.tsx ADDED Viewed

@@ -0,0 +1,19 @@
+// Re-export all shared UI components from the components/ directory
+export {
+  Modal,
+  EmptyState,
+  PageHeader,
+  Breadcrumb,
+  Table,
+  DetailField,
+  CodeBlock,
+  FilterInput,
+  PillButton,
+  RefreshButton,
+  LoadMoreButton,
+  DeleteButton,
+  TableLink,
+  StatusBadge,
+  ServiceInfo,
+  SqlBrowser,
+} from "./components/index";

package/runtime/dashboard/index.html ADDED Viewed

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="en" class="h-full">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Bunflare Dashboard</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet" />
+  <link rel="stylesheet" href="./style.css" />
+</head>
+<body class="h-full bg-surface text-ink" style="font-family: 'Poppins', sans-serif;">
+  <script>
+    // Apply saved theme before first paint to prevent flash
+    (function() {
+      var t = localStorage.getItem("bunflare-theme");
+      if (t === "light" || t === "dark") document.documentElement.setAttribute("data-theme", t);
+    })();
+  </script>
+  <div id="app" class="h-full"></div>
+  <script type="module" src="./app.tsx"></script>
+</body>
+</html>

package/runtime/dashboard/lib.ts ADDED Viewed

@@ -0,0 +1,45 @@
+import { useState, useEffect } from "preact/hooks";
+export function useRoute(): string {
+  const [route, setRoute] = useState(location.hash.slice(1) || "/");
+  useEffect(() => {
+    const handler = () => setRoute(location.hash.slice(1) || "/");
+    window.addEventListener("hashchange", handler);
+    return () => window.removeEventListener("hashchange", handler);
+  }, []);
+  return route;
+}
+export function navigate(path: string) {
+  location.hash = path;
+}
+export function replaceRoute(path: string) {
+  history.replaceState(null, "", "#" + path);
+}
+export function parseHashRoute(hash: string): { segments: string[]; query: URLSearchParams } {
+  const raw = hash.startsWith("#") ? hash.slice(1) : hash;
+  const qIdx = raw.indexOf("?");
+  const pathname = qIdx >= 0 ? raw.slice(0, qIdx) : raw;
+  const queryStr = qIdx >= 0 ? raw.slice(qIdx + 1) : "";
+  const segments = pathname.split("/").filter(Boolean);
+  return { segments, query: new URLSearchParams(queryStr) };
+}
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+export function formatTime(ts: number): string {
+  return new Date(ts).toLocaleString();
+}
+export function classNames(...classes: (string | false | null | undefined)[]): string {
+  return classes.filter(Boolean).join(" ");
+}

package/runtime/dashboard/rpc/client.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { Procedures } from "./server";
+type EmptyObject = Record<string, never>;
+export async function rpc<K extends keyof Procedures>(
+  procedure: K,
+  ...args: Procedures[K]["input"] extends EmptyObject ? [] : [Procedures[K]["input"]]
+): Promise<Procedures[K]["output"]> {
+  const input = args[0] ?? {};
+  const res = await fetch("/__dashboard/api/rpc", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ procedure, input }),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(text);
+  }
+  return res.json();
+}

package/runtime/dashboard/rpc/handlers/ai.ts ADDED Viewed

@@ -0,0 +1,71 @@
+import type { HandlerContext, AiRequest, OkResponse } from "../types";
+import { getDatabase } from "../../../db";
+import type { SQLQueryBindings } from "bun:sqlite";
+export const handlers = {
+	"ai.list"({ model, status, limit = 50 }: { model?: string; status?: string; limit?: number }): AiRequest[] {
+		const db = getDatabase();
+		let query = "SELECT id, model, input_summary, output_summary, duration_ms, status, error, is_streaming, created_at FROM ai_requests";
+		const conditions: string[] = [];
+		const params: SQLQueryBindings[] = [];
+		if (model) {
+			conditions.push("model = ?");
+			params.push(model);
+		}
+		if (status) {
+			conditions.push("status = ?");
+			params.push(status);
+		}
+		if (conditions.length) {
+			query += " WHERE " + conditions.join(" AND ");
+		}
+		query += " ORDER BY created_at DESC LIMIT ?";
+		params.push(limit);
+		return db.prepare(query).all(...params) as AiRequest[];
+	},
+	"ai.get"({ id }: { id: string }): AiRequest | null {
+		const db = getDatabase();
+		return db.query<AiRequest, [string]>(
+			"SELECT id, model, input_summary, output_summary, duration_ms, status, error, is_streaming, created_at FROM ai_requests WHERE id = ?",
+		).get(id);
+	},
+	"ai.delete"({ id }: { id: string }): OkResponse {
+		const db = getDatabase();
+		db.prepare("DELETE FROM ai_requests WHERE id = ?").run(id);
+		return { ok: true };
+	},
+	"ai.stats"(_input: {}): { total: number; byModel: Record<string, number>; byStatus: Record<string, number>; avgDuration: number } {
+		const db = getDatabase();
+		const total = db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM ai_requests").get()?.count ?? 0;
+		const modelRows = db.query<{ model: string; count: number }, []>(
+			"SELECT model, COUNT(*) as count FROM ai_requests GROUP BY model ORDER BY count DESC",
+		).all();
+		const byModel: Record<string, number> = {};
+		for (const r of modelRows) byModel[r.model] = r.count;
+		const statusRows = db.query<{ status: string; count: number }, []>(
+			"SELECT status, COUNT(*) as count FROM ai_requests GROUP BY status",
+		).all();
+		const byStatus: Record<string, number> = {};
+		for (const r of statusRows) byStatus[r.status] = r.count;
+		const avgDuration = db.query<{ avg: number | null }, []>(
+			"SELECT AVG(duration_ms) as avg FROM ai_requests",
+		).get()?.avg ?? 0;
+		return { total, byModel, byStatus, avgDuration: Math.round(avgDuration) };
+	},
+	"ai.models"(_input: {}): string[] {
+		const db = getDatabase();
+		return db.query<{ model: string }, []>(
+			"SELECT DISTINCT model FROM ai_requests ORDER BY model",
+		).all().map(r => r.model);
+	},
+};

package/runtime/dashboard/rpc/handlers/analytics-engine.ts ADDED Viewed

@@ -0,0 +1,53 @@
+import type { HandlerContext, OkResponse, AnalyticsEngineDataPoint as AEDataPoint } from "../types";
+import { getDatabase } from "../../../db";
+import type { SQLQueryBindings } from "bun:sqlite";
+export const handlers = {
+	"analyticsEngine.list"({ dataset, limit = 50 }: { dataset?: string; limit?: number }): AEDataPoint[] {
+		const db = getDatabase();
+		let query = "SELECT id, dataset, timestamp, index1, blob1, blob2, blob3, blob4, blob5, double1, double2, double3, double4, double5, _sample_interval FROM analytics_engine";
+		const params: SQLQueryBindings[] = [];
+		if (dataset) {
+			query += " WHERE dataset = ?";
+			params.push(dataset);
+		}
+		query += " ORDER BY timestamp DESC LIMIT ?";
+		params.push(limit);
+		return db.prepare(query).all(...params) as AEDataPoint[];
+	},
+	"analyticsEngine.get"({ id }: { id: string }): AEDataPoint | null {
+		const db = getDatabase();
+		return db.query<AEDataPoint, [string]>(
+			`SELECT * FROM analytics_engine WHERE id = ?`,
+		).get(id);
+	},
+	"analyticsEngine.delete"({ id }: { id: string }): OkResponse {
+		const db = getDatabase();
+		db.prepare("DELETE FROM analytics_engine WHERE id = ?").run(id);
+		return { ok: true };
+	},
+	"analyticsEngine.datasets"(_input: {}): string[] {
+		const db = getDatabase();
+		return db.query<{ dataset: string }, []>(
+			"SELECT DISTINCT dataset FROM analytics_engine ORDER BY dataset",
+		).all().map(r => r.dataset);
+	},
+	"analyticsEngine.stats"(_input: {}): { total: number; byDataset: Record<string, number> } {
+		const db = getDatabase();
+		const total = db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM analytics_engine").get()?.count ?? 0;
+		const rows = db.query<{ dataset: string; count: number }, []>(
+			"SELECT dataset, COUNT(*) as count FROM analytics_engine GROUP BY dataset ORDER BY count DESC",
+		).all();
+		const byDataset: Record<string, number> = {};
+		for (const r of rows) byDataset[r.dataset] = r.count;
+		return { total, byDataset };
+	},
+};

package/runtime/dashboard/rpc/handlers/cache.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import type { CacheName, CacheEntry, OkResponse } from "../types";
+import { getDatabase } from "../../../db";
+export const handlers = {
+  "cache.listCaches"(_input: {}): CacheName[] {
+    const db = getDatabase();
+    return db.query<{ cache_name: string; count: number }, []>(
+      "SELECT cache_name, COUNT(*) as count FROM cache_entries GROUP BY cache_name ORDER BY cache_name"
+    ).all();
+  },
+  "cache.listEntries"({ name }: { name: string }): CacheEntry[] {
+    const db = getDatabase();
+    return db.query<{ url: string; status: number; headers: string; expires_at: number | null }, [string]>(
+      "SELECT url, status, headers, expires_at FROM cache_entries WHERE cache_name = ? ORDER BY url"
+    ).all(name);
+  },
+  "cache.deleteEntry"({ name, url }: { name: string; url: string }): OkResponse {
+    const db = getDatabase();
+    db.prepare("DELETE FROM cache_entries WHERE cache_name = ? AND url = ?").run(name, url);
+    return { ok: true };
+  },
+};

package/runtime/dashboard/rpc/handlers/config.ts ADDED Viewed

@@ -0,0 +1,137 @@
+import type { HandlerContext } from "../types";
+import { getAllConfigs } from "../types";
+export interface ConfigItem {
+  name: string;
+  value: string;
+}
+export interface ConfigGroup {
+  title: string;
+  items: ConfigItem[];
+}
+export const handlers = {
+  "config.forService"({ type }: { type: string }, ctx: HandlerContext): ConfigGroup[] {
+    const groups: ConfigGroup[] = [];
+    for (const config of getAllConfigs(ctx)) {
+      switch (type) {
+        case "kv": {
+          const items = (config.kv_namespaces ?? []).map(ns => ({ name: ns.binding, value: ns.id }));
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "r2": {
+          const items = (config.r2_buckets ?? []).map(b => ({ name: b.binding, value: b.bucket_name }));
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "queue": {
+          const producers = (config.queues?.producers ?? []).map(p => {
+            let value = p.queue;
+            if (p.delivery_delay != null) value += ` · delay ${p.delivery_delay}s`;
+            return { name: p.binding, value };
+          });
+          if (producers.length) groups.push({ title: "Producers", items: producers });
+          const consumers = (config.queues?.consumers ?? []).map(c => {
+            const parts: string[] = [];
+            if (c.max_batch_size != null) parts.push(`batch ${c.max_batch_size}`);
+            if (c.max_retries != null) parts.push(`retries ${c.max_retries}`);
+            if (c.max_batch_timeout != null) parts.push(`timeout ${c.max_batch_timeout}s`);
+            if (c.dead_letter_queue) parts.push(`dlq ${c.dead_letter_queue}`);
+            return { name: c.queue, value: parts.join(" · ") || "defaults" };
+          });
+          if (consumers.length) groups.push({ title: "Consumers", items: consumers });
+          break;
+        }
+        case "do": {
+          const items = (config.durable_objects?.bindings ?? []).map(b => ({ name: b.name, value: b.class_name }));
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "workflows": {
+          const items = (config.workflows ?? []).map(w => ({ name: w.binding, value: w.class_name }));
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "d1": {
+          const items = (config.d1_databases ?? []).map(db => ({ name: db.binding, value: db.database_name }));
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "containers": {
+          const items = (config.containers ?? []).map(c => ({
+            name: c.name ?? c.class_name,
+            value: `${c.image}${c.max_instances ? ` · max ${c.max_instances}` : ""}`,
+          }));
+          if (items.length) groups.push({ title: "Containers", items });
+          break;
+        }
+        case "scheduled": {
+          const crons = config.triggers?.crons ?? [];
+          if (crons.length) {
+            groups.push({
+              title: "Cron Triggers",
+              items: crons.map((c, i) => ({ name: `Trigger ${i + 1}`, value: c })),
+            });
+          }
+          break;
+        }
+        case "ai": {
+          if (config.ai) {
+            groups.push({ title: "Bindings", items: [{ name: config.ai.binding, value: "Workers AI" }] });
+          }
+          break;
+        }
+        case "hyperdrive": {
+          const items = (config.hyperdrive ?? []).map(hd => {
+            let value = hd.id;
+            if (hd.localConnectionString) {
+              try {
+                const url = new URL(hd.localConnectionString);
+                value += ` · ${url.hostname}`;
+              } catch {}
+            }
+            return { name: hd.binding, value };
+          });
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "analytics_engine": {
+          const items = (config.analytics_engine_datasets ?? []).map(ae => ({
+            name: ae.binding,
+            value: ae.dataset ?? ae.binding,
+          }));
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+        case "email": {
+          const items = (config.send_email ?? []).map(e => {
+            let value = e.destination_address ?? "any destination";
+            if (e.allowed_destination_addresses?.length) {
+              value = e.allowed_destination_addresses.join(", ");
+            }
+            return { name: e.name, value };
+          });
+          if (items.length) groups.push({ title: "Bindings", items });
+          break;
+        }
+      }
+    }
+    return groups;
+  },
+};

package/runtime/dashboard/rpc/handlers/containers.ts ADDED Viewed

@@ -0,0 +1,194 @@
+import { $ } from "bun";
+import type { HandlerContext, ContainerSummary, ContainerInstance, ContainerDetail, OkResponse } from "../types";
+import { getAllConfigs, getDoNamespace } from "../types";
+import { getDatabase } from "../../../db";
+import { DockerManager } from "../../../bindings/container-docker";
+import type { ContainerBase } from "../../../bindings/container";
+interface DockerPsEntry {
+  Names: string;
+  State: string;
+  Status: string;
+  Ports: string;
+}
+const DOCKER_JSON_FORMAT = "{{json .}}";
+async function listDockerContainers(filterPrefix: string): Promise<DockerPsEntry[]> {
+  const result = await $`docker ps -a --filter name=${filterPrefix} --format=${DOCKER_JSON_FORMAT}`.quiet().nothrow();
+  if (result.exitCode !== 0) return [];
+  const lines = result.stdout.toString().trim().split("\n").filter(Boolean);
+  return lines.map(line => JSON.parse(line) as DockerPsEntry);
+}
+function parsePorts(portsStr: string): Record<string, string> {
+  const ports: Record<string, string> = {};
+  if (!portsStr) return ports;
+  for (const part of portsStr.split(", ")) {
+    const match = part.match(/(.+)->(\d+\/\w+)/);
+    if (match) {
+      ports[match[2]!] = match[1]!;
+    }
+  }
+  return ports;
+}
+export const handlers = {
+  async "containers.list"(_input: {}, ctx: HandlerContext): Promise<ContainerSummary[]> {
+    const seen = new Map<string, ContainerSummary>();
+    const db = getDatabase();
+    for (const config of getAllConfigs(ctx)) {
+      for (const c of config.containers ?? []) {
+        if (seen.has(c.class_name)) continue;
+        const row = db.query<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM do_instances WHERE namespace = ?"
+        ).get(c.class_name);
+        seen.set(c.class_name, {
+          className: c.class_name,
+          image: c.image,
+          maxInstances: c.max_instances ?? null,
+          bindingName: c.name ?? c.class_name,
+          instanceCount: row?.count ?? 0,
+          runningCount: 0,
+        });
+      }
+    }
+    // Count running Docker containers per class
+    for (const [className, summary] of seen) {
+      const entries = await listDockerContainers(`bunflare-${className}-`);
+      summary.runningCount = entries.filter(e => e.State === "running").length;
+    }
+    return Array.from(seen.values());
+  },
+  async "containers.listInstances"({ className }: { className: string }, _ctx: HandlerContext): Promise<ContainerInstance[]> {
+    const db = getDatabase();
+    // Primary source: DO instances from SQLite
+    const doInstances = db.query<{ id: string; name: string | null }, [string]>(
+      "SELECT id, name FROM do_instances WHERE namespace = ? ORDER BY id"
+    ).all(className);
+    // Secondary source: Docker containers for state info
+    const dockerEntries = await listDockerContainers(`bunflare-${className}-`);
+    const dockerByPrefix = new Map<string, DockerPsEntry>();
+    for (const e of dockerEntries) {
+      // Container name format: bunflare-{className}-{idHex.slice(0,12)}
+      const prefix = e.Names.replace(`bunflare-${className}-`, "");
+      if (prefix) dockerByPrefix.set(prefix, e);
+    }
+    // Map DO instances with Docker state
+    const seenPrefixes = new Set<string>();
+    const results: ContainerInstance[] = doInstances.map(inst => {
+      const idPrefix = inst.id.slice(0, 12);
+      seenPrefixes.add(idPrefix);
+      const docker = dockerByPrefix.get(idPrefix);
+      return {
+        id: inst.id,
+        doName: inst.name,
+        containerName: docker?.Names ?? `bunflare-${className}-${idPrefix}`,
+        state: docker?.State ?? "stopped",
+        ports: docker ? parsePorts(docker.Ports) : {},
+      };
+    });
+    // Include any Docker containers without a matching DO instance
+    for (const [prefix, docker] of dockerByPrefix) {
+      if (seenPrefixes.has(prefix)) continue;
+      results.push({
+        id: prefix,
+        doName: null,
+        containerName: docker.Names,
+        state: docker.State,
+        ports: parsePorts(docker.Ports),
+      });
+    }
+    return results;
+  },
+  async "containers.getDetail"({ className, id }: { className: string; id: string }, ctx: HandlerContext): Promise<ContainerDetail> {
+    const db = getDatabase();
+    const docker = new DockerManager();
+    // Get DO instance info
+    const inst = db.query<{ id: string; name: string | null }, [string, string]>(
+      "SELECT id, name FROM do_instances WHERE namespace = ? AND id = ?"
+    ).get(className, id);
+    const containerName = `bunflare-${className}-${id.slice(0, 12)}`;
+    // Get Docker state
+    const dockerInfo = await docker.inspect(containerName);
+    // Get container config from live instance if available
+    let config = {
+      defaultPort: 8080,
+      sleepAfter: null as string | number | null,
+      enableInternet: true,
+      pingEndpoint: "/",
+    };
+    // Try to find config from wrangler config
+    let image = "";
+    for (const cfg of getAllConfigs(ctx)) {
+      const containerCfg = cfg.containers?.find(c => c.class_name === className);
+      if (containerCfg) {
+        image = containerCfg.image;
+        break;
+      }
+    }
+    // Try to get config from live DO instance
+    const namespace = getDoNamespace(ctx, className);
+    if (namespace) {
+      const instance = (namespace as any)._getInstance(id) as ContainerBase | null;
+      if (instance) {
+        config.defaultPort = instance.defaultPort ?? 8080;
+        config.sleepAfter = instance.sleepAfter ?? null;
+        config.enableInternet = instance.enableInternet;
+        config.pingEndpoint = instance.pingEndpoint;
+      }
+    }
+    return {
+      id,
+      doName: inst?.name ?? null,
+      containerName,
+      image,
+      state: dockerInfo?.state ?? "stopped",
+      exitCode: dockerInfo?.exitCode ?? null,
+      ports: dockerInfo?.ports ?? {},
+      created: null, // docker inspect State.StartedAt could be used but not in DockerContainerInfo
+      config,
+    };
+  },
+  async "containers.getLogs"({ className, id, tail }: { className: string; id: string; tail?: number }): Promise<{ logs: string }> {
+    const docker = new DockerManager();
+    const containerName = `bunflare-${className}-${id.slice(0, 12)}`;
+    const logs = await docker.logs(containerName, tail);
+    return { logs };
+  },
+  async "containers.stop"({ className, id }: { className: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const docker = new DockerManager();
+    const containerName = `bunflare-${className}-${id.slice(0, 12)}`;
+    await docker.stop(containerName, 10);
+    return { ok: true };
+  },
+  async "containers.destroy"({ className, id }: { className: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const docker = new DockerManager();
+    const containerName = `bunflare-${className}-${id.slice(0, 12)}`;
+    await docker.remove(containerName);
+    return { ok: true };
+  },
+};

package/runtime/dashboard/rpc/handlers/d1.ts ADDED Viewed

@@ -0,0 +1,84 @@
+import type { HandlerContext, D1Database as D1DatabaseInfo, D1Table, QueryResult } from "../types";
+import { getAllConfigs } from "../types";
+import { getDataDir } from "../../../db";
+import { Database } from "bun:sqlite";
+import { join } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+export const handlers = {
+  "d1.listDatabases"(_input: {}, ctx: HandlerContext): D1DatabaseInfo[] {
+    const d1Dir = join(getDataDir(), "d1");
+    const databases: D1DatabaseInfo[] = [];
+    const seen = new Set<string>();
+    if (existsSync(d1Dir)) {
+      const files = readdirSync(d1Dir).filter(f => f.endsWith(".sqlite"));
+      for (const f of files) {
+        const name = f.replace(".sqlite", "");
+        seen.add(name);
+        const d1db = new Database(join(d1Dir, f));
+        try {
+          const tables = d1db.query<{ name: string }, []>(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+          ).all();
+          databases.push({ name, tables: tables.length });
+        } finally {
+          d1db.close();
+        }
+      }
+    }
+    for (const config of getAllConfigs(ctx)) {
+      for (const d of config.d1_databases ?? []) {
+        if (!seen.has(d.database_name)) {
+          databases.push({ name: d.database_name, tables: 0 });
+          seen.add(d.database_name);
+        }
+      }
+    }
+    databases.sort((a, b) => a.name.localeCompare(b.name));
+    return databases;
+  },
+  "d1.listTables"({ dbName }: { dbName: string }): D1Table[] {
+    const dbPath = join(getDataDir(), "d1", `${dbName}.sqlite`);
+    if (!existsSync(dbPath)) throw new Error("Database not found");
+    const d1db = new Database(dbPath);
+    try {
+      const tables = d1db.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 = d1db.query<{ count: number }, []>(`SELECT COUNT(*) as count FROM "${t.name}"`).get();
+        return { name: t.name, sql: t.sql, rows: row?.count ?? 0 };
+      });
+    } finally {
+      d1db.close();
+    }
+  },
+  "d1.query"({ dbName, sql }: { dbName: string; sql: string }): QueryResult {
+    if (!sql) throw new Error("Missing sql field");
+    const dbPath = join(getDataDir(), "d1", `${dbName}.sqlite`);
+    if (!existsSync(dbPath)) throw new Error("Database not found");
+    const d1db = new Database(dbPath);
+    try {
+      const stmt = d1db.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 = d1db.query<{ c: number }, []>("SELECT changes() as c").get()?.c ?? 0;
+        return { columns: [], rows: [], count: changes, message: `${changes} row(s) affected` };
+      }
+    } finally {
+      d1db.close();
+    }
+  },
+};