mirror of
https://github.com/morluto/rea.git
synced 2026-11-17 12:14:12 +00:00
* feat: add FreeBuff agent support for REA setup Register FreeBuff as a supported setup client using the shared user agents directory (~/.agents/mcp.json with mcpServers, skills in ~/.agents/skills), which matches what FreeBuff Desktop loads. Adds the client definition, boundary tests, supported-agent docs, and the skill reference client list. * fix(freebuff): detect FreeBuff from its profile directory, not shared .agents The ~/.agents marker made FreeBuff appear installed for any home where REA had installed shared skills (the default skill destination, also Gemini CLI's), producing false doctor failures. Detect FreeBuff from its own fixed profile directory ~/.config/freebuff-desktop instead, and add a regression test covering a home with only the shared agents skill directory. * fix(setup): require product evidence for FreeBuff discovery Address review findings at their producing boundaries and preserve directly affected consumers. Source inspection and git diff --check completed. Tests and automated checks were not run at the user’s explicit request. * fix(uninstall): retain unverified shared client configuration * fix(clients): preserve scoped removal evidence * fix(doctor): omit undefined selectedClientIds under exactOptionalPropertyTypes Passing selectedClientIds explicitly as undefined fails typecheck on this branch (TS2379), which blocks the focused test workflow before any test can run. Spread the option only when defined. * fix(update): separate ownership evidence from product applicability rea update's maintenance scope inspected only product applicability evidence, so when a FreeBuff profile was absent but REA already owned a version-pinned row in the shared ~/.agents/mcp.json, the plan omitted freebuff and left the integration stale. FreeBuff now declares its registration storage as shared, which proves ownership of an owned row but never product applicability, and maintenance requests ownership evidence through that declaration instead of reinterpreting the shared paths. Doctor and setup keep readiness evidence, foreign rows stay out of maintenance, and the Doctor exactOptionalPropertyTypes fix makes the focused test workflow runnable. * test(dotnet): split oversized operand extent diagnostics describe The describe callback reached 162 lines (max 150), failing max-lines-per-function and blocking the pre-push check for this branch. Move the single-case extent scenarios into their own describe; no test content or order changes. * fix(update): preserve ZCode's disabled shared registration during maintenance The shared user agents file doubles as ZCode's fallback, where `enable: false` disables the registration. Ownership-based maintenance read that row as a FreeBuff registration, whose format does not recognize the flag, so the row was selected and the emitted setup command rewrote it, dropping the flag and silently re-enabling a registration the user had disabled. registrationActivation now honors `enable: false` for any client whose registration storage is shared, because the activation fact binds every reader of that storage. Maintenance leaves such rows out; doctor reports them as stale, matching ZCode's own treatment. * fix(doctor): let explicit client selection authorize the config read When an ACL or an inaccessible shared parent made every access probe fail, a client selected by name was omitted before the configuration read could return its unreadable-config detail, so doctor reported it as not detected with installation remediation: an unresolved selected path collapsed to absence. An explicit selection now authorizes the read outright and the probes serve automatic discovery only. A selected client with an unreadable config reports invalid with the read failure; one with no config reports missing; automatic discovery still probes before inspecting. * fix(uninstall): share shared-storage checks between ZCode and FreeBuff clients() queued ~/.agents/mcp.json twice: once as zcode_fallback and once as freebuff. ZCode has no discoveryPaths, so its strict read still blocked uninstall on malformed shared text, despite FreeBuff's new retain-and-continue behavior. For a valid owned entry, ZCode removed it first, so FreeBuff reported skipped rather than removed. Make the shared file's checks and removal one shared decision: - Add zcodeDiscoveryPaths to ZCode so it has its own applicability evidence. - Gate zcode_fallback push on applicable, not just zcodeFallbackPath presence. - Report shared storage ownership as one decision for both clients: FreeBuff and ZCode now use clientOwnershipEvidencePaths together, so a recognizable REA-owned row proves ownership once for the shared storage, and both clients report the same result consistently. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix(uninstall): merge duplicated host and prove shared ownership from owned rows Uninstall.ts declared systemUninstallHost twice, preventing module load, with the exported copy returning only clients and the second copy missing clientWriteBlocker. Merge into one exported host carrying both blockers. hasOwnershipEvidence used access() existence, so an unrelated malformed ~/.agents/mcp.json established ownership and blocked every removal. Ownership now requires a readable, recognizable REA-owned row via the injected filesystem, so unrelated shared data stays retained. Also cover ZCode discoveryPaths in its path test. * fix(uninstall): keep denied product-local configurations fail-closed Unproven product applicability marked every configuration path of that client unverified, so a denied ZCode profile turned an unreadable product-local config into a retained item: uninstall continued and could report complete with REA still registered. The retain-and-continue exception now applies only to storage REA does not own, classified once by clientSharedRegistrationPaths (shared configuration plus another product's same-scope fallback). Covers the Greptile P1 on Uninstall.ts. Validation: the new test fails on the pre-fix Uninstall and passes after it; freebuff/zcode/updateMaintenance/bom/dsh suites green; clientLifecycle, clientRegistrationStatus and claudeDesktop keep the same 8 host failures as the pre-merge baseline (symlink EPERM, stale-vs-aligned on Windows). * fix(update): retain FreeBuff when ZCode reads the shared fallback Maintenance deduplicated clients on the path each inspection read, so ZCode's fallback view of ~/.agents/mcp.json marked that file "covered" and dropped FreeBuff from the scope. ZCode setup writes ~/.zcode/cli/config.json and deliberately leaves the fallback untouched (docs/client-configuration.md), so the emitted command refreshed only ZCode while the shared row both products load stayed pinned to the old package version. Each setup action rewrites only its own configuration path and no other action rewrites the shared row, so every selected client keeps its own maintenance action; the read-path covered/deduped filter is removed. Covers the Codex P2 on UpdateMaintenance.ts:104. Validation: the new regression fails one2fdec384with {clients:["zcode"]} and passes with {clients:["freebuff","zcode"]}; updateMaintenance 31/31, setupClientConfigCleanupOwnership, cliUpdateAlias, updateOutput, cliStartupImports green; tsc --noEmit, oxlint (0 errors) and oxfmt --check clean; clientRegistrationStatus keeps the same 4 symlink/stale-vs-aligned failures this Windows host has on basee2fdec384(verified by stashing the change). 🤖 Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com> * fix(uninstall): preserve completed reads as shared ownership evidence hasOwnershipEvidence caught every read failure and kept scanning, so a handle-close failure after a successful read — a RegularFileCleanupFailure whose completed outcome still contains the exact shared-file text — was discarded as "no proof". FreeBuff's applicability-unverified storage therefore never got its ownership fact, and once the retained handle blocked later reads, readClientConfiguration downgraded them to retained: inspection passed, removals soft-failed, and runUninstall(true) could purge REA data while the active shared registration remained. The catch now parses the completed outcome for the ownership text while missing or unreadable storage and malformed data keep their proves-nothing semantics, so ownership holds and every later read failure stays blocking. Covers the Codex P2 on Uninstall.ts:252. Validation: the new regression fails on4dbfdf1a9(freebuff reports no blocking failure while the poisoned-scope error lands on claude_code) and passes after; setupClientConfigCleanupOwnership 25/25; the other 21 Uninstall-consumer suites are byte-identical to base4dbfdf1a9(61 pre-existing Windows-host failures: symlink EPERM, stale-vs-aligned); tsc --noEmit, oxlint (0 errors, same 6 warnings) and oxfmt --check clean. 🤖 Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com> * fix(uninstall): keep owned-row proof through removal refusals hasOwnershipEvidence treated any clientRegistrationRemoval refusal as no ownership: an effective REA-owned rea member shadowed by an earlier foreign duplicate (shadowed_unowned_member), or an owned native row beside a foreign V1 fallback (foreign_legacy_fallback), discarded the already-parsed positive row fact. With FreeBuff unverified and close failures recurring on the preflight/removal rereads, those failures were then downgraded to retained, so runUninstall(true) removed the skill and purged REA data while the active owned row remained. The refusal now carries the owned rows that motivated it — the refusal only refuses the edit — and hasOwnershipEvidence evaluates that fact on both paths; preflight and removal keep refusing the unsafe edit exactly as before. Covers the Codex P2 on Uninstall.ts:269. Validation: the new regression fails on225cb214a(freebuff reports no blocking failure while the poisoned-scope error lands on claude_code) and passes after; setupClientConfigCleanupOwnership 26/26; the 21 Uninstall-consumer suites are byte-identical to the recorded225cb214abaseline (61 pre-existing Windows-host failures: symlink EPERM, stale-vs-aligned); tsc --noEmit, oxlint (0 errors, same 6 warnings) and oxfmt --check clean. 🤖 Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com> * fix(uninstall): keep unresolved discovery probes from softening shared failures The discovery probe swallowed every stat failure, so a FreeBuff profile denied with EACCES/EIO was indistinguishable from an absent profile: shared storage was marked applicability-unverified and, when ~/.agents/mcp.json also remained unreadable, the ownership and removal reads softened to retained. runUninstall(true) then removed the skill and purged REA data while an installed FreeBuff could still hold an active registration — the regression even reports complete. Absence (ENOENT) is now the only state that leaves shared paths unverified; any other probe failure leaves applicability unresolved, and shared-config failures stay blocking. Covers the Codex P2 on Uninstall.ts:318. Validation: the new regression fails on7572a7082with status complete and purged data and passes after; freebuffClientConfiguration 13/13; the Uninstall-consumer batches are byte-identical to the recorded baselines (61 pre-existing Windows-host failures: symlink EPERM, stale-vs-aligned); tsc --noEmit, oxlint (0 errors, same warning rules) and oxfmt --check clean. 🤖 Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com> * fix(uninstall): retain completed configuration reads as removal evidence A close failure after a completed read discarded the text that read produced, so an owned registration row the text proves softened to retained. The completed text now drives removal, keeping shared-config failures blocking when ownership evidence exists. Co-Authored-By: Anthropic <noreply@anthropic.com> * fix(uninstall): stop removal when a cleanup retry leaves a handle unreleased A completed reread whose handle the cleanup retry cannot release now fails blockingly instead of serving the text: with no owned row, the soft path let removeAll purge managed data before close() reported the incomplete cleanup. The completed text is served only after the retry releases the handle; an unreleased handle is REA's own failure, never applicability uncertainty, so it bypasses the retained softening. Co-Authored-By: Anthropic <noreply@anthropic.com> * fix(uninstall): keep the ZCode fallback when its profile probe is unresolved A denied or failed profile probe leaves ZCode's applicability unresolved, never absent, but the fallback branch dropped the shared row on applicability alone: with the native config and FreeBuff's profile both absent, an installed ZCode kept its uninspected registration while uninstall purged skill and data. Unresolved probes now keep the fallback in scope with the same fail-closed treatment as other unresolved shared paths; definitive absence still keeps ZCode out of another product's primary storage. Co-Authored-By: Anthropic <noreply@anthropic.com> * fix(setup): preserve a shared row's enable:false during FreeBuff repair The shared agents file doubles as ZCode's fallback, so its `enable: false` binds every reader: doctor now reports the disabled row as stale for FreeBuff, but following that remediation rebuilt the generic JSON entry without the flag and silently re-enabled a registration ZCode disabled. Repairs of shared storage now carry the activation fact forward, while a client's own native storage keeps its established single-reader repair contract; the denied-profile uninstall regression also pins the fallback's new fail-closed inspection beside the denied read. Co-Authored-By: Anthropic <noreply@anthropic.com> * test(uninstall): retarget the completed-reread regression to a released retry The concurrent-writer regression held the reread handle open forever, which the fail-closed path now serves: it duplicated the unreleased-handle regression while documenting the opposite contract. The fixture's close spy gains a failure limit so the cleanup retry releases the handle, and the test again proves the completed text drives removal of the concurrently added owned row, with purge verified against the cache layout purge actually removes. Co-Authored-By: Anthropic <noreply@anthropic.com> * fix(doctor): report a preserved shared disable as a manual conflict Preserving a shared row's enable:false left doctor recommending a setup run that registrationCurrent correctly treats as already current, so the scoped doctor returned needs_human forever. The shared-enable interpretation now has one owner, sharedEnableFlagBinds, used by both the activation rule and the remediation: a row disabled through the shared flag reports the manual conflict and states that rea setup will not change it, instead of an endlessly ineffective repair. Co-Authored-By: Anthropic <noreply@anthropic.com> * fix(doctor): keep a native ZCode disable on the setup repair path The manual-conflict remediation matched a native zcode row through sharedEnableFlagBinds, but setup drops enable:false on single-reader storage, so a native disabled registration was told setup would not change it. The remediation now reads setup's own writer rule, exported as setupPreservesDisabledActivation: shared storage and the zcode fallback view keep the manual-conflict message, while a native row keeps the working rea setup instruction. Regressions pin both remediations. 🤖 Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com> * revert: drop the unrelated managed-CIL describe split The split does not belong to FreeBuff client support and only widens this PR's diff. 🤖 Generated with Codebuff Co-Authored-By: Codebuff <noreply@codebuff.com> * fix(uninstall): remove the shared agent registration once for both clients ZCode's ~/.agents/mcp.json fallback and FreeBuff's own configuration queued the same physical file twice, so ZCode removed the row and FreeBuff then reported it absent, losing the outcome for the client that owns the file. Resolve every configuration path to one owner -- the client whose configuration it is -- and project that single inspection and removal to each client that loads it. A fallback reader still contributes its discovery probe, so an installed or unresolved reader keeps the shared file fail-closed. Discovery also accepted a dangling ~/.config/freebuff-desktop link, which setup and doctor reject because they follow the target, so an unrelated malformed shared file blocked every other removal. Resolve the link before treating the profile as installation evidence, keeping lstat for removal safety. Also date the FreeBuff release wording against the published 6.7.0 package. * fix(uninstall): keep a row per client when two clients own one file OPENCODE_CONFIG can point OpenCode at FreeBuff's configuration file, where OpenCode writes `mcp.rea` and FreeBuff writes `mcpServers.rea`. Grouping by filename gave that path a single owner, so uninstall removed only OpenCode's row, reported that removal for FreeBuff, and could purge managed data with FreeBuff's registration still active. Share the decision only through a fallback view of another client's row: every client that declares the path as its own configuration keeps its own inspection and removal, and the fallback reader reports each of them. * fix(clients): preserve discovery and fallback registration identity Follow product discovery link targets without losing configuration entry presence or explicitly selected inspections. Associate fallback readers with the format owner's registration table and project outcomes by owner and path, so OpenCode removal cannot be reported as a ZCode fallback removal. All three new boundary regressions fail against the previous source and pass with the fixes. Validation: check:fast; 217 focused tests passed; the two changed test files were rerun with 50 passing tests. No installed FreeBuff client was launched. --------- Co-authored-by: morluto <76467478+morluto@users.noreply.github.com> Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com> Co-authored-by: Codebuff <noreply@codebuff.com>
709 lines
22 KiB
TypeScript
709 lines
22 KiB
TypeScript
import { open, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
|
|
import {
|
|
withArtifactFileHandle,
|
|
bindArtifactFileCleanup,
|
|
} from "./ArtifactFileOperation.js";
|
|
import {
|
|
ArtifactResourceRetryFailure,
|
|
ArtifactResourceScope,
|
|
} from "./ArtifactResourceScope.js";
|
|
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
|
|
import { expect, it } from "vitest";
|
|
|
|
import { err, ok } from "../domain/result.js";
|
|
import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
|
|
import {
|
|
ArtifactReaderFailure,
|
|
type ArtifactReader,
|
|
} from "./ArtifactReader.js";
|
|
import { translateArtifactFailure } from "./ArtifactOperationFailure.js";
|
|
|
|
const deferred = <T>() => {
|
|
let resolve: (value: T) => void = () => {};
|
|
const promise = new Promise<T>((resolvePromise) => {
|
|
resolve = resolvePromise;
|
|
});
|
|
return { promise, resolve };
|
|
};
|
|
|
|
it("waits for admitted operations and shares concurrent close", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
const started = deferred<void>();
|
|
const finish = deferred<void>();
|
|
const operation = scope.run(async () => {
|
|
started.resolve();
|
|
await finish.promise;
|
|
});
|
|
await started.promise;
|
|
|
|
const close = scope.close();
|
|
expect(scope.close()).toBe(close);
|
|
await expect(scope.run(async () => undefined)).rejects.toMatchObject({
|
|
reason: "unavailable",
|
|
message: "Artifact resource scope is closed",
|
|
});
|
|
let closed = false;
|
|
void close.then(() => {
|
|
closed = true;
|
|
});
|
|
await Promise.resolve();
|
|
expect(closed).toBe(false);
|
|
|
|
finish.resolve();
|
|
await operation;
|
|
await close;
|
|
expect(closed).toBe(true);
|
|
});
|
|
|
|
it("stops a close hook even when retained cleanup is still failing", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let releases = 0;
|
|
const owner = {
|
|
kind: "lease" as const,
|
|
resource: "stuck lease",
|
|
lease: {
|
|
async release() {
|
|
releases += 1;
|
|
if (releases < 3) throw new Error("still owned");
|
|
},
|
|
},
|
|
};
|
|
expect(await scope.release(owner)).toMatchObject({ kind: "failed" });
|
|
let hookRuns = 0;
|
|
scope.addCloseHook(async () => {
|
|
hookRuns += 1;
|
|
if (hookRuns === 1) throw new Error("hook still stopping");
|
|
});
|
|
|
|
const closeFailure = await scope.close().then(
|
|
() => {
|
|
throw new Error("close succeeded while cleanup and the hook failed");
|
|
},
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(closeFailure).toMatchObject({
|
|
message: "Artifact cleanup remains incomplete: stuck lease, close hook",
|
|
failedOwners: [owner],
|
|
cleanup: {
|
|
reason: "still owned; hook still stopping",
|
|
resources: ["stuck lease", "close hook"],
|
|
},
|
|
});
|
|
expect(closeFailure).toBeInstanceOf(ArtifactResourceRetryFailure);
|
|
const causes = (closeFailure as ArtifactResourceRetryFailure).cause;
|
|
expect(causes).toBeInstanceOf(AggregateError);
|
|
expect(
|
|
(causes as AggregateError).errors.map((error) =>
|
|
error instanceof Error ? error.message : String(error),
|
|
),
|
|
).toEqual([
|
|
"Artifact cleanup remains incomplete: stuck lease",
|
|
"hook still stopping",
|
|
]);
|
|
expect(releases).toBe(2);
|
|
expect(hookRuns).toBe(1);
|
|
await scope.close();
|
|
expect(releases).toBe(3);
|
|
expect(hookRuns).toBe(2);
|
|
});
|
|
|
|
it("runs later close hooks when an earlier hook fails", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
const order: string[] = [];
|
|
scope.addCloseHook(async () => {
|
|
order.push("first");
|
|
throw new Error("first hook failed");
|
|
});
|
|
scope.addCloseHook(async () => {
|
|
order.push("second");
|
|
throw new Error("second hook failed");
|
|
});
|
|
|
|
const failure = await scope.close().then(
|
|
() => {
|
|
throw new Error("close succeeded while hooks failed");
|
|
},
|
|
(cause: unknown) => cause,
|
|
);
|
|
expect(order).toEqual(["first", "second"]);
|
|
expect(failure).toBeInstanceOf(AggregateError);
|
|
expect(
|
|
(failure as AggregateError).errors.map((error) =>
|
|
error instanceof Error ? error.message : String(error),
|
|
),
|
|
).toEqual(["first hook failed", "second hook failed"]);
|
|
|
|
order.length = 0;
|
|
await expect(scope.close()).rejects.toBeInstanceOf(AggregateError);
|
|
expect(order).toEqual(["first", "second"]);
|
|
});
|
|
|
|
it("rejects a close hook's undefined reason and retries through the same scope", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
let failedHookRuns = 0;
|
|
let laterHookRuns = 0;
|
|
scope.addCloseHook(async () => {
|
|
failedHookRuns += 1;
|
|
if (denied) throw undefined;
|
|
});
|
|
scope.addCloseHook(async () => {
|
|
laterHookRuns += 1;
|
|
});
|
|
|
|
try {
|
|
const close = scope.close();
|
|
expect(scope.close()).toBe(close);
|
|
await expect(close).rejects.toBeUndefined();
|
|
expect(failedHookRuns).toBe(1);
|
|
expect(laterHookRuns).toBe(1);
|
|
|
|
denied = false;
|
|
await scope.close();
|
|
expect(failedHookRuns).toBe(2);
|
|
expect(laterHookRuns).toBe(2);
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it.each([
|
|
{ name: "null", reason: null },
|
|
{ name: "false", reason: false },
|
|
{ name: "zero", reason: 0 },
|
|
{ name: "empty string", reason: "" },
|
|
{ name: "Error", reason: new Error("single hook failure") },
|
|
])("preserves a close hook's exact $name rejection", async ({ reason }) => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
scope.addCloseHook(async () => {
|
|
if (denied) throw reason;
|
|
});
|
|
try {
|
|
await expect(scope.close()).rejects.toBe(reason);
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it("preserves undefined alongside other close hook failures", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
const failure = new Error("third hook failed");
|
|
const reasons = [undefined, null, failure];
|
|
let denied = true;
|
|
const attempted: unknown[] = [];
|
|
for (const reason of reasons)
|
|
scope.addCloseHook(async () => {
|
|
attempted.push(reason);
|
|
if (denied) throw reason;
|
|
});
|
|
|
|
try {
|
|
const outcome = await scope.close().then(
|
|
() => ok(undefined),
|
|
(error: unknown) => err(error),
|
|
);
|
|
expect(outcome.ok).toBe(false);
|
|
if (outcome.ok || !(outcome.error instanceof AggregateError))
|
|
throw new Error("Expected all hook failures");
|
|
expect(outcome.error.errors).toEqual(reasons);
|
|
expect(outcome.error.errors[2]).toBe(failure);
|
|
expect(attempted).toEqual(reasons);
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it("retains both a failed owner and an undefined hook failure until each recovers", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
const ownerFailure = new Error("lease still owned");
|
|
let ownerDenied = true;
|
|
let hookDenied = true;
|
|
let releases = 0;
|
|
let hookRuns = 0;
|
|
const owner = {
|
|
kind: "lease" as const,
|
|
resource: "retained lease",
|
|
lease: {
|
|
async release() {
|
|
releases += 1;
|
|
if (ownerDenied) throw ownerFailure;
|
|
},
|
|
},
|
|
};
|
|
scope.addCloseHook(async () => {
|
|
hookRuns += 1;
|
|
if (hookDenied) throw undefined;
|
|
});
|
|
|
|
try {
|
|
const released = await scope.release(owner);
|
|
expect(released).toMatchObject({ kind: "failed", cause: ownerFailure });
|
|
const outcome = await scope.close().then(
|
|
() => ok(undefined),
|
|
(error: unknown) => err(error),
|
|
);
|
|
expect(outcome.ok).toBe(false);
|
|
if (outcome.ok || !(outcome.error instanceof ArtifactResourceRetryFailure))
|
|
throw new Error("Expected both retained cleanup failures");
|
|
expect(outcome.error.failedOwners).toEqual([owner]);
|
|
expect(outcome.error.failedOwners[0]).toBe(owner);
|
|
expect(outcome.error.cleanup).toEqual({
|
|
reason: "lease still owned; undefined",
|
|
resources: ["retained lease", "close hook"],
|
|
});
|
|
const combined = outcome.error.cause;
|
|
expect(combined).toBeInstanceOf(AggregateError);
|
|
if (!(combined instanceof AggregateError))
|
|
throw new Error("Expected retained cleanup and hook causes");
|
|
expect(combined.errors).toHaveLength(2);
|
|
expect(combined.errors[1]).toBeUndefined();
|
|
expect(combined.errors[0]).toMatchObject({
|
|
failedOwners: [owner],
|
|
cause: { errors: [ownerFailure] },
|
|
});
|
|
expect(scope.hasPending).toBe(true);
|
|
expect(releases).toBe(2);
|
|
expect(hookRuns).toBe(1);
|
|
|
|
ownerDenied = false;
|
|
await expect(scope.close()).rejects.toBeUndefined();
|
|
expect(scope.hasPending).toBe(false);
|
|
expect(scope.cleanupResources).toEqual([]);
|
|
expect(releases).toBe(3);
|
|
expect(hookRuns).toBe(2);
|
|
|
|
hookDenied = false;
|
|
await scope.close();
|
|
expect(releases).toBe(3);
|
|
expect(hookRuns).toBe(3);
|
|
} finally {
|
|
ownerDenied = false;
|
|
hookDenied = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it("retains the same failed reader owner in a retry failure and retries before admitting work", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let closeAttempts = 0;
|
|
const reader = {
|
|
async close() {
|
|
closeAttempts += 1;
|
|
if (closeAttempts < 4) throw new Error(`close attempt ${closeAttempts}`);
|
|
},
|
|
} as unknown as ArtifactReader;
|
|
const owner = { kind: "reader" as const, resource: "fixture reader", reader };
|
|
|
|
expect(await scope.release(owner)).toMatchObject({ kind: "failed" });
|
|
expect(closeAttempts).toBe(1);
|
|
|
|
await expect(scope.run(async () => "must not run")).rejects.toMatchObject({
|
|
reason: "unavailable",
|
|
message: "Artifact cleanup remains incomplete: fixture reader",
|
|
failedOwners: [owner],
|
|
});
|
|
expect(closeAttempts).toBe(2);
|
|
await expect(scope.close()).rejects.toMatchObject({
|
|
reason: "unavailable",
|
|
});
|
|
expect(closeAttempts).toBe(3);
|
|
await scope.close();
|
|
expect(closeAttempts).toBe(4);
|
|
});
|
|
|
|
it("reports only owners whose cleanup failed during a mixed retry", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let firstAttempts = 0;
|
|
let secondAttempts = 0;
|
|
const first = {
|
|
kind: "lease" as const,
|
|
resource: "first lease",
|
|
lease: {
|
|
async release() {
|
|
firstAttempts += 1;
|
|
if (firstAttempts === 1) throw new Error("first initial close");
|
|
},
|
|
},
|
|
};
|
|
const second = {
|
|
kind: "lease" as const,
|
|
resource: "second lease",
|
|
lease: {
|
|
async release() {
|
|
secondAttempts += 1;
|
|
if (secondAttempts < 3) throw new Error("second close still denied");
|
|
},
|
|
},
|
|
};
|
|
expect(await scope.release(first)).toMatchObject({ kind: "failed" });
|
|
expect(await scope.release(second)).toMatchObject({ kind: "failed" });
|
|
expect(scope.cleanupResources).toEqual(["first lease", "second lease"]);
|
|
|
|
await expect(scope.retryCleanup()).rejects.toMatchObject({
|
|
failedOwners: [second],
|
|
cleanup: { resources: ["second lease"] },
|
|
});
|
|
expect(firstAttempts).toBe(2);
|
|
expect(secondAttempts).toBe(2);
|
|
expect(scope.cleanupResources).toEqual(["second lease"]);
|
|
await scope.close();
|
|
expect(firstAttempts).toBe(2);
|
|
expect(secondAttempts).toBe(3);
|
|
expect(scope.cleanupResources).toEqual([]);
|
|
});
|
|
|
|
it("retains a failed source analyzer until shutdown can verify its release", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let releaseAllowed = false;
|
|
const failure = new AnalysisOutputError(
|
|
"analyze_javascript_application",
|
|
"Owned worker is still running",
|
|
);
|
|
const owner = {
|
|
kind: "javascript-source-analysis" as const,
|
|
resource: "fixture source analyzer",
|
|
analysis: {
|
|
async analyze() {
|
|
return err({
|
|
error: failure,
|
|
javascript: null,
|
|
module: null,
|
|
projection: null,
|
|
});
|
|
},
|
|
async close() {
|
|
if (!releaseAllowed) throw failure;
|
|
},
|
|
},
|
|
};
|
|
expect(await scope.release(owner)).toMatchObject({
|
|
kind: "failed",
|
|
cause: failure,
|
|
owner,
|
|
});
|
|
let admitted = false;
|
|
await expect(
|
|
scope.run(async () => {
|
|
admitted = true;
|
|
}),
|
|
).rejects.toMatchObject({
|
|
cleanup: { resources: ["fixture source analyzer"] },
|
|
});
|
|
expect(admitted).toBe(false);
|
|
await expect(scope.close()).rejects.toMatchObject({
|
|
cleanup: { resources: ["fixture source analyzer"] },
|
|
});
|
|
releaseAllowed = true;
|
|
await scope.close();
|
|
});
|
|
|
|
it("retains a canonical retry lease for a plain cleanup capability", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
let closes = 0;
|
|
const owner = {
|
|
kind: "lease",
|
|
resource: "plain cleanup owner",
|
|
lease: {
|
|
release: async () => {
|
|
closes++;
|
|
if (denied) throw new Error("close denied");
|
|
},
|
|
},
|
|
} as const;
|
|
try {
|
|
expect(await scope.release(owner)).toMatchObject({ kind: "failed" });
|
|
const retry: unknown = await scope
|
|
.retryCleanup()
|
|
.catch((cause: unknown) => cause);
|
|
if (!(retry instanceof ArtifactResourceRetryFailure))
|
|
throw new Error("Expected exact failed owners");
|
|
expect(retry.cleanupLeases).toHaveLength(1);
|
|
const failure = new ProviderCleanupError("fixture", [owner.resource], {
|
|
reason: "close denied",
|
|
});
|
|
bindArtifactFileCleanup(retry, failure);
|
|
expect(failure.cleanupIncomplete).toBe(true);
|
|
denied = false;
|
|
await scope.close();
|
|
expect(failure.cleanupIncomplete).toBe(false);
|
|
expect(failure.cleanupResources).toEqual([]);
|
|
expect(closes).toBe(3);
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it("binds initial mixed cleanup to only its unresolved owners", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denyFirst = true,
|
|
denySecond = true;
|
|
const first = {
|
|
kind: "lease" as const,
|
|
resource: "first",
|
|
lease: {
|
|
async release() {
|
|
if (denyFirst) throw new Error("first denied");
|
|
},
|
|
},
|
|
};
|
|
const second = {
|
|
kind: "lease" as const,
|
|
resource: "second",
|
|
lease: {
|
|
async release() {
|
|
if (denySecond) throw new Error("second denied");
|
|
},
|
|
},
|
|
};
|
|
try {
|
|
const a = await scope.release(first),
|
|
b = await scope.release(second);
|
|
if (a.kind !== "failed" || b.kind !== "failed")
|
|
throw new Error("Expected owned cleanup failures");
|
|
const initial = scope.cleanupFailure({ kind: "completed" }, [a, b]);
|
|
expect(initial.cleanupLeases).toEqual([a.lease, b.lease]);
|
|
const error = translateArtifactFailure("inventory_artifact", initial);
|
|
denyFirst = false;
|
|
const retry = await scope.retryCleanup().catch((cause: unknown) => cause);
|
|
expect(retry).toBeInstanceOf(ArtifactResourceRetryFailure);
|
|
if (!(retry instanceof ArtifactResourceRetryFailure))
|
|
throw new Error("Expected failed second owner");
|
|
expect(retry.cleanupLeases).toEqual([b.lease]);
|
|
expect(error.cleanupIncomplete).toBe(true);
|
|
expect(error.cleanupResources).toEqual(["second"]);
|
|
denySecond = false;
|
|
await scope.retryCleanup();
|
|
expect(error.cleanupIncomplete).toBe(false);
|
|
expect(error.cleanupResources).toEqual([]);
|
|
} finally {
|
|
denyFirst = false;
|
|
denySecond = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it.each(["owned-close", "independent-primary"] as const)(
|
|
"keeps the scope of unknown cleanup explicit: %s",
|
|
async (kind) => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
const unknown = new ArtifactReaderFailure("io", "unknown cleanup", {
|
|
cleanup: { resources: ["unverified"], reason: "no capability" },
|
|
});
|
|
const owner = {
|
|
kind: "lease" as const,
|
|
resource: "known owner",
|
|
lease: {
|
|
async release() {
|
|
if (denied) throw unknown;
|
|
},
|
|
},
|
|
};
|
|
try {
|
|
const attempt = await scope.release(owner);
|
|
if (attempt.kind !== "failed") throw new Error("Expected owned failure");
|
|
const outcome =
|
|
kind === "owned-close"
|
|
? { kind: "completed" as const }
|
|
: { kind: "failed" as const, cause: unknown };
|
|
const initial = scope.cleanupFailure(outcome, [attempt]);
|
|
const error = translateArtifactFailure("inventory_artifact", initial);
|
|
expect(error.cleanupIncomplete).toBe(true);
|
|
denied = false;
|
|
await scope.close();
|
|
expect(attempt.lease.released).toBe(true);
|
|
expect(error.cleanupIncomplete).toBe(kind === "independent-primary");
|
|
expect(initial.cleanupLeases === undefined).toBe(
|
|
kind === "independent-primary",
|
|
);
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([undefined, null, { reason: "opaque reason" }])(
|
|
"retains cancellation provenance through initial cleanup and recovery: %j",
|
|
async (reason) => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
const owner = {
|
|
kind: "lease" as const,
|
|
resource: "cancelled reader",
|
|
lease: {
|
|
async release() {
|
|
if (denied) throw new Error("denied");
|
|
},
|
|
},
|
|
};
|
|
try {
|
|
const attempt = await scope.release(owner);
|
|
if (attempt.kind !== "failed") throw new Error("Expected owned failure");
|
|
const primary = new ArtifactReaderFailure(
|
|
"cancelled",
|
|
"primary cancelled",
|
|
{ cancellation: { reason } },
|
|
);
|
|
const initial = scope.cleanupFailure({ kind: "failed", cause: primary }, [
|
|
attempt,
|
|
]);
|
|
expect(initial.reason).toBe("cancelled");
|
|
expect(initial.cancellation?.reason).toBe(reason);
|
|
const error = translateArtifactFailure("inventory_artifact", initial);
|
|
expect(error.cause).toBe(reason);
|
|
denied = false;
|
|
await scope.close();
|
|
expect(error.cleanupIncomplete).toBe(false);
|
|
expect(error.cause).toBe(reason);
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
it("does not clear independent domain cleanup when a new scope owner releases", async () => {
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
const primary = new ProviderCleanupError("independent", ["other resource"], {
|
|
reason: "unknown authority",
|
|
});
|
|
const owner = {
|
|
kind: "lease" as const,
|
|
resource: "new owner",
|
|
lease: {
|
|
async release() {
|
|
if (denied) throw new Error("denied");
|
|
},
|
|
},
|
|
};
|
|
try {
|
|
const attempt = await scope.release(owner);
|
|
if (attempt.kind !== "failed") throw new Error("Expected owned failure");
|
|
const initial = scope.cleanupFailure({ kind: "failed", cause: primary }, [
|
|
attempt,
|
|
]);
|
|
const error = translateArtifactFailure("inventory_artifact", initial);
|
|
denied = false;
|
|
await scope.close();
|
|
expect(attempt.lease.released).toBe(true);
|
|
expect(primary.cleanupIncomplete).toBe(true);
|
|
expect(error.cleanupIncomplete).toBe(true);
|
|
expect(initial.cleanupLeases).toBeUndefined();
|
|
expect(initial.cleanup?.resources).toContain("other resource");
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
}
|
|
});
|
|
|
|
it.each(["completed", "failed"] as const)(
|
|
"preserves physical file ownership separately from a typed close rejection after %s work",
|
|
async (outcome) => {
|
|
const directory = await createTestTempDirectory(
|
|
"rea-scope-file-authority-",
|
|
);
|
|
const path = join(directory, "payload");
|
|
await writeFile(path, "selected bytes");
|
|
const file = await open(path, "r");
|
|
const close = file.close.bind(file);
|
|
const scope = new ArtifactResourceScope();
|
|
let denied = true;
|
|
const primary = new ProviderCleanupError(
|
|
"independent",
|
|
["independent resource"],
|
|
{ reason: "unverified primary" },
|
|
);
|
|
const closeCause = new ProviderCleanupError("file-close", [path], {
|
|
reason: "close denied",
|
|
});
|
|
file.close = async () => {
|
|
if (denied) throw closeCause;
|
|
await close();
|
|
};
|
|
try {
|
|
const failure = await withArtifactFileHandle(
|
|
path,
|
|
file,
|
|
scope,
|
|
undefined,
|
|
async () => {
|
|
if (outcome === "failed") throw primary;
|
|
return 42;
|
|
},
|
|
).catch((cause: unknown) => cause);
|
|
if (!(failure instanceof ArtifactReaderFailure))
|
|
throw new Error("Expected physical file failure");
|
|
const error = translateArtifactFailure("inventory_artifact", failure);
|
|
expect(error.cleanupIncomplete).toBe(true);
|
|
denied = false;
|
|
await scope.close();
|
|
expect(file.fd).toBe(-1);
|
|
expect(error.cleanupIncomplete).toBe(outcome === "failed");
|
|
expect(failure.cleanupLeases === undefined).toBe(outcome === "failed");
|
|
} finally {
|
|
denied = false;
|
|
await scope.close();
|
|
await close();
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each(["artifact", "domain"] as const)(
|
|
"keeps initial %s composite labels current when a later close retains only one child",
|
|
async (kind) => {
|
|
const scope = new ArtifactResourceScope();
|
|
let children = ["first child", "second child"];
|
|
const owner = {
|
|
kind: "lease" as const,
|
|
resource: "composite owner",
|
|
lease: {
|
|
async release() {
|
|
if (children.length > 0) {
|
|
if (kind === "domain")
|
|
throw new ProviderCleanupError("composite", [...children], {
|
|
reason: "held children",
|
|
});
|
|
throw new ArtifactReaderFailure("io", "child close denied", {
|
|
cleanup: { reason: "held children", resources: [...children] },
|
|
});
|
|
}
|
|
},
|
|
},
|
|
};
|
|
try {
|
|
const attempt = await scope.release(owner);
|
|
if (attempt.kind !== "failed")
|
|
throw new Error("Expected retained children");
|
|
const error = translateArtifactFailure(
|
|
"inventory_artifact",
|
|
scope.cleanupFailure({ kind: "completed" }, [attempt]),
|
|
);
|
|
expect(error.cleanupResources).toEqual(children);
|
|
children = ["second child"];
|
|
await expect(scope.retryCleanup()).rejects.toMatchObject({
|
|
cleanupLeases: [attempt.lease],
|
|
});
|
|
expect(error.cleanupIncomplete).toBe(true);
|
|
expect(error.cleanupResources).toEqual(children);
|
|
expect(scope.cleanupResources).toEqual(children);
|
|
children = [];
|
|
await scope.close();
|
|
expect(error.cleanupIncomplete).toBe(false);
|
|
expect(error.cleanupResources).toEqual([]);
|
|
} finally {
|
|
children = [];
|
|
await scope.close();
|
|
}
|
|
},
|
|
);
|