@langchain/sandbox-standard-tests 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sandbox = require("./sandbox-D7MiOPSd.cjs");
+const require_sandbox = require("./sandbox-Cna4fdRg.cjs");
 exports.sandboxStandardTests = require_sandbox.sandboxStandardTests;
 exports.withRetry = require_sandbox.withRetry;

package/dist/index.d.cts

@@ -1,2 +1,2 @@
-import { a as HookFn, c as SandboxInstanceV2, d as TestFn, f as TestRunner, i as ExpectFn, l as StandardTestsConfig, n as withRetry, o as SandboxInstance, r as AnySandboxInstance, s as SandboxInstanceV1, t as sandboxStandardTests, u as SuiteFn } from "./sandbox-C81RxygO.cjs";
+import { a as HookFn, c as SandboxInstanceV2, d as TestFn, f as TestRunner, i as ExpectFn, l as StandardTestsConfig, n as withRetry, o as SandboxInstance, r as AnySandboxInstance, s as SandboxInstanceV1, t as sandboxStandardTests, u as SuiteFn } from "./sandbox-B5zI_2m-.cjs";
 export { type AnySandboxInstance, type ExpectFn, type HookFn, type SandboxInstance, type SandboxInstanceV1, type SandboxInstanceV2, type StandardTestsConfig, type SuiteFn, type TestFn, type TestRunner, sandboxStandardTests, withRetry };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as HookFn, c as SandboxInstanceV2, d as TestFn, f as TestRunner, i as ExpectFn, l as StandardTestsConfig, n as withRetry, o as SandboxInstance, r as AnySandboxInstance, s as SandboxInstanceV1, t as sandboxStandardTests, u as SuiteFn } from "./sandbox-BmvI_rV6.js";
+import { a as HookFn, c as SandboxInstanceV2, d as TestFn, f as TestRunner, i as ExpectFn, l as StandardTestsConfig, n as withRetry, o as SandboxInstance, r as AnySandboxInstance, s as SandboxInstanceV1, t as sandboxStandardTests, u as SuiteFn } from "./sandbox-B5zI_2m-.js";
 export { type AnySandboxInstance, type ExpectFn, type HookFn, type SandboxInstance, type SandboxInstanceV1, type SandboxInstanceV2, type StandardTestsConfig, type SuiteFn, type TestFn, type TestRunner, sandboxStandardTests, withRetry };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { n as withRetry, t as sandboxStandardTests } from "./sandbox-BbDX1T-X.js";
+import { n as withRetry, t as sandboxStandardTests } from "./sandbox-Bnab52lG.js";
 export { sandboxStandardTests, withRetry };

package/dist/{sandbox-BmvI_rV6.d.ts → sandbox-B5zI_2m-.d.cts}

@@ -1,5 +1,4 @@
 import { FileDownloadResponse, FileUploadResponse, MaybePromise, SandboxBackendProtocol, SandboxBackendProtocolV2 } from "deepagents";
