@tea-agent/loop-agent 0.8.0 → 0.10.0

package/dist/worker/observe/routes.js

@@ -1,11 +1,14 @@
 import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { parseWorkerEventLine } from "../observability/events.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
 import { buildGlobalSnapshot } from "../observability/read-model.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
 import { resolveArtifactPath, toRepoRelativeArtifactPath, } from "./paths.js";
+export function createObserveSnapshotCache() {
+    return { expiresAt: 0 };
+}
 const ROUTES = [
     { method: "GET", pattern: /^\/api\/health$/, handler: handleHealth },
     { method: "GET", pattern: /^\/api\/snapshot$/, handler: handleSnapshot },
@@ -99,16 +102,38 @@ async function handleHealth(_req, res, _match, ctx) {
         generatedAt: new Date().toISOString(),
     });
 }
+async function getSnapshot(ctx) {
+    const now = Date.now();
+    if (ctx.snapshotCache.snapshot && now < ctx.snapshotCache.expiresAt) {
+        return ctx.snapshotCache.snapshot;
+    }
+    if (ctx.snapshotCache.inFlight) {
+        return ctx.snapshotCache.inFlight;
+    }
+    const inFlight = buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    ctx.snapshotCache.inFlight = inFlight;
+    try {
+        const snapshot = await inFlight;
+        ctx.snapshotCache.snapshot = snapshot;
+        ctx.snapshotCache.expiresAt = Date.now() + ctx.pollIntervalMs;
+        return snapshot;
+    }
+    finally {
+        if (ctx.snapshotCache.inFlight === inFlight) {
+            ctx.snapshotCache.inFlight = undefined;
+        }
+    }
+}
 async function handleSnapshot(_req, res, _match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot);
 }
 async function handleBatches(_req, res, _match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot.batches);
 }
 async function handleBatchById(_req, res, match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const batch = snapshot.batches.find((b) => b.batchRunId === match.params.id);
     if (!batch) {
         sendJson(res, 404, { error: "Batch not found" });
@@ -117,11 +142,11 @@ async function handleBatchById(_req, res, match, ctx) {
     sendJson(res, 200, batch);
 }
 async function handleTasks(_req, res, _match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot.tasks);
 }
 async function handleTaskById(_req, res, match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const task = snapshot.tasks.find((t) => t.taskId === match.params.id);
     if (!task) {
         sendJson(res, 404, { error: "Task not found" });
@@ -134,7 +159,7 @@ async function handleRunById(_req, res, match, ctx) {
         sendJson(res, 400, { error: "Invalid run identifier" });
         return;
     }
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const task = findRunByWorkerRunId(snapshot.tasks, snapshot.batches, match.params.id);
     if (!task) {
         sendJson(res, 404, { error: "Run not found" });
@@ -159,7 +184,7 @@ async function handleRunArtifacts(_req, res, match, ctx) {
         sendJson(res, 400, { error: "Invalid run identifier" });
         return;
     }
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const task = findRunByWorkerRunId(snapshot.tasks, snapshot.batches, workerRunId);
     const artifacts = [];
     const seen = new Set();
@@ -190,7 +215,7 @@ async function handleRunArtifacts(_req, res, match, ctx) {
     sendJson(res, 200, { artifacts });
 }
 async function handleDagRunById(_req, res, match, ctx) {
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);
     if (!dagRun) {
         sendJson(res, 404, { error: "DAG run not found" });
@@ -206,7 +231,7 @@ async function handleDagNodeSessionEvents(_req, res, match, ctx) {
         return;
     }
     const after = parseNonNegativeInt(match.query.get("after"), 0);
-    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === dagRunId);
     const eventsPath = resolveSessionEventsPath(ctx.repoRoot, dagRunId, nodeId, dagRun?.dagPath);
     if (!eventsPath) {
@@ -258,9 +283,29 @@ async function handleEventStream(req, res, match, ctx) {
     const observabilityRoot = path.join(getTaskPoolRoot(ctx.repoRoot), "observability");
     const eventsPath = path.join(observabilityRoot, "events.jsonl");
     let offset = 0;
+    let knownFileSize;
+    let timer;
+    let closed = false;
     const sendMatchingEvents = async (initial) => {
+        let currentFileSize;
+        try {
+            currentFileSize = (await stat(eventsPath)).size;
+        }
+        catch {
+            knownFileSize = undefined;
+            offset = 0;
+            return;
+        }
+        if (!shouldReadSseEventFile(knownFileSize, currentFileSize))
+            return;
+        if (knownFileSize !== undefined && currentFileSize < knownFileSize) {
+            offset = 0;
+        }
         const page = await readFilteredEvents(eventsPath, offset, batchRunId, ctx.repoRoot);
+        if (!page.ok)
+            return;
         offset = page.nextOffset;
+        knownFileSize = currentFileSize;
         for (const event of page.events) {
             if (initial || !res.writableEnded) {
                 res.write(`data: ${JSON.stringify(event)}\n\n`);
@@ -268,15 +313,25 @@ async function handleEventStream(req, res, match, ctx) {
         }
     };
     await sendMatchingEvents(true);
-    const timer = setInterval(() => {
-        void sendMatchingEvents(false).catch(() => {
-            clearInterval(timer);
-            if (!res.writableEnded)
-                res.end();
-        });
-    }, ctx.pollIntervalMs);
+    const scheduleNextPoll = () => {
+        if (closed)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            void sendMatchingEvents(false)
+                .then(scheduleNextPoll)
+                .catch(() => {
+                closed = true;
+                if (!res.writableEnded)
+                    res.end();
+            });
+        }, ctx.pollIntervalMs);
+    };
+    scheduleNextPoll();
     req.on("close", () => {
-        clearInterval(timer);
+        closed = true;
+        if (timer)
+            clearTimeout(timer);
         if (!res.writableEnded)
             res.end();
     });
@@ -368,12 +423,15 @@ async function readFilteredEvents(filePath, offset, batchRunId, repoRoot) {
                 events.push(normalizeEventArtifactRefs(repoRoot, event));
             }
         }
-        return { events, nextOffset: lines.length };
+        return { events, nextOffset: lines.length, ok: true };
     }
     catch {
-        return { events: [], nextOffset: offset };
+        return { events: [], nextOffset: offset, ok: false };
     }
 }
+export function shouldReadSseEventFile(previousSize, currentSize) {
+    return previousSize !== currentSize;
+}
 function normalizeEventArtifactRefs(repoRoot, value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;

package/dist/worker/observe/server.js

@@ -1,7 +1,7 @@
 import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { handleRequest, serveStatic } from "./routes.js";
+import { createObserveSnapshotCache, handleRequest, serveStatic, } from "./routes.js";
 const STATIC_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "static");
 export function createObserveServer(options) {
     const repoRoot = path.resolve(options.repoRoot);
@@ -11,6 +11,12 @@ export function createObserveServer(options) {
     }
     const port = options.port ?? 0;
     const pollIntervalMs = options.pollIntervalMs ?? 1000;
+    const routeContext = {
+        repoRoot,
+        pollIntervalMs,
+        staticDir: STATIC_DIR,
+        snapshotCache: createObserveSnapshotCache(),
+    };
     return new Promise((resolve, reject) => {
         const server = createServer((req, res) => {
             void dispatch(req, res).catch((error) => {
@@ -27,11 +33,7 @@ export function createObserveServer(options) {
             });
         });
         async function dispatch(req, res) {
-            const handled = await handleRequest(req, res, {
-                repoRoot,
-                pollIntervalMs,
-                staticDir: STATIC_DIR,
-            });
+            const handled = await handleRequest(req, res, routeContext);
             if (!handled) {
                 await serveStatic(req, res, STATIC_DIR);
             }