create-claude-code-visualizer 0.1.0

package/templates/app/src/app/api/runs/[id]/stream/route.ts

@@ -0,0 +1,201 @@
+import { NextRequest } from "next/server";
+import { supabase } from "@/lib/supabase";
+import { getRunContext } from "@/lib/agent-runner";
+
+export const maxDuration = 300; // 5 min max for long-running SSE observation
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id: runId } = await params;
+
+  // Fetch the run record
+  const { data: run, error } = await supabase
+    .from("agent_runs")
+    .select("*")
+    .eq("id", runId)
+    .single();
+
+  if (error || !run) {
+    return new Response(`data: ${JSON.stringify({ type: "error", error: "Run not found" })}\n\n`, {
+      status: 404,
+      headers: { "Content-Type": "text/event-stream" },
+    });
+  }
+
+  // If already completed/failed/stopped and no RunContext, return final state
+  const ctx = getRunContext(runId);
+  if (!ctx && (run.status === "completed" || run.status === "failed" || run.status === "stopped")) {
+    // Map DB status to the SSE event types the client expects
+    const eventType = run.status === "completed" ? "done"
+      : run.status === "stopped" ? "stopped"
+      : "error";
+    const payload = eventType === "error"
+      ? { type: "error", error: run.error || "Run failed" }
+      : { type: eventType, output: run.output, cost_usd: run.cost_usd, duration_ms: run.duration_ms };
+    const encoder = new TextEncoder();
+    const body = encoder.encode(`data: ${JSON.stringify(payload)}\n\n`);
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  }
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      let closed = false;
+
+      const send = (data: Record<string, unknown>) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+        } catch {
+          // stream closed
+          closed = true;
+        }
+      };
+
+      // --- Mode 1: Live attach (RunContext exists) ---
+      if (ctx) {
+        ctx.subscriberCount++;
+
+        // Load historical events written before this connection (for mid-run reconnection)
+        const afterSeq = parseInt(req.nextUrl.searchParams.get("after_seq") || "0", 10);
+        if (afterSeq > 0) {
+          const { data: events } = await supabase
+            .from("run_events")
+            .select("*")
+            .eq("run_id", runId)
+            .gt("seq", afterSeq)
+            .order("seq", { ascending: true });
+
+          if (events) {
+            for (const evt of events) {
+              send({ type: evt.event_type, seq: evt.seq, ...evt.payload });
+            }
+          }
+        }
+
+        // Subscribe to live emitter
+        const onEvent = (data: Record<string, unknown>) => {
+          send(data);
+        };
+
+        ctx.emitter.on("event", onEvent);
+
+        // Wait for client disconnect or run completion
+        const cleanup = () => {
+          ctx.emitter.off("event", onEvent);
+          ctx.subscriberCount = Math.max(0, ctx.subscriberCount - 1);
+          if (!closed) {
+            closed = true;
+            try { controller.close(); } catch { /* already closed */ }
+          }
+        };
+
+        // Watch for client disconnect
+        req.signal.addEventListener("abort", cleanup);
+
+        // Also close when run finishes (after a small delay to flush final events)
+        const checkDone = () => {
+          if (ctx.status === "done") {
+            setTimeout(() => cleanup(), 500);
+          } else {
+            setTimeout(checkDone, 1000);
+          }
+        };
+        checkDone();
+
+        return; // keep stream open
+      }
+
+      // --- Mode 2: Historical replay (RunContext not found) ---
+      // Load all events from DB
+      const { data: events } = await supabase
+        .from("run_events")
+        .select("*")
+        .eq("run_id", runId)
+        .order("seq", { ascending: true });
+
+      if (events && events.length > 0) {
+        for (const evt of events) {
+          send({ type: evt.event_type, seq: evt.seq, ...evt.payload });
+        }
+      }
+
+      // If run is still "running" but no RunContext (server restarted), poll for new events
+      if (run.status === "running" || run.status === "queued") {
+        let lastSeq = events?.length ? events[events.length - 1].seq : 0;
+        const pollInterval = setInterval(async () => {
+          if (closed || req.signal.aborted) {
+            clearInterval(pollInterval);
+            if (!closed) {
+              closed = true;
+              try { controller.close(); } catch { /* ok */ }
+            }
+            return;
+          }
+
+          // Check for new events
+          const { data: newEvents } = await supabase
+            .from("run_events")
+            .select("*")
+            .eq("run_id", runId)
+            .gt("seq", lastSeq)
+            .order("seq", { ascending: true });
+
+          if (newEvents && newEvents.length > 0) {
+            for (const evt of newEvents) {
+              send({ type: evt.event_type, seq: evt.seq, ...evt.payload });
+            }
+            lastSeq = newEvents[newEvents.length - 1].seq;
+
+            // Check if run is done
+            const doneEvt = newEvents.find((e) => e.event_type === "done" || e.event_type === "stopped" || e.event_type === "error");
+            if (doneEvt) {
+              clearInterval(pollInterval);
+              closed = true;
+              try { controller.close(); } catch { /* ok */ }
+            }
+          }
+
+          // Also check if the run status changed (stale cleanup may have updated it)
+          const { data: freshRun } = await supabase
+            .from("agent_runs")
+            .select("status")
+            .eq("id", runId)
+            .single();
+
+          if (freshRun && (freshRun.status === "completed" || freshRun.status === "failed" || freshRun.status === "stopped")) {
+            clearInterval(pollInterval);
+            // Send final event if no done event was sent
+            if (!newEvents?.some((e) => e.event_type === "done" || e.event_type === "stopped")) {
+              const eventType = freshRun.status === "completed" ? "done" : freshRun.status === "stopped" ? "stopped" : "error";
+              send({ type: eventType });
+            }
+            closed = true;
+            try { controller.close(); } catch { /* ok */ }
+          }
+        }, 2000);
+
+        return; // keep stream open for polling
+      }
+
+      // Run is terminal and no events — just close
+      controller.close();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}

