@tea-agent/loop-agent 0.16.26 → 0.17.0

package/dist/worker/console/operation-sse.js

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import { ensureSecureDir, writeSecureJsonSync } from "./app-data.js";
+const DEFAULT_MAX_EVENTS = 1000;
+function safeOperationId(operationId) {
+    return operationId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
+}
+export function createOperationEventStore(options) {
+    const maxEvents = options?.maxEventsPerOperation ?? DEFAULT_MAX_EVENTS;
+    const persistenceDir = options?.persistenceDir
+        ? path.resolve(options.persistenceDir)
+        : undefined;
+    if (persistenceDir)
+        ensureSecureDir(persistenceDir);
+    const rings = new Map();
+    function persistedPath(operationId) {
+        return persistenceDir
+            ? path.join(persistenceDir, `${safeOperationId(operationId)}.json`)
+            : undefined;
+    }
+    function loadRing(operationId) {
+        const file = persistedPath(operationId);
+        if (!file || !existsSync(file))
+            return undefined;
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf8"));
+            if (parsed.schemaVersion !== 1 ||
+                parsed.operationId !== operationId ||
+                !Array.isArray(parsed.events)) {
+                throw new Error("invalid persisted operation event ring");
+            }
+            const events = parsed.events.slice(-maxEvents);
+            return {
+                events,
+                nextSeq: Math.max(parsed.nextSeq, (events[events.length - 1]?.seq ?? 0) + 1),
+                minSeq: events[0]?.seq ?? parsed.minSeq ?? parsed.nextSeq,
+                maxEvents,
+            };
+        }
+        catch (error) {
+            throw new Error(`invalid persisted operation events ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    function persist(operationId, ring) {
+        const file = persistedPath(operationId);
+        if (!file)
+            return;
+        writeSecureJsonSync(file, {
+            schemaVersion: 1,
+            operationId,
+            events: ring.events,
+            nextSeq: ring.nextSeq,
+            minSeq: ring.minSeq,
+        });
+    }
+    function ringFor(operationId) {
+        let ring = rings.get(operationId);
+        if (!ring) {
+            ring = loadRing(operationId) ?? {
+                events: [],
+                nextSeq: 1,
+                minSeq: 1,
+                maxEvents,
+            };
+            rings.set(operationId, ring);
+        }
+        return ring;
+    }
+    return {
+        append(operationId, partial) {
+            const ring = ringFor(operationId);
+            const seq = ring.nextSeq++;
+            const event = {
+                schemaVersion: 1,
+                eventId: `${operationId}:${seq}`,
+                operationId,
+                seq,
+                at: partial.at ?? new Date().toISOString(),
+                kind: partial.kind,
+                message: partial.message,
+                state: partial.state,
+                data: partial.data,
+            };
+            ring.events.push(event);
+            while (ring.events.length > ring.maxEvents) {
+                const dropped = ring.events.shift();
+                if (dropped)
+                    ring.minSeq = dropped.seq + 1;
+            }
+            if (ring.events.length > 0) {
+                ring.minSeq = ring.events[0].seq;
+            }
+            persist(operationId, ring);
+            return event;
+        },
+        listFrom(operationId, afterSeq) {
+            const ring = rings.get(operationId) ?? loadRing(operationId);
+            if (!ring) {
+                return { events: [] };
+            }
+            rings.set(operationId, ring);
+            // Gap between requested cursor and retained window → must re-snapshot.
+            if (ring.events.length > 0 && afterSeq + 1 < ring.minSeq) {
+                return { error: "EVENT_CURSOR_EXPIRED" };
+            }
+            const events = ring.events.filter((e) => e.seq > afterSeq);
+            return { events };
+        },
+        snapshot(operationId) {
+            const ring = rings.get(operationId) ?? loadRing(operationId);
+            if (ring)
+                rings.set(operationId, ring);
+            return ring?.events.slice() ?? [];
+        },
+        clear(operationId) {
+            rings.delete(operationId);
+            const file = persistedPath(operationId);
+            if (file)
+                rmSync(file, { force: true });
+        },
+    };
+}
+export function parseLastEventId(header) {
+    if (!header)
+        return 0;
+    const raw = header.trim();
+    if (!raw)
+        return 0;
+    // Accept either bare seq or "operationId:seq"
+    const colon = raw.lastIndexOf(":");
+    const seqPart = colon >= 0 ? raw.slice(colon + 1) : raw;
+    const n = Number.parseInt(seqPart, 10);
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+export function writeSseEvent(res, event) {
+    res.write(`id: ${event.eventId}\n`);
+    res.write(`event: operator\n`);
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+export function openSseResponse(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+    });
+    // Help some proxies flush immediately
+    res.write(": connected\n\n");
+}
+export function stateEvent(store, operation, state, message) {
+    return store.append(operation.operationId, {
+        at: new Date().toISOString(),
+        kind: "state",
+        state,
+        message,
+        data: { action: operation.action },
+    });
+}

package/dist/worker/console/operation-store.js

@@ -0,0 +1,147 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
+export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out"]);
+function operationFile(appData, operationId) {
+    return path.join(appData.operations, `${operationId}.json`);
+}
+function requestIndexFile(appData, clientRequestId) {
+    const safe = clientRequestId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
+    return path.join(appData.operations, `req-${safe}.json`);
+}
+export function computeActionPayloadHash(action, actionParams) {
+    return sha256Json({ action, actionParams });
+}
+export function newOperationId() {
+    return `op_${randomBytes(12).toString("hex")}`;
+}
+export class OperationStore {
+    appData;
+    constructor(appData) {
+        this.appData = appData;
+    }
+    async create(input) {
+        const clientRequestId = input.clientRequestId.trim();
+        if (!clientRequestId) {
+            throw new Error("clientRequestId is required for mutation operations");
+        }
+        const payloadHash = computeActionPayloadHash(input.action, input.actionParams);
+        const indexPath = requestIndexFile(this.appData, clientRequestId);
+        const existingIndex = await readJsonIfExists(indexPath);
+        if (existingIndex) {
+            const existing = await this.get(existingIndex.operationId);
+            if (existing) {
+                if (existing.payloadHash === payloadHash) {
+                    return { kind: "idempotent", operation: existing };
+                }
+                return {
+                    kind: "conflict",
+                    code: "REQUEST_ID_REUSE_CONFLICT",
+                    message: `clientRequestId ${clientRequestId} was reused with a different payload`,
+                    existing,
+                };
+            }
+        }
+        const operationId = newOperationId();
+        const now = new Date().toISOString();
+        const operation = {
+            schemaVersion: 1,
+            operationId,
+            clientRequestId,
+            action: input.action,
+            actionParams: input.actionParams,
+            payloadHash,
+            state: "queued",
+            createdAt: now,
+            taskId: input.taskId,
+            cliArgs: input.cliArgs,
+        };
+        await writeSecureJson(operationFile(this.appData, operationId), operation);
+        await writeSecureJson(indexPath, { operationId, payloadHash });
+        return { kind: "created", operation };
+    }
+    async get(operationId) {
+        return readJsonIfExists(operationFile(this.appData, operationId));
+    }
+    async save(operation) {
+        await writeSecureJson(operationFile(this.appData, operation.operationId), operation);
+        return operation;
+    }
+    async update(operationId, patch) {
+        const current = await this.get(operationId);
+        if (!current) {
+            throw new Error(`operation not found: ${operationId}`);
+        }
+        const next = {
+            ...current,
+            ...patch,
+            operationId: current.operationId,
+            schemaVersion: 1,
+            clientRequestId: current.clientRequestId,
+            payloadHash: current.payloadHash,
+            action: current.action,
+            createdAt: current.createdAt,
+        };
+        return this.save(next);
+    }
+    async list() {
+        const files = await listJsonFiles(this.appData.operations);
+        const ops = [];
+        for (const file of files) {
+            const base = path.basename(file);
+            if (base.startsWith("req-"))
+                continue;
+            const rec = await readJsonIfExists(file);
+            if (rec?.operationId)
+                ops.push(rec);
+        }
+        ops.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        return ops;
+    }
+    /**
+     * On Console boot: any non-terminal operation that cannot be proven still
+     * running becomes needs-reconcile (never invent succeeded/failed).
+     */
+    async reconcileOnBoot(options) {
+        const isAlive = options?.isProcessAlive ??
+            ((pid) => {
+                try {
+                    process.kill(pid, 0);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+        const changed = [];
+        for (const op of await this.list()) {
+            if (TERMINAL_OPERATION_STATES.has(op.state))
+                continue;
+            if (op.state === "needs-reconcile")
+                continue;
+            let next;
+            if (op.state === "running" &&
+                typeof op.pid === "number" &&
+                isAlive(op.pid, op.processStartIdentity)) {
+                // still running — leave as-is
+                continue;
+            }
+            // queued/starting/running without proven process → needs-reconcile
+            next = await this.update(op.operationId, {
+                state: "needs-reconcile",
+                errorCode: "OPERATION_NEEDS_RECONCILE",
+                errorMessage: "Console restart or lost process evidence; operation needs reconcile (not cancelled)",
+            });
+            changed.push(next);
+        }
+        return changed;
+    }
+}
+export function isTerminalOperationState(state) {
+    return TERMINAL_OPERATION_STATES.has(state);
+}
+export function clipPreview(text, max = 4096) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}\n…[truncated ${text.length - max} chars]`;
+}