lopata 0.0.1

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

@@ -0,0 +1,91 @@
+import type { HandlerContext, OkResponse } from "../types";
+import { getAllConfigs } from "../types";
+
+export interface ScheduledTrigger {
+  expression: string;
+  description: string;
+  workerName: string | null;
+}
+
+export const handlers = {
+  "scheduled.listTriggers"(_input: {}, ctx: HandlerContext): ScheduledTrigger[] {
+    const triggers: ScheduledTrigger[] = [];
+
+    if (ctx.registry) {
+      for (const [name, mgr] of ctx.registry.listManagers()) {
+        for (const cron of mgr.config.triggers?.crons ?? []) {
+          triggers.push({ expression: cron, description: cronToHuman(cron), workerName: name });
+        }
+      }
+    } else if (ctx.config) {
+      for (const cron of ctx.config.triggers?.crons ?? []) {
+        triggers.push({ expression: cron, description: cronToHuman(cron), workerName: null });
+      }
+    }
+
+    return triggers;
+  },
+
+  async "scheduled.trigger"({ cron, workerName }: { cron: string; workerName?: string | null }, ctx: HandlerContext): Promise<OkResponse> {
+    let gen;
+    if (workerName && ctx.registry) {
+      const mgr = ctx.registry.listManagers().get(workerName);
+      gen = mgr?.active;
+    } else {
+      gen = ctx.manager?.active;
+    }
+    if (!gen) throw new Error("No active generation");
+    const res = await gen.callScheduled(cron);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(text || `Scheduled handler failed with status ${res.status}`);
+    }
+    return { ok: true };
+  },
+};
+
+const SPECIAL_DESCRIPTIONS: Record<string, string> = {
+  "@daily": "Every day at midnight",
+  "@midnight": "Every day at midnight",
+  "@hourly": "Every hour",
+  "@weekly": "Every week (Sunday midnight)",
+  "@monthly": "First day of every month",
+  "@yearly": "First day of every year",
+  "@annually": "First day of every year",
+};
+
+function cronToHuman(expression: string): string {
+  const trimmed = expression.trim();
+  const special = SPECIAL_DESCRIPTIONS[trimmed.toLowerCase()];
+  if (special) return special;
+
+  const parts = trimmed.split(/\s+/);
+  if (parts.length !== 5) return expression;
+
+  const [minute, hour, dom, month, dow] = parts;
+  const segments: string[] = [];
+
+  if (minute === "*" && hour === "*" && dom === "*" && month === "*" && dow === "*") {
+    return "Every minute";
+  }
+
+  // Detect common patterns
+  if (minute!.startsWith("*/")) {
+    return `Every ${minute!.slice(2)} minutes`;
+  }
+  if (hour!.startsWith("*/") && minute === "0") {
+    return `Every ${hour!.slice(2)} hours`;
+  }
+
+  if (hour !== "*" && minute !== "*") {
+    segments.push(`At ${hour!.padStart(2, "0")}:${minute!.padStart(2, "0")}`);
+  } else if (minute !== "*") {
+    segments.push(`At minute ${minute}`);
+  }
+
+  if (dow !== "*") segments.push(`on day-of-week ${dow}`);
+  if (dom !== "*") segments.push(`on day ${dom}`);
+  if (month !== "*") segments.push(`in month ${month}`);
+
+  return segments.join(" ") || expression;
+}

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