package/templates/app/src/app/api/runs/route.ts

@@ -0,0 +1,95 @@
+import { NextRequest, NextResponse } from "next/server";
+import { supabase } from "@/lib/supabase";
+import { requireRole } from "@/lib/auth-guard";
+
+export async function GET(req: NextRequest) {
+  const { searchParams } = req.nextUrl;
+  const agentSlug = searchParams.get("agent_slug");
+  const limit = parseInt(searchParams.get("limit") || "50", 10);
+  const offset = parseInt(searchParams.get("offset") || "0", 10);
+
+  let query = supabase
+    .from("agent_runs")
+    .select("*, run_events(count)")
+    .order("created_at", { ascending: false })
+    .range(offset, offset + limit - 1);
+
+  if (agentSlug) {
+    query = query.eq("agent_slug", agentSlug);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  // Flatten the nested run_events count into a top-level event_count field
+  const normalized = (data || []).map((run: Record<string, unknown>) => {
+    const events = run.run_events as { count: number }[] | undefined;
+    const { run_events: _, ...rest } = run;
+    return { ...rest, event_count: events?.[0]?.count ?? 0 };
+  });
+
+  return NextResponse.json(normalized);
+}
+
+export async function DELETE(req: NextRequest) {
+  const { searchParams } = req.nextUrl;
+  const sessionId = searchParams.get("session_id");
+
+  if (!sessionId) {
+    return NextResponse.json(
+      { error: "session_id is required" },
+      { status: 400 }
+    );
+  }
+
+  const { error } = await supabase
+    .from("agent_runs")
+    .delete()
+    .eq("session_id", sessionId);
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  return NextResponse.json({ deleted: true });
+}
+
+export async function POST(req: NextRequest) {
+  const auth = await requireRole(req, ["admin", "operator"], "create_run", "agent_runs");
+  if (!auth.authorized) return auth.response;
+
+  const body = await req.json();
+  const { agent_slug, agent_name, prompt, session_id } = body;
+
+  if (!agent_slug || !agent_name || !prompt) {
+    return NextResponse.json(
+      { error: "agent_slug, agent_name, and prompt are required" },
+      { status: 400 }
+    );
+  }
+
+  const { data, error } = await supabase
+    .from("agent_runs")
+    .insert({
+      agent_slug,
+      agent_name,
+      prompt,
+      status: "queued",
+      ...(session_id ? { session_id } : {}),
+      metadata: {
+        created_by: auth.user!.email,
+        created_by_role: auth.user!.role,
+      },
+    })
+    .select()
+    .single();
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  return NextResponse.json(data, { status: 201 });
+}

package/templates/app/src/app/api/schedules/[id]/route.ts

@@ -0,0 +1,81 @@
+import { NextRequest, NextResponse } from "next/server";
+import { supabase } from "@/lib/supabase";
+import { getQueue } from "@/lib/queue";
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await req.json();
+
+  const updates: Record<string, unknown> = { updated_at: new Date().toISOString() };
+  if (body.prompt !== undefined) updates.prompt = body.prompt;
+  if (body.cron !== undefined) updates.cron = body.cron;
+  if (body.enabled !== undefined) updates.enabled = body.enabled;
+  if (body.skill_slug !== undefined) updates.skill_slug = body.skill_slug || null;
+
+  const { data, error } = await supabase
+    .from("agent_schedules")
+    .update(updates)
+    .eq("id", id)
+    .select()
+    .single();
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  // Sync with BullMQ
+  try {
+    const queue = getQueue();
+    if (data.enabled) {
+      await queue.upsertJobScheduler(
+        `schedule-${id}`,
+        { pattern: data.cron },
+        {
+          name: "scheduled-agent-run",
+          data: {
+            scheduleId: data.id,
+            agentSlug: data.agent_slug,
+            agentName: data.agent_name,
+            prompt: data.prompt,
+            skillSlug: data.skill_slug || undefined,
+          },
+        }
+      );
+    } else {
+      await queue.removeJobScheduler(`schedule-${id}`);
+    }
+  } catch (err) {
+    console.error("Failed to sync BullMQ scheduler:", err);
+  }
+
+  return NextResponse.json(data);
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  // Remove from BullMQ first
+  try {
+    const queue = getQueue();
+    await queue.removeJobScheduler(`schedule-${id}`);
+  } catch (err) {
+    console.error("Failed to remove BullMQ scheduler:", err);
+  }
+
+  const { error } = await supabase
+    .from("agent_schedules")
+    .delete()
+    .eq("id", id);
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  return NextResponse.json({ ok: true });
+}

