Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(process): preserve cancellation through liveness rechecks

morluto39275420ea18
diff --git a/src/process/ProcessOwnership.observation.test.ts b/src/process/ProcessOwnership.observation.test.ts
index 58085eb21..c105e7cd7 100644
--- a/src/process/ProcessOwnership.observation.test.ts
+++ b/src/process/ProcessOwnership.observation.test.ts
@@ -136,6 +136,116 @@ describe("multi-group ownership observation", () => {
});
});
+describe("multi-group ownership observation cancellation", () => {
+ it("cancels an unavailable-token liveness recheck before the host releases it", async () => {
+ const controller = new AbortController();
+ const reason = new Error("cancel process liveness recheck");
+ const rows = [processes[0]!];
+ let listCalls = 0;
+ let releaseSecondList: (() => void) | undefined;
+ let signalAtSecondList: AbortSignal | undefined;
+ let announceSecondList: (() => void) | undefined;
+ const secondListStarted = new Promise<void>((resolve) => {
+ announceSecondList = resolve;
+ });
+ const listProcesses = vi.fn<ProcessOwnershipHost["listProcesses"]>(
+ (signal) => {
+ listCalls += 1;
+ if (listCalls === 1) return Promise.resolve(rows);
+ signalAtSecondList = signal;
+ announceSecondList?.();
+ return new Promise((resolve, reject) => {
+ releaseSecondList = () => resolve(rows);
+ if (signal === undefined) return;
+ const rejectOnAbort = () => reject(signal.reason);
+ signal.addEventListener("abort", rejectOnAbort, { once: true });
+ if (signal.aborted) rejectOnAbort();
+ });
+ },
+ );
+ const signalGroup = vi.fn();
+ const observed = observeOwnedProcessGroups(
+ ownership.runId,
+ [ownership.processGroupId],
+ {
+ listProcesses,
+ environment: vi.fn(() => Promise.resolve({})),
+ runTokens: vi.fn(() =>
+ Promise.resolve(
+ new Map([
+ [
+ ownership.leaderPid,
+ { state: "unavailable" as const, reason: "token unavailable" },
+ ],
+ ]),
+ ),
+ ),
+ signalGroup,
+ },
+ controller.signal,
+ ).then(
+ (value) => ({ kind: "resolved" as const, value }),
+ (cause: unknown) => ({ kind: "rejected" as const, cause }),
+ );
+ let settled = false;
+ const observedOutcome = observed.then((outcome) => {
+ settled = true;
+ return outcome;
+ });
+ let settledBeforeRelease = false;
+ try {
+ await secondListStarted;
+ controller.abort(reason);
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ settledBeforeRelease = settled;
+ } finally {
+ releaseSecondList?.();
+ }
+
+ const outcome = await observedOutcome;
+ expect(settledBeforeRelease).toBe(true);
+ expect(signalAtSecondList).toBe(controller.signal);
+ expect(outcome.kind).toBe("rejected");
+ if (outcome.kind !== "rejected")
+ throw new Error(
+ "The cancelled process observation unexpectedly resolved",
+ );
+ expect(outcome.cause).toBe(reason);
+ expect(signalGroup).not.toHaveBeenCalled();
+ expect(listProcesses).toHaveBeenCalledTimes(2);
+ });
+
+ it("preserves cancellation when a liveness recheck returns successfully after abort", async () => {
+ const controller = new AbortController();
+ const reason = new Error("cancel at liveness completion");
+ const listProcesses = vi
+ .fn<ProcessOwnershipHost["listProcesses"]>()
+ .mockResolvedValueOnce(processes)
+ .mockImplementation(async (signal) => {
+ expect(signal).toBe(controller.signal);
+ controller.abort(reason);
+ return [];
+ });
+ const signalGroup = vi.fn();
+ await expect(
+ observeOwnedProcessGroups(
+ ownership.runId,
+ [ownership.processGroupId],
+ {
+ listProcesses,
+ environment: async () => {
+ throw new Error("token unavailable");
+ },
+ signalGroup,
+ },
+ controller.signal,
+ ),
+ ).rejects.toBe(reason);
+ expect(listProcesses).toHaveBeenCalledTimes(2);
+ expect(signalGroup).not.toHaveBeenCalled();
+ });
+});
+
describe("multi-group observation short-circuit", () => {
it("stops missing-row fallbacks once every live group is unverifiable", async () => {
const listProcesses = vi.fn(() => Promise.resolve(processes));
diff --git a/src/process/ProcessOwnershipObservation.ts b/src/process/ProcessOwnershipObservation.ts
index 4a5ec39cc..b2db045e2 100644
--- a/src/process/ProcessOwnershipObservation.ts
+++ b/src/process/ProcessOwnershipObservation.ts
@@ -77,7 +77,7 @@ export const observeOwnedProcessGroups = async (
pendingGroups.delete(member.processGroupId);
}
} else {
- const gone = await processIsGone(host, member.pid);
+ const gone = await processIsGone(host, member.pid, signal);
signal?.throwIfAborted();
if (!gone) {
observations.set(member.processGroupId, {
@@ -564,13 +564,17 @@ export const prepareProcessOwnershipInspection = async (
const processIsGone = async (
host: ProcessOwnershipHost,
pid: number,
+ signal?: AbortSignal,
): Promise<boolean> => {
try {
- return !liveProcesses(await host.listProcesses()).some(
- (process) => process.pid === pid,
- );
+ const processes =
+ signal === undefined
+ ? await host.listProcesses()
+ : await host.listProcesses(signal);
+ return !liveProcesses(processes).some((process) => process.pid === pid);
} catch (cause: unknown) {
- // best-effort cleanup: optional liveness probing; failure means not gone.
+ signal?.throwIfAborted();
+ // A failed optional probe cannot establish that the process exited.
void cause;
return false;
}