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(sqlite): retain completed worker evidence and unresolved cleanup ownership
morlutob940ad0d65a4
diff --git a/src/process/OwnedCommand.ts b/src/process/OwnedCommand.tsindex 3c2e0912d..3a77c7342 100644--- a/src/process/OwnedCommand.ts+++ b/src/process/OwnedCommand.ts@@ -1,6 +1,7 @@import type {OwnedProviderProcessSpawnOptions,ProviderProcessSnapshot,+ ProviderProcessStopResult,SpawnedOwnedProviderProcess,} from "./ProviderProcess.js";import {@@ -63,7 +64,10 @@ export const runOwnedCommand = async (options: {readonly signal?: AbortSignal | undefined;/** Synchronously accept unresolved cleanup ownership; execution still returns its original outcome. Must not throw. */- readonly retainCleanup?: (owner: ProviderProcessSupervisor) => void;+ readonly retainCleanup?: (+ owner: ProviderProcessSupervisor,+ result: Extract<ProviderProcessStopResult, { status: "incomplete" }>,+ ) => void;readonly launcher?: (input: OwnedProviderProcessSpawnOptions,) => Promise<SpawnedOwnedProviderProcess>;@@ -102,7 +106,10 @@ const collectOwnedCommand = async () => Promise<SpawnedOwnedProviderProcess>,deadline: ProviderStartupDeadline,callerSignal?: AbortSignal,- retainCleanup?: (owner: ProviderProcessSupervisor) => void,+ retainCleanup?: (+ owner: ProviderProcessSupervisor,+ result: Extract<ProviderProcessStopResult, { status: "incomplete" }>,+ ) => void,): Promise<ProviderProcessSnapshot> => {const signal = deadline.signal;let launched: SpawnedOwnedProviderProcess;@@ -216,7 +223,7 @@ const collectOwnedCommand = async (const stopped = await supervisor.stop();const snapshot = supervisor.snapshot();if (stopped.status === "incomplete" && retainCleanup !== undefined)- retainCleanup(supervisor);+ retainCleanup(supervisor, stopped);else if (stopped.status === "incomplete")throw new OwnedCommandFailure(failure?.reason ?? "process",diff --git a/src/sqlite/SqliteDatabaseProvider.ts b/src/sqlite/SqliteDatabaseProvider.tsindex c44185616..03929b2a7 100644--- a/src/sqlite/SqliteDatabaseProvider.ts+++ b/src/sqlite/SqliteDatabaseProvider.ts@@ -17,6 +17,7 @@ import {AnalysisResourceConstraintError,} from "../domain/analysisErrorCore.js";import { projectAnalysisError } from "../domain/analysisErrorProjection.js";+import type { JsonValue } from "../domain/jsonValue.js";import { createEvidence } from "../domain/evidence.js";import { ProviderCleanupError } from "../domain/providerCleanupError.js";import { err, ok, type Result } from "../domain/result.js";@@ -29,8 +30,14 @@ import {} from "../domain/sqlite/sqliteDatabase.js";import { isAbsolute } from "node:path";import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";-import { OwnedCommandFailure } from "../process/OwnedCommand.js";-import type { ProviderProcessSupervisor } from "../process/ProviderProcess.js";+import {+ OwnedCommandFailure,+ ownedCommandResources,+} from "../process/OwnedCommand.js";+import type {+ ProviderProcessStopResult,+ ProviderProcessSupervisor,+} from "../process/ProviderProcess.js";import { sqliteDatabaseFailure } from "./SqliteDatabaseFailures.js";import { captureSqliteDatabaseSnapshot } from "./SqliteDatabaseSnapshot.js";import { SQLITE_DATABASE_LIMITS } from "./SqliteDatabaseLimits.js";@@ -228,6 +235,9 @@ export class SqliteDatabaseProvider implements SqliteDatabasePort {): Promise<SqliteOutcome> {let root: Pick<PrivateRuntimeRoot, "path" | "close"> | undefined;let processOwner: ProviderProcessSupervisor | undefined;+ let processCleanup:+ | Extract<ProviderProcessStopResult, { status: "incomplete" }>+ | undefined;let retainedOutput: AnalysisCapturedOutput | undefined;let phase = "configuration";let result: Result<AnalysisExecution, AnalysisError>;@@ -258,6 +268,10 @@ export class SqliteDatabaseProvider implements SqliteDatabasePort {captured: (output) => {retainedOutput = output;},+ retainCleanup: (owner, result) => {+ processOwner = owner;+ processCleanup = result;+ },});const validated = sqliteDatabaseSchema.safeParse({artifact: snapshot.artifact,@@ -293,6 +307,39 @@ export class SqliteDatabaseProvider implements SqliteDatabasePort {output: retainedOutput,process: processOwner,});+ if (processCleanup !== undefined) {+ const ownership = processOwner.launch.ownership;+ return err(+ sqliteCleanupFailure(+ ownership === undefined+ ? ["owned-sqlite-worker", root.path]+ : ownedCommandResources(ownership, root.path),+ processCleanup.reason,+ result,+ input,+ retainedOutput,+ processCleanup.cleanupResult === undefined+ ? undefined+ : {+ ...(processCleanup.cleanupResult.failures === undefined+ ? {}+ : {+ failures: processCleanup.cleanupResult.failures.map(+ (failure) => ({ ...failure }),+ ),+ }),+ ...(processCleanup.cleanupResult.unverified === undefined+ ? {}+ : {+ unverified:+ processCleanup.cleanupResult.unverified.map(+ (process) => ({ ...process }),+ ),+ }),+ },+ ),+ );+ }return result;}const cleaned = await cleanupSqliteRoot(@@ -360,41 +407,55 @@ const cleanupSqliteRoot = async (return ok(null);} catch (cause: unknown) {return err(- new ProviderCleanupError(- SQLITE_PROVIDER_IDENTITY.id,+ sqliteCleanupFailure([root.path],- {- reason: cause instanceof Error ? cause.message : String(cause),- previous_error: result.ok ? null : projectAnalysisError(result.error),- ...(output === undefined ? {} : { captured_output: { ...output } }),- },- {- operation,- cause,- ...(result.ok- ? {- partialObservation: createEvidence(- result.value.subject ?? undefined,- result.value.provider,- {- operation,- parameters: sqliteInspectionParameters(input),- result: result.value.result,- confidence: "observed",- locations: result.value.locations,- limitations: result.value.limitations,- },- ),- }- : result.error.partialObservation === undefined- ? {}- : { partialObservation: result.error.partialObservation }),- },+ cause instanceof Error ? cause.message : String(cause),+ result,+ input,+ output,+ undefined,+ cause,),);}};+const sqliteCleanupFailure = (+ resources: readonly string[],+ reason: string,+ result: SqliteOutcome,+ input: InspectSqliteDatabaseInput,+ output?: AnalysisCapturedOutput,+ details?: Readonly<Record<string, JsonValue>>,+ cause?: unknown,+): ProviderCleanupError => {+ const partialObservation = result.ok+ ? createEvidence(result.value.subject ?? undefined, result.value.provider, {+ operation,+ parameters: sqliteInspectionParameters(input),+ result: result.value.result,+ confidence: "observed",+ locations: result.value.locations,+ limitations: result.value.limitations,+ })+ : result.error.partialObservation;+ return new ProviderCleanupError(+ SQLITE_PROVIDER_IDENTITY.id,+ resources,+ {+ ...details,+ reason,+ previous_error: result.ok ? null : projectAnalysisError(result.error),+ ...(output === undefined ? {} : { captured_output: { ...output } }),+ },+ {+ operation,+ ...(cause === undefined ? {} : { cause }),+ ...(partialObservation === undefined ? {} : { partialObservation }),+ },+ );+};+const validateSqliteInput = (input: InspectSqliteDatabaseInput): void => {const parsed = inspectSqliteDatabaseInputSchema.safeParse(input);if (!parsed.success || !isAbsolute(input.path))diff --git a/src/sqlite/SqliteDatabaseWorkerExecution.ts b/src/sqlite/SqliteDatabaseWorkerExecution.tsindex cba180399..930a871a4 100644--- a/src/sqlite/SqliteDatabaseWorkerExecution.ts+++ b/src/sqlite/SqliteDatabaseWorkerExecution.ts@@ -19,6 +19,10 @@ import { readStableArtifact } from "../artifacts/readStableArtifact.js";import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";import type { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";import { runOwnedCommand } from "../process/OwnedCommand.js";+import type {+ ProviderProcessSupervisor,+ ProviderProcessStopResult,+} from "../process/ProviderProcess.js";import { capturedSqliteOutput } from "./SqliteDatabaseFailures.js";import { SQLITE_DATABASE_LIMITS } from "./SqliteDatabaseLimits.js";@@ -109,6 +113,10 @@ export const executeSqliteDatabaseWorker = async (request: {readonly launcher?: SqliteWorkerLauncher;readonly signal?: AbortSignal;readonly captured: (output: AnalysisCapturedOutput) => void;+ readonly retainCleanup?: (+ owner: ProviderProcessSupervisor,+ result: Extract<ProviderProcessStopResult, { status: "incomplete" }>,+ ) => void;}): Promise<z.output<typeof inspectionSchema>> => {const requestPath = join(request.root, "request.json");const replyPath = join(request.root, "reply.json");@@ -143,6 +151,9 @@ export const executeSqliteDatabaseWorker = async (request: {{...(request.signal === undefined ? {} : { signal: request.signal }),...(request.launcher === undefined ? {} : { launcher: request.launcher }),+ ...(request.retainCleanup === undefined+ ? {}+ : { retainCleanup: request.retainCleanup }),},);const capturedOutput = capturedSqliteOutput(execution);diff --git a/tests/boundary/sqlite/sqliteDatabaseProvider.test.ts b/tests/boundary/sqlite/sqliteDatabaseProvider.test.tsindex 5ecc35672..20f882726 100644--- a/tests/boundary/sqlite/sqliteDatabaseProvider.test.ts+++ b/tests/boundary/sqlite/sqliteDatabaseProvider.test.ts@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";import { expect, it as nativeTest, onTestFinished } from "vitest";import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";import { SqliteDatabaseProvider } from "../../../src/sqlite/SqliteDatabaseProvider.js";+import { inspectSqliteDatabaseSnapshot } from "../../../src/sqlite/SqliteDatabaseInspection.js";import { spawnOwnedProviderProcess } from "../../../src/process/ProviderProcess.js";import { PrivateRuntimeRoot } from "../../../src/process/PrivateRuntimeRoot.js";import { waitForProviderProcessReady } from "../../fixtures/providerProcess.js";@@ -49,6 +50,90 @@ const createFixture = async (wal = false) => {const expectPrivateRootRemoved = (path: string) =>expect(access(path)).rejects.toMatchObject({ code: "ENOENT" });+it.each(["completed reply", "malformed reply"] as const)(+ "preserves the primary result for a %s while retaining unconfirmed cleanup ownership",+ async (replyKind) => {+ const { workspace, database } = await createFixture();+ let cleanupAttempts = 0;+ let ownedRoot = "";+ const provider = new SqliteDatabaseProvider(process.env, async (spawn) => {+ ownedRoot = spawn.cwd ?? "";+ const requestPath = spawn.arguments[2];+ if (requestPath === undefined)+ throw new Error("SQLite request path missing");+ const request = JSON.parse(await readFile(requestPath, "utf8")) as {+ snapshot_path: string;+ reply_path: string;+ input: Parameters<typeof inspectSqliteDatabaseSnapshot>[1];+ };+ const inspection =+ replyKind === "completed reply"+ ? inspectSqliteDatabaseSnapshot(request.snapshot_path, request.input)+ : undefined;+ await writeFile(+ request.reply_path,+ inspection === undefined+ ? "{ malformed reply"+ : JSON.stringify({ ok: true, inspection }),+ { flag: "wx", mode: 0o600 },+ );+ const launched = await spawnOwnedProviderProcess({+ ...spawn,+ arguments: ["-e", "process.exit(0)"],+ });+ return {+ ...launched,+ cleanup: async () => {+ cleanupAttempts += 1;+ return cleanupAttempts === 1+ ? { cleaned: false, reason: "fixture cleanup denial" }+ : { cleaned: true, signaled: false };+ },+ };+ });+ onTestFinished(async () => {+ await provider.close();+ await removeTestWorkspace(workspace.root);+ });++ const result = await provider.inspect({+ path: database.path,+ table: "records",+ columns: ["id"],+ row_limit: 1,+ });+ expect(result).toMatchObject({+ ok: false,+ error: {+ cleanupIncomplete: true,+ cleanupResources: expect.arrayContaining([ownedRoot]),+ diagnostics: {+ reason: "fixture cleanup denial",+ previous_error:+ replyKind === "malformed reply" ? expect.any(Object) : null,+ },+ ...(replyKind === "completed reply"+ ? {+ partialObservation: {+ operation: "inspect_sqlite_database",+ confidence: "observed",+ normalized_result: {+ schema: { tables: expect.any(Array) },+ rows: { returned_rows: 1 },+ },+ },+ }+ : { partialObservation: undefined }),+ },+ });+ expect(cleanupAttempts).toBe(1);+ await expect(access(`${ownedRoot}/reply.json`)).resolves.toBeUndefined();+ await provider.close();+ expect(cleanupAttempts).toBe(2);+ await expectPrivateRootRemoved(ownedRoot);+ },+);+it.each(["late-cancellation", "cleanup-failure"])("preserves completed native-worker observations across %s",async (scenario) => {