package/templates/app/src/app/api/schedules/route.ts

@@ -0,0 +1,75 @@
+import { NextRequest, NextResponse } from "next/server";
+import { supabase } from "@/lib/supabase";
+import { getQueue } from "@/lib/queue";
+
+export async function GET() {
+  const { data, error } = await supabase
+    .from("agent_schedules")
+    .select("*")
+    .order("created_at", { ascending: false });
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  return NextResponse.json(data);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { agent_slug, agent_name, prompt, cron, skill_slug } = body;
+
+  if (!agent_slug || !agent_name || !cron) {
+    return NextResponse.json(
+      { error: "agent_slug, agent_name, and cron are required" },
+      { status: 400 }
+    );
+  }
+
+  if (!prompt && !skill_slug) {
+    return NextResponse.json(
+      { error: "Either prompt or skill_slug is required" },
+      { status: 400 }
+    );
+  }
+
+  const { data, error } = await supabase
+    .from("agent_schedules")
+    .insert({
+      agent_slug,
+      agent_name,
+      prompt: prompt || "",
+      cron,
+      skill_slug: skill_slug || null,
+      enabled: true,
+    })
+    .select()
+    .single();
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  // Register with BullMQ
+  try {
+    const queue = getQueue();
+    await queue.upsertJobScheduler(
+      `schedule-${data.id}`,
+      { pattern: cron },
+      {
+        name: "scheduled-agent-run",
+        data: {
+          scheduleId: data.id,
+          agentSlug: data.agent_slug,
+          agentName: data.agent_name,
+          prompt: data.prompt,
+          skillSlug: data.skill_slug || undefined,
+        },
+      }
+    );
+  } catch (err) {
+    console.error("Failed to register BullMQ scheduler:", err);
+  }
+
+  return NextResponse.json(data, { status: 201 });
+}

package/templates/app/src/app/api/settings/access-logs/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createClient } from "@/lib/supabase-server";
+import { requireRole } from "@/lib/auth-guard";
+
+export async function GET(req: NextRequest) {
+  const auth = await requireRole(req, ["admin"], "view_access_logs", "settings/access-logs");
+  if (!auth.authorized) return auth.response;
+
+  const { searchParams } = req.nextUrl;
+  const limit = parseInt(searchParams.get("limit") || "100", 10);
+  const filter = searchParams.get("filter"); // "blocked" | "allowed" | null
+
+  const supabase = await createClient();
+  let query = supabase
+    .from("access_logs")
+    .select("*")
+    .order("created_at", { ascending: false })
+    .limit(limit);
+
+  if (filter === "blocked") {
+    query = query.eq("allowed", false);
+  } else if (filter === "allowed") {
+    query = query.eq("allowed", true);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+
+  return NextResponse.json(data);
+}

package/templates/app/src/app/api/settings/claude-md/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireRole } from "@/lib/auth-guard";
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+
+const PROJECT_ROOT = process.env.PROJECT_ROOT || "/mnt/c/Users/Admin/Documents/PersonalAIssistant";
+const CLAUDE_MD_PATH = join(PROJECT_ROOT, "CLAUDE.md");
+
+export async function GET(req: NextRequest) {
+  const auth = await requireRole(req, ["admin"], "view_claude_md", "settings/claude-md");
+  if (!auth.authorized) return auth.response;
+
+  try {
+    const content = await readFile(CLAUDE_MD_PATH, "utf-8");
+    return NextResponse.json({ content, path: CLAUDE_MD_PATH });
+  } catch (err: unknown) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return NextResponse.json({ content: "", path: CLAUDE_MD_PATH });
+    }
+    return NextResponse.json(
+      { error: "Failed to read CLAUDE.md" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(req: NextRequest) {
+  const auth = await requireRole(req, ["admin"], "edit_claude_md", "settings/claude-md");
+  if (!auth.authorized) return auth.response;
+
+  try {
+    const { content } = await req.json();
+    if (typeof content !== "string") {
+      return NextResponse.json({ error: "content must be a string" }, { status: 400 });
+    }
+    await writeFile(CLAUDE_MD_PATH, content, "utf-8");
+    return NextResponse.json({ success: true });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to write CLAUDE.md" },
+      { status: 500 }
+    );
+  }
+}