-
 //#region src/types.d.ts
 /** A `describe` / suite function accepted by the standard tests. */
 interface SuiteFn {
@@ -194,4 +193,4 @@ declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, delayMs
 declare function sandboxStandardTests<T extends AnySandboxInstance>(config: StandardTestsConfig<T>): void;
 //#endregion
 export { HookFn as a, SandboxInstanceV2 as c, TestFn as d, TestRunner as f, ExpectFn as i, StandardTestsConfig as l, withRetry as n, SandboxInstance as o, AnySandboxInstance as r, SandboxInstanceV1 as s, sandboxStandardTests as t, SuiteFn as u };
-//# sourceMappingURL=sandbox-BmvI_rV6.d.ts.map
+//# sourceMappingURL=sandbox-B5zI_2m-.d.cts.map

package/dist/{sandbox-C81RxygO.d.cts → sandbox-B5zI_2m-.d.ts}

@@ -1,5 +1,4 @@
 import { FileDownloadResponse, FileUploadResponse, MaybePromise, SandboxBackendProtocol, SandboxBackendProtocolV2 } from "deepagents";
-
 //#region src/types.d.ts
 /** A `describe` / suite function accepted by the standard tests. */
 interface SuiteFn {
@@ -194,4 +193,4 @@ declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, delayMs
 declare function sandboxStandardTests<T extends AnySandboxInstance>(config: StandardTestsConfig<T>): void;
 //#endregion
 export { HookFn as a, SandboxInstanceV2 as c, TestFn as d, TestRunner as f, ExpectFn as i, StandardTestsConfig as l, withRetry as n, SandboxInstance as o, AnySandboxInstance as r, SandboxInstanceV1 as s, sandboxStandardTests as t, SuiteFn as u };
-//# sourceMappingURL=sandbox-C81RxygO.d.cts.map
+//# sourceMappingURL=sandbox-B5zI_2m-.d.ts.map

package/dist/{sandbox-BbDX1T-X.js → sandbox-Bnab52lG.js}

@@ -67,7 +67,8 @@ function registerCommandExecutionTests(getShared, config, timeout) {
 			expect(result.truncated).toBe(false);
 		}, timeout);
 		it("should capture non-zero exit code", async () => {
-			expect((await getShared().execute("exit 42")).exitCode).toBe(42);
+			const result = await getShared().execute("exit 42");
+			expect(result.exitCode).toBe(42);
 		}, timeout);
 		it("should capture multiline output", async () => {
 			const result = await getShared().execute("echo \"line1\" && echo \"line2\" && echo \"line3\"");
@@ -77,15 +78,17 @@ function registerCommandExecutionTests(getShared, config, timeout) {
 			expect(result.output).toContain("line3");
 		}, timeout);
 		it("should capture stderr output", async () => {
-			expect((await getShared().execute("echo \"error message\" >&2")).output).toContain("error message");
+			const result = await getShared().execute("echo \"error message\" >&2");
+			expect(result.output).toContain("error message");
 		}, timeout);
 		it("should handle command with environment variables", async () => {
-			const result = await getShared().execute("export MY_VAR=\"test_value\" && echo $MY_VAR");
+			const result = await withRetry(() => getShared().execute("export MY_VAR=\"test_value\" && echo $MY_VAR"), 3, 2e3);
 			expect(result.exitCode).toBe(0);
 			expect(result.output.trim()).toBe("test_value");
 		}, timeout);
 		it("should handle non-existent command", async () => {
-			expect((await getShared().execute("nonexistent_command_12345")).exitCode).not.toBe(0);
+			const result = await getShared().execute("nonexistent_command_12345");
+			expect(result.exitCode).not.toBe(0);
 		}, timeout);
 	});
 }