@@ -0,0 +1,64 @@
+import { getTraceStore } from "../../../tracing/store";
+import type { TraceSummary, TraceDetail } from "../../../tracing/types";
+
+export const handlers = {
+  "traces.list"(input: { limit?: number; cursor?: string }): { items: TraceSummary[]; cursor: string | null } {
+    if (input.limit !== undefined && (typeof input.limit !== "number" || input.limit < 1)) {
+      throw new Error("limit must be a positive number");
+    }
+    if (input.cursor !== undefined && typeof input.cursor !== "string") {
+      throw new Error("cursor must be a string");
+    }
+    const store = getTraceStore();
+    return store.listTraces({ limit: input.limit ?? 50, cursor: input.cursor });
+  },
+
+  "traces.getTrace"(input: { traceId: string }): TraceDetail {
+    if (!input.traceId || typeof input.traceId !== "string") {
+      throw new Error("traceId is required and must be a string");
+    }
+    const store = getTraceStore();
+    return store.getTrace(input.traceId);
+  },
+
+  "traces.search"(input: { query: string; limit?: number }): { items: TraceSummary[]; cursor: string | null } {
+    if (!input.query || typeof input.query !== "string") {
+      throw new Error("query is required and must be a string");
+    }
+    if (input.limit !== undefined && (typeof input.limit !== "number" || input.limit < 1)) {
+      throw new Error("limit must be a positive number");
+    }
+    const store = getTraceStore();
+    return store.searchTraces(input.query, input.limit ?? 50);
+  },
+
+  "traces.listSpans"(input: { limit?: number; cursor?: string }): { items: Array<{ spanId: string; traceId: string; name: string; status: string; durationMs: number | null; startTime: number; workerName: string | null }>; cursor: string | null } {
+    if (input.limit !== undefined && (typeof input.limit !== "number" || input.limit < 1)) {
+      throw new Error("limit must be a positive number");
+    }
+    const store = getTraceStore();
+    return store.listAllSpans({ limit: input.limit ?? 50, cursor: input.cursor });
+  },
+
+  "traces.listLogs"(input: { limit?: number; cursor?: string }): { items: Array<{ id: number; spanId: string; traceId: string; timestamp: number; name: string; level: string | null; message: string | null }>; cursor: string | null } {
+    if (input.limit !== undefined && (typeof input.limit !== "number" || input.limit < 1)) {
+      throw new Error("limit must be a positive number");
+    }
+    const store = getTraceStore();
+    return store.listAllLogs({ limit: input.limit ?? 50, cursor: input.cursor });
+  },
+
+  "traces.errors"(input: { traceId: string }) {
+    if (!input.traceId || typeof input.traceId !== "string") {
+      throw new Error("traceId is required and must be a string");
+    }
+    const store = getTraceStore();
+    return store.getErrorsForTrace(input.traceId);
+  },
+
+  "traces.clear"(_input: {}): { ok: true } {
+    const store = getTraceStore();
+    store.clearTraces();
+    return { ok: true };
+  },
+};

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

@@ -0,0 +1,65 @@
+import type { HandlerContext, WorkerInfo, WorkerBinding } from "../types";
+import type { WranglerConfig } from "../../../config";
+
+function extractBindings(config: WranglerConfig): WorkerBinding[] {
+  const bindings: WorkerBinding[] = [];
+
+  for (const ns of config.kv_namespaces ?? []) {
+    bindings.push({ type: "kv", name: ns.binding, target: ns.id, href: `#/kv/${encodeURIComponent(ns.id)}` });
+  }
+  for (const b of config.r2_buckets ?? []) {
+    bindings.push({ type: "r2", name: b.binding, target: b.bucket_name, href: `#/r2/${encodeURIComponent(b.bucket_name)}` });
+  }
+  for (const db of config.d1_databases ?? []) {
+    bindings.push({ type: "d1", name: db.binding, target: db.database_name, href: `#/d1/${encodeURIComponent(db.database_name)}` });
+  }
+  for (const b of config.durable_objects?.bindings ?? []) {
+    bindings.push({ type: "do", name: b.name, target: b.class_name, href: `#/do/${encodeURIComponent(b.class_name)}` });
+  }
+  for (const p of config.queues?.producers ?? []) {
+    bindings.push({ type: "queue", name: p.binding, target: p.queue, href: `#/queue/${encodeURIComponent(p.queue)}` });
+  }
+  for (const w of config.workflows ?? []) {
+    bindings.push({ type: "workflow", name: w.binding, target: w.class_name, href: `#/workflows/${encodeURIComponent(w.binding)}` });
+  }
+  for (const c of config.containers ?? []) {
+    bindings.push({ type: "container", name: c.name ?? c.class_name, target: c.image, href: `#/containers/${encodeURIComponent(c.class_name)}` });
+  }
+  for (const s of config.services ?? []) {
+    const target = s.entrypoint ? `${s.service}#${s.entrypoint}` : s.service;
+    bindings.push({ type: "service", name: s.binding, target, href: null });
+  }
+  if (config.images) {
+    bindings.push({ type: "images", name: config.images.binding, target: "", href: null });
+  }
+
+  return bindings;
+}
+
+export const handlers = {
+  "workers.list"(_input: {}, ctx: HandlerContext): WorkerInfo[] {
+    if (ctx.registry) {
+      const workers: WorkerInfo[] = [];
+      let isFirst = true;
+      for (const [name, mgr] of ctx.registry.listManagers()) {
+        workers.push({
+          name,
+          isMain: isFirst,
+          bindings: extractBindings(mgr.config),
+        });
+        isFirst = false;
+      }
+      return workers;
+    }
+
+    if (ctx.config) {
+      return [{
+        name: ctx.config.name || "main",
+        isMain: true,
+        bindings: extractBindings(ctx.config),
+      }];
+    }
+
+    return [];
+  },
+};

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

