llm-deep-trace 0.1.0

package/src/app/api/sessions/[sessionId]/messages/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from "next/server";
+import { getSessionMessages } from "@/lib/sessions";
+
+export const dynamic = "force-dynamic";
+
+// Cap any single string value at this length before sending to the browser.
+// Large tool results (file reads, bash output) are the main offender.
+const MAX_CHARS = 6000;
+
+function truncateDeep(value: unknown, path = ""): unknown {
+  if (typeof value === "string") {
+    if (value.length > MAX_CHARS) {
+      return value.slice(0, MAX_CHARS) + `\n\n… [truncated — ${Math.round(value.length / 1024)}KB total]`;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => truncateDeep(v));
+  }
+  if (value !== null && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = truncateDeep(v, path ? `${path}.${k}` : k);
+    }
+    return out;
+  }
+  return value;
+}
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ sessionId: string }> }
+) {
+  const { sessionId } = await params;
+  const url = new URL(_request.url);
+  const source = url.searchParams.get("source") || "kova";
+  const full = url.searchParams.get("full") === "1"; // opt-in to untruncated
+
+  const entries = getSessionMessages(sessionId, source);
+  if (!entries) {
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  }
+
+  const result = full ? entries : truncateDeep(entries);
+  return NextResponse.json(result);
+}

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

@@ -0,0 +1,86 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+const SESSIONS_DIR = path.join(
+  os.homedir(),
+  ".openclaw",
+  "agents",
+  "main",
+  "sessions"
+);
+
+export async function GET() {
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    start(controller) {
+      function sendEvent(data: Record<string, unknown>) {
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify(data)}\n\n`)
+        );
+      }
+
+      // Send initial connected event
+      sendEvent({ event: "connected" });
+
+      // Set up file watching using fs.watch
+      let watcher: fs.FSWatcher | null = null;
+      try {
+        if (fs.existsSync(SESSIONS_DIR)) {
+          watcher = fs.watch(SESSIONS_DIR, (_eventType, filename) => {
+            if (!filename) return;
+            try {
+              if (filename.includes(".jsonl")) {
+                const sessionId = filename.split(".jsonl")[0];
+                sendEvent({
+                  event: "session_updated",
+                  sessionId,
+                });
+              } else if (filename === "sessions.json") {
+                sendEvent({ event: "sessions_index_updated" });
+              }
+            } catch {
+              // stream may be closed
+            }
+          });
+        }
+      } catch {
+        // watcher setup failed
+      }
+
+      // Keep-alive ping every 30s
+      const pingInterval = setInterval(() => {
+        try {
+          sendEvent({ event: "ping" });
+        } catch {
+          clearInterval(pingInterval);
+        }
+      }, 30000);
+
+      // Cleanup on close
+      const cleanup = () => {
+        clearInterval(pingInterval);
+        if (watcher) watcher.close();
+      };
+
+      // Store cleanup for cancel
+      (controller as unknown as Record<string, unknown>).__cleanup = cleanup;
+    },
+    cancel() {
+      // Called when the client disconnects
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}