@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/projection/projection-status-observation.js

@@ -1,434 +0,0 @@
-import fs from "node:fs";
-import * as path from "node:path";
-import { isErrnoException } from "../../errno.js";
-import { executionEventsPath } from "./projection-core.js";
-import { ProjectionStateError } from "../atomic-publish.js";
-import { foldPublicProjectionActivity } from "./projection-activity.js";
-import { readProjectionIdentity } from "./projection-identity.js";
-import { readPendingTellWindow, readProjectionTellCounts } from "./tell/store.js";
-import { ProjectionGenerationStoreError } from "./generation/store.js";
-import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { selectCurrentGeneration } from "./generation/protocol.js";
-import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "../stored-agent-event.js";
-import { projectTerminalFailure } from "./projection-terminal-failure.js";
-import { extractTerminalTimestamp } from "./generation/model.js";
-function latestActivityRow(activity, kind, predicate) {
-    const rows = activity?.retainedTimeline.filter((row) => row.kind === kind) ?? [];
-    return [...rows].reverse().find((row) => predicate?.(row) ?? true);
-}
-export function deriveProjectionStatusReadFacts(input) {
-    const warning = latestActivityRow(input.activity, "warning");
-    const runningTool = latestActivityRow(input.activity, "ran", (row) => row.state === "running");
-    const said = latestActivityRow(input.activity, "said");
-    const answer = typeof input.verdictFacts?.finalMessage === "string"
-        ? { kind: "text", text: input.verdictFacts.finalMessage }
-        : undefined;
-    const responsePath = typeof input.verdictFacts?.responsePath === "string" ? input.verdictFacts.responsePath : undefined;
-    const artifactId = typeof input.verdictFacts?.artifactId === "string" ? input.verdictFacts.artifactId : undefined;
-    const launchInputs = input.launchFacts?.inputs;
-    const incognito = launchInputs !== null && typeof launchInputs === "object" && !Array.isArray(launchInputs)
-        && launchInputs.persistProjectionResponse === false;
-    const persistenceFailed = input.verdictFacts?.responsePersistError !== undefined;
-    const snapshot = warning
-        ? { kind: "warning", row: warning }
-        : runningTool
-            ? { kind: "running-tool", row: runningTool }
-            : said
-                ? { kind: "said", row: said }
-                : input.activity?.plan
-                    ? { kind: "plan", plan: input.activity.plan }
-                    : undefined;
-    const responseArtifact = input.verdictFacts === undefined
-        ? undefined
-        : responsePath
-            ? { state: "retained", path: responsePath, ...(artifactId ? { artifactId } : {}) }
-            : incognito
-                ? { state: "none", reason: "incognito" }
-                : { state: "unavailable", reason: persistenceFailed ? "persistence-failed" : "not-observed" };
-    return {
-        ...(answer ? { terminalAnswer: answer } : {}),
-        ...(responseArtifact ? { responseArtifact } : {}),
-        attention: { ...(warning ? { latestWarning: warning } : {}) },
-        ...(snapshot ? { snapshot } : {}),
-    };
-}
-const MAX_STATUS_FILE_BYTES = 256 * 1024;
-class ProjectionStatusFileError extends Error {
-    diagnostic;
-    constructor(kind, filePath) {
-        const label = path.basename(filePath);
-        const detail = `${label} is not a regular file`;
-        super(detail);
-        this.name = "ProjectionStatusFileError";
-        this.diagnostic = { kind, detail };
-    }
-}
-function oversizedProjectionFileDiagnostic(filePath) {
-    return {
-        kind: "oversized-projection-file",
-        fileName: path.basename(filePath),
-    };
-}
-function recordProjectionStatusFileError(error, diagnostics) {
-    if (!(error instanceof ProjectionStatusFileError))
-        return false;
-    diagnostics.push(error.diagnostic);
-    return true;
-}
-function readBoundedRegularFileTail(filePath) {
-    const before = fs.lstatSync(filePath);
-    if (!before.isFile())
-        throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-    let fd;
-    try {
-        fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | fs.constants.O_NOFOLLOW);
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ELOOP") {
-            throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-        }
-        throw error;
-    }
-    try {
-        const opened = fs.fstatSync(fd);
-        if (!opened.isFile())
-            throw new ProjectionStatusFileError("non-regular-projection-file", filePath);
-        const snapshotSize = opened.size;
-        const truncated = snapshotSize > MAX_STATUS_FILE_BYTES;
-        const readLength = Math.min(snapshotSize, MAX_STATUS_FILE_BYTES);
-        const readOffset = Math.max(0, snapshotSize - MAX_STATUS_FILE_BYTES);
-        const buffer = Buffer.allocUnsafe(readLength);
-        let total = 0;
-        while (total < readLength) {
-            const bytesRead = fs.readSync(fd, buffer, total, readLength - total, readOffset + total);
-            if (bytesRead === 0)
-                break;
-            total += bytesRead;
-        }
-        let tail = buffer.subarray(0, total);
-        if (truncated) {
-            const firstLf = tail.indexOf(0x0a);
-            if (firstLf < 0) {
-                return { content: "", truncated: true };
-            }
-            tail = tail.subarray(firstLf + 1);
-        }
-        return { content: tail.toString("utf8"), truncated };
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-function displayedTellCounts(counts) {
-    return {
-        inbox: counts.inbox,
-        inflight: counts.inflight,
-        submitted: counts.submitted,
-        seen: counts.seen,
-        consumed: counts.consumed,
-    };
-}
-function emptyTellCounts() {
-    return { inbox: 0, inflight: 0, submitted: 0, seen: 0, consumed: 0 };
-}
-function readIdentityFacts(projectionDir, diagnostics) {
-    try {
-        const identity = readProjectionIdentity(projectionDir);
-        return {
-            identity,
-            pid: identity.pid,
-            akuma: identity.akuma,
-            provider: identity.provider,
-            binding: identity.binding,
-            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, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
-        }
-        if (error instanceof ProjectionGenerationStoreError) {
-            diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
-        }
-        if (error instanceof ProjectionStateError) {
-            diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
-        }
-        diagnostics.push({ kind: "unreadable-identity", detail: `heart identity unreadable: ${String(error)}` });
-        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
-    }
-}
-function readHeartTellCounts(projectionDir, diagnostics) {
-    try {
-        return displayedTellCounts(readProjectionTellCounts(projectionDir));
-    }
-    catch (error) {
-        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 readPendingTells(projectionDir, diagnostics) {
-    try {
-        // Kanshi is an operator surface: unconsumed tells are actionable facts, not
-        // a count to hide behind. This is one heart read and does not enumerate a
-        // second projection topology.
-        return readPendingTellWindow(projectionDir, Number.MAX_SAFE_INTEGER).window;
-    }
-    catch (error) {
-        if (error instanceof ProjectionGenerationStoreError || error instanceof ProjectionStateError) {
-            diagnostics.push({ kind: "unreadable-tells", detail: error.message });
-            return [];
-        }
-        diagnostics.push({ kind: "unreadable-tells", detail: `heart tells unreadable: ${String(error)}` });
-        return [];
-    }
-}
-function readStoredEvents(projectionDir, executionId, diagnostics) {
-    let content;
-    let truncated = false;
-    const eventsPath = executionEventsPath(projectionDir, executionId);
-    try {
-        const read = readBoundedRegularFileTail(eventsPath);
-        content = read.content;
-        truncated = read.truncated;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT")
-            return [];
-        if (recordProjectionStatusFileError(error, diagnostics))
-            return [];
-        diagnostics.push({ kind: "unreadable-activity", detail: `activity ledger unreadable: ${String(error)}` });
-        return [];
-    }
-    if (truncated) {
-        diagnostics.push(oversizedProjectionFileDiagnostic(eventsPath));
-    }
-    // Parse only LF-terminated records. An unterminated final line is ignored even
-    // when it happens to parse: it may be a concurrent append fragment.
-    const lines = content.split("\n");
-    const values = [];
-    let malformed = 0;
-    for (const line of lines.slice(0, -1)) {
-        try {
-            values.push(JSON.parse(line));
-        }
-        catch {
-            malformed += 1;
-        }
-    }
-    if (malformed > 0) {
-        diagnostics.push({
-            kind: "invalid-activity-event",
-            detail: `${malformed} persisted activity event${malformed === 1 ? "" : "s"} malformed`,
-        });
-    }
-    return values;
-}
-function latestValidEvent(events) {
-    let latest;
-    for (const event of events) {
-        const atMs = Date.parse(event.at);
-        if (!Number.isFinite(atMs))
-            continue;
-        if (latest === undefined || atMs > latest.atMs)
-            latest = { at: event.at, atMs };
-    }
-    return latest;
-}
-function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallbackAt) {
-    const fallbackAtMs = fallbackAt === undefined ? undefined : Date.parse(fallbackAt);
-    const validFallback = fallbackAt !== undefined && Number.isFinite(fallbackAtMs)
-        ? { at: fallbackAt, atMs: fallbackAtMs }
-        : undefined;
-    if (!executionId) {
-        return validFallback
-            ? { activityAt: validFallback.at, activityAtMs: validFallback.atMs, activityAgeMs: Math.max(0, nowMs - validFallback.atMs) }
-            : {};
-    }
-    const stored = readStoredEvents(projectionDir, executionId, diagnostics);
-    const { events, malformed } = selectValidStoredAgentEvents(stored);
-    const invalidActivity = invalidActivityEventDiagnostic(malformed);
-    if (invalidActivity)
-        diagnostics.push(invalidActivity);
-    const latest = latestValidEvent(events) ?? validFallback;
-    return {
-        ...(events.length > 0 ? { activity: foldPublicProjectionActivity(events) } : {}),
-        ...(latest !== undefined
-            ? {
-                activityAt: latest.at,
-                activityAtMs: latest.atMs,
-                activityAgeMs: Math.max(0, nowMs - latest.atMs),
-            }
-            : {}),
-    };
-}
-function terminalTimestamp(current) {
-    return extractTerminalTimestamp(current?.verdict?.facts);
-}
-function terminalAgeAt(terminalAt, observedAtMs) {
-    const terminalAtMs = Date.parse(terminalAt ?? "");
-    return Number.isFinite(terminalAtMs) ? Math.max(0, observedAtMs - terminalAtMs) : undefined;
-}
-function projectionStatusState(life) {
-    if (life.verdict === "lost-runner")
-        return "dead";
-    return life.phase === "active" || life.phase === "quiescent" ? "out" : life.phase;
-}
-export function readProjectionSummary(projectionDir, id, alias, nowMs, options) {
-    const diagnostics = [];
-    const snapshot = observeProjectionLifeSnapshot(projectionDir, {
-        nowMs,
-    });
-    if (snapshot.compatibility === "incompatible") {
-        return {
-            id,
-            ...(alias ? { alias } : {}),
-            projectionDir,
-            snapshot,
-            identityFacts: null,
-            diagnostics,
-            state: "incompatible",
-        };
-    }
-    const life = snapshot.life;
-    const state = projectionStatusState(life);
-    const identityFacts = options?.requiresIdentity?.(state) === false
-        ? null
-        : readIdentityFacts(projectionDir, diagnostics);
-    return {
-        id,
-        ...(alias ? { alias } : {}),
-        projectionDir,
-        snapshot,
-        identityFacts,
-        diagnostics,
-        state,
-    };
-}
-export function readProjectionRow(summary, nowMs, readDetails) {
-    const { id, alias, projectionDir, snapshot } = summary;
-    const identity = { canonicalId: id };
-    const diagnostics = [...summary.diagnostics];
-    if (snapshot.compatibility === "incompatible") {
-        return {
-            id,
-            identity,
-            observedAtMs: nowMs,
-            ...(alias ? { alias } : {}),
-            state: "incompatible",
-            observation: snapshot,
-            tellCounts: emptyTellCounts(),
-            attention: {},
-            diagnostics,
-        };
-    }
-    const identityFacts = summary.identityFacts;
-    if (identityFacts === null && !readDetails) {
-        const current = snapshot.records ? selectCurrentGeneration(snapshot.records) : null;
-        const terminalAt = terminalTimestamp(current);
-        const terminalAgeMs = current?.verdict ? terminalAgeAt(terminalAt, nowMs) : undefined;
-        const readFacts = deriveProjectionStatusReadFacts({ state: summary.state });
-        return {
-            id,
-            identity,
-            observedAtMs: nowMs,
-            ...(alias ? { alias } : {}),
-            state: summary.state,
-            observation: { compatibility: "current", lifecycle: snapshot.life },
-            ...(terminalAt ? { terminalAt } : {}),
-            ...(terminalAgeMs !== undefined ? { terminalAgeMs } : {}),
-            tellCounts: emptyTellCounts(),
-            ...readFacts,
-            diagnostics,
-        };
-    }
-    if (identityFacts === null || !identityFacts.identity) {
-        const diagnostic = diagnostics.map((entry) => entry.detail).find((detail) => detail !== undefined)
-            ?? "projection identity could not be observed";
-        return {
-            id,
-            identity,
-            observedAtMs: nowMs,
-            ...(alias ? { alias } : {}),
-            state: "unknown",
-            observation: {
-                compatibility: "current",
-                lifecycle: { phase: "unknown", diagnostic },
-            },
-            tellCounts: emptyTellCounts(),
-            attention: {},
-            diagnostics,
-        };
-    }
-    const life = snapshot.life;
-    const current = snapshot.records ? selectCurrentGeneration(snapshot.records) : null;
-    const adoptedAt = current?.adoption?.facts.adoptedAt;
-    const adoptedAtMs = typeof adoptedAt === "string"
-        ? Date.parse(adoptedAt)
-        : Number.NaN;
-    const tellCounts = readDetails
-        ? readHeartTellCounts(projectionDir, diagnostics)
-        : emptyTellCounts();
-    const pendingTells = readDetails
-        ? readPendingTells(projectionDir, diagnostics)
-        : [];
-    const activityFacts = readDetails
-        ? readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, typeof adoptedAt === "string" && Number.isFinite(adoptedAtMs) ? adoptedAt : identityFacts.mintedAt)
-        : {};
-    const mintedAtMs = Date.parse(identityFacts.mintedAt ?? "");
-    const terminalAt = terminalTimestamp(current);
-    const terminalAtMs = Date.parse(terminalAt ?? "");
-    const terminalAgeMs = current?.verdict ? terminalAgeAt(terminalAt, nowMs) : undefined;
-    const durationAnchorMs = current?.verdict
-        ? terminalAtMs
-        : nowMs;
-    const durationMs = Number.isFinite(mintedAtMs) && Number.isFinite(durationAnchorMs)
-        ? Math.max(0, durationAnchorMs - mintedAtMs)
-        : undefined;
-    const displayAgeMs = activityFacts.activityAgeMs
-        ?? (Number.isFinite(mintedAtMs) ? Math.max(0, nowMs - mintedAtMs) : undefined);
-    if (life.phase === "unknown" && life.diagnostic) {
-        diagnostics.push({ kind: "unknown-lifecycle", detail: life.diagnostic });
-    }
-    const state = projectionStatusState(life);
-    const terminalFailure = current?.verdict
-        ? projectTerminalFailure(current.verdict.facts.state, current.verdict.facts)
-        : undefined;
-    const readFacts = deriveProjectionStatusReadFacts({
-        state,
-        activity: activityFacts.activity,
-        verdictFacts: current?.verdict?.facts,
-        launchFacts: current?.launch.facts,
-    });
-    return {
-        id,
-        identity,
-        observedAtMs: nowMs,
-        ...(alias ? { alias } : {}),
-        state,
-        observation: { compatibility: "current", lifecycle: life },
-        akuma: identityFacts.akuma,
-        provider: identityFacts.provider,
-        binding: identityFacts.binding,
-        pid: identityFacts.pid,
-        mintedAt: identityFacts.mintedAt,
-        ...(terminalAt ? { terminalAt } : {}),
-        ...(terminalAgeMs !== undefined ? { terminalAgeMs } : {}),
-        ...(durationMs !== undefined ? { durationMs } : {}),
-        ...(identityFacts.workspaceRoot ? { workspaceRoot: identityFacts.workspaceRoot } : {}),
-        ...activityFacts,
-        ...(displayAgeMs !== undefined ? { activityAgeMs: displayAgeMs } : {}),
-        ...(terminalFailure ? { terminalFailure } : {}),
-        ...readFacts,
-        tellCounts,
-        ...(pendingTells.length > 0 ? { pendingTells } : {}),
-        diagnostics,
-    };
-}