The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
import { access, readFile, rename, writeFile } from "node:fs/promises";
import path from "node:path";
import type { RunnerApi } from "./api.js";
import { collectAttemptFeedback, emptyFeedbackSummary, type FeedbackEvidence, type FeedbackSummary } from "./feedback.js";
import { assertSecretFree, sanitizeJson } from "./redaction.js";
export interface FeedbackRecoveryIdentity {
campaignId: string;
attemptId: string;
executionId: string;
}
const exists = (file: string) => access(file).then(() => true, () => false);
export async function recoverInterruptedFeedback(input: {
identity: FeedbackRecoveryIdentity;
caseDirectory: string;
api: Pick<RunnerApi, "get">;
secrets: readonly string[];
deadlineAt: number;
}) {
const deadline = AbortSignal.timeout(Math.max(1, input.deadlineAt - Date.now()));
if (await exists(path.join(input.caseDirectory, "result.json"))) return;
const snapshots = path.join(input.caseDirectory, "snapshots");
let fixture: { executionId?: string; companyId?: string };
try { fixture = JSON.parse(await readFile(path.join(snapshots, "fixtures.json"), { encoding: "utf8", signal: deadline })); }
catch { return; }
if (fixture.executionId !== input.identity.executionId || !/^[a-f0-9-]{36}$/i.test(fixture.companyId ?? "")) return;
const companyId = fixture.companyId!;
let summary = emptyFeedbackSummary();
let checkpoint: FeedbackEvidence | undefined;
const recoveryReceipt = (summary: FeedbackSummary) => ({ version: 1, ...input.identity, companyId,
reason: "worker_exited_without_result", summary });
const save = async (name: string, value: unknown, signal: AbortSignal = deadline) => {
const text = JSON.stringify(sanitizeJson(value, input.secrets), null, 2) + "\n";
assertSecretFree(text, input.secrets, name);
await writeFile(path.join(snapshots, `${name}.pending`), text, { mode: 0o600, signal });
signal.throwIfAborted();
await rename(path.join(snapshots, `${name}.pending`), path.join(snapshots, name));
};
const saveCheckpoint = (evidence: FeedbackEvidence, signal: AbortSignal = deadline) =>
save("agent-feedback-recovered.json", { ...evidence, recovery: recoveryReceipt({ ...evidence.summary,
collection: evidence.summary.bodiesCollected ? "partial" : "unavailable",
invocationCollection: evidence.invocations.length ? "partial" : "unavailable" }) }, signal);
try {
const original = JSON.parse(await readFile(path.join(snapshots, "agent-feedback.json"), { encoding: "utf8", signal: deadline }));
if (original.version === 1 && original.companyId === companyId && original.summary?.version === 1
&& Array.isArray(original.entries) && Array.isArray(original.invocations)
&& original.summary.bodiesCollected === original.entries.length) {
await saveCheckpoint(original);
checkpoint = original;
summary = structuredClone(original.summary);
}
} catch {}
try {
const collected = await collectAttemptFeedback({ api: input.api, companyId, deadlineAt: input.deadlineAt,
persist: async (evidence, signal) => {
if (checkpoint && (!checkpoint.entries.every(entry => evidence.entries.some(next => next.id === entry.id))
|| !checkpoint.invocations.every(call => evidence.invocations.some(next => next.runId === call.runId && next.callId === call.callId)))) return;
await saveCheckpoint(evidence, signal);
checkpoint = structuredClone(evidence);
summary = structuredClone(evidence.summary);
},
});
summary.collection = summary.bodiesCollected ? "partial" : collected.collection;
summary.invocationCollection = summary.invocations.completed + summary.invocations.failed + summary.invocations.unknown
? "partial" : collected.invocationCollection;
} catch {
summary.collection = summary.bodiesCollected ? "partial" : "unavailable";
summary.invocationCollection = "unavailable";
}
await save("feedback-recovery.json", recoveryReceipt(summary));
}
export async function readRecoveredFeedback(caseDirectory: string, identity: FeedbackRecoveryIdentity): Promise<FeedbackSummary | undefined> {
try {
const snapshots = path.join(caseDirectory, "snapshots");
const evidence = JSON.parse(await readFile(path.join(snapshots, "agent-feedback-recovered.json"), "utf8"));
let receipt = evidence.recovery;
try { receipt = JSON.parse(await readFile(path.join(snapshots, "feedback-recovery.json"), "utf8")); }
catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") return; }
if (receipt?.version !== 1 || evidence.version !== 1 || receipt.reason !== "worker_exited_without_result"
|| !receipt.companyId || receipt.companyId !== evidence.companyId
|| Object.entries(identity).some(([key, value]) => receipt[key] !== value)) return;
const summary = evidence.summary as FeedbackSummary;
const statuses = ["complete", "partial", "unavailable", "not_started"];
if (summary?.version !== 1 || !Array.isArray(evidence.entries) || !Array.isArray(evidence.invocations)
|| summary.bodiesCollected !== evidence.entries.length || !Array.isArray(summary.review)
|| ![summary.complaints, summary.suggestions, summary.bodiesCollected, summary.runsInspected,
summary.invocations?.completed, summary.invocations?.failed, summary.invocations?.unknown]
.every(value => Number.isSafeInteger(value) && value >= 0)
|| !["observed", "unknown"].includes(summary.toolAvailability)
|| !["collection", "invocationCollection"].every(key => {
const original = summary[key as "collection" | "invocationCollection"];
const recovered = receipt.summary?.[key];
return statuses.includes(original) && statuses.includes(recovered)
&& (recovered === original || recovered === "partial" || recovered === "unavailable");
})) return;
return { ...summary, collection: receipt.summary.collection, invocationCollection: receipt.summary.invocationCollection };
} catch { return; }
}