Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(cli): retry retained browser scenario cleanup
Ysopwnable4daea941bfee
diff --git a/src/cliBrowserScenarioCommands.ts b/src/cliBrowserScenarioCommands.tsindex a1a1f86e1..c42d4e25d 100644--- a/src/cliBrowserScenarioCommands.ts+++ b/src/cliBrowserScenarioCommands.ts@@ -6,7 +6,9 @@ import { CLI_COMMANDS } from "./cliCommandNames.js";import { parseCliJsonInput, resolveCliJsonPaths } from "./cliJsonInput.js";import { logCliCommand } from "./cliLogging.js";import { AnalysisInputError } from "./domain/analysisErrorCore.js";+import { AnalysisError } from "./domain/analysisErrorBase.js";import { projectAnalysisError } from "./domain/analysisErrorProjection.js";+import { BrowserObservationError } from "./domain/browserObservationError.js";import { projectInputIssues } from "./domain/inputIssueProjection.js";import { browserScenarioSchema } from "./domain/browserScenario.js";import type { JsonValue } from "./domain/jsonValue.js";@@ -46,11 +48,40 @@ export const registerBrowserScenarioCommands = (// Load Playwright only for this command, not during CLI startup.const { createBrowserScenarioProvider } =await import("./composition/browserScenario.js");- const result = await captureBrowserScenario(- createBrowserScenarioProvider(environment),- scenario.data,- );- return result.ok ? result.value : cliError(result.error);+ const provider = createBrowserScenarioProvider(environment);+ let result:+ | Awaited<ReturnType<typeof captureBrowserScenario>>+ | undefined;+ try {+ result = await captureBrowserScenario(provider, scenario.data);+ return result.ok ? result.value : cliError(result.error);+ } finally {+ try {+ await provider?.close?.();+ } catch (cause: unknown) {+ // Failed captures already retain their primary error and partial+ // observations. A cleanup retry must not replace that outcome.+ if (result?.ok)+ throw new BrowserObservationError(OPERATION, "cleanup_failed", {+ cause,+ cleanup:+ cause instanceof AnalysisError && cause.cleanup !== undefined+ ? cause.cleanup+ : {+ reason:+ cause instanceof Error+ ? cause.message+ : String(cause),+ resources:+ cause instanceof AnalysisError &&+ cause.cleanupResources.length > 0+ ? cause.cleanupResources+ : ["browser_transport"],+ },+ partialObservation: result.value,+ });+ }+ }}),});};diff --git a/tests/boundary/cli/browserScenarioCleanup.test.ts b/tests/boundary/cli/browserScenarioCleanup.test.tsnew file mode 100644index 000000000..45df1b49b--- /dev/null+++ b/tests/boundary/cli/browserScenarioCleanup.test.ts@@ -0,0 +1,302 @@+import { Cli } from "incur";+import { expect, it, vi } from "vitest";++import type { BrowserScenarioCapturePort } from "../../../src/application/BrowserScenarioCapturePort.js";+import { createBrowserScenarioEvidence } from "../../../src/application/BrowserScenarioEvidence.js";+import type { BrowserScenarioSessionPort } from "../../../src/browser/BrowserScenarioSessionPort.js";+import { PlaywrightBrowserScenarioProvider } from "../../../src/browser/PlaywrightBrowserScenarioProvider.js";+import { PlaywrightScenarioBrowserCleanupOwner } from "../../../src/browser/PlaywrightScenarioBrowser.js";+import { registerBrowserScenarioCommands } from "../../../src/cliBrowserScenarioCommands.js";+import { sanitizeBrowserUrl } from "../../../src/domain/browserObservation.js";+import {+ browserScenarioSchema,+ type BrowserScenario,+} from "../../../src/domain/browserScenario.js";+import type { BrowserScenarioAction } from "../../../src/domain/browserScenarioValues.js";+import { browserStepArtifactsSchema } from "../../../src/domain/browserScenarioCaptureValues.js";+import { silentLogger } from "../../../src/logger.js";+import {+ AnalysisCancelledError,+ AnalysisTimeoutError,+} from "../../../src/domain/analysisErrorCore.js";+import { BrowserObservationError } from "../../../src/domain/browserObservationError.js";+import { parseEvidence } from "../../../src/domain/evidence.js";+import { jsonObjectSchema } from "../../../src/domain/jsonValue.js";+import { ok } from "../../../src/domain/result.js";++const state = vi.hoisted(() => ({+ provider: undefined as BrowserScenarioCapturePort | undefined,+}));+vi.mock("../../../src/composition/browserScenario.js", () => ({+ createBrowserScenarioProvider: () => state.provider,+}));++const scenario = browserScenarioSchema.parse({+ browser: { mode: "launch", executable_path: "/fixture/chromium" },+ start_url: { url: "https://app.example.test/" },+ actions: [{ step_id: "wait", action: "wait_for_timeout", duration_ms: 1 }],+ storage: {},+ capture: { after_each_step: ["url"], at_end: [], events: [] },+});++// Controlled session failures exercise the real provider and cleanup owner;+// this fixture opens no browser process or profile directory.+class RetrySession implements BrowserScenarioSessionPort {+ readonly mode = "launch";+ readonly processOwnership = "provider-owned";+ readonly product = "Fixture Chromium";+ readonly version = "1";+ readonly initialUrl = "https://app.example.test/";+ closeBrowserCalls = 0;+ profileRemovalCalls = 0;+ readonly cleanup = new PlaywrightScenarioBrowserCleanupOwner({+ closeBrowser: async () => {+ this.closeBrowserCalls += 1;+ if (this.closeBrowserCalls <= this.closeFailures)+ throw new Error(`injected close failure ${this.closeBrowserCalls}`);+ },+ removeProfile: async () => {+ expect(this.cleanup.browserClosed).toBe(true);+ this.profileRemovalCalls += 1;+ },+ });++ constructor(private readonly closeFailures = 1) {}++ currentUrl() {+ return this.initialUrl;+ }+ sanitizeUrl(value: string) {+ return sanitizeBrowserUrl(value);+ }+ setStep(_index: number) {}+ nextEventSequence() {+ return 1;+ }+ lastEventSequence() {+ return 0;+ }+ events() {+ return { retained: 0, dropped: 0, items: [] };+ }+ async perform(_action: BrowserScenarioAction) {}+ async capture(+ requested: ReadonlySet<+ BrowserScenario["capture"]["after_each_step"][number]+ >,+ ) {+ const artifact = (+ kind: BrowserScenario["capture"]["after_each_step"][number],+ ) =>+ !requested.has(kind)+ ? { state: "not_requested" }+ : kind === "url"+ ? { state: "captured", value: this.sanitizeUrl(this.initialUrl) }+ : { state: "missing", reason: "fixture unavailable" };+ return browserStepArtifactsSchema.parse({+ screenshot: artifact("screenshot"),+ dom: artifact("dom"),+ accessibility: artifact("accessibility"),+ url: artifact("url"),+ history: artifact("history"),+ storage: artifact("storage"),+ });+ }+ async close() {+ await this.cleanup.close();+ return "terminated-owned-process" as const;+ }+ redactError(error: unknown) {+ return error instanceof Error ? error.message : "fixture failure";+ }+}++const serveScenario = async () => {+ const cli = Cli.create("browser-cleanup-test", { sync: false });+ registerBrowserScenarioCommands(cli, silentLogger, {});+ let stdout = "";+ let exitCode = 0;+ await cli.serve(+ ["capture-browser-scenario", JSON.stringify(scenario), "--json"],+ {+ env: {},+ exit: (code) => {+ exitCode = code;+ },+ stdout: (text) => {+ stdout += text;+ },+ },+ );+ return {+ output: jsonObjectSchema.parse(JSON.parse(stdout)),+ exitCode,+ processExitCode: process.exitCode,+ };+};++it("retries retained browser cleanup before the one-shot CLI releases its provider", async () => {+ const savedExitCode = process.exitCode;+ const session = new RetrySession();+ const provider = new PlaywrightBrowserScenarioProvider(async () => session);+ const close = vi.spyOn(provider, "close");+ state.provider = provider;+ try {+ const result = await serveScenario();+ expect(result.processExitCode).toBe(1);+ expect(result.output).toMatchObject({+ code: "cleanup_incomplete",+ category: "execution_failure",+ details: {+ cleanup: "incomplete",+ resources: ["browser_transport", "browser_profile"],+ partial_observation: {+ capture: { browser: { cleanup: "incomplete" } },+ },+ },+ });+ const details = jsonObjectSchema.parse(result.output.details);+ const partial = jsonObjectSchema.parse(details.partial_observation);+ expect(jsonObjectSchema.parse(partial.capture).steps).toHaveLength(2);+ expect(close).toHaveBeenCalledTimes(1);+ expect(session.closeBrowserCalls).toBe(2);+ expect(session.profileRemovalCalls).toBe(1);+ } finally {+ // The red baseline must also release this controlled owner.+ await provider.close();+ state.provider = undefined;+ process.exitCode = savedExitCode;+ }+});++it("preserves the initial partial observation when the provider cleanup retry also fails", async () => {+ const savedExitCode = process.exitCode;+ const session = new RetrySession(2);+ const provider = new PlaywrightBrowserScenarioProvider(async () => session);+ const close = vi.spyOn(provider, "close");+ state.provider = provider;+ try {+ const result = await serveScenario();+ expect(result.output).toMatchObject({ code: "cleanup_incomplete" });+ expect(JSON.stringify(result.output)).toContain("injected close failure 1");+ expect(JSON.stringify(result.output)).not.toContain(+ "injected close failure 2",+ );+ expect(close).toHaveBeenCalledTimes(1);+ expect(session.closeBrowserCalls).toBe(2);+ expect(session.profileRemovalCalls).toBe(0);+ // Retained ownership remains retryable after the command's failed retry.+ await provider.close();+ expect(session.closeBrowserCalls).toBe(3);+ expect(session.profileRemovalCalls).toBe(1);+ } finally {+ await provider.close();+ state.provider = undefined;+ process.exitCode = savedExitCode;+ }+});++it("retains completed Evidence when provider shutdown fails after a successful capture", async () => {+ const savedExitCode = process.exitCode;+ const provider = new PlaywrightBrowserScenarioProvider(+ async () => new RetrySession(0),+ );+ const captured = await provider.captureScenario(scenario);+ if (!captured.ok) throw captured.error;+ const evidence = createBrowserScenarioEvidence(+ scenario,+ captured.value,+ provider.identity(),+ );+ const close = vi.fn().mockRejectedValue(+ new BrowserObservationError("capture_browser_scenario", "cleanup_failed", {+ cleanup: {+ reason: "injected shutdown failure",+ resources: ["browser_profile"],+ },+ }),+ );+ state.provider = {+ identity: () => provider.identity(),+ captureScenario: async () => ok(captured.value),+ close,+ };+ try {+ const result = await serveScenario();+ expect(result.processExitCode).toBe(1);+ expect(result.output).toMatchObject({+ code: "cleanup_incomplete",+ details: { resources: ["browser_profile"] },+ });+ const details = jsonObjectSchema.parse(result.output.details);+ expect(parseEvidence(details.partial_observation)).toEqual(evidence);+ expect(close).toHaveBeenCalledTimes(1);+ } finally {+ await provider.close();+ state.provider = undefined;+ process.exitCode = savedExitCode;+ }+});++it("preserves cancellation diagnostics while retrying retained cleanup", async () => {+ const savedExitCode = process.exitCode;+ const session = new RetrySession();+ vi.spyOn(session, "capture").mockRejectedValue(+ new AnalysisCancelledError("capture_browser_scenario"),+ );+ const provider = new PlaywrightBrowserScenarioProvider(async () => session);+ state.provider = provider;+ try {+ const result = await serveScenario();+ expect(result.output).toMatchObject({+ code: "cleanup_incomplete",+ category: "execution_failure",+ details: {+ cleanup: "incomplete",+ diagnostics: {+ primary_error: { code: "cancelled", category: "cancelled" },+ },+ partial_observation: { kind: "browser-scenario-observation" },+ },+ });+ expect(session.closeBrowserCalls).toBe(2);+ expect(session.profileRemovalCalls).toBe(1);+ } finally {+ await provider.close();+ state.provider = undefined;+ process.exitCode = savedExitCode;+ }+});++it("preserves a thrown capture error when provider shutdown also rejects", async () => {+ const savedExitCode = process.exitCode;+ const provider = new PlaywrightBrowserScenarioProvider(+ async () => new RetrySession(0),+ );+ const primary = new AnalysisTimeoutError("capture_browser_scenario", 123);+ const close = vi+ .fn()+ .mockRejectedValue(new Error("secondary shutdown failure"));+ state.provider = {+ identity: () => provider.identity(),+ captureScenario: async () => {+ throw primary;+ },+ close,+ };+ try {+ const result = await serveScenario();+ expect(result.output).toMatchObject({+ code: "provider_timeout",+ category: "timeout",+ });+ expect(JSON.stringify(result.output)).not.toContain(+ "secondary shutdown failure",+ );+ expect(close).toHaveBeenCalledTimes(1);+ } finally {+ await provider.close();+ state.provider = undefined;+ process.exitCode = savedExitCode;+ }+});