Files
reverse-engineering-anything/src/desktop/BuildComputerLongRuns.ts
T
morluto 793ab582be refactor(desktop): give the agentenv provider name an entry file and name the build computer's controlled routes as a port (#11600)
* refactor(desktop): give the agentenv provider name its own entry file and move ComputerRelease into src/domain

* refactor(desktop): name the build computer's controlled routes and controller answer as a port (#11604)
2026-11-16 08:51:27 +08:00

335 lines
11 KiB
TypeScript

import { randomUUID } from "node:crypto";
import { AnalysisError } from "../domain/analysisErrorBase.js";
import {
AnalysisCancelledError,
cancelledBy,
} from "../domain/analysisErrorCore.js";
import type { JsonValue } from "../domain/jsonValue.js";
import { ProviderAdapterError } from "../domain/providerAdapterError.js";
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
import { AGENTENV_PROVIDER } from "./AgentEnvProviderIdentity.js";
import type { ComputerRelease } from "../domain/desktop/computerRelease.js";
import { answerSchema, runBuildController } from "./BuildComputerController.js";
import type {
BuildControllerAnswer,
ControlledComputer,
} from "../ports/BuildComputerControl.js";
import { errorMessage } from "../kernel/errorMessage.js";
const OPERATION = "export_build_environment";
const POLL_S = 30;
const CANCEL_S = 10;
interface Job {
readonly path: string;
readonly token: string;
readonly stdout: string;
/** Failures naming this job, kept to retain its completion receipt. */
readonly failures: Set<WeakRef<ProviderCleanupError>>;
}
/** Owns REA commands that need longer than one computer-exec call permits. */
export class BuildComputerLongRuns {
readonly #jobs = new Set<Job>();
constructor(private readonly computer: ControlledComputer) {}
get cleanupResources(): readonly string[] {
return [...this.#jobs].map(({ path }) => path);
}
async run(
argv: readonly string[],
options: {
readonly work: string;
readonly stdout: string;
readonly files?: Readonly<Record<string, string>>;
readonly timeoutS: number;
readonly signal: AbortSignal;
},
): Promise<{
readonly stdoutBytes: number;
readonly exitCode: number | null;
readonly stderr: string;
}> {
const { signal } = options;
if (signal.aborted) throw cancelledBy(OPERATION, signal);
const previous = await this.release();
if (!previous.verified)
throw this.#cleanupFailure(
previous.reason,
signal.aborted ? cancelledBy(OPERATION, signal) : undefined,
);
if (signal.aborted) throw cancelledBy(OPERATION, signal);
const token = randomUUID();
const job: Job = {
path: `${options.work}/jobs/${token}`,
token,
stdout: options.stdout,
failures: new Set(),
};
this.#jobs.add(job);
const deadline = performance.now() + options.timeoutS * 1000;
let observedCommand: JsonValue | undefined;
try {
const started = answerSchema.parse(
await runBuildController(
this.computer,
"run-begin",
{
job: job.path,
token,
work: options.work,
stdout: options.stdout,
files: { ...options.files },
argv: [...argv],
timeout_s: options.timeoutS,
},
{ timeoutS: POLL_S, signal },
),
);
if (typeof started.refused === "string") {
this.#jobs.delete(job);
throw new Error(started.refused);
}
if (started.started !== true)
throw new Error(
typeof started.error === "string"
? started.error
: "The REA command did not start.",
);
for (;;) {
if (performance.now() >= deadline)
throw new Error(
"The REA command exceeded its time budget and is still stopping.",
);
const answer = answerSchema.parse(
await runBuildController(
this.computer,
"run-poll",
{
job: job.path,
token,
timeout_s: POLL_S,
},
{ timeoutS: POLL_S, signal },
),
);
if (answer.pending === true && answer.timed_out === true)
throw new Error(
"The REA command exceeded its time budget and is still stopping.",
);
if (answer.pending === true) continue;
if (answer.finished !== true)
throw new Error(
typeof answer.error === "string"
? answer.error
: "The REA command did not report its outcome.",
);
if (answer.settled === false) {
observedCommand = this.#receipt(job, answer);
throw new Error(
typeof answer.error === "string"
? answer.error
: "The REA command did not confirm that its process had exited.",
);
}
this.#jobs.delete(job);
if (answer.timed_out === true || typeof answer.error === "string") {
const failure = new ProviderAdapterError(
AGENTENV_PROVIDER,
OPERATION,
{
userMessage:
answer.error ?? "The REA command exceeded its time budget.",
},
);
throw failure.retainDiagnostics({
completed_command: this.#receipt(job, answer),
});
}
if (
typeof answer.exit_code !== "number" ||
typeof answer.stdout_bytes !== "number"
)
throw new Error(
"The REA command did not report its output and exit status.",
);
return {
stdoutBytes: answer.stdout_bytes,
exitCode: answer.exit_code,
stderr: typeof answer.stderr === "string" ? answer.stderr : "",
};
}
} catch (cause: unknown) {
let primary = signal.aborted
? cancelledBy(OPERATION, signal)
: cause instanceof AnalysisError
? cause
: new ProviderAdapterError(AGENTENV_PROVIDER, OPERATION, {
userMessage: errorMessage(cause),
cause,
});
if (signal.aborted && cause instanceof AnalysisError && cause !== primary)
primary.retainSecondaryFailure(cause);
if (observedCommand !== undefined)
primary.retainDiagnostics({ completed_command: observedCommand });
if (!this.#jobs.has(job)) throw primary;
const released = await this.#cancel(job);
const completed = released.completed ?? observedCommand;
if (signal.aborted && !(primary instanceof AnalysisCancelledError)) {
const cancelled = cancelledBy(OPERATION, signal);
cancelled.retainSecondaryFailure(primary);
primary = cancelled;
}
if (released.verified) {
if (completed !== undefined)
primary.retainDiagnostics({ completed_command: completed });
throw primary;
}
const failure = this.#cleanupFailure(released.reason, primary, job);
if (completed !== undefined)
failure.retainDiagnostics({ completed_command: completed });
throw failure;
}
}
/** Stop each command and retain any job whose completion cannot be confirmed. */
async release(): Promise<ComputerRelease> {
const failures: string[] = [];
for (const job of this.#jobs) {
const result = await this.#cancel(job);
if (!result.verified) failures.push(result.reason);
}
return failures.length === 0
? { verified: true, teardown: "agentenv" }
: {
verified: false,
reason: failures.join("; "),
resources: this.cleanupResources,
};
}
/** Clear retained jobs after a verified computer teardown removed their processes. */
resolveAfterVerifiedComputerTeardown(): void {
// Each retained failure's release claim reads job membership, so leaving
// the set is what records the verified stop.
this.#jobs.clear();
}
async #cancel(job: Job): Promise<
| { readonly verified: true; readonly completed?: JsonValue }
| {
readonly verified: false;
readonly reason: string;
readonly completed?: JsonValue;
}
> {
try {
const answer = answerSchema.parse(
await runBuildController(
this.computer,
"run-cancel",
{
job: job.path,
token: job.token,
timeout_s: CANCEL_S,
},
{ timeoutS: CANCEL_S },
),
);
if (answer.finished === true && answer.settled === false) {
const completed = this.#receipt(job, answer);
for (const reference of job.failures)
reference
.deref()
?.retainDiagnostics({ completed_command: completed });
return {
verified: false,
reason:
typeof answer.error === "string"
? answer.error
: "The REA command did not confirm that its process had exited.",
completed,
};
}
if (answer.absent !== true && answer.finished !== true)
return {
verified: false,
reason:
typeof answer.error === "string"
? answer.error
: `The remote REA command has not confirmed that it stopped.${answer.progress === undefined ? "" : ` Supervisor output: ${answer.progress}`}`,
};
const completed =
answer.finished === true ? this.#receipt(job, answer) : undefined;
this.#jobs.delete(job);
for (const reference of job.failures) {
const failure = reference.deref();
if (completed !== undefined)
failure?.retainDiagnostics({ completed_command: completed });
}
return {
verified: true,
...(completed === undefined ? {} : { completed }),
};
} catch (cause: unknown) {
return {
verified: false,
reason: errorMessage(cause),
};
}
}
#receipt(job: Job, answer: BuildControllerAnswer): JsonValue {
return {
stdout: job.stdout,
...(typeof answer.stdout_bytes === "number"
? { stdout_bytes: answer.stdout_bytes }
: {}),
...(answer.exit_code === undefined
? {}
: { exit_code: answer.exit_code }),
...(typeof answer.stderr === "string" ? { stderr: answer.stderr } : {}),
...(typeof answer.error === "string" ? { error: answer.error } : {}),
...(answer.timed_out === undefined
? {}
: { timed_out: answer.timed_out }),
...(answer.cancelled === undefined
? {}
: { cancelled: answer.cancelled }),
...(answer.settled === undefined ? {} : { settled: answer.settled }),
};
}
#cleanupFailure(
reason: string,
primary?: AnalysisError,
job?: Job,
): ProviderCleanupError {
const failure = new ProviderCleanupError(
AGENTENV_PROVIDER,
this.cleanupResources,
{ reason },
{
operation: OPERATION,
...(primary === undefined ? {} : { cleanupPrimary: primary }),
remediationAction:
"Retry the export or close the build computer to retry stopping the owned command.",
},
);
failure.bindCleanupResourceOwner(this);
const jobs = job === undefined ? [...this.#jobs] : [job];
for (const pending of jobs) pending.failures.add(new WeakRef(failure));
// Released once every job it names has confirmed its stop. Jobs leave
// only after that, and never return, so the release cannot reopen.
const owned = this.#jobs;
return failure.bindCleanupReleaseClaim({
get cleanupReleased() {
return jobs.every((pending) => !owned.has(pending));
},
});
}
}