@@ -0,0 +1,171 @@
+import type { HandlerContext, WorkflowSummary, WorkflowInstance, WorkflowDetail, OkResponse } from "../types";
+import { getAllConfigs } from "../types";
+import { getDatabase } from "../../../db";
+import type { SQLQueryBindings } from "bun:sqlite";
+import type { SqliteWorkflowBinding } from "../../../bindings/workflow";
+import { getWaitingEventTypes, isInstanceSleeping } from "../../../bindings/workflow";
+
+function getWorkflowBinding(ctx: HandlerContext, name: string): SqliteWorkflowBinding {
+  if (ctx.registry) {
+    for (const manager of ctx.registry.listManagers().values()) {
+      const gen = manager.active;
+      if (!gen) continue;
+      const entry = gen.registry.workflows.find(w => w.bindingName === name);
+      if (entry) return entry.binding;
+    }
+  }
+  if (ctx.manager?.active) {
+    const entry = ctx.manager.active.registry.workflows.find(w => w.bindingName === name);
+    if (entry) return entry.binding;
+  }
+  throw new Error(`Workflow binding "${name}" not found`);
+}
+
+export const handlers = {
+  "workflows.list"(_input: {}, ctx: HandlerContext): WorkflowSummary[] {
+    const db = getDatabase();
+    const rows = db.query<{ workflow_name: string; status: string; count: number }, []>(
+      "SELECT workflow_name, status, COUNT(*) as count FROM workflow_instances GROUP BY workflow_name, status ORDER BY workflow_name"
+    ).all();
+
+    const grouped = new Map<string, { total: number; byStatus: Record<string, number> }>();
+    for (const row of rows) {
+      let entry = grouped.get(row.workflow_name);
+      if (!entry) {
+        entry = { total: 0, byStatus: {} };
+        grouped.set(row.workflow_name, entry);
+      }
+      entry.total += row.count;
+      entry.byStatus[row.status] = row.count;
+    }
+
+    for (const config of getAllConfigs(ctx)) {
+      for (const w of config.workflows ?? []) {
+        if (!grouped.has(w.binding)) {
+          grouped.set(w.binding, { total: 0, byStatus: {} });
+        }
+      }
+    }
+
+    return Array.from(grouped.entries())
+      .sort((a, b) => a[0].localeCompare(b[0]))
+      .map(([name, data]) => ({ name, ...data }));
+  },
+
+  "workflows.listInstances"({ name, status }: { name: string; status?: string }): WorkflowInstance[] {
+    const db = getDatabase();
+    let query = "SELECT id, status, params, output, error, created_at, updated_at FROM workflow_instances WHERE workflow_name = ?";
+    const params: SQLQueryBindings[] = [name];
+
+    if (status) { query += " AND status = ?"; params.push(status); }
+    query += " ORDER BY created_at DESC LIMIT 100";
+
+    return db.prepare(query).all(...params) as WorkflowInstance[];
+  },
+
+  "workflows.getInstance"({ id }: { name: string; id: string }): WorkflowDetail {
+    const db = getDatabase();
+    const instance = db.query<Record<string, unknown>, [string]>(
+      "SELECT * FROM workflow_instances WHERE id = ?"
+    ).get(id);
+    if (!instance) throw new Error("Workflow instance not found");
+
+    const steps = db.query<{ step_name: string; output: string | null; completed_at: number }, [string]>(
+      "SELECT step_name, output, completed_at FROM workflow_steps WHERE instance_id = ? ORDER BY completed_at"
+    ).all(id);
+
+    const stepAttempts = db.query<{ step_name: string; failed_attempts: number; last_error: string | null; last_error_name: string | null; last_error_id: string | null; updated_at: number | null }, [string]>(
+      "SELECT step_name, failed_attempts, last_error, last_error_name, last_error_id, updated_at FROM workflow_step_attempts WHERE instance_id = ? ORDER BY updated_at DESC"
+    ).all(id);
+
+    const events = db.query<{ id: number; event_type: string; payload: string | null; created_at: number }, [string]>(
+      "SELECT id, event_type, payload, created_at FROM workflow_events WHERE instance_id = ? ORDER BY created_at"
+    ).all(id);
+
+    // Compute active sleep: check if the instance is currently sleeping (in-memory)
+    let activeSleep: WorkflowDetail["activeSleep"] = null;
+    if (instance.status === "running" && isInstanceSleeping(id)) {
+      // Find the latest sleep/sleepUntil step to get the "until" time
+      for (let i = steps.length - 1; i >= 0; i--) {
+        const s = steps[i]!;
+        if ((s.step_name.startsWith("sleep:") || s.step_name.startsWith("sleepUntil:")) && s.output) {
+          try {
+            const parsed = JSON.parse(s.output) as { until: number | string };
+            const until = typeof parsed.until === "string" ? new Date(parsed.until).getTime() : parsed.until;
+            if (until > Date.now()) {
+              activeSleep = { stepName: s.step_name, until };
+              break;
+            }
+          } catch {}
+        }
+      }
+    }
+
+    // Compute waiting event types from in-memory registry
+    const waitingForEvents = instance.status === "waiting" ? getWaitingEventTypes(id) : [];
+
+    return { ...instance, steps, stepAttempts, events, activeSleep, waitingForEvents } as WorkflowDetail;
+  },
+
+  async "workflows.terminate"({ name, id }: { name: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const binding = getWorkflowBinding(ctx, name);
+    const instance = await binding.get(id);
+    await instance.terminate();
+    return { ok: true };
+  },
+
+  async "workflows.create"({ name, params }: { name: string; params: string }, ctx: HandlerContext): Promise<{ ok: true; id: string }> {
+    const binding = getWorkflowBinding(ctx, name);
+    const parsed = JSON.parse(params);
+    const instance = await binding.create({ params: parsed });
+    return { ok: true, id: instance.id };
+  },
+
+  async "workflows.pause"({ name, id }: { name: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const binding = getWorkflowBinding(ctx, name);
+    const instance = await binding.get(id);
+    await instance.pause();
+    return { ok: true };
+  },
+
+  async "workflows.resume"({ name, id }: { name: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const binding = getWorkflowBinding(ctx, name);
+    const instance = await binding.get(id);
+    await instance.resume();
+    return { ok: true };
+  },
+
+  async "workflows.restart"({ name, id, fromStep }: { name: string; id: string; fromStep?: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const binding = getWorkflowBinding(ctx, name);
+    const instance = await binding.get(id);
+    await instance.restart(fromStep ? { fromStep } : undefined);
+    return { ok: true };
+  },
+
+  async "workflows.skipSleep"({ name, id }: { name: string; id: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const binding = getWorkflowBinding(ctx, name);
+    const instance = await binding.get(id);
+    await instance.skipSleep();
+    return { ok: true };
+  },
+
+  async "workflows.sendEvent"({ name, id, type, payload }: { name: string; id: string; type: string; payload?: string }, ctx: HandlerContext): Promise<OkResponse> {
+    const binding = getWorkflowBinding(ctx, name);
+    const instance = await binding.get(id);
+    const parsed = payload ? JSON.parse(payload) : undefined;
+    await instance.sendEvent({ type, payload: parsed });
+    return { ok: true };
+  },
+
+  async "workflows.duplicate"({ name, id }: { name: string; id: string }, ctx: HandlerContext): Promise<{ ok: true; id: string }> {
+    const binding = getWorkflowBinding(ctx, name);
+    const db = getDatabase();
+    const row = db.query<{ params: string | null }, [string]>(
+      "SELECT params FROM workflow_instances WHERE id = ?"
+    ).get(id);
+    if (!row) throw new Error("Workflow instance not found");
+    const params = row.params !== null ? JSON.parse(row.params) : {};
+    const newInstance = await binding.create({ params });
+    return { ok: true, id: newInstance.id };
+  },
+};

package/runtime/dashboard/rpc/hooks.ts

@@ -0,0 +1,132 @@
+import { useState, useEffect, useRef } from "preact/hooks";
+import { rpc } from "./client";
+import type { Procedures } from "./server";
+import type { Paginated } from "./types";
+
+type EmptyObject = Record<string, never>;
+
+// ─── useQuery ────────────────────────────────────────────────────────
+
+interface QueryResult<T> {
+  data: T | null;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useQuery<K extends keyof Procedures>(
+  procedure: K,
+  ...args: Procedures[K]["input"] extends EmptyObject ? [] : [Procedures[K]["input"]]
+): QueryResult<Procedures[K]["output"]> {
+  type Output = Procedures[K]["output"];
+  const [state, setState] = useState<{ data: Output | null; isLoading: boolean; error: Error | null }>({
+    data: null, isLoading: true, error: null,
+  });
+  const input = args[0];
+  const key = JSON.stringify(input ?? {});
+  const genRef = useRef(0);
+
+  const doFetch = () => {
+    const gen = ++genRef.current;
+    setState(s => ({ ...s, isLoading: true, error: null }));
+    (rpc as Function)(procedure, input)
+      .then((data: Output) => {
+        if (genRef.current === gen) setState({ data, isLoading: false, error: null });
+      })
+      .catch((err: unknown) => {
+        if (genRef.current === gen) setState({ data: null, isLoading: false, error: toError(err) });
+      });
+  };
+
+  useEffect(() => { doFetch(); }, [procedure, key]);
+
+  return { ...state, refetch: doFetch };
+}
+
+// ─── usePaginatedQuery ───────────────────────────────────────────────
+
+type PaginatedProcedures = {
+  [K in keyof Procedures]: Procedures[K]["output"] extends Paginated<any> ? K : never;
+}[keyof Procedures];
+
+type PaginatedItem<K extends PaginatedProcedures> =
+  Procedures[K]["output"] extends Paginated<infer T> ? T : never;
+
+interface PaginatedQueryResult<T> {
+  items: T[];
+  isLoading: boolean;
+  hasMore: boolean;
+  loadMore: () => void;
+  refetch: () => void;
+}
+
+export function usePaginatedQuery<K extends PaginatedProcedures>(
+  procedure: K,
+  input: Omit<Procedures[K]["input"], "cursor">,
+): PaginatedQueryResult<PaginatedItem<K>> {
+  type Item = PaginatedItem<K>;
+  const [items, setItems] = useState<Item[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const cursorRef = useRef<string | null>(null);
+  const [hasMore, setHasMore] = useState(false);
+  const key = JSON.stringify(input);
+
+  const load = (reset: boolean) => {
+    setIsLoading(true);
+    const fullInput = { ...input, cursor: reset ? "" : (cursorRef.current ?? "") };
+    (rpc as Function)(procedure, fullInput).then((data: Paginated<Item>) => {
+      setItems(prev => reset ? data.items : [...prev, ...data.items]);
+      cursorRef.current = data.cursor;
+      setHasMore(data.cursor !== null);
+      setIsLoading(false);
+    });
+  };
+
+  useEffect(() => {
+    cursorRef.current = null;
+    load(true);
+  }, [procedure, key]);
+
+  return { items, isLoading, hasMore, loadMore: () => load(false), refetch: () => load(true) };
+}
+
+// ─── useMutation ─────────────────────────────────────────────────────
+
+interface MutationResult<Input, Output> {
+  mutate: (...args: Input extends EmptyObject ? [] : [Input]) => Promise<Output | undefined>;
+  data: Output | null;
+  isLoading: boolean;
+  error: Error | null;
+  reset: () => void;
+}
+
+export function useMutation<K extends keyof Procedures>(
+  procedure: K,
+): MutationResult<Procedures[K]["input"], Procedures[K]["output"]> {
+  type Output = Procedures[K]["output"];
+  const [state, setState] = useState<{ data: Output | null; isLoading: boolean; error: Error | null }>({
+    data: null, isLoading: false, error: null,
+  });
+
+  const mutate = async (...args: any[]): Promise<Output | undefined> => {
+    setState({ data: null, isLoading: true, error: null });
+    try {
+      const result = await (rpc as Function)(procedure, args[0]);
+      setState({ data: result, isLoading: false, error: null });
+      return result;
+    } catch (err) {
+      setState({ data: null, isLoading: false, error: toError(err) });
+      return undefined;
+    }
+  };
+
+  const reset = () => setState({ data: null, isLoading: false, error: null });
+
+  return { ...state, mutate: mutate as MutationResult<Procedures[K]["input"], Output>["mutate"], reset };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function toError(err: unknown): Error {
+  return err instanceof Error ? err : new Error(String(err));
+}

package/runtime/dashboard/rpc/server.ts

@@ -0,0 +1,70 @@
+import type { HandlerContext } from "./types";
+import { handlers as overview } from "./handlers/overview";
+import { handlers as kv } from "./handlers/kv";
+import { handlers as r2 } from "./handlers/r2";
+import { handlers as queue } from "./handlers/queue";
+import { handlers as durableObjects } from "./handlers/do";
+import { handlers as workflows } from "./handlers/workflows";
+import { handlers as d1 } from "./handlers/d1";
+import { handlers as cache } from "./handlers/cache";
+import { handlers as generations } from "./handlers/generations";
+import { handlers as workers } from "./handlers/workers";
+import { handlers as containers } from "./handlers/containers";
+import { handlers as traces } from "./handlers/traces";
+import { handlers as config } from "./handlers/config";
+import { handlers as errors } from "./handlers/errors";
+import { handlers as scheduled } from "./handlers/scheduled";
+import { handlers as email } from "./handlers/email";
+import { handlers as ai } from "./handlers/ai";
+import { handlers as analyticsEngine } from "./handlers/analytics-engine";
+
+const allHandlers = {
+  ...overview,
+  ...kv,
+  ...r2,
+  ...queue,
+  ...durableObjects,
+  ...workflows,
+  ...d1,
+  ...cache,
+  ...generations,
+  ...workers,
+  ...containers,
+  ...traces,
+  ...config,
+  ...errors,
+  ...scheduled,
+  ...email,
+  ...ai,
+  ...analyticsEngine,
+};
+
+export type Procedures = {
+  [K in keyof typeof allHandlers]: {
+    input: Parameters<(typeof allHandlers)[K]>[0];
+    output: Awaited<ReturnType<(typeof allHandlers)[K]>>;
+  };
+};
+
+function json(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export async function dispatch(request: Request, ctx: HandlerContext): Promise<Response> {
+  try {
+    const body = await request.json() as { procedure: string; input: unknown };
+    if (!body.procedure || typeof body.procedure !== "string") {
+      return json({ error: "procedure must be a string" }, 400);
+    }
+    const handler = allHandlers[body.procedure as keyof typeof allHandlers];
+    if (!handler) return json({ error: `Unknown procedure: ${body.procedure}` }, 404);
+    const result = await (handler as Function)(body.input ?? {}, ctx);
+    return json(result);
+  } catch (err) {
+    console.error("[bunflare dashboard] RPC error:", err);
+    return json({ error: String(err) }, 500);
+  }
+}