@tea-agent/loop-agent 0.5.0 → 0.7.0

package/dist/worker/observability/snapshot-store.js

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+function writeDiagnostic(context, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[snapshot-store] ${context}: ${message}\n`);
+}
+export function createSnapshotStore(snapshotPath) {
+    return {
+        async write(snapshot) {
+            const dir = path.dirname(snapshotPath);
+            const tempPath = path.join(dir, `.${path.basename(snapshotPath)}.${randomUUID()}.tmp`);
+            try {
+                await mkdir(dir, { recursive: true });
+                await writeFile(tempPath, JSON.stringify(snapshot), "utf-8");
+                await rename(tempPath, snapshotPath);
+            }
+            catch (error) {
+                writeDiagnostic(`write failed (${snapshotPath})`, error);
+            }
+        },
+        async read() {
+            try {
+                const raw = await readFile(snapshotPath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch (error) {
+                if (isNotFound(error))
+                    return undefined;
+                return undefined;
+            }
+        },
+        path() {
+            return snapshotPath;
+        },
+    };
+}
+function isNotFound(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/worker/observability/types.js

@@ -0,0 +1 @@
+export {};

package/dist/worker/observe/paths.js

@@ -0,0 +1,64 @@
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+export function resolveArtifactPath(repoRoot, relative) {
+    if (!relative || path.isAbsolute(relative)) {
+        return null;
+    }
+    if (!isAllowedArtifactRelativePath(relative)) {
+        return null;
+    }
+    const resolvedRepoRoot = path.resolve(repoRoot);
+    let realRepoRoot;
+    try {
+        realRepoRoot = realpathSync(resolvedRepoRoot);
+    }
+    catch {
+        realRepoRoot = resolvedRepoRoot;
+    }
+    const candidate = path.resolve(realRepoRoot, relative);
+    if (!isPathInside(realRepoRoot, candidate)) {
+        return null;
+    }
+    if (!existsSync(candidate)) {
+        return candidate;
+    }
+    try {
+        const realCandidate = realpathSync(candidate);
+        return isPathInside(realRepoRoot, realCandidate) ? realCandidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAllowedArtifactRelativePath(relative) {
+    const normalized = path.normalize(relative);
+    const segments = normalized.split(path.sep).filter(Boolean);
+    if (segments[0] === ".task-pool") {
+        return ["artifacts", "failure-handoffs", "reports"].includes(segments[1] ?? "");
+    }
+    if (segments[0] === ".harness" && segments[1] === "tasks") {
+        return segments.includes("artifacts");
+    }
+    return false;
+}
+export function toRepoRelativeArtifactPath(repoRoot, artifactPath) {
+    if (!artifactPath)
+        return null;
+    const resolvedRoot = path.resolve(repoRoot);
+    const resolvedArtifact = path.isAbsolute(artifactPath)
+        ? path.resolve(artifactPath)
+        : path.resolve(resolvedRoot, artifactPath);
+    const relative = path.relative(resolvedRoot, resolvedArtifact);
+    if (relative === "" ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative)) {
+        return null;
+    }
+    return relative.split(path.sep).join("/");
+}
+function isPathInside(root, target) {
+    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    const normalizedTarget = path.normalize(target);
+    return normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot);
+}

package/dist/worker/observe/routes.js

@@ -0,0 +1,423 @@
+import { existsSync } from "node:fs";
+import { readFile } 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 { resolveArtifactPath, toRepoRelativeArtifactPath, } from "./paths.js";
+const ROUTES = [
+    { method: "GET", pattern: /^\/api\/health$/, handler: handleHealth },
+    { method: "GET", pattern: /^\/api\/snapshot$/, handler: handleSnapshot },
+    { method: "GET", pattern: /^\/api\/batches$/, handler: handleBatches },
+    { method: "GET", pattern: /^\/api\/batches\/([^/]+)$/, handler: handleBatchById },
+    { method: "GET", pattern: /^\/api\/tasks$/, handler: handleTasks },
+    { method: "GET", pattern: /^\/api\/tasks\/([^/]+)$/, handler: handleTaskById },
+    { method: "GET", pattern: /^\/api\/runs\/([^/]+)$/, handler: handleRunById },
+    {
+        method: "GET",
+        pattern: /^\/api\/runs\/([^/]+)\/events$/,
+        handler: handleRunEvents,
+    },
+    {
+        method: "GET",
+        pattern: /^\/api\/runs\/([^/]+)\/artifacts$/,
+        handler: handleRunArtifacts,
+    },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/session-events$/,
+        handler: handleDagNodeSessionEvents,
+    },
+    { method: "GET", pattern: /^\/api\/dag-runs\/([^/]+)$/, handler: handleDagRunById },
+    { method: "GET", pattern: /^\/api\/artifacts$/, handler: handleArtifactRead },
+    { method: "GET", pattern: /^\/api\/events\/stream$/, handler: handleEventStream },
+];
+export async function handleRequest(req, res, ctx) {
+    const method = req.method ?? "GET";
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const pathname = decodeURIComponent(url.pathname);
+    if (method !== "GET") {
+        sendJson(res, 405, { error: "Method not allowed" });
+        return true;
+    }
+    for (const route of ROUTES) {
+        if (route.method !== method)
+            continue;
+        const match = route.pattern.exec(pathname);
+        if (!match)
+            continue;
+        const params = {};
+        if (match[1])
+            params.id = match[1];
+        if (match[2])
+            params.sub = match[2];
+        try {
+            await route.handler(req, res, { params, query: url.searchParams }, ctx);
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                sendJson(res, 500, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return true;
+    }
+    if (pathname.startsWith("/api/")) {
+        sendJson(res, 404, { error: "Not found" });
+        return true;
+    }
+    return false;
+}
+export async function serveStatic(req, res, staticDir) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    let pathname = decodeURIComponent(url.pathname);
+    if (pathname === "/") {
+        pathname = "/index.html";
+    }
+    const filePath = path.join(staticDir, pathname);
+    const resolvedStatic = path.resolve(staticDir);
+    const resolvedFile = path.resolve(filePath);
+    if (!resolvedFile.startsWith(resolvedStatic + path.sep) && resolvedFile !== resolvedStatic) {
+        sendJson(res, 404, { error: "Not found" });
+        return;
+    }
+    if (!existsSync(resolvedFile)) {
+        sendJson(res, 404, { error: "Not found" });
+        return;
+    }
+    const content = await readFile(resolvedFile);
+    const contentType = contentTypeFor(pathname);
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+}
+async function handleHealth(_req, res, _match, ctx) {
+    sendJson(res, 200, {
+        ok: true,
+        repoRoot: ctx.repoRoot,
+        generatedAt: new Date().toISOString(),
+    });
+}
+async function handleSnapshot(_req, res, _match, ctx) {
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    sendJson(res, 200, snapshot);
+}
+async function handleBatches(_req, res, _match, ctx) {
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    sendJson(res, 200, snapshot.batches);
+}
+async function handleBatchById(_req, res, match, ctx) {
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const batch = snapshot.batches.find((b) => b.batchRunId === match.params.id);
+    if (!batch) {
+        sendJson(res, 404, { error: "Batch not found" });
+        return;
+    }
+    sendJson(res, 200, batch);
+}
+async function handleTasks(_req, res, _match, ctx) {
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    sendJson(res, 200, snapshot.tasks);
+}
+async function handleTaskById(_req, res, match, ctx) {
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const task = snapshot.tasks.find((t) => t.taskId === match.params.id);
+    if (!task) {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+    }
+    sendJson(res, 200, task);
+}
+async function handleRunById(_req, res, match, ctx) {
+    if (!isSafeObservabilityIdentifier(match.params.id)) {
+        sendJson(res, 400, { error: "Invalid run identifier" });
+        return;
+    }
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const task = findRunByWorkerRunId(snapshot.tasks, snapshot.batches, match.params.id);
+    if (!task) {
+        sendJson(res, 404, { error: "Run not found" });
+        return;
+    }
+    sendJson(res, 200, task);
+}
+async function handleRunEvents(_req, res, match, ctx) {
+    const workerRunId = match.params.id;
+    if (!isSafeObservabilityIdentifier(workerRunId)) {
+        sendJson(res, 400, { error: "Invalid run identifier" });
+        return;
+    }
+    const after = parseNonNegativeInt(match.query.get("after"), 0);
+    const eventsPath = path.join(ctx.repoRoot, ".task-pool", "observability", "runs", workerRunId, "events.jsonl");
+    const events = (await readJsonlLines(eventsPath, after)).map((event) => normalizeEventArtifactRefs(ctx.repoRoot, event));
+    sendJson(res, 200, { events });
+}
+async function handleRunArtifacts(_req, res, match, ctx) {
+    const workerRunId = match.params.id;
+    if (!isSafeObservabilityIdentifier(workerRunId)) {
+        sendJson(res, 400, { error: "Invalid run identifier" });
+        return;
+    }
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const task = findRunByWorkerRunId(snapshot.tasks, snapshot.batches, workerRunId);
+    const artifacts = [];
+    const seen = new Set();
+    if (task?.artifactRefs) {
+        for (const [label, artifactPath] of Object.entries(task.artifactRefs)) {
+            if (!artifactPath || seen.has(artifactPath))
+                continue;
+            seen.add(artifactPath);
+            artifacts.push({ path: artifactPath, label });
+        }
+    }
+    const eventsPath = path.join(ctx.repoRoot, ".task-pool", "observability", "runs", workerRunId, "events.jsonl");
+    const runEvents = await readJsonlLines(eventsPath, 0);
+    for (const event of runEvents) {
+        const parsed = event;
+        if (parsed.workerRunId && parsed.workerRunId !== workerRunId)
+            continue;
+        if (!parsed.artifactRefs)
+            continue;
+        for (const [label, artifactPath] of Object.entries(parsed.artifactRefs)) {
+            const relativePath = toRepoRelativeArtifactPath(ctx.repoRoot, artifactPath);
+            if (!relativePath || seen.has(relativePath))
+                continue;
+            seen.add(relativePath);
+            artifacts.push({ path: relativePath, label });
+        }
+    }
+    sendJson(res, 200, { artifacts });
+}
+async function handleDagRunById(_req, res, match, ctx) {
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);
+    if (!dagRun) {
+        sendJson(res, 404, { error: "DAG run not found" });
+        return;
+    }
+    sendJson(res, 200, dagRun);
+}
+async function handleDagNodeSessionEvents(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const nodeId = match.params.sub;
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        sendJson(res, 400, { error: "Invalid dag run or node identifier" });
+        return;
+    }
+    const after = parseNonNegativeInt(match.query.get("after"), 0);
+    const snapshot = await buildGlobalSnapshot({ repoRoot: ctx.repoRoot });
+    const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === dagRunId);
+    const eventsPath = resolveSessionEventsPath(ctx.repoRoot, dagRunId, nodeId, dagRun?.dagPath);
+    if (!eventsPath) {
+        sendJson(res, 400, { error: "Invalid session events path" });
+        return;
+    }
+    if (!existsSync(eventsPath)) {
+        sendJson(res, 200, { events: [], nextOffset: 0 });
+        return;
+    }
+    const page = await readJsonlPage(eventsPath, after);
+    sendJson(res, 200, page);
+}
+async function handleArtifactRead(_req, res, match, ctx) {
+    const relativePath = match.query.get("path") ?? "";
+    const resolved = resolveArtifactPath(ctx.repoRoot, relativePath);
+    if (!resolved) {
+        sendJson(res, 400, { error: "Invalid artifact path" });
+        return;
+    }
+    if (!existsSync(resolved)) {
+        sendJson(res, 404, { error: "Artifact not found" });
+        return;
+    }
+    const raw = await readFile(resolved, "utf-8");
+    const tail = match.query.get("tail");
+    if (tail !== null) {
+        const tailLines = parsePositiveInt(tail, 0);
+        if (tailLines > 0) {
+            const lines = raw.replace(/\n$/, "").split("\n");
+            const content = lines.slice(-tailLines).join("\n");
+            sendJson(res, 200, { content });
+            return;
+        }
+    }
+    sendJson(res, 200, { content: raw });
+}
+async function handleEventStream(req, res, match, ctx) {
+    const batchRunId = match.query.get("batchRunId");
+    if (!batchRunId) {
+        sendJson(res, 400, { error: "batchRunId is required" });
+        return;
+    }
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
+    const observabilityRoot = path.join(ctx.repoRoot, ".task-pool", "observability");
+    const eventsPath = path.join(observabilityRoot, "events.jsonl");
+    let offset = 0;
+    const sendMatchingEvents = async (initial) => {
+        const page = await readFilteredEvents(eventsPath, offset, batchRunId, ctx.repoRoot);
+        offset = page.nextOffset;
+        for (const event of page.events) {
+            if (initial || !res.writableEnded) {
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            }
+        }
+    };
+    await sendMatchingEvents(true);
+    const timer = setInterval(() => {
+        void sendMatchingEvents(false).catch(() => {
+            clearInterval(timer);
+            if (!res.writableEnded)
+                res.end();
+        });
+    }, ctx.pollIntervalMs);
+    req.on("close", () => {
+        clearInterval(timer);
+        if (!res.writableEnded)
+            res.end();
+    });
+}
+function findRunByWorkerRunId(tasks, batches, workerRunId) {
+    return (tasks.find((task) => task.workerRunId === workerRunId) ??
+        batches.flatMap((batch) => batch.tasks).find((task) => task.workerRunId === workerRunId));
+}
+async function readJsonlLines(filePath, after) {
+    const page = await readJsonlPage(filePath, after);
+    return page.events;
+}
+async function readJsonlPage(filePath, after) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        const lines = raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const events = lines.slice(after).map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return undefined;
+            }
+        }).filter((line) => line !== undefined);
+        return { events, nextOffset: lines.length };
+    }
+    catch {
+        return { events: [], nextOffset: after };
+    }
+}
+const DAG_RUN_LIFECYCLE_DIRS = ["active", "completed", "paused"];
+function resolveSessionEventsPath(repoRoot, dagRunId, nodeId, dagRunDir) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
+    const candidates = [];
+    if (dagRunDir) {
+        candidates.push(path.join(dagRunDir, nodeId, "session-events.jsonl"));
+    }
+    for (const lifecycle of DAG_RUN_LIFECYCLE_DIRS) {
+        candidates.push(path.join(dagRunsRoot, lifecycle, dagRunId, nodeId, "session-events.jsonl"));
+    }
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        if (!isPathInside(dagRunsRoot, resolved))
+            continue;
+        if (!isExpectedSessionEventsRelativePath(dagRunsRoot, resolved, dagRunId, nodeId)) {
+            continue;
+        }
+        if (existsSync(resolved))
+            return resolved;
+    }
+    const fallback = path.resolve(dagRunsRoot, "active", dagRunId, nodeId, "session-events.jsonl");
+    if (isPathInside(dagRunsRoot, fallback) &&
+        isExpectedSessionEventsRelativePath(dagRunsRoot, fallback, dagRunId, nodeId)) {
+        return fallback;
+    }
+    return null;
+}
+function isExpectedSessionEventsRelativePath(dagRunsRoot, resolvedPath, dagRunId, nodeId) {
+    const relative = path.relative(dagRunsRoot, resolvedPath);
+    const parts = relative.split(path.sep).filter(Boolean);
+    return (parts.length === 4 &&
+        DAG_RUN_LIFECYCLE_DIRS.includes(parts[0]) &&
+        parts[1] === dagRunId &&
+        parts[2] === nodeId &&
+        parts[3] === "session-events.jsonl");
+}
+function isPathInside(root, target) {
+    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    const normalizedTarget = path.normalize(target);
+    return normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot);
+}
+async function readFilteredEvents(filePath, offset, batchRunId, repoRoot) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        const lines = raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const events = [];
+        for (let i = offset; i < lines.length; i++) {
+            const event = parseWorkerEventLine(lines[i]);
+            if (event && event.batchRunId === batchRunId) {
+                events.push(normalizeEventArtifactRefs(repoRoot, event));
+            }
+        }
+        return { events, nextOffset: lines.length };
+    }
+    catch {
+        return { events: [], nextOffset: offset };
+    }
+}
+function normalizeEventArtifactRefs(repoRoot, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const event = value;
+    if (!event.artifactRefs)
+        return event;
+    const artifactRefs = {};
+    for (const [key, artifactPath] of Object.entries(event.artifactRefs)) {
+        const relativePath = toRepoRelativeArtifactPath(repoRoot, artifactPath);
+        if (relativePath)
+            artifactRefs[key] = relativePath;
+    }
+    return {
+        ...event,
+        artifactRefs,
+    };
+}
+function parseNonNegativeInt(value, fallback) {
+    if (value === null)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function parsePositiveInt(value, fallback) {
+    if (value === null)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+function contentTypeFor(pathname) {
+    if (pathname.endsWith(".html"))
+        return "text/html; charset=utf-8";
+    if (pathname.endsWith(".js"))
+        return "text/javascript; charset=utf-8";
+    if (pathname.endsWith(".css"))
+        return "text/css; charset=utf-8";
+    if (pathname.endsWith(".json"))
+        return "application/json; charset=utf-8";
+    return "application/octet-stream";
+}

package/dist/worker/observe/server.js

@@ -0,0 +1,61 @@
+import { createServer } from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { 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);
+    const host = options.host ?? "127.0.0.1";
+    if (!isLoopbackHost(host)) {
+        return Promise.reject(new Error(`observe serve is local-only; refusing non-loopback host ${host}`));
+    }
+    const port = options.port ?? 0;
+    const pollIntervalMs = options.pollIntervalMs ?? 1000;
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            void dispatch(req, res).catch((error) => {
+                if (!res.headersSent) {
+                    const payload = JSON.stringify({
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    res.writeHead(500, {
+                        "Content-Type": "application/json",
+                        "Content-Length": Buffer.byteLength(payload),
+                    });
+                    res.end(payload);
+                }
+            });
+        });
+        async function dispatch(req, res) {
+            const handled = await handleRequest(req, res, {
+                repoRoot,
+                pollIntervalMs,
+                staticDir: STATIC_DIR,
+            });
+            if (!handled) {
+                await serveStatic(req, res, STATIC_DIR);
+            }
+        }
+        server.on("error", reject);
+        server.listen(port, host, () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                reject(new Error("Failed to get server address"));
+                return;
+            }
+            resolve({
+                url: `http://${host}:${addr.port}`,
+                close: () => new Promise((closeResolve, closeReject) => {
+                    server.close((err) => (err ? closeReject(err) : closeResolve()));
+                }),
+            });
+        });
+    });
+}
+function isLoopbackHost(host) {
+    const normalized = host.toLowerCase();
+    return (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "[::1]" ||
+        /^127(?:\.\d{1,3}){3}$/.test(normalized));
+}