@@ -141,7 +144,8 @@ function registerFileOperationTests(getShared, config, timeout) {
 			expect(results.length).toBe(1);
 			expect(results[0].path).toBe(filePath);
 			expect(results[0].error).toBeNull();
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe("Hello from test file!");
+			const checkResult = await shared.execute(`cat ${filePath}`);
+			expect(checkResult.output.trim()).toBe("Hello from test file!");
 		}, timeout);
 		it("should download files from sandbox", async () => {
 			const shared = getShared();
@@ -152,7 +156,8 @@ function registerFileOperationTests(getShared, config, timeout) {
 			expect(results.length).toBe(1);
 			expect(results[0].error).toBeNull();
 			expect(results[0].content).not.toBeNull();
-			expect(new TextDecoder().decode(results[0].content).trim()).toBe("Download test content");
+			const content = new TextDecoder().decode(results[0].content);
+			expect(content.trim()).toBe("Download test content");
 		}, timeout);
 		it("should handle file not found on download", async () => {
 			const filePath = config.resolvePath("nonexistent-file-12345.txt");
@@ -166,20 +171,23 @@ function registerFileOperationTests(getShared, config, timeout) {
 			const filePath = config.resolvePath("read-test.txt");
 			const encoder = new TextEncoder();
 			await shared.uploadFiles([[filePath, encoder.encode("Read test content")]]);
-			expect((await shared.read(filePath)).content).toContain("Read test content");
+			const content = await shared.read(filePath);
+			expect(content.content).toContain("Read test content");
 		}, timeout);
 		it("should use inherited write method from BaseSandbox", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("write-test.txt");
 			await shared.write(filePath, "Written via BaseSandbox");
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe("Written via BaseSandbox");
+			const result = await shared.execute(`cat ${filePath}`);
+			expect(result.output.trim()).toBe("Written via BaseSandbox");
 		}, timeout);
 		it("should use inherited edit method from BaseSandbox", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("edit-test.txt");
 			await shared.write(filePath, "Hello World");
 			await shared.edit(filePath, "Hello World", "Hello Edited World");
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe("Hello Edited World");
+			const result = await shared.execute(`cat ${filePath}`);
+			expect(result.output.trim()).toBe("Hello Edited World");
 		}, timeout);
 		it("should upload multiple files at once", async () => {
 			const shared = getShared();
@@ -204,7 +212,7 @@ function registerFileOperationTests(getShared, config, timeout) {
 //#endregion
 //#region src/tests/write.ts
 /**
-* Register detailed write() tests (new file, parent dirs, existing file,
+* Register detailed write() tests (new file, parent dirs, existing file overwrite,
 * special chars, empty, spaces, unicode, slashes, long content, newlines).
 */
 function registerWriteTests(getShared, config, timeout) {
@@ -217,71 +225,88 @@ function registerWriteTests(getShared, config, timeout) {
 			const result = await shared.write(filePath, content);
 			expect(result.error).toBeUndefined();
 			expect(result.path).toBe(filePath);
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe(content);
+			const execResult = await shared.execute(`cat ${filePath}`);
+			expect(execResult.output.trim()).toBe(content);
 		}, timeout);
 		it("should create parent directories automatically", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-parents/deep/nested/dir/file.txt");
 			const content = "Nested file content";
-			expect((await shared.write(filePath, content)).error).toBeUndefined();
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe(content);
+			const result = await shared.write(filePath, content);
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`cat ${filePath}`);
+			expect(execResult.output.trim()).toBe(content);
 		}, timeout);
-		it("should fail when writing to an existing file", async () => {
+		it("should overwrite an existing file", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-existing.txt");
 			await shared.write(filePath, "First content");
 			const result = await shared.write(filePath, "Second content");
-			expect(result.error).toBeDefined();
-			expect(result.error.toLowerCase()).toContain("already exists");
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe("First content");
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`cat ${filePath}`);
+			expect(execResult.output.trim()).toBe("Second content");
 		}, timeout);
 		it("should handle special characters and escape sequences", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-special.txt");
 			const content = "Special chars: $VAR, `command`, $(subshell)\nTab	here\nBackslash: \\";
-			expect((await shared.write(filePath, content)).error).toBeUndefined();
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe(content);
+			const result = await shared.write(filePath, content);
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`cat ${filePath}`);
+			expect(execResult.output.trim()).toBe(content);
 		}, timeout);
 		it("should write an empty file", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-empty.txt");
-			expect((await shared.write(filePath, "")).error).toBeUndefined();
-			expect((await shared.execute(`[ -f ${filePath} ] && echo 'exists' || echo 'missing'`)).output).toContain("exists");
+			const result = await shared.write(filePath, "");
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`[ -f ${filePath} ] && echo 'exists' || echo 'missing'`);
+			expect(execResult.output).toContain("exists");
 		}, timeout);
 		it("should write a file with spaces in the path", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-spaces/dir with spaces/file name.txt");
 			const content = "Content in file with spaces";
-			expect((await shared.write(filePath, content)).error).toBeUndefined();
-			expect((await shared.execute(`cat '${filePath}'`)).output.trim()).toBe(content);
+			const result = await shared.write(filePath, content);
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`cat '${filePath}'`);
+			expect(execResult.output.trim()).toBe(content);
 		}, timeout);
 		it("should write unicode content", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-unicode.txt");
 			const content = "Hello 👋 世界 مرحبا Привет 🌍\nLine with émojis 🎉";
-			expect((await shared.write(filePath, content)).error).toBeUndefined();
-			expect((await shared.execute(`cat ${filePath}`)).output.trim()).toBe(content);
+			const result = await shared.write(filePath, content);
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`cat ${filePath}`);
+			expect(execResult.output.trim()).toBe(content);
 		}, timeout);
 		it("should handle consecutive slashes in path", async () => {
 			const shared = getShared();
 			const basePath = config.resolvePath("wt-slashes");
 			const filePath = `${basePath}//subdir///file.txt`;
 			const content = "Content";
-			expect((await shared.write(filePath, content)).error).toBeUndefined();
-			expect((await shared.execute(`cat ${basePath}/subdir/file.txt`)).output.trim()).toBe(content);
+			const result = await shared.write(filePath, content);
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`cat ${basePath}/subdir/file.txt`);
+			expect(execResult.output.trim()).toBe(content);
 		}, timeout);
 		it("should write very long content (1000 lines)", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-long.txt");
 			const content = Array.from({ length: 1e3 }, (_, i) => `Line ${i} with some content here`).join("\n");
-			expect((await shared.write(filePath, content)).error).toBeUndefined();
-			expect((await shared.execute(`wc -l < ${filePath}`)).output.trim()).toMatch(/^(999|1000)$/);
+			const result = await shared.write(filePath, content);
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`wc -l < ${filePath}`);
+			expect(execResult.output.trim()).toMatch(/^(999|1000)$/);
 		}, timeout);
 		it("should write content with only newlines", async () => {
 			const shared = getShared();
 			const filePath = config.resolvePath("wt-newlines.txt");
-			expect((await shared.write(filePath, "\n\n\n\n\n")).error).toBeUndefined();
-			expect((await shared.execute(`wc -l < ${filePath}`)).output.trim()).toBe("5");
+			const result = await shared.write(filePath, "\n\n\n\n\n");
+			expect(result.error).toBeUndefined();
+			const execResult = await shared.execute(`wc -l < ${filePath}`);
+			expect(execResult.output.trim()).toBe("5");
 		}, timeout);
 	});
 }
@@ -314,7 +339,8 @@ function registerReadTests(getShared, config, timeout) {
 			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-empty.txt");
 			await shared.write(filePath, "");
-			expect((await shared.read(filePath)).error).toBeUndefined();
+			const result = await shared.read(filePath);
+			expect(result.error).toBeUndefined();
 		}, timeout);
 		it("should read with offset parameter", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -369,7 +395,8 @@ function registerReadTests(getShared, config, timeout) {
 			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-zero-limit.txt");
 			await shared.write(filePath, "Line 1\nLine 2\nLine 3");
-			expect((await shared.read(filePath, 0, 0)).content).not.toContain("Line 1");
+			const result = await shared.read(filePath, 0, 0);
+			expect(result.content).not.toContain("Line 1");
 		}, timeout);
 		it("should handle offset beyond file length", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -449,7 +476,8 @@ function registerEditTests(getShared, config, timeout) {
 			expect(result.occurrences).toBe(3);
 			const execResult = await shared.execute(`cat ${filePath}`);
 			expect(execResult.output).not.toContain("apple");
-			expect(execResult.output.split("pear").length - 1).toBe(3);
+			const pearCount = execResult.output.split("pear").length - 1;
+			expect(pearCount).toBe(3);
 		}, timeout);
 		it("should return error when string is not found", async () => {
 			const shared = getShared();
@@ -469,8 +497,10 @@ function registerEditTests(getShared, config, timeout) {
 			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-special.txt");
 			await shared.write(filePath, "Price: $100.00\nPattern: [a-z]*\nPath: /usr/bin");
-			expect((await shared.edit(filePath, "$100.00", "$200.00")).error).toBeUndefined();
-			expect((await shared.edit(filePath, "[a-z]*", "[0-9]+")).error).toBeUndefined();
+			const result1 = await shared.edit(filePath, "$100.00", "$200.00");
+			expect(result1.error).toBeUndefined();
+			const result2 = await shared.edit(filePath, "[a-z]*", "[0-9]+");
+			expect(result2.error).toBeUndefined();
 			const content = await shared.read(filePath);
 			expect(content.content).toContain("$200.00");
 			expect(content.content).toContain("[0-9]+");
@@ -506,7 +536,8 @@ function registerEditTests(getShared, config, timeout) {
 			const result = await shared.edit(filePath, "Same text", "Same text");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
-			expect((await shared.read(filePath)).content).toContain("Same text");
+			const content = await shared.read(filePath);
+			expect(content.content).toContain("Same text");
 		}, timeout);
 		it("should handle unicode content", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -526,7 +557,8 @@ function registerEditTests(getShared, config, timeout) {
 			const result = await shared.edit(filePath, "    ", " ");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
-			expect((await shared.read(filePath)).content).toContain("Line1 Line2");
+			const content = await shared.read(filePath);
+			expect(content.content).toContain("Line1 Line2");
 		}, timeout);
 		it("should handle very long old and new strings", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -545,7 +577,8 @@ function registerEditTests(getShared, config, timeout) {
 			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-line-endings.txt");
 			await shared.write(filePath, "Line 1\nLine 2\nLine 3\n");
-			expect((await shared.edit(filePath, "Line 2", "Modified Line 2")).error).toBeUndefined();
+			const result = await shared.edit(filePath, "Line 2", "Modified Line 2");
+			expect(result.error).toBeUndefined();
 			const content = await shared.read(filePath);
 			expect(content.content).toContain("Line 1");
 			expect(content.content).toContain("Modified Line 2");
@@ -558,7 +591,8 @@ function registerEditTests(getShared, config, timeout) {
 			const result = await shared.edit(filePath, "brown fox", "red cat");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
-			expect((await shared.execute(`cat ${filePath}`)).output).toContain("The quick red cat jumps");
+			const execResult = await shared.execute(`cat ${filePath}`);
+			expect(execResult.output).toContain("The quick red cat jumps");
 		}, timeout);
 	});
 }
@@ -642,7 +676,8 @@ function registerLsInfoTests(getShared, config, timeout) {
 			await shared.write(`${baseDir}/\u0444\u0430\u0439\u043B.txt`, "content");
 			const lsResult = await shared.ls(baseDir);
 			expect(lsResult.error).toBeUndefined();
-			expect((lsResult.files || []).length).toBe(2);
+			const result = lsResult.files || [];
+			expect(result.length).toBe(2);
 		}, timeout);
 		it("should handle large directories", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -662,7 +697,8 @@ function registerLsInfoTests(getShared, config, timeout) {
 			await shared.write(`${baseDir}/file.txt`, "content");
 			const lsResult = await shared.ls(`${baseDir}/`);
 			expect(lsResult.error).toBeUndefined();
-			expect((lsResult.files || []).length).toBeGreaterThanOrEqual(1);
+			const result = lsResult.files || [];
+			expect(result.length).toBeGreaterThanOrEqual(1);
 		}, timeout);
 		it("should handle special characters in filenames", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -732,7 +768,8 @@ function registerGrepRawTests(getShared, config, timeout) {
 			expect(result.error).toBeUndefined();
 			const matches = result.matches;
 			expect(matches.length).toBe(3);
-			expect(matches.map((m) => m.line)).toEqual([
+			const lineNumbers = matches.map((m) => m.line);
+			expect(lineNumbers).toEqual([
 				1,
 				3,
 				5
@@ -927,7 +964,8 @@ function registerGlobInfoTests(getShared, config, timeout) {
 			expect(globResult.error).toBeUndefined();
 			const result = globResult.files || [];
 			expect(result.length).toBe(2);
-			expect(result.map((info) => info.path)).not.toContain("file10.txt");
+			const paths = result.map((info) => info.path);
+			expect(paths).not.toContain("file10.txt");
 		}, timeout);
 		it("should match multiple extensions separately", async () => {
 			const shared = adaptSandboxInstance(getShared());
@@ -996,8 +1034,10 @@ function registerInitialFilesTests(config, timeout) {
 			} }));
 			try {
 				expect(tmp.isRunning).toBe(true);
-				expect((await tmp.execute(`cat ${buttonPath}`)).output).toContain("Button");
-				expect((await tmp.execute(`cat ${helperPath}`)).output).toContain("capitalize");
+				const buttonContent = await tmp.execute(`cat ${buttonPath}`);
+				expect(buttonContent.output).toContain("Button");
+				const helperContent = await tmp.execute(`cat ${helperPath}`);
+				expect(helperContent.output).toContain("capitalize");
 			} finally {
 				await config.closeSandbox?.(tmp);
 			}
@@ -1017,7 +1057,8 @@ function registerInitialFilesTests(config, timeout) {
 			const filePath = config.resolvePath("init-read-test.txt");
 			const tmp = await withRetry(() => config.createSandbox({ initialFiles: { [filePath]: "Content for read test" } }));
 			try {
-				expect((await adaptSandboxInstance(tmp).read(filePath)).content).toContain("Content for read test");
+				const content = await adaptSandboxInstance(tmp).read(filePath);
+				expect(content.content).toContain("Content for read test");
 			} finally {
 				await config.closeSandbox?.(tmp);
 			}
@@ -1029,7 +1070,8 @@ function registerInitialFilesTests(config, timeout) {
 				const results = await tmp.downloadFiles([filePath]);
 				expect(results[0].error).toBeNull();
 				expect(results[0].content).not.toBeNull();
-				expect(new TextDecoder().decode(results[0].content)).toContain("Content for download test");
+				const content = new TextDecoder().decode(results[0].content);
+				expect(content).toContain("Content for download test");
 			} finally {
 				await config.closeSandbox?.(tmp);
 			}
@@ -1052,7 +1094,8 @@ function registerInitialFilesTests(config, timeout) {
 			try {
 				const lsResult = await adaptSandboxInstance(tmp).ls(dirPath);
 				expect(lsResult.error).toBeUndefined();
-				expect((lsResult.files || []).map((e) => e.path.replace(/\/$/, ""))).toContain(filePath);
+				const paths = (lsResult.files || []).map((e) => e.path.replace(/\/$/, ""));
+				expect(paths).toContain(filePath);
 			} finally {
 				await config.closeSandbox?.(tmp);
 			}
@@ -1070,9 +1113,12 @@ function registerIntegrationTests(getShared, config, timeout) {
 		it("should complete a write-read-edit-read workflow", async () => {
 			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("intg-workflow.txt");
-			expect((await shared.write(filePath, "Original content")).error).toBeUndefined();
-			expect((await shared.read(filePath)).content).toContain("Original content");
-			expect((await shared.edit(filePath, "Original", "Modified")).error).toBeUndefined();
+			const writeResult = await shared.write(filePath, "Original content");
+			expect(writeResult.error).toBeUndefined();
+			const content = await shared.read(filePath);
+			expect(content.content).toContain("Original content");
+			const editResult = await shared.edit(filePath, "Original", "Modified");
+			expect(editResult.error).toBeUndefined();
 			const updatedContent = await shared.read(filePath);
 			expect(updatedContent.content).toContain("Modified content");
 			expect(updatedContent.content).not.toContain("Original");
@@ -1092,7 +1138,8 @@ function registerIntegrationTests(getShared, config, timeout) {
 			expect(lsPaths).toContain(`${baseDir}/subdir2`);
 			const globResult = await shared.glob("**/*.txt", baseDir);
 			expect(globResult.error).toBeUndefined();
-			expect((globResult.files || []).length).toBe(3);
+			const files = globResult.files || [];
+			expect(files.length).toBe(3);
 			const grepResult = await shared.grep("file", baseDir);
 			expect(grepResult.error).toBeUndefined();
 			expect(grepResult.matches.length).toBeGreaterThanOrEqual(3);
@@ -1120,7 +1167,7 @@ function registerIntegrationTests(getShared, config, timeout) {
 * - Sandbox lifecycle (create, isRunning, close, two-step initialization)
 * - Command execution (echo, exit codes, multiline output, stderr, env vars)
 * - File operations (upload, download, read, write, edit, multiple files)
-* - write() (new file, parent dirs, existing file, special chars, unicode, long content)
+* - write() (new file, parent dirs, existing file overwrite, special chars, unicode, long content)
 * - read() (basic, nonexistent, offset, limit, offset+limit, unicode, chunked)
 * - edit() (single/multi occurrence, replaceAll, not found, special chars, multiline, unicode)
 * - ls() (basic listing, empty dir, hidden files, large dir, absolute paths)
@@ -1227,4 +1274,4 @@ function sandboxStandardTests(config) {
 //#endregion
 export { withRetry as n, sandboxStandardTests as t };
 
-//# sourceMappingURL=sandbox-BbDX1T-X.js.map
+//# sourceMappingURL=sandbox-Bnab52lG.js.map