mirror of
https://github.com/morluto/rea.git
synced 2026-11-19 21:23:45 +00:00
* fix(desktop): release a capture when its start is cancelled after launch Cancelling start_build_capture during the opened app's screenshot left the capture running, so the next start was refused. The capture is now kept for the owner's cleanup, and the next start stops it first. * fix(desktop): keep a published witness error and tag an app data refusal A second failure to close a published witness returns the original error, so its record and cleanup lease stay bound. A reset the app itself refuses is an AppDataRefusal; only a reply that is not that refusal stays unsettled. A missing child of a cut view is undecided with the same description in both evaluators, and the shared cases cover it. * fix(desktop): align a cut view's missing text with the Python check A missing child of a truncated view is undecided for the same sentence in both evaluators, including the pointer the view does not contain. * fix(desktop): keep one published witness cleanup across retries A published record and its bound cleanup error stay together. A later close failure returns that error, and the unused path that built a fresh adapter error is gone. * fix(desktop): keep a bundle task read inside the witness result A cancelled, refused, or failed read of the bundle's task files returns the witness's Result, including a cleanup lease when a handle would not close. * test(desktop): pass the settle timing when reading a witness bundle The witness takes the settle timing before the bundle path, so the bundle-read tests keep the path in its own argument. * fix(desktop): bound a guest file answer and split a long controller argument A data/get whose base64 answer would exceed a quarter of the V8 heap is refused before it is read. Controller JSON that exceeds Linux's single-argument limit travels as several arguments the controller joins. * fix(desktop): keep an underreported guest file from raising its read A data/get answer is admitted only when its base64 body fits in the heap quarter after the copies held during parse. Decoded bytes larger than the computer reported are dropped. * fix(desktop): grade shipped seeds and keep selected settings and sqlite logs Seed checks follow the files the bundle ships, so an omitted lock is absent. An incomplete checkpoint is not reported as no change. A selected link keeps its spelling, and a database's wal and journal stay supporting state. Closing the fake computer stops a detached capture. * fix(desktop): keep added-record checks off ids, dates, and joined timestamps A position-named record's fields keep their paths, so an identifier, a stamped date, and text past the limit are not suggested checks. A whole-text check does not climb into an ancestor whose text joins a timestamp. * fix(desktop): bound home fetches and keep unsettled edits readable Split home-folder reads by the guest answer budget, keep a capacity error from the capture output, and drop the superseded task-argument refusal. Grade kept text per line, leave unretained dconf unread, and reserve by-position notes for XML children. Map a linked database's sidecars through the selected spelling and stop a detached capture only when its start identity still owns the pid. * fix(desktop): describe unretained dconf as unread The key comparison treats a missing copy as unknown. The comment still said that copy counted as an empty key list. * test(desktop): keep a capture capacity error through endedCapture An output past the guest answer ceiling stays the resource constraint, with its heap recovery and non-retryable status, instead of a generic capture-exit message. * fix(desktop): keep nested save times and formatting runs out of checks A field check drops save-time leaves before it joins the field, so a nested timestamp is not part of the suggested text. A text check beside a save time uses the paragraph when the diff names a formatting run. * test(desktop): read paragraph pointers from checks that have them * test(desktop): expect a large task to export intact The 96 KiB refusal is gone. A prompt past that size reaches the computer and comes back unchanged, instead of failing before export. * fix(desktop): keep real edits that save-side heuristics were dropping Repeated unnamed fields stay content checks. A formula that still has text is not renumbered with its ExprID. One gained style attribute is the edit; a repeated fill-in stays upkeep. Phone numbers and plain clock times stay text, and a decimal is the element's whole text. An older verifier matches on the task it states, not its evaluator source. * fix(desktop): cover repeated records and keep timestamps out of checks An added record whose words are already in the seed still gets the list's text when that text fits. Readiness is a start reason, so a final check names seed locks without matching the message. Field text split by a timestamp stays separate, and a timestamp line is not offered as a guard. * fix(desktop): compare a cell's joined decimal within tolerance The whole-element check keeps numeric tolerance, so 437.80 and a long float still match 437.8, including when a run splits the digits. A different number or other text does not. Both evaluators read an element's text for that comparison. * fix(desktop): grade a number from a complete XML element only A tolerance check joins an element's text only in an XML file or an XML archive entry, and leaves that check undecided when the view is cut, so a dropped descendant cannot turn the kept runs into a passing number. A JSON object with the same shape stays the value itself. Equivalent decimals and a split run on a whole cell still match. * fix(desktop): accept an older grader only when its index helper agrees The witness still matches a bundle whose evaluator is this REA's, or the older index expression alone when no path segment is a leading-zero number. A truncated verifier, a changed grader, or that older helper beside a segment such as 01 no longer counts as the same task. * fix(desktop): require the added record and leave save times out of list checks A record a selector names is checked itself, so its words have to be in that record. When an unnamed record only repeats words the seed already has, a list that holds a save time is checked by the text around that time. A later save of the same records still passes, and a missing or rewritten record fails. * fix(desktop): judge the older index helper by pointer segments only A leading zero in a file name or a URL does not change how the older index helper reads a pointer. The witness still rejects that helper when a pointer segment is a number such as 01. * fix(desktop): do not suggest list text the seed already passes A repeated record is shown by text the seed does not hold. The seed's own text is not a check. A pointer inside a check value is not a pointer segment for the older index helper. * fix(desktop): keep a linked settings file in the folder the link points at A selected ~/.config alias no longer moves MuseScore settings to that alias. The seed keeps settings/MuseScore or Documents, which is the path the export opens the note from. * fix(desktop): split home fetches by answer size and keep a size refusal A batch of tiny files stops before each path's envelope exceeds the host answer budget. A capture output past that ceiling stays a resource error instead of becoming a generic exit. * fix(desktop): seed a selected link under the path the app uses The selected spelling wins, so ~/.config/MuseScore is not rewritten to the folder it points at and the note stays the one launched document. A database wal and journal follow that database. A launch argument is respelled the same way. Teardown signals a detached PID only when its start identity still matches. * fix(desktop): keep a witness's actions and an incomplete checkpoint A failed witness save retries the action log it first recorded. A deletion left unconfirmed between the seed and the end is not reported as no change. Windows packs npm through a shell, which can start npm.cmd. * fix(desktop): read verifier pointers from the parsed checks A brace inside a check value is not an object boundary. A leading-zero pointer after that value still rejects the older index helper. * fix(desktop): prefer the most specific home spelling and retarget launch files A selected parent directory no longer hides a settings folder walked through a link. A launch filename under that folder is replaced with the seeded file's absolute path. * fix(desktop): pack the build runtime through npm's JavaScript entry npm pack and npm ci no longer spawn npm.cmd through a shell, so a temporary directory whose path contains spaces stays one argument. * fix(desktop): spell launch settings and keep a database log exact A database log matches only that file, so a neighboring folder is not moved. A launch option and the working directory use the same home spelling as the seed. * fix(desktop): move a state database's logs with the database The write-ahead log and journal follow the spelling the database received, including a walked state link. A neighboring folder stays put. A separate --config argument uses that spelling too. * fix(desktop): keep a selected file ahead of a database-log guess A file selected as itself keeps that spelling even when its name ends in -journal. Relative launch arguments are resolved in the captured working directory before that directory moves. * fix(desktop): keep outside-home database logs and option values A selected database outside the home keeps its write-ahead log. Launch options are rewritten only when they name a captured file or settings path. * fix(desktop): follow a database mapping and own limitation text A selected database keeps its log when a parent folder moves or the file sits outside the home. Trash and seed-lock tests compare the owning notice with the paths, and launch options that are not captured paths stay as written. * fix(desktop): retarget a settings folder that holds captured files A nested profile directory is a captured path when a seeded file is inside it. An option value that only resolves under the home stays as written. * fix(desktop): keep a program word and a directory's neighbor The program after env stays the program even when a captured file sits in a folder of that name. A selected directory is not a database, so a neighboring file keeps the parent folder's spelling. * fix(desktop): record whether a selected path is a directory Capture stores the walked path's kind. A neighboring file of a selected directory keeps the parent folder's spelling even when that directory never changes and its children are not content roots. * fix(desktop): mark containing paths without a pairwise scan A recorded path marks its known ancestors as directories in one walk up the path, instead of comparing every recorded path with every other. * fix(desktop): keep a selected folder that is named like a database log A folder the caller selected stays a selected root when its name ends in -journal or -wal. A generated log beside a database file still does not. * fix(desktop): refuse a build command that exceeds the argument vector Splitting one argument still leaves the whole command under Linux's E2BIG limit. A request past that budget is refused before the process starts. * fix(desktop): remap a captured path in an env assignment The program word stays the program. A NAME=value assignment keeps its name and follows a captured path value when that path's spelling moves. * fix(desktop): keep oversized text out of draft guards A value or line longer than the draft's text bound is not copied into a guard, so one large frame cannot fill the task by itself. * fix(desktop): keep an empty env value empty An empty assignment is not a path. Resolving it named the working directory and rewrote the value when that directory's spelling moved. * fix(desktop): check build runtime export capability * fix(desktop): provide complete runtime repack command * fix(desktop): retain runtime probe failures * test(desktop): identify capture independently of schema preflight * fix(desktop): preserve document URLs and value formats * fix(desktop): bound added checks and omit noisy text guards * fix(desktop): preserve launch URLs and JSON draft values * fix(desktop): recognize captured file URL documents * fix(desktop): render captured file URLs for runtime home * fix(desktop): distinguish phone numbers from save metadata * fix(desktop): preserve launch URLs and user text * fix(desktop): preserve local file URL authority * fix(desktop): preserve local file URL authority * fix(desktop): render captured file URLs at launch * fix(desktop): classify numeric timestamps using field context * fix(desktop): classify numeric timestamps using field context * fix(desktop): retain context for generated draft values * fix(desktop): retain context for generated draft values * test(desktop): cover generated IDs in text guards * test(desktop): cover generated IDs in text guards * fix(desktop): isolate launcher URL encoding * fix(desktop): isolate launcher URL encoding * fix(desktop): isolate launcher URL encoding * fix(desktop): retain clean text in noisy record fields * style(desktop): format the noisy-record draft files with the pinned oxfmt Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(desktop): move launch execution to boundary suite * fix(desktop): redact build schema failure output * refactor(desktop): normalize schema failure once * fix(desktop): omit unsafe schema parser snippets * fix(desktop): preserve draft change and selected path evidence * test(desktop): group retained dconf note regressions * fix(desktop): respect archive entry format in draft checks * test(desktop): separate unowned-file draft note cases * docs(desktop): clarify task checks before scratch export * fix(desktop): respell selected paths in file URLs * test(desktop): group captured document spelling cases * fix(desktop): bound draft preview serialization * fix(desktop): restore selected state aliases * fix(desktop): respect entry format in draft noise * test(desktop): match exported alias evidence at its JSON boundary * style: fix desktop launch test formatting * style: format native command path schema * fix(desktop): map selected external launch paths * style(desktop): format seed document regressions * test(desktop): group launch URL regressions * fix(desktop): omit redundant nested state aliases * fix(desktop): compare added free text as a whole * fix(desktop): check recompressed seeds as shipped * fix(desktop): map captured launch paths once * refactor: remove unused whole-text guard state * refactor: stop passing unused text children * test: align free-text checks with whole-note policy * fix: validate recompressed desktop archive seeds * style(desktop): format archive seed regression * fix(desktop): redact runtime schema errors * fix(desktop): normalize captured file URLs * fix(desktop): report seeded files by capture path * fix(desktop): retain startup readiness failure stage * fix(desktop): retain JSON date checks * fix(desktop): preserve archive formatting checks * fix(desktop): preserve explicitly selected journal files * fix(desktop): report build command transport limits * style(desktop): format capture review fixes --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com> Co-authored-by: morluto <76467478+morluto@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
538 lines
17 KiB
TypeScript
538 lines
17 KiB
TypeScript
import { z } from "zod";
|
|
|
|
import { AnalysisError } from "../../domain/analysisErrorBase.js";
|
|
import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
|
|
import type { BuildRequest } from "../../domain/desktop/appBuild.js";
|
|
import { BUILD_PACKAGE_FILE } from "../../domain/desktop/appBuild.js";
|
|
import {
|
|
END_CHECKPOINT,
|
|
SEED_CHECKPOINT,
|
|
} from "../../domain/desktop/buildCapture.js";
|
|
import {
|
|
captureProgressEvent,
|
|
type DesktopCaptureEvent,
|
|
} from "../../domain/desktop/desktopCapture.js";
|
|
import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
|
|
import { err, ok, type Result } from "../../domain/result.js";
|
|
import { AGENTENV_PROVIDER } from "../../desktop/AgentEnvComputerHelper.js";
|
|
import type { ControlledComputer } from "../../desktop/BuildComputerController.js";
|
|
import {
|
|
endedCapture,
|
|
notAnswered,
|
|
type CaptureStep,
|
|
} from "./DesktopBuildCaptureFailure.js";
|
|
import {
|
|
adapterError,
|
|
controller,
|
|
errorText,
|
|
refused,
|
|
runRea,
|
|
WORK,
|
|
type Answer,
|
|
} from "./DesktopBuildCommands.js";
|
|
import {
|
|
exportBuild,
|
|
type BuildExportRequest,
|
|
type ExportedBuild,
|
|
} from "./DesktopBuildExport.js";
|
|
import {
|
|
summarizeCapture,
|
|
type StoppedCapture,
|
|
} from "./DesktopBuildSummary.js";
|
|
|
|
const START = "start_build_capture";
|
|
const MARK = "mark_build_checkpoint";
|
|
const STOP = "stop_build_capture";
|
|
const EXPORT = "export_build_environment";
|
|
/** The start's step, for a capture that ended before the app's window opened. */
|
|
const STARTING: CaptureStep = {
|
|
operation: START,
|
|
when: "before the app's window opened",
|
|
afterAppExit:
|
|
"The app does not run as installed: check what it needs, such as a runtime its stderr names, or install it from another source on a new build computer, and close this one.",
|
|
};
|
|
/** A checkpoint's step, for a capture that ended before acknowledging it. */
|
|
const marking = (name: string): CaptureStep => ({
|
|
operation: MARK,
|
|
when: `before checkpoint ${name}`,
|
|
afterAppExit:
|
|
"The capture ended with the app: stop_build_capture reads what it recorded, then start_build_capture captures again.",
|
|
});
|
|
const NOT_RUNNING = [
|
|
"No capture is running on this computer.",
|
|
"Start one with start_build_capture.",
|
|
] as const;
|
|
|
|
/** What the agent asks of a capture's launch: arguments for the app, and files or folders in the home that are its state. */
|
|
export interface CaptureInput {
|
|
readonly arguments?: readonly string[] | undefined;
|
|
readonly state_paths?: readonly string[] | undefined;
|
|
}
|
|
|
|
const exportOptionsSchema = z.object({
|
|
options: z.object({ properties: z.record(z.string(), z.unknown()) }),
|
|
});
|
|
const repackRuntime =
|
|
"Run npm run pack:build-computer-runtime -- /absolute/path/rea-prod.tar.xz in a current REA checkout, set REA_BUILD_COMPUTER_REA_ARCHIVE to that archive, restart the REA MCP server, and start a new build computer.";
|
|
const schemaCommandError = (exitCode: number | null, detail: string) =>
|
|
new ProviderAdapterError(AGENTENV_PROVIDER, START, {
|
|
userMessage: `The build computer's REA export schema command ${exitCode === null ? "ended without an exit status" : `exited ${String(exitCode)}`}: ${detail}`,
|
|
remediationAction: `Inspect the command error. If the runtime is outdated, ${repackRuntime}`,
|
|
});
|
|
|
|
/** Check the installed runtime's advertised export contract before capturing the user's work. */
|
|
const checkExportRuntime = async (
|
|
computer: ControlledComputer,
|
|
signal: AbortSignal,
|
|
): Promise<Result<void, AnalysisError>> => {
|
|
try {
|
|
const path = `${WORK}/export-schema.json`;
|
|
const command = await runRea(
|
|
computer,
|
|
["export-desktop-application", "--schema", "--json"],
|
|
{ stdout: path, timeoutS: 30, signal },
|
|
);
|
|
if (command.exitCode !== 0 && command.stderr !== "")
|
|
return err(
|
|
schemaCommandError(command.exitCode, computer.redacted(command.stderr)),
|
|
);
|
|
if (command.stdoutBytes > 1024 * 1024)
|
|
return err(
|
|
adapterError(
|
|
START,
|
|
"The build computer's REA export schema exceeds 1 MiB.",
|
|
),
|
|
);
|
|
const content = (
|
|
await computer.homeFiles([path], command.stdoutBytes, signal)
|
|
).get(path);
|
|
if (content === undefined)
|
|
return err(
|
|
adapterError(
|
|
START,
|
|
"The build computer did not return its REA export schema.",
|
|
),
|
|
);
|
|
if (command.exitCode !== 0)
|
|
return err(
|
|
schemaCommandError(
|
|
command.exitCode,
|
|
computer.redacted(content.toString("utf8")).slice(-2048),
|
|
),
|
|
);
|
|
let rawSchema: unknown;
|
|
try {
|
|
rawSchema = JSON.parse(content.toString("utf8"));
|
|
} catch {
|
|
// Parser errors can quote only a fragment of a credential, which cannot
|
|
// be removed reliably by exact-token redaction.
|
|
return err(
|
|
adapterError(
|
|
START,
|
|
"The build computer's REA export schema is invalid JSON.",
|
|
),
|
|
);
|
|
}
|
|
const schema = exportOptionsSchema.safeParse(rawSchema);
|
|
if (!schema.success)
|
|
return err(
|
|
adapterError(
|
|
START,
|
|
"The build computer's REA returned an invalid export schema.",
|
|
),
|
|
);
|
|
if (!("syntheticSeed" in schema.data.options.properties))
|
|
return err(
|
|
refused(
|
|
START,
|
|
"The REA runtime in this build computer does not support synthetic seeds required by build export.",
|
|
repackRuntime,
|
|
),
|
|
);
|
|
return ok(undefined);
|
|
} catch (cause: unknown) {
|
|
if (signal.aborted)
|
|
return err(new AnalysisCancelledError(START, { cause: signal.reason }));
|
|
const message = errorText(cause);
|
|
const redacted = computer.redacted(message);
|
|
return err(
|
|
adapterError(
|
|
START,
|
|
`Could not read the build computer's REA export schema: ${redacted}`,
|
|
redacted === message ? cause : undefined,
|
|
),
|
|
);
|
|
}
|
|
};
|
|
|
|
/** A taken checkpoint as the tool reports it: changed files null when the REA in the computer predates them. */
|
|
type CheckpointTaken = Omit<
|
|
Extract<DesktopCaptureEvent, { kind: "checkpoint" }>,
|
|
"kind" | "changed_files" | "more_changed_files"
|
|
> & {
|
|
readonly changed_files: string[] | null;
|
|
readonly more_changed_files: number | null;
|
|
};
|
|
|
|
/** The capture's progress event in a line the controller waited for. */
|
|
const eventOf = (line: string): DesktopCaptureEvent | undefined =>
|
|
captureProgressEvent(line);
|
|
|
|
/**
|
|
* One capture in the computer. `unreleased` is a capture that may be
|
|
* running although its start failed, kept until a stop is confirmed;
|
|
* `stopped` keeps the stop's result once it was read, so a retried stop
|
|
* resumes or repeats it.
|
|
*/
|
|
interface CaptureRun {
|
|
readonly folder: string;
|
|
status: "running" | "unreleased" | "stopped" | "released";
|
|
/** Checkpoints the capture acknowledged, then those its own Evidence records. */
|
|
checkpoints: Set<string>;
|
|
/** The capture's package installs only from its file, so the export takes the request's URL. */
|
|
packageFile?: boolean;
|
|
outputBytes?: number;
|
|
stopped?: StoppedCapture;
|
|
exports: number;
|
|
}
|
|
|
|
/** The capture of a failed start may still run; REA still owns it. */
|
|
const unreleasedError = (
|
|
operation: string,
|
|
run: CaptureRun,
|
|
cause: AnalysisError | undefined,
|
|
) =>
|
|
new ProviderAdapterError(AGENTENV_PROVIDER, operation, {
|
|
userMessage: `The capture REA began in ~/${run.folder} could not be confirmed stopped${cause === undefined ? "" : ` after: ${cause.message}`}.`,
|
|
remediationAction:
|
|
"Call start_build_capture again, which retries its stop first, or close the computer.",
|
|
cleanup: {
|
|
reason: "its stop was not confirmed",
|
|
resources: [`~/${run.folder}`],
|
|
},
|
|
...(cause === undefined ? {} : { cause }),
|
|
});
|
|
|
|
/**
|
|
* REA's capture of a build computer's app, run inside the computer by REA's
|
|
* controller: start it, take named checkpoints with their acknowledgements,
|
|
* stop it and draft the task between `seed` and `end`, then export the
|
|
* bundle with the agent's task and bring it back to this host. Every step
|
|
* can be asked again after a lost answer.
|
|
*/
|
|
export class DesktopBuildCapture {
|
|
#count = 0;
|
|
#run: CaptureRun | undefined;
|
|
readonly #entry: string | undefined;
|
|
readonly #packageFile: { readonly url: string } | undefined;
|
|
|
|
constructor(
|
|
private readonly computer: ControlledComputer,
|
|
request: BuildRequest | undefined,
|
|
) {
|
|
this.#entry = request?.desktop_entry;
|
|
this.#packageFile =
|
|
request?.install.kind === "package_file"
|
|
? { url: request.install.url }
|
|
: undefined;
|
|
}
|
|
|
|
async start(
|
|
input: CaptureInput,
|
|
signal: AbortSignal,
|
|
): Promise<
|
|
Result<
|
|
{
|
|
readonly desktop_entry: string;
|
|
readonly package_lists: number;
|
|
readonly package_lists_error: string | null;
|
|
},
|
|
AnalysisError
|
|
>
|
|
> {
|
|
const entry = this.#entry;
|
|
if (entry === undefined)
|
|
return err(
|
|
refused(
|
|
START,
|
|
"This computer was started from a bundle folder; REA captures the app of a computer started from a request, which installs REA inside it.",
|
|
"Start a computer from a request with start_build_computer and capture its app there.",
|
|
),
|
|
);
|
|
const previous = this.#run;
|
|
if (previous?.status === "running")
|
|
return err(
|
|
refused(
|
|
START,
|
|
"A capture is already running on this computer.",
|
|
"Stop it with stop_build_capture before starting another.",
|
|
),
|
|
);
|
|
if (
|
|
previous?.status === "unreleased" &&
|
|
!(await this.#release(previous, signal))
|
|
)
|
|
return err(unreleasedError(START, previous, undefined));
|
|
const runtime = await checkExportRuntime(this.computer, signal);
|
|
if (!runtime.ok) return runtime;
|
|
this.#count += 1;
|
|
const run: CaptureRun = {
|
|
folder: `${WORK}/captures/${String(this.#count)}`,
|
|
status: "running",
|
|
checkpoints: new Set(),
|
|
exports: 0,
|
|
};
|
|
this.#run = run;
|
|
const started = await this.#launch(run, entry, input, signal);
|
|
if (started.ok) return started;
|
|
// An answer naming no live capture means none runs; anything else may have left one running.
|
|
const released =
|
|
started.error.answer !== undefined &&
|
|
started.error.answer.timed_out !== true;
|
|
if (released) run.status = "released";
|
|
else if (!(await this.#release(run, signal)))
|
|
return err(unreleasedError(START, run, started.error.failure));
|
|
return err(started.error.failure);
|
|
}
|
|
|
|
/**
|
|
* The capture launched, then the caller cancelled before the start was
|
|
* reported. The next start stops it; until then it is not a second capture.
|
|
*/
|
|
abandon(): void {
|
|
const run = this.#run;
|
|
if (run?.status === "running" && run.stopped === undefined)
|
|
run.status = "unreleased";
|
|
}
|
|
|
|
async #launch(
|
|
run: CaptureRun,
|
|
entry: string,
|
|
input: CaptureInput,
|
|
signal: AbortSignal,
|
|
): Promise<
|
|
Result<
|
|
{
|
|
readonly desktop_entry: string;
|
|
readonly package_lists: number;
|
|
readonly package_lists_error: string | null;
|
|
},
|
|
{ readonly failure: AnalysisError; readonly answer?: Answer }
|
|
>
|
|
> {
|
|
let answer: Answer;
|
|
try {
|
|
answer = await controller(
|
|
this.computer,
|
|
"start",
|
|
{
|
|
work: WORK,
|
|
capture: run.folder,
|
|
desktop_entry: entry,
|
|
arguments: [...(input.arguments ?? [])],
|
|
state_paths: [...(input.state_paths ?? [])],
|
|
...(this.#packageFile === undefined
|
|
? {}
|
|
: { package_file: BUILD_PACKAGE_FILE }),
|
|
timeout_s: 120,
|
|
apt_timeout_s: 600,
|
|
},
|
|
{ timeoutS: 720, signal },
|
|
);
|
|
} catch (cause: unknown) {
|
|
return err({
|
|
failure:
|
|
cause instanceof AnalysisError
|
|
? cause
|
|
: adapterError(START, errorText(cause), cause),
|
|
});
|
|
}
|
|
if (answer.refused !== undefined)
|
|
return err({
|
|
failure: refused(
|
|
START,
|
|
answer.refused,
|
|
"Name files or folders under the computer's home in state_paths, relative to it or absolute, with no link on the way leading out of it.",
|
|
),
|
|
answer,
|
|
});
|
|
const event = answer.line === undefined ? undefined : eventOf(answer.line);
|
|
if (event?.kind !== "window_open")
|
|
return err({
|
|
failure: await endedCapture(
|
|
this.computer,
|
|
{ ...STARTING, folder: run.folder },
|
|
answer,
|
|
signal,
|
|
),
|
|
answer,
|
|
});
|
|
return ok({
|
|
desktop_entry: entry,
|
|
package_lists: answer.apt?.lists ?? 0,
|
|
package_lists_error: answer.apt?.error ?? null,
|
|
});
|
|
}
|
|
|
|
/** Stop a capture whose start failed; true once the computer confirms it ended or never launched. */
|
|
async #release(run: CaptureRun, signal: AbortSignal): Promise<boolean> {
|
|
try {
|
|
const answer = await controller(
|
|
this.computer,
|
|
"stop",
|
|
{ capture: run.folder, timeout_s: 120 },
|
|
{ timeoutS: 120, signal },
|
|
);
|
|
const confirmed =
|
|
answer.absent === true || typeof answer.exit_code === "number";
|
|
run.status = confirmed ? "released" : "unreleased";
|
|
return confirmed;
|
|
} catch {
|
|
run.status = "unreleased";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async mark(
|
|
name: string,
|
|
signal: AbortSignal,
|
|
): Promise<Result<CheckpointTaken, AnalysisError>> {
|
|
const run = this.#run;
|
|
if (run?.status !== "running") return err(refused(MARK, ...NOT_RUNNING));
|
|
if (run.checkpoints.has(name))
|
|
return err(
|
|
refused(
|
|
MARK,
|
|
`A checkpoint named ${name} was already taken.`,
|
|
"Each name is taken once per capture; use another name, or capture again to retake it.",
|
|
),
|
|
);
|
|
try {
|
|
// A checkpoint the capture already took, whose answer was lost, comes back from its log.
|
|
const answer = await controller(
|
|
this.computer,
|
|
"mark",
|
|
{ capture: run.folder, name, timeout_s: 600 },
|
|
{ timeoutS: 600, signal },
|
|
);
|
|
const event =
|
|
answer.line === undefined ? undefined : eventOf(answer.line);
|
|
if (event?.kind === "checkpoint_refused")
|
|
return err(refused(MARK, event.reason, "Use another checkpoint name."));
|
|
if (event?.kind !== "checkpoint")
|
|
return err(
|
|
await endedCapture(
|
|
this.computer,
|
|
{ ...marking(name), folder: run.folder },
|
|
answer,
|
|
signal,
|
|
),
|
|
);
|
|
run.checkpoints.add(name);
|
|
const {
|
|
kind: _kind,
|
|
changed_files: changed,
|
|
more_changed_files: more,
|
|
...taken
|
|
} = event;
|
|
return ok({
|
|
...taken,
|
|
changed_files: changed ?? null,
|
|
more_changed_files: more ?? null,
|
|
});
|
|
} catch (cause: unknown) {
|
|
return err(
|
|
cause instanceof AnalysisError
|
|
? cause
|
|
: adapterError(MARK, errorText(cause), cause),
|
|
);
|
|
}
|
|
}
|
|
|
|
/** Stop the capture, read what it recorded and draft the task; asked again, it resumes or repeats the result. */
|
|
async stop(
|
|
signal: AbortSignal,
|
|
): Promise<Result<StoppedCapture, AnalysisError>> {
|
|
const run = this.#run;
|
|
if (run?.status === "unreleased")
|
|
return (await this.#release(run, signal))
|
|
? err(
|
|
refused(
|
|
STOP,
|
|
`The capture of the failed start in ~/${run.folder} is now stopped; no capture is running.`,
|
|
"Start one with start_build_capture.",
|
|
),
|
|
)
|
|
: err(unreleasedError(STOP, run, undefined));
|
|
if (run === undefined || run.status === "released")
|
|
return err(refused(STOP, ...NOT_RUNNING));
|
|
if (run.stopped !== undefined) return ok(run.stopped);
|
|
try {
|
|
if (run.outputBytes === undefined) {
|
|
const answer = await controller(
|
|
this.computer,
|
|
"stop",
|
|
{ capture: run.folder, timeout_s: 600 },
|
|
{ timeoutS: 600, signal },
|
|
);
|
|
if (answer.exit_code === undefined || answer.output_bytes === undefined)
|
|
return err(notAnswered(STOP, answer));
|
|
run.status = "stopped";
|
|
run.outputBytes = answer.output_bytes;
|
|
}
|
|
const summary = await summarizeCapture(
|
|
this.computer,
|
|
{ folder: run.folder, outputBytes: run.outputBytes },
|
|
signal,
|
|
);
|
|
if (!summary.ok) {
|
|
run.status = "released";
|
|
return summary;
|
|
}
|
|
run.checkpoints = summary.value.checkpoints;
|
|
run.packageFile = summary.value.packageFile;
|
|
run.stopped = summary.value.stopped;
|
|
return ok(summary.value.stopped);
|
|
} catch (cause: unknown) {
|
|
return err(
|
|
cause instanceof AnalysisError
|
|
? cause
|
|
: adapterError(STOP, errorText(cause), cause),
|
|
);
|
|
}
|
|
}
|
|
|
|
/** Export the bundle with the agent's task inside the computer and write it to a folder on this host. */
|
|
async export(
|
|
input: BuildExportRequest,
|
|
signal: AbortSignal,
|
|
): Promise<Result<ExportedBuild, AnalysisError>> {
|
|
const run = this.#run;
|
|
if (
|
|
run?.stopped === undefined ||
|
|
!run.checkpoints.has(SEED_CHECKPOINT) ||
|
|
!run.checkpoints.has(END_CHECKPOINT)
|
|
)
|
|
return err(
|
|
refused(
|
|
EXPORT,
|
|
`Export needs a stopped capture with ${SEED_CHECKPOINT} and ${END_CHECKPOINT} checkpoints; capture with start_build_capture, mark both and stop it.`,
|
|
"Capture with start_build_capture, mark seed and end, then call stop_build_capture.",
|
|
),
|
|
);
|
|
run.exports += 1;
|
|
return exportBuild(
|
|
this.computer,
|
|
{
|
|
folder: run.folder,
|
|
attempt: run.exports,
|
|
...(this.#packageFile === undefined || run.packageFile !== true
|
|
? {}
|
|
: { packageUrl: this.#packageFile.url }),
|
|
},
|
|
input,
|
|
signal,
|
|
);
|
|
}
|
|
}
|