@a5c-ai/babysitter-observer-dashboard 5.0.1-staging.7a8768ec

package/src/app/api/runs/[runId]/route.ts

@@ -0,0 +1,84 @@
+import { NextResponse } from "next/server";
+import { findRunDir } from "@/lib/path-resolver";
+import { ensureInitialized } from "@/lib/server-init";
+import { getRunCached } from "@/lib/run-cache";
+import { normalizeError } from "@/lib/error-handler";
+import { createHash } from "crypto";
+
+export const dynamic = "force-dynamic";
+
+function isValidId(id: string): boolean {
+  return /^[a-zA-Z0-9_\-]+$/.test(id);
+}
+
+const DEFAULT_MAX_EVENTS = 50;
+
+/**
+ * Generate a lightweight ETag from run state.
+ * Uses status, task count, event count, and updatedAt as a fingerprint
+ * to avoid re-serializing unchanged data to the client.
+ */
+function generateETag(run: { status: string; updatedAt: string; tasks: unknown[]; events: unknown[] }): string {
+  const fingerprint = `${run.status}:${run.tasks.length}:${run.events.length}:${run.updatedAt}`;
+  const hash = createHash("md5").update(fingerprint).digest("hex").slice(0, 16);
+  return `"${hash}"`;
+}
+
+export async function GET(
+  request: Request,
+  { params }: { params: { runId: string } }
+) {
+  try {
+    // Ensure watcher and cache are initialized
+    await ensureInitialized();
+
+    const { runId } = params;
+    if (!isValidId(runId)) {
+      return NextResponse.json({ error: "Invalid run ID" }, { status: 400 });
+    }
+
+    const found = await findRunDir(runId);
+    if (!found) {
+      return NextResponse.json({ error: "Run not found" }, { status: 404 });
+    }
+
+    // Use cached run for better performance
+    const run = await getRunCached(found.runDir, found.source, found.projectName);
+
+    // Limit events returned (keep most recent) to reduce payload size
+    const { searchParams } = new URL(request.url);
+    const maxEvents = parseInt(searchParams.get("maxEvents") || String(DEFAULT_MAX_EVENTS));
+    const totalEvents = run.events.length;
+    const limitedRun = totalEvents > maxEvents
+      ? { ...run, events: run.events.slice(-maxEvents), totalEvents }
+      : { ...run, totalEvents };
+
+    // ETag support: if client sends If-None-Match and data hasn't changed,
+    // return 304 Not Modified to save bandwidth and serialization cost.
+    const etag = generateETag(limitedRun);
+    const ifNoneMatch = request.headers.get("If-None-Match");
+    if (ifNoneMatch && ifNoneMatch === etag) {
+      return new NextResponse(null, {
+        status: 304,
+        headers: {
+          ETag: etag,
+          "Cache-Control": "no-cache",
+        },
+      });
+    }
+
+    return NextResponse.json({ run: limitedRun }, {
+      headers: {
+        "Cache-Control": "no-cache",
+        ETag: etag,
+      },
+    });
+  } catch (error) {
+    console.error("Failed to read run:", error);
+    const normalized = normalizeError(error);
+    return NextResponse.json(
+      { error: normalized.message, code: normalized.code },
+      { status: normalized.status }
+    );
+  }
+}

package/src/app/api/runs/[runId]/tasks/[effectId]/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server";
+import { findRunDir } from "@/lib/path-resolver";
+import { parseTaskDetail } from "@/lib/parser";
+import { normalizeError } from "@/lib/error-handler";
+
+export const dynamic = "force-dynamic";
+
+function isValidId(id: string): boolean {
+  return /^[a-zA-Z0-9_\-]+$/.test(id);
+}
+
+export async function GET(
+  _request: Request,
+  { params }: { params: { runId: string; effectId: string } }
+) {
+  try {
+    const { runId, effectId } = params;
+    if (!isValidId(runId) || !isValidId(effectId)) {
+      return NextResponse.json({ error: "Invalid ID" }, { status: 400 });
+    }
+
+    const found = await findRunDir(runId);
+    if (!found) {
+      return NextResponse.json({ error: "Run not found" }, { status: 404 });
+    }
+
+    const task = await parseTaskDetail(found.runDir, effectId);
+
+    if (!task) {
+      return NextResponse.json({ error: "Task not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ task }, {
+      headers: { "Cache-Control": "no-cache, no-store" },
+    });
+  } catch (error) {
+    console.error("Failed to read task:", error);
+    const normalized = normalizeError(error);
+    return NextResponse.json(
+      { error: normalized.message, code: normalized.code },
+      { status: normalized.status }
+    );
+  }
+}

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

@@ -0,0 +1,48 @@
+import { NextResponse } from "next/server";
+import { ensureInitialized } from "@/lib/server-init";
+import { normalizeError } from "@/lib/error-handler";
+import { RunQueryService, type SortMode } from "@/lib/services/run-query-service";
+
+export const dynamic = "force-dynamic";
+
+const NO_CACHE_HEADERS = { "Cache-Control": "no-cache, no-store" };
+
+const service = new RunQueryService();
+
+export async function GET(request: Request) {
+  try {
+    await ensureInitialized();
+
+    const { searchParams } = new URL(request.url);
+    const mode = searchParams.get("mode");
+    const project = searchParams.get("project");
+    const limit = parseInt(searchParams.get("limit") || "0");
+    const offset = parseInt(searchParams.get("offset") || "0");
+    const search = searchParams.get("search") || "";
+    const status = searchParams.get("status") || "";
+    const sort = (searchParams.get("sort") || "status") as SortMode;
+
+    // Mode: projects - return lightweight project summaries
+    if (mode === "projects") {
+      const data = await service.listProjects();
+      return NextResponse.json(data, { headers: NO_CACHE_HEADERS });
+    }
+
+    // Mode: project - return paginated runs for a specific project
+    if (project) {
+      const data = await service.listProjectRuns({ project, limit, offset, search, status, sort });
+      return NextResponse.json(data, { headers: NO_CACHE_HEADERS });
+    }
+
+    // Default: return all runs with totalCount
+    const data = await service.listAllRuns({ limit, offset, search, status, sort });
+    return NextResponse.json(data, { headers: NO_CACHE_HEADERS });
+  } catch (error) {
+    console.error("Failed to read runs:", error);
+    const normalized = normalizeError(error);
+    return NextResponse.json(
+      { error: normalized.message, code: normalized.code },
+      { status: normalized.status }
+    );
+  }
+}

package/src/app/api/stream/route.ts

@@ -0,0 +1,136 @@
+import path from "path";
+import { ensureInitialized, serverEvents, type BatchedRunChangedEvent } from "@/lib/server-init";
+
+export const dynamic = "force-dynamic";
+
+// Extract runId from a runDir path (last segment of the directory)
+function extractRunId(runDir: string): string {
+  return path.basename(runDir);
+}
+
+export async function GET() {
+  try {
+    // Ensure watcher and cache are initialized
+    await ensureInitialized();
+
+    // Track cleanup via closure so cancel() can access it
+    let cleanup: (() => void) | null = null;
+
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+
+        // Send initial connection message
+        controller.enqueue(
+          encoder.encode(
+            `data: ${JSON.stringify({ type: "connected", timestamp: new Date().toISOString() })}\n\n`
+          )
+        );
+
+        // Listen for run-changed events (batched by leading-edge debounce).
+        // Each event contains runIds[] and runDirs[] for targeted client refresh.
+        const runChangedListener = (event: BatchedRunChangedEvent) => {
+          try {
+            const message = {
+              type: "update",
+              runIds: event.runIds,
+              // Keep singular runId for backward compatibility (first in batch)
+              runId: event.runIds[0],
+              timestamp: new Date().toISOString(),
+            };
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify(message)}\n\n`)
+            );
+          } catch (err) {
+            console.error("Failed to send run-changed event:", err);
+          }
+        };
+
+        // Listen for new-run events
+        const newRunListener = (event: {
+          type: string;
+          runDir: string;
+          error?: Error;
+        }) => {
+          try {
+            const runId = extractRunId(event.runDir);
+            const message = {
+              type: "new-run",
+              runId,
+              runDir: event.runDir,
+              timestamp: new Date().toISOString(),
+            };
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify(message)}\n\n`)
+            );
+          } catch (err) {
+            console.error("Failed to send new-run event:", err);
+          }
+        };
+
+        // Listen for watcher-error events (deduplicated in server-init)
+        // These are logged server-side but NOT forwarded as SSE data events
+        // to prevent transient filesystem errors from triggering client-side
+        // status flashes. The client will self-heal via normal polling.
+        const errorListener = (event: {
+          type: string;
+          runDir: string;
+          error?: Error;
+        }) => {
+          // Log server-side only; do not push to client SSE stream
+          console.warn(
+            "Watcher error (suppressed from SSE):",
+            event.error?.message ?? "unknown",
+            event.runDir
+          );
+        };
+
+        serverEvents.on("run-changed", runChangedListener);
+        serverEvents.on("new-run", newRunListener);
+        serverEvents.on("watcher-error", errorListener);
+
+        // Keep-alive ping every 15 seconds
+        const pingInterval = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(": ping\n\n"));
+          } catch (err) {
+            console.error("Failed to send ping:", err);
+            clearInterval(pingInterval);
+          }
+        }, 15000);
+
+        // Store cleanup via closure (accessible from cancel)
+        cleanup = () => {
+          clearInterval(pingInterval);
+          serverEvents.off("run-changed", runChangedListener);
+          serverEvents.off("new-run", newRunListener);
+          serverEvents.off("watcher-error", errorListener);
+        };
+      },
+      cancel() {
+        if (cleanup) {
+          cleanup();
+          cleanup = null;
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-store",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error) {
+    console.error("Failed to initialize SSE stream:", error);
+    return new Response(
+      JSON.stringify({ error: "Failed to initialize stream" }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+}
+

package/src/app/api/test/route.ts

@@ -0,0 +1 @@
+export async function GET() { return new Response("test", { status: 200 }); }

package/src/app/api/version/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+export const dynamic = "force-dynamic";
+
+function detectVersion(command: string): string {
+  try {
+    const raw = execSync(command, { encoding: "utf-8", timeout: 3000 }).trim();
+    const match = raw.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : raw || "N/A";
+  } catch {
+    return "N/A";
+  }
+}
+
+function getAppVersion(): string {
+  try {
+    const pkgPath = resolve(__dirname, "..", "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version || process.env.NEXT_PUBLIC_APP_VERSION || "unknown";
+  } catch {
+    return process.env.NEXT_PUBLIC_APP_VERSION || "unknown";
+  }
+}
+
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes for normal polling
+const IDLE_THRESHOLD_MS = 60 * 1000; // 1 minute gap = user was away
+
+let cached: { app: string; babysitter: string } | null = null;
+let cachedAt = 0;
+let lastRequestAt = 0;
+
+function isCacheStale(): boolean {
+  const now = Date.now();
+  const idleGap = now - lastRequestAt;
+  const cacheAge = now - cachedAt;
+
+  // User returned after being away — likely upgraded something
+  if (lastRequestAt > 0 && idleGap > IDLE_THRESHOLD_MS) return true;
+
+  // Normal TTL expiry
+  return cacheAge > CACHE_TTL_MS;
+}
+
+export async function GET() {
+  if (!cached || isCacheStale()) {
+    cached = {
+      app: getAppVersion(),
+      babysitter: detectVersion("babysitter --version"),
+    };
+    cachedAt = Date.now();
+  }
+  lastRequestAt = Date.now();
+  return NextResponse.json(cached);
+}