@astrosheep/keiyaku 1.0.1 → 1.0.2

package/build/core/projection-status.js

@@ -1,158 +1,259 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isErrnoException } from "../errno.js";
-import { deriveProjectionPhase, projectionRoot } from "./projection-core.js";
-const HEARTBEAT_STALE_MS = 15_000;
-const TELL_LAYERS = ["inbox", "inflight", "submitted", "consumed"];
-function statOrNull(filePath) {
-    try {
-        return fs.statSync(filePath);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return null;
-        throw error;
+import { executionEventsPath, projectionRoot, } from "./projection-core.js";
+import { ProjectionStateError } from "./atomic-publish.js";
+import { foldAgentActivity, } from "./projection-activity.js";
+import { readProjectionIdentity } from "./projection-identity.js";
+import { readProjectionTellCounts, } from "./projection-tells.js";
+import { ProjectionGenerationStoreError } from "./projection-generation-store.js";
+import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./projection-generation-launcher.js";
+import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
+import { selectCurrentGeneration } from "./projection-life-protocol.js";
+import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "./stored-agent-event.js";
+const MAX_STATUS_FILE_BYTES = 256 * 1024;
+class ProjectionStatusFileError extends Error {
+    diagnostic;
+    constructor(kind, filePath) {
+        const label = path.basename(filePath);
+        const detail = kind === "non-regular-projection-file"
+            ? `${label} is not a regular file`
+            : `${label} exceeds status read limit`;
+        super(detail);
+        this.name = "ProjectionStatusFileError";
+        this.diagnostic = { kind, detail };
     }
 }
-function readJsonFile(filePath) {
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+function recordProjectionStatusFileError(error, diagnostics) {
+    if (!(error instanceof ProjectionStatusFileError))
+        return false;
+    diagnostics.push(error.diagnostic);
+    return true;
 }
-function countTellLayer(projectionDir, layer, diagnostics) {
-    const layerDir = path.join(projectionDir, layer);
-    let entries;
+function readBoundedRegularFile(filePath) {
+    const before = fs.lstatSync(filePath);
+    if (!before.isFile())
+        throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
+    if (before.size > MAX_STATUS_FILE_BYTES) {
+        throw new ProjectionStatusFileError("oversized-projection-file", filePath);
+    }
+    let fd;
     try {
-        entries = fs.readdirSync(layerDir);
+        fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | fs.constants.O_NOFOLLOW);
     }
     catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            diagnostics.push({ kind: "missing-layer", detail: `${layer}/ missing` });
-            return 0;
+        if (isErrnoException(error) && error.code === "ELOOP") {
+            throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
         }
-        diagnostics.push({ kind: "unreadable-layer", detail: `${layer}/ unreadable: ${String(error)}` });
-        return 0;
+        throw error;
     }
-    let count = 0;
-    for (const entry of entries) {
-        if (entry.startsWith("."))
-            continue;
-        try {
-            if (fs.statSync(path.join(layerDir, entry)).isFile())
-                count += 1;
+    try {
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile())
+            throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
+        if (opened.size > MAX_STATUS_FILE_BYTES) {
+            throw new ProjectionStatusFileError("oversized-projection-file", filePath);
+        }
+        const chunks = [];
+        let total = 0;
+        while (total <= MAX_STATUS_FILE_BYTES) {
+            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, MAX_STATUS_FILE_BYTES + 1 - total));
+            const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, null);
+            if (bytesRead === 0)
+                break;
+            chunks.push(chunk.subarray(0, bytesRead));
+            total += bytesRead;
         }
-        catch (error) {
-            diagnostics.push({ kind: "layer-entry", detail: `${layer}/${entry} unreadable: ${String(error)}` });
+        if (total > MAX_STATUS_FILE_BYTES) {
+            throw new ProjectionStatusFileError("oversized-projection-file", filePath);
         }
+        return Buffer.concat(chunks, total).toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
     }
-    return count;
 }
-function readTellCounts(projectionDir, diagnostics) {
+function displayedTellCounts(counts) {
     return {
-        inbox: countTellLayer(projectionDir, "inbox", diagnostics),
-        inflight: countTellLayer(projectionDir, "inflight", diagnostics),
-        submitted: countTellLayer(projectionDir, "submitted", diagnostics),
-        consumed: countTellLayer(projectionDir, "consumed", diagnostics),
+        inbox: counts.inbox,
+        inflight: counts.inflight,
+        submitted: counts.submitted,
+        consumed: counts.consumed,
     };
 }
-function readPactFacts(projectionDir, diagnostics) {
-    const pactPath = path.join(projectionDir, "pact.json");
-    const pactStat = statOrNull(pactPath);
-    if (!pactStat) {
-        diagnostics.push({ kind: "missing-pact", detail: "pact.json missing" });
-        return { pact: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined };
-    }
+function emptyTellCounts() {
+    return { inbox: 0, inflight: 0, submitted: 0, consumed: 0 };
+}
+function readIdentityFacts(projectionDir, diagnostics) {
     try {
-        const pact = readJsonFile(pactPath);
-        const pid = Number.isInteger(pact.pid) && pact.pid >= 0 ? pact.pid : undefined;
-        if (pid === undefined) {
-            diagnostics.push({ kind: "invalid-pact", detail: "pact.json pid invalid" });
-        }
-        if (typeof pact.akuma !== "string" || pact.akuma.trim() === "") {
-            diagnostics.push({ kind: "invalid-pact", detail: "pact.json akuma invalid" });
+        const identity = readProjectionIdentity(projectionDir);
+        return {
+            identity,
+            pid: identity.pid,
+            akuma: identity.akuma,
+            provider: identity.provider,
+            mintedAt: identity.mintedAt,
+            workspaceRoot: identity.workspaceRoot,
+        };
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            diagnostics.push({ kind: "missing-identity", detail: "heart identity missing" });
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
-        if (typeof pact.provider !== "string" || pact.provider.trim() === "") {
-            diagnostics.push({ kind: "invalid-pact", detail: "pact.json provider invalid" });
+        if (error instanceof ProjectionGenerationStoreError) {
+            diagnostics.push({ kind: "invalid-identity", detail: error.message });
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
-        if (typeof pact.mintedAt !== "string" || pact.mintedAt.trim() === "") {
-            diagnostics.push({ kind: "invalid-pact", detail: "pact.json mintedAt invalid" });
+        if (error instanceof ProjectionStateError) {
+            diagnostics.push({ kind: "invalid-identity", detail: error.message });
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
-        return {
-            pact,
-            pid,
-            akuma: typeof pact.akuma === "string" && pact.akuma.trim() ? pact.akuma : undefined,
-            provider: typeof pact.provider === "string" && pact.provider.trim() ? pact.provider : undefined,
-            mintedAt: typeof pact.mintedAt === "string" && pact.mintedAt.trim() ? pact.mintedAt : undefined,
-        };
+        diagnostics.push({ kind: "unreadable-identity", detail: `heart identity unreadable: ${String(error)}` });
+        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+    }
+}
+function readHeartTellCounts(projectionDir, diagnostics) {
+    try {
+        return displayedTellCounts(readProjectionTellCounts(projectionDir));
     }
     catch (error) {
-        diagnostics.push({ kind: "unreadable-pact", detail: `pact.json unreadable: ${String(error)}` });
-        return { pact: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined };
+        if (error instanceof ProjectionGenerationStoreError || error instanceof ProjectionStateError) {
+            diagnostics.push({ kind: "unreadable-tells", detail: error.message });
+            return emptyTellCounts();
+        }
+        diagnostics.push({ kind: "unreadable-tells", detail: `heart tells unreadable: ${String(error)}` });
+        return emptyTellCounts();
     }
 }
-function readVerdictState(projectionDir, diagnostics) {
-    const verdictPath = path.join(projectionDir, "verdict.json");
-    if (!statOrNull(verdictPath))
-        return null;
+function readStoredEvents(projectionDir, executionId, diagnostics) {
+    let content;
     try {
-        const verdict = readJsonFile(verdictPath);
-        if (verdict.state === "done" || verdict.state === "dismissed" || verdict.state === "failed")
-            return verdict.state;
-        diagnostics.push({ kind: "invalid-verdict", detail: "verdict.json state invalid" });
-        return null;
+        content = readBoundedRegularFile(executionEventsPath(projectionDir, executionId));
     }
     catch (error) {
-        diagnostics.push({ kind: "unreadable-verdict", detail: `verdict.json unreadable: ${String(error)}` });
-        return null;
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return [];
+        if (recordProjectionStatusFileError(error, diagnostics))
+            return [];
+        diagnostics.push({ kind: "unreadable-activity", detail: `activity ledger unreadable: ${String(error)}` });
+        return [];
+    }
+    const lines = content.split("\n");
+    const terminated = content.endsWith("\n");
+    const values = [];
+    let malformed = 0;
+    for (const line of lines.slice(0, -1)) {
+        try {
+            values.push(JSON.parse(line));
+        }
+        catch {
+            malformed += 1;
+        }
+    }
+    const finalLine = lines.at(-1);
+    if (!terminated && finalLine) {
+        try {
+            values.push(JSON.parse(finalLine));
+        }
+        catch {
+            // A concurrent append can leave only this final record incomplete.
+        }
+    }
+    if (malformed > 0) {
+        diagnostics.push({
+            kind: "invalid-activity-event",
+            detail: `${malformed} persisted activity event${malformed === 1 ? "" : "s"} malformed`,
+        });
     }
+    return values;
 }
-function readHeartbeatFacts(projectionDir, nowMs, diagnostics) {
-    const heartbeatPath = path.join(projectionDir, "heartbeat");
-    const heartbeat = statOrNull(heartbeatPath);
-    if (!heartbeat) {
-        diagnostics.push({ kind: "missing-heartbeat", detail: "heartbeat missing" });
-        return {};
+function latestValidEventAtMs(events) {
+    let latest;
+    for (const event of events) {
+        const atMs = Date.parse(event.at);
+        if (!Number.isFinite(atMs))
+            continue;
+        if (latest === undefined || atMs > latest)
+            latest = atMs;
     }
+    return latest;
+}
+function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallbackAtMs) {
+    if (!executionId)
+        return {};
+    const stored = readStoredEvents(projectionDir, executionId, diagnostics);
+    const { events, malformed } = selectValidStoredAgentEvents(stored);
+    const invalidActivity = invalidActivityEventDiagnostic(malformed);
+    if (invalidActivity)
+        diagnostics.push(invalidActivity);
+    const activityAtMs = latestValidEventAtMs(events) ?? fallbackAtMs;
     return {
-        heartbeatMtimeMs: heartbeat.mtimeMs,
-        heartbeatAgeMs: Math.max(0, nowMs - heartbeat.mtimeMs),
+        ...(events.length > 0 ? { activity: foldAgentActivity(events) } : {}),
+        ...(activityAtMs !== undefined
+            ? {
+                activityAtMs,
+                activityAgeMs: Math.max(0, nowMs - activityAtMs),
+            }
+            : {}),
     };
 }
-function readProjectionRow(projectionDir, id, nowMs, probePid) {
+function readProjectionRow(projectionDir, id, nowMs) {
     const diagnostics = [];
-    const tellCounts = readTellCounts(projectionDir, diagnostics);
-    const ready = statOrNull(path.join(projectionDir, "ready"));
-    const pactFacts = readPactFacts(projectionDir, diagnostics);
-    if (!ready) {
+    const identityFacts = readIdentityFacts(projectionDir, diagnostics);
+    const tellCounts = identityFacts.identity
+        ? readHeartTellCounts(projectionDir, diagnostics)
+        : emptyTellCounts();
+    if (!identityFacts.identity) {
         return {
             id,
-            state: "minting",
-            akuma: pactFacts.akuma,
-            provider: pactFacts.provider,
-            pid: pactFacts.pid,
-            mintedAt: pactFacts.mintedAt,
+            state: "unknown",
             tellCounts,
             diagnostics,
         };
     }
-    const heartbeatFacts = readHeartbeatFacts(projectionDir, nowMs, diagnostics);
-    // Keep malformed verdict evidence visible without using this adapter as a
-    // second phase authority.
-    readVerdictState(projectionDir, diagnostics);
-    const phase = deriveProjectionPhase(projectionDir, nowMs, probePid);
+    const observation = observeProjectionLifeSnapshot(projectionDir, {
+        nowMs,
+        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+    });
+    const life = observation.life;
+    const current = observation.records
+        ? selectCurrentGeneration(observation.records)
+        : null;
+    const adoptedAt = current?.adoption?.facts.adoptedAt;
+    const adoptedAtMs = typeof adoptedAt === "string"
+        ? Date.parse(adoptedAt)
+        : Number.NaN;
+    const activityFacts = readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, Number.isFinite(adoptedAtMs) ? adoptedAtMs : undefined);
+    if (life.phase === "unknown" && life.diagnostic) {
+        diagnostics.push({ kind: "unknown-lifecycle", detail: life.diagnostic });
+    }
+    const phase = life.phase;
     const state = phase === "active" || phase === "quiescent" ? "out" : phase;
     return {
         id,
         state,
-        akuma: pactFacts.akuma,
-        provider: pactFacts.provider,
-        pid: pactFacts.pid,
-        mintedAt: pactFacts.mintedAt,
+        akuma: identityFacts.akuma,
+        provider: identityFacts.provider,
+        pid: identityFacts.pid,
+        mintedAt: identityFacts.mintedAt,
+        ...(identityFacts.workspaceRoot ? { workspaceRoot: identityFacts.workspaceRoot } : {}),
+        ...activityFacts,
         tellCounts,
         diagnostics,
-        ...heartbeatFacts,
     };
 }
-export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
+export function readProjectionStatusBoard(cwd, nowMs) {
     const root = projectionRoot(cwd);
+    try {
+        if (!fs.lstatSync(root).isDirectory())
+            return null;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
     let entries;
     try {
         entries = fs.readdirSync(root);
@@ -162,18 +263,17 @@ export function readProjectionStatusBoard(cwd, nowMs, options = {}) {
             return null;
         throw error;
     }
-    const probePid = options.probePid ?? ((pid) => process.kill(pid, 0));
     const rows = entries
         .filter((entry) => !entry.startsWith("."))
         .filter((entry) => {
         try {
-            return fs.statSync(path.join(root, entry)).isDirectory();
+            return fs.lstatSync(path.join(root, entry)).isDirectory();
         }
         catch {
             return false;
         }
     })
         .sort()
-        .map((id) => readProjectionRow(path.join(root, id), id, nowMs, probePid));
+        .map((id) => readProjectionRow(path.join(root, id), id, nowMs));
     return rows.length > 0 ? { rows } : null;
 }