@langchain/sandbox-standard-tests 0.0.3 → 1.0.0-alpha.0

package/dist/{sandbox-C22TOwhI.cjs → sandbox-D7MiOPSd.cjs}

@@ -1,4 +1,4 @@
-
+let deepagents = require("deepagents");
 //#region src/tests/lifecycle.ts
 /**
 * Register sandbox lifecycle tests (create, isRunning, close, two-step init).
@@ -8,8 +8,6 @@
 */
 function registerLifecycleTests(getShared, config, timeout) {
 	const { describe, it, expect, beforeAll, afterAll } = config.runner;
-	const describeSkipIf = describe.skipIf ?? ((condition) => condition ? describe.skip ?? (() => {}) : describe);
-	const itSkipIf = it.skipIf ?? ((condition) => condition ? () => {} : it);
 	describe("sandbox lifecycle", () => {
 		it("should create sandbox and have a valid id", () => {
 			const shared = getShared();
@@ -21,7 +19,7 @@ function registerLifecycleTests(getShared, config, timeout) {
 		it("should have isRunning as true after creation", () => {
 			expect(getShared().isRunning).toBe(true);
 		}, timeout);
-		describeSkipIf(!(typeof config.closeSandbox === "function"))("close", () => {
+		if (typeof config.closeSandbox === "function") describe("close", () => {
 			let tmp;
 			beforeAll(async () => {
 				tmp = await withRetry(() => config.createSandbox());
@@ -37,14 +35,14 @@ function registerLifecycleTests(getShared, config, timeout) {
 				expect(tmp.isRunning).toBe(false);
 			}, timeout);
 		});
-		describe("two-step initialization", () => {
+		if (config.createUninitializedSandbox) describe("two-step initialization", () => {
 			let tmp;
 			afterAll(async () => {
 				try {
 					if (tmp) await config.closeSandbox?.(tmp);
 				} catch {}
 			}, timeout);
-			itSkipIf(!config.createUninitializedSandbox)("should work with two-step initialization", async () => {
+			it("should work with two-step initialization", async () => {
 				tmp = config.createUninitializedSandbox();
 				expect(tmp.isRunning).toBe(false);
 				await withRetry(() => tmp.initialize());
@@ -54,7 +52,6 @@ function registerLifecycleTests(getShared, config, timeout) {
 		});
 	});
 }
-
 //#endregion
 //#region src/tests/command-execution.ts
 /**
@@ -92,7 +89,42 @@ function registerCommandExecutionTests(getShared, config, timeout) {
 		}, timeout);
 	});
 }
-
+//#endregion
+//#region src/adapter.ts
+/**
+* Adapter to convert v1 SandboxInstance to v2 SandboxInstanceV2.
+*/
+/**
+* Adapt a sandbox instance (v1 or v2) to SandboxInstanceV2.
+*
+* This builds on {@link adaptSandboxProtocol} from deepagents, which handles
+* the core protocol adaptation (BackendProtocol → BackendProtocolV2 and
+* sandbox properties execute/id).
+*
+* This function additionally preserves test-specific properties:
+* - `isRunning` (required)
+* - `close` (optional)
+* - `initialize` (optional)
+* - `uploadFiles` (required, though optional in base protocol)
+* - `downloadFiles` (required, though optional in base protocol)
+*
+* @param sandbox - Sandbox instance (v1 or v2)
+* @returns SandboxInstanceV2-compatible sandbox
+*/
+function adaptSandboxInstance(sandbox) {
+	const adapted = (0, deepagents.adaptSandboxProtocol)(sandbox);
+	const sb = sandbox;
+	if (typeof sb.close === "function") adapted.close = () => sb.close();
+	if (Object.getOwnPropertyDescriptor(Object.getPrototypeOf(sandbox), "isRunning")?.get) Object.defineProperty(adapted, "isRunning", {
+		get: () => sb.isRunning,
+		enumerable: true
+	});
+	else if ("isRunning" in sandbox) adapted.isRunning = sb.isRunning;
+	if (typeof sb.initialize === "function") adapted.initialize = () => sb.initialize();
+	if (typeof sb.uploadFiles === "function") adapted.uploadFiles = (files) => sb.uploadFiles(files);
+	if (typeof sb.downloadFiles === "function") adapted.downloadFiles = (paths) => sb.downloadFiles(paths);
+	return adapted;
+}
 //#endregion
 //#region src/tests/file-operations.ts
 /**
@@ -130,11 +162,11 @@ function registerFileOperationTests(getShared, config, timeout) {
 			expect(results[0].error).toBe("file_not_found");
 		}, timeout);
 		it("should use inherited read method from BaseSandbox", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			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)).toContain("Read test content");
+			expect((await shared.read(filePath)).content).toContain("Read test content");
 		}, timeout);
 		it("should use inherited write method from BaseSandbox", async () => {
 			const shared = getShared();
@@ -169,7 +201,6 @@ function registerFileOperationTests(getShared, config, timeout) {
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/write.ts
 /**
@@ -254,7 +285,6 @@ function registerWriteTests(getShared, config, timeout) {
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/read.ts
 /**
@@ -265,120 +295,119 @@ function registerReadTests(getShared, config, timeout) {
 	const { describe, it, expect } = config.runner;
 	describe("read", () => {
 		it("should read a file with line numbers", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-basic.txt");
 			await shared.write(filePath, "Line 1\nLine 2\nLine 3");
 			const result = await shared.read(filePath);
-			expect(result).not.toContain("Error:");
-			expect(result).toContain("Line 1");
-			expect(result).toContain("Line 2");
-			expect(result).toContain("Line 3");
+			expect(result.error).toBeUndefined();
+			expect(result.content).toContain("Line 1");
+			expect(result.content).toContain("Line 2");
+			expect(result.content).toContain("Line 3");
 		}, timeout);
 		it("should return error for nonexistent file", async () => {
 			const filePath = config.resolvePath("rd-nonexistent-xyz.txt");
-			const result = await getShared().read(filePath);
-			expect(result).toContain("Error:");
-			expect(result.toLowerCase()).toContain("not found");
+			const result = await adaptSandboxInstance(getShared()).read(filePath);
+			expect(result.error).toBeDefined();
+			expect(result.error.toLowerCase()).toContain("not found");
 		}, timeout);
 		it("should handle reading an empty file", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-empty.txt");
 			await shared.write(filePath, "");
-			expect((await shared.read(filePath)).toLowerCase()).not.toContain("error:");
+			expect((await shared.read(filePath)).error).toBeUndefined();
 		}, timeout);
 		it("should read with offset parameter", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-offset.txt");
 			const content = Array.from({ length: 10 }, (_, i) => `Row_${i + 1}_content`).join("\n");
 			await shared.write(filePath, content);
 			const result = await shared.read(filePath, 5);
-			expect(result).toContain("Row_6_content");
-			expect(result).not.toContain("Row_1_content");
+			expect(result.content).toContain("Row_6_content");
+			expect(result.content).not.toContain("Row_1_content");
 		}, timeout);
 		it("should read with limit parameter", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-limit.txt");
 			const content = Array.from({ length: 100 }, (_, i) => `Row_${i + 1}_content`).join("\n");
 			await shared.write(filePath, content);
 			const result = await shared.read(filePath, 0, 5);
-			expect(result).toContain("Row_1_content");
-			expect(result).toContain("Row_5_content");
-			expect(result).not.toContain("Row_6_content");
+			expect(result.content).toContain("Row_1_content");
+			expect(result.content).toContain("Row_5_content");
+			expect(result.content).not.toContain("Row_6_content");
 		}, timeout);
 		it("should read with both offset and limit", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-offset-limit.txt");
 			const content = Array.from({ length: 20 }, (_, i) => `Row_${i + 1}_content`).join("\n");
 			await shared.write(filePath, content);
 			const result = await shared.read(filePath, 10, 5);
-			expect(result).toContain("Row_11_content");
-			expect(result).toContain("Row_15_content");
-			expect(result).not.toContain("Row_10_content");
-			expect(result).not.toContain("Row_16_content");
+			expect(result.content).toContain("Row_11_content");
+			expect(result.content).toContain("Row_15_content");
+			expect(result.content).not.toContain("Row_10_content");
+			expect(result.content).not.toContain("Row_16_content");
 		}, timeout);
 		it("should read unicode content", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-unicode.txt");
 			await shared.write(filePath, "Hello 👋 世界\nПривет мир\nمرحبا العالم");
 			const result = await shared.read(filePath);
-			expect(result).not.toContain("Error:");
-			expect(result).toContain("👋");
-			expect(result).toContain("世界");
-			expect(result).toContain("Привет");
+			expect(result.error).toBeUndefined();
+			expect(result.content).toContain("👋");
+			expect(result.content).toContain("世界");
+			expect(result.content).toContain("Привет");
 		}, timeout);
 		it("should handle files with very long lines", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-long-lines.txt");
 			const content = `Short line\n${"x".repeat(3e3)}\nAnother short line`;
 			await shared.write(filePath, content);
 			const result = await shared.read(filePath);
-			expect(result).not.toContain("Error:");
-			expect(result).toContain("Short line");
+			expect(result.error).toBeUndefined();
+			expect(result.content).toContain("Short line");
 		}, timeout);
 		it("should return nothing with limit=0", async () => {
-			const shared = getShared();
+			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)).not.toContain("Line 1");
+			expect((await shared.read(filePath, 0, 0)).content).not.toContain("Line 1");
 		}, timeout);
 		it("should handle offset beyond file length", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-offset-beyond.txt");
 			await shared.write(filePath, "Line 1\nLine 2\nLine 3");
 			const result = await shared.read(filePath, 100, 10);
-			expect(result).not.toContain("Line 1");
-			expect(result).not.toContain("Line 2");
-			expect(result).not.toContain("Line 3");
+			expect(result.content ?? "").not.toContain("Line 1");
+			expect(result.content ?? "").not.toContain("Line 2");
+			expect(result.content ?? "").not.toContain("Line 3");
 		}, timeout);
 		it("should handle offset exactly at file length", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-offset-exact.txt");
 			const content = Array.from({ length: 5 }, (_, i) => `Line ${i + 1}`).join("\n");
 			await shared.write(filePath, content);
 			const result = await shared.read(filePath, 5, 10);
-			expect(result).not.toContain("Line 1");
-			expect(result).not.toContain("Line 5");
+			expect(result.content ?? "").not.toContain("Line 1");
+			expect(result.content ?? "").not.toContain("Line 5");
 		}, timeout);
 		it("should read a large file in chunks", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("rd-chunked.txt");
 			const content = Array.from({ length: 1e3 }, (_, i) => `Line_${String(i).padStart(4, "0")}_content`).join("\n");
 			await shared.write(filePath, content);
 			const chunk1 = await shared.read(filePath, 0, 100);
-			expect(chunk1).toContain("Line_0000_content");
-			expect(chunk1).toContain("Line_0099_content");
-			expect(chunk1).not.toContain("Line_0100_content");
+			expect(chunk1.content).toContain("Line_0000_content");
+			expect(chunk1.content).toContain("Line_0099_content");
+			expect(chunk1.content).not.toContain("Line_0100_content");
 			const chunk2 = await shared.read(filePath, 500, 100);
-			expect(chunk2).toContain("Line_0500_content");
-			expect(chunk2).toContain("Line_0599_content");
-			expect(chunk2).not.toContain("Line_0499_content");
+			expect(chunk2.content).toContain("Line_0500_content");
+			expect(chunk2.content).toContain("Line_0599_content");
+			expect(chunk2.content).not.toContain("Line_0499_content");
 			const chunk3 = await shared.read(filePath, 900, 100);
-			expect(chunk3).toContain("Line_0900_content");
-			expect(chunk3).toContain("Line_0999_content");
+			expect(chunk3.content).toContain("Line_0900_content");
+			expect(chunk3.content).toContain("Line_0999_content");
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/edit.ts
 /**
@@ -390,26 +419,26 @@ function registerEditTests(getShared, config, timeout) {
 	const { describe, it, expect } = config.runner;
 	describe("edit", () => {
 		it("should edit a single occurrence", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-single.txt");
 			await shared.write(filePath, "Hello world\nGoodbye world\nHello again");
 			const result = await shared.edit(filePath, "Goodbye", "Farewell");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
 			const content = await shared.read(filePath);
-			expect(content).toContain("Farewell world");
-			expect(content).not.toContain("Goodbye");
+			expect(content.content).toContain("Farewell world");
+			expect(content.content).not.toContain("Goodbye");
 		}, timeout);
 		it("should fail with multiple occurrences without replaceAll", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-multi-fail.txt");
 			await shared.write(filePath, "apple\nbanana\napple\norange\napple");
 			const result = await shared.edit(filePath, "apple", "pear", false);
 			expect(result.error).toBeDefined();
 			expect(result.error.toLowerCase()).toContain("multiple");
 			const content = await shared.read(filePath);
-			expect(content).toContain("apple");
-			expect(content).not.toContain("pear");
+			expect(content.content).toContain("apple");
+			expect(content.content).not.toContain("pear");
 		}, timeout);
 		it("should replace all occurrences with replaceAll=true", async () => {
 			const shared = getShared();
@@ -437,70 +466,70 @@ function registerEditTests(getShared, config, timeout) {
 			expect(result.error.toLowerCase()).toContain("not found");
 		}, timeout);
 		it("should handle special characters and regex metacharacters", async () => {
-			const shared = getShared();
+			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 content = await shared.read(filePath);
-			expect(content).toContain("$200.00");
-			expect(content).toContain("[0-9]+");
+			expect(content.content).toContain("$200.00");
+			expect(content.content).toContain("[0-9]+");
 		}, timeout);
 		it("should handle multiline string replacement", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-multiline.txt");
 			await shared.write(filePath, "Line 1\nLine 2\nLine 3");
 			const result = await shared.edit(filePath, "Line 1\nLine 2", "Combined");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
 			const content = await shared.read(filePath);
-			expect(content).toContain("Combined");
-			expect(content).toContain("Line 3");
-			expect(content).not.toContain("Line 1");
+			expect(content.content).toContain("Combined");
+			expect(content.content).toContain("Line 3");
+			expect(content.content).not.toContain("Line 1");
 		}, timeout);
 		it("should delete content by replacing with empty string", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-delete.txt");
 			await shared.write(filePath, "Keep this\nDelete this part\nKeep this too");
 			const result = await shared.edit(filePath, "Delete this part\n", "");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
 			const content = await shared.read(filePath);
-			expect(content).toContain("Keep this");
-			expect(content).toContain("Keep this too");
-			expect(content).not.toContain("Delete this part");
+			expect(content.content).toContain("Keep this");
+			expect(content.content).toContain("Keep this too");
+			expect(content.content).not.toContain("Delete this part");
 		}, timeout);
 		it("should handle identical old and new strings", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-identical.txt");
 			await shared.write(filePath, "Same text");
 			const result = await shared.edit(filePath, "Same text", "Same text");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
-			expect(await shared.read(filePath)).toContain("Same text");
+			expect((await shared.read(filePath)).content).toContain("Same text");
 		}, timeout);
 		it("should handle unicode content", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-unicode.txt");
 			await shared.write(filePath, "Hello 👋 world\n世界 is beautiful");
 			const result = await shared.edit(filePath, "👋", "🌍");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
 			const content = await shared.read(filePath);
-			expect(content).toContain("🌍");
-			expect(content).not.toContain("👋");
+			expect(content.content).toContain("🌍");
+			expect(content.content).not.toContain("👋");
 		}, timeout);
 		it("should handle whitespace-only strings", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-whitespace.txt");
 			await shared.write(filePath, "Line1    Line2");
 			const result = await shared.edit(filePath, "    ", " ");
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
-			expect(await shared.read(filePath)).toContain("Line1 Line2");
+			expect((await shared.read(filePath)).content).toContain("Line1 Line2");
 		}, timeout);
 		it("should handle very long old and new strings", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const filePath = config.resolvePath("ed-long.txt");
 			const oldString = "x".repeat(1e3);
 			const newString = "y".repeat(1e3);
@@ -509,18 +538,18 @@ function registerEditTests(getShared, config, timeout) {
 			expect(result.error).toBeUndefined();
 			expect(result.occurrences).toBe(1);
 			const content = await shared.read(filePath);
-			expect(content).toContain("y".repeat(100));
-			expect(content).not.toContain("x".repeat(100));
+			expect(content.content).toContain("y".repeat(100));
+			expect(content.content).not.toContain("x".repeat(100));
 		}, timeout);
 		it("should preserve line endings correctly", async () => {
-			const shared = getShared();
+			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 content = await shared.read(filePath);
-			expect(content).toContain("Line 1");
-			expect(content).toContain("Modified Line 2");
-			expect(content).toContain("Line 3");
+			expect(content.content).toContain("Line 1");
+			expect(content.content).toContain("Modified Line 2");
+			expect(content.content).toContain("Line 3");
 		}, timeout);
 		it("should edit a substring within a line", async () => {
 			const shared = getShared();
@@ -533,32 +562,35 @@ function registerEditTests(getShared, config, timeout) {
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/ls-info.ts
 /**
-* Register lsInfo() tests (absolute paths, files + subdirs, empty dir,
+* Register ls() tests (absolute paths, files + subdirs, empty dir,
 * nonexistent dir, hidden files, spaces, unicode, large dir, trailing slash,
 * special characters).
 */
 function registerLsInfoTests(getShared, config, timeout) {
 	const { describe, it, expect } = config.runner;
-	describe("lsInfo", () => {
+	describe("ls", () => {
 		it("should return absolute paths", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-absolute");
 			await shared.write(`${baseDir}/file.txt`, "content");
-			const result = await shared.lsInfo(baseDir);
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const result = lsResult.files || [];
 			expect(result.length).toBe(1);
 			expect(result[0].path).toBe(`${baseDir}/file.txt`);
 		}, timeout);
 		it("should list files and subdirectories", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-basic");
 			await shared.write(`${baseDir}/file1.txt`, "content1");
 			await shared.write(`${baseDir}/file2.txt`, "content2");
 			await shared.execute(`mkdir -p '${baseDir}/subdir'`);
-			const result = await shared.lsInfo(baseDir);
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const result = lsResult.files || [];
 			expect(result.length).toBe(3);
 			const paths = result.map((info) => info.path.replace(/\/$/, ""));
 			expect(paths).toContain(`${baseDir}/file1.txt`);
@@ -568,86 +600,101 @@ function registerLsInfoTests(getShared, config, timeout) {
 			else expect(info.is_dir).toBe(false);
 		}, timeout);
 		it("should return empty list for empty directory", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const emptyDir = config.resolvePath("li-empty-dir");
 			await shared.execute(`mkdir -p '${emptyDir}'`);
-			expect(await shared.lsInfo(emptyDir)).toEqual([]);
+			const lsResult = await shared.ls(emptyDir);
+			expect(lsResult.error).toBeUndefined();
+			expect(lsResult.files).toEqual([]);
 		}, timeout);
 		it("should return empty list for nonexistent directory", async () => {
 			const nonexistentDir = config.resolvePath("li-does-not-exist-12345");
-			expect(await getShared().lsInfo(nonexistentDir)).toEqual([]);
+			const lsResult = await adaptSandboxInstance(getShared()).ls(nonexistentDir);
+			expect(lsResult.error).toBeUndefined();
+			expect(lsResult.files).toEqual([]);
 		}, timeout);
 		it("should include hidden files", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-hidden");
 			await shared.write(`${baseDir}/.hidden`, "hidden content");
 			await shared.write(`${baseDir}/visible.txt`, "visible content");
-			const paths = (await shared.lsInfo(baseDir)).map((info) => info.path);
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const paths = (lsResult.files || []).map((info) => info.path);
 			expect(paths).toContain(`${baseDir}/.hidden`);
 			expect(paths).toContain(`${baseDir}/visible.txt`);
 		}, timeout);
 		it("should handle directories with spaces in names", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-spaces");
 			await shared.write(`${baseDir}/file with spaces.txt`, "content");
 			await shared.execute(`mkdir -p '${baseDir}/dir with spaces'`);
-			const paths = (await shared.lsInfo(baseDir)).map((info) => info.path.replace(/\/$/, ""));
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const paths = (lsResult.files || []).map((info) => info.path.replace(/\/$/, ""));
 			expect(paths).toContain(`${baseDir}/file with spaces.txt`);
 			expect(paths).toContain(`${baseDir}/dir with spaces`);
 		}, timeout);
 		it("should handle unicode filenames", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-unicode");
 			await shared.write(`${baseDir}/\u6D4B\u8BD5\u6587\u4EF6.txt`, "content");
 			await shared.write(`${baseDir}/\u0444\u0430\u0439\u043B.txt`, "content");
-			expect((await shared.lsInfo(baseDir)).length).toBe(2);
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			expect((lsResult.files || []).length).toBe(2);
 		}, timeout);
 		it("should handle large directories", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-large");
 			await shared.execute(`mkdir -p '${baseDir}' && cd '${baseDir}' && for i in \$(seq 0 49); do echo 'content' > file_\$(printf '%03d' \$i).txt; done`);
-			const result = await shared.lsInfo(baseDir);
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const result = lsResult.files || [];
 			expect(result.length).toBe(50);
 			const paths = result.map((info) => info.path);
 			expect(paths).toContain(`${baseDir}/file_000.txt`);
 			expect(paths).toContain(`${baseDir}/file_049.txt`);
 		}, timeout);
 		it("should handle trailing slash in path", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-trailing");
 			await shared.write(`${baseDir}/file.txt`, "content");
-			expect((await shared.lsInfo(`${baseDir}/`)).length).toBeGreaterThanOrEqual(1);
+			const lsResult = await shared.ls(`${baseDir}/`);
+			expect(lsResult.error).toBeUndefined();
+			expect((lsResult.files || []).length).toBeGreaterThanOrEqual(1);
 		}, timeout);
 		it("should handle special characters in filenames", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("li-special-chars");
 			await shared.write(`${baseDir}/file(1).txt`, "content");
 			await shared.write(`${baseDir}/file-3.txt`, "content");
-			const paths = (await shared.lsInfo(baseDir)).map((info) => info.path);
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const paths = (lsResult.files || []).map((info) => info.path);
 			expect(paths).toContain(`${baseDir}/file(1).txt`);
 			expect(paths).toContain(`${baseDir}/file-3.txt`);
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/grep-raw.ts
 /**
-* Register grepRaw() tests (basic search, glob filter, no matches,
+* Register grep() tests (basic search, glob filter, no matches,
 * multi matches, literal matching, unicode, case sensitivity, special chars,
 * empty dir, nested dirs, line numbers).
 */
 function registerGrepRawTests(getShared, config, timeout) {
 	const { describe, it, expect } = config.runner;
-	describe("grepRaw", () => {
+	describe("grep", () => {
 		it("should find basic literal pattern matches", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-basic");
 			await shared.write(`${baseDir}/file1.txt`, "Hello world\nGoodbye world");
 			await shared.write(`${baseDir}/file2.txt`, "Hello there\nGoodbye friend");
-			const result = await shared.grepRaw("Hello", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("Hello", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(2);
 			const paths = matches.map((m) => m.path);
 			expect(paths.some((p) => p.includes("file1.txt"))).toBe(true);
@@ -658,32 +705,32 @@ function registerGrepRawTests(getShared, config, timeout) {
 			}
 		}, timeout);
 		it("should filter files with glob pattern", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-glob");
 			await shared.write(`${baseDir}/test.txt`, "pattern_match");
 			await shared.write(`${baseDir}/test.py`, "pattern_match");
 			await shared.write(`${baseDir}/test.md`, "pattern_match");
-			const result = await shared.grepRaw("pattern_match", baseDir, "*.py");
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("pattern_match", baseDir, "*.py");
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(1);
 			expect(matches[0].path).toContain("test.py");
 		}, timeout);
-		it("should return empty array when no matches found", async () => {
-			const shared = getShared();
+		it("should return empty matches when no matches found", async () => {
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-no-match");
 			await shared.write(`${baseDir}/file.txt`, "Hello world");
-			const result = await shared.grepRaw("nonexistent_str", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			expect(result.length).toBe(0);
+			const result = await shared.grep("nonexistent_str", baseDir);
+			expect(result.error).toBeUndefined();
+			expect(result.matches.length).toBe(0);
 		}, timeout);
 		it("should find multiple matches in a single file", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-multi");
 			await shared.write(`${baseDir}/fruits.txt`, "apple\nbanana\napple\norange\napple");
-			const result = await shared.grepRaw("apple", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("apple", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(3);
 			expect(matches.map((m) => m.line)).toEqual([
 				1,
@@ -692,99 +739,101 @@ function registerGrepRawTests(getShared, config, timeout) {
 			]);
 		}, timeout);
 		it("should match literal strings not regex", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-literal");
 			await shared.write(`${baseDir}/numbers.txt`, "test123\ntest456\nabcdef");
-			const result = await shared.grepRaw("test123", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("test123", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(1);
 			expect(matches[0].text).toContain("test123");
 		}, timeout);
 		it("should find unicode patterns", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-unicode");
 			await shared.write(`${baseDir}/unicode.txt`, "Hello 世界\nПривет мир\n测试 pattern");
-			const result = await shared.grepRaw("世界", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("世界", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(1);
 			expect(matches[0].text).toContain("世界");
 		}, timeout);
 		it("should be case-sensitive by default", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-case");
 			await shared.write(`${baseDir}/case.txt`, "Hello\nhello\nHELLO");
-			const result = await shared.grepRaw("Hello", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("Hello", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(1);
 			expect(matches[0].text).toContain("Hello");
 		}, timeout);
 		it("should handle special characters as literals", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-special");
 			await shared.write(`${baseDir}/special.txt`, "Price: $100\nPath: /usr/bin\nPattern: [a-z]*");
-			const result1 = await shared.grepRaw("$100", baseDir);
-			expect(Array.isArray(result1)).toBe(true);
-			const matches1 = result1;
+			const result1 = await shared.grep("$100", baseDir);
+			expect(result1.error).toBeUndefined();
+			const matches1 = result1.matches;
 			expect(matches1.length).toBe(1);
 			expect(matches1[0].text).toContain("$100");
-			const result2 = await shared.grepRaw("[a-z]*", baseDir);
-			expect(Array.isArray(result2)).toBe(true);
-			const matches2 = result2;
+			const result2 = await shared.grep("[a-z]*", baseDir);
+			expect(result2.error).toBeUndefined();
+			const matches2 = result2.matches;
 			expect(matches2.length).toBe(1);
 			expect(matches2[0].text).toContain("[a-z]*");
 		}, timeout);
-		it("should return empty array for empty directory", async () => {
-			const shared = getShared();
+		it("should return empty matches for empty directory", async () => {
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-empty-dir");
 			await shared.execute(`mkdir -p '${baseDir}'`);
-			const result = await shared.grepRaw("anything", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			expect(result.length).toBe(0);
+			const result = await shared.grep("anything", baseDir);
+			expect(result.error).toBeUndefined();
+			expect(result.matches.length).toBe(0);
 		}, timeout);
 		it("should search recursively across nested directories", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-nested");
 			await shared.write(`${baseDir}/root.txt`, "target_nested here");
 			await shared.write(`${baseDir}/sub1/level1.txt`, "target_nested here");
 			await shared.write(`${baseDir}/sub1/sub2/level2.txt`, "target_nested here");
-			const result = await shared.grepRaw("target_nested", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			expect(result.length).toBe(3);
+			const result = await shared.grep("target_nested", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
+			expect(matches.length).toBe(3);
 		}, timeout);
 		it("should report correct line numbers", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gr-line-nums");
 			const content = Array.from({ length: 100 }, (_, i) => `Line ${i + 1}`).join("\n");
 			await shared.write(`${baseDir}/long.txt`, content);
-			const result = await shared.grepRaw("Line 50", baseDir);
-			expect(Array.isArray(result)).toBe(true);
-			const matches = result;
+			const result = await shared.grep("Line 50", baseDir);
+			expect(result.error).toBeUndefined();
+			const matches = result.matches;
 			expect(matches.length).toBe(1);
 			expect(matches[0].line).toBe(50);
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/glob-info.ts
 /**
-* Register globInfo() tests (wildcard, recursive, no matches, directories,
+* Register glob() tests (wildcard, recursive, no matches, directories,
 * extension filter, hidden files, character classes, question mark,
 * multiple extensions, deeply nested).
 */
 function registerGlobInfoTests(getShared, config, timeout) {
 	const { describe, it, expect } = config.runner;
-	describe("globInfo", () => {
+	describe("glob", () => {
 		it("should match basic wildcard pattern", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-basic");
 			await shared.write(`${baseDir}/file1.txt`, "content");
 			await shared.write(`${baseDir}/file2.txt`, "content");
 			await shared.write(`${baseDir}/file3.py`, "content");
-			const result = await shared.globInfo("*.txt", baseDir);
+			const globResult = await shared.glob("*.txt", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBe(2);
 			const paths = result.map((info) => info.path);
 			expect(paths).toContain("file1.txt");
@@ -792,29 +841,35 @@ function registerGlobInfoTests(getShared, config, timeout) {
 			expect(paths.every((p) => !p.endsWith(".py"))).toBe(true);
 		}, timeout);
 		it("should match recursive pattern (**)", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-recursive");
 			await shared.write(`${baseDir}/root.txt`, "content");
 			await shared.write(`${baseDir}/subdir1/nested1.txt`, "content");
 			await shared.write(`${baseDir}/subdir2/nested2.txt`, "content");
-			const result = await shared.globInfo("**/*.txt", baseDir);
+			const globResult = await shared.glob("**/*.txt", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBeGreaterThanOrEqual(2);
 			const paths = result.map((info) => info.path);
 			expect(paths.some((p) => p.includes("nested1.txt"))).toBe(true);
 			expect(paths.some((p) => p.includes("nested2.txt"))).toBe(true);
 		}, timeout);
 		it("should return empty array when no matches", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-no-match");
 			await shared.write(`${baseDir}/file.txt`, "content");
-			expect(await shared.globInfo("*.py", baseDir)).toEqual([]);
+			const globResult = await shared.glob("*.py", baseDir);
+			expect(globResult.error).toBeUndefined();
+			expect(globResult.files).toEqual([]);
 		}, timeout);
 		it("should include directories in results", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-dirs");
 			await shared.execute(`mkdir -p '${baseDir}/dir1' '${baseDir}/dir2'`);
 			await shared.write(`${baseDir}/file.txt`, "content");
-			const result = await shared.globInfo("*", baseDir);
+			const globResult = await shared.glob("*", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBe(3);
 			const dirCount = result.filter((info) => info.is_dir).length;
 			const fileCount = result.filter((info) => !info.is_dir).length;
@@ -822,33 +877,39 @@ function registerGlobInfoTests(getShared, config, timeout) {
 			expect(fileCount).toBe(1);
 		}, timeout);
 		it("should match specific file extensions", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-ext");
 			await shared.write(`${baseDir}/test.py`, "content");
 			await shared.write(`${baseDir}/test.txt`, "content");
 			await shared.write(`${baseDir}/test.md`, "content");
-			const result = await shared.globInfo("*.py", baseDir);
+			const globResult = await shared.glob("*.py", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBe(1);
 			expect(result[0].path).toContain("test.py");
 		}, timeout);
 		it("should match hidden files explicitly", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-hidden");
 			await shared.write(`${baseDir}/.hidden1`, "content");
 			await shared.write(`${baseDir}/.hidden2`, "content");
 			await shared.write(`${baseDir}/visible.txt`, "content");
-			const paths = (await shared.globInfo(".*", baseDir)).map((info) => info.path);
+			const globResult = await shared.glob(".*", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const paths = (globResult.files || []).map((info) => info.path);
 			expect(paths.some((p) => p.includes(".hidden1") || p.includes(".hidden2"))).toBe(true);
 			expect(paths.every((p) => !p.includes("visible"))).toBe(true);
 		}, timeout);
 		it("should match character class patterns", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-charclass");
 			await shared.write(`${baseDir}/file1.txt`, "content");
 			await shared.write(`${baseDir}/file2.txt`, "content");
 			await shared.write(`${baseDir}/file3.txt`, "content");
 			await shared.write(`${baseDir}/fileA.txt`, "content");
-			const result = await shared.globInfo("file[1-2].txt", baseDir);
+			const globResult = await shared.glob("file[1-2].txt", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBe(2);
 			const paths = result.map((info) => info.path);
 			expect(paths).toContain("file1.txt");
@@ -857,39 +918,46 @@ function registerGlobInfoTests(getShared, config, timeout) {
 			expect(paths).not.toContain("fileA.txt");
 		}, timeout);
 		it("should match single character wildcard (?)", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-question");
 			await shared.write(`${baseDir}/file1.txt`, "content");
 			await shared.write(`${baseDir}/file2.txt`, "content");
 			await shared.write(`${baseDir}/file10.txt`, "content");
-			const result = await shared.globInfo("file?.txt", baseDir);
+			const globResult = await shared.glob("file?.txt", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBe(2);
 			expect(result.map((info) => info.path)).not.toContain("file10.txt");
 		}, timeout);
 		it("should match multiple extensions separately", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-multi-ext");
 			await shared.write(`${baseDir}/file.txt`, "content");
 			await shared.write(`${baseDir}/file.py`, "content");
 			await shared.write(`${baseDir}/file.md`, "content");
 			await shared.write(`${baseDir}/file.js`, "content");
-			const resultTxt = await shared.globInfo("*.txt", baseDir);
-			const resultPy = await shared.globInfo("*.py", baseDir);
+			const globResultTxt = await shared.glob("*.txt", baseDir);
+			expect(globResultTxt.error).toBeUndefined();
+			const resultTxt = globResultTxt.files || [];
+			const globResultPy = await shared.glob("*.py", baseDir);
+			expect(globResultPy.error).toBeUndefined();
+			const resultPy = globResultPy.files || [];
 			expect(resultTxt.length).toBe(1);
 			expect(resultPy.length).toBe(1);
 		}, timeout);
 		it("should match deeply nested patterns", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("gl-deep");
 			await shared.write(`${baseDir}/a/b/c/d/deep.txt`, "content");
 			await shared.write(`${baseDir}/a/b/other.txt`, "content");
-			const result = await shared.globInfo("**/deep.txt", baseDir);
+			const globResult = await shared.glob("**/deep.txt", baseDir);
+			expect(globResult.error).toBeUndefined();
+			const result = globResult.files || [];
 			expect(result.length).toBeGreaterThanOrEqual(1);
 			expect(result.some((info) => info.path.includes("deep.txt"))).toBe(true);
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/initial-files.ts
 /**
@@ -949,7 +1017,7 @@ 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 tmp.read(filePath)).toContain("Content for read test");
+				expect((await adaptSandboxInstance(tmp).read(filePath)).content).toContain("Content for read test");
 			} finally {
 				await config.closeSandbox?.(tmp);
 			}
@@ -977,19 +1045,20 @@ function registerInitialFilesTests(config, timeout) {
 				await config.closeSandbox?.(tmp);
 			}
 		}, timeout);
-		it("should make initialFiles in subdirectories visible via lsInfo()", async () => {
+		it("should make initialFiles in subdirectories visible via ls()", async () => {
 			const dirPath = config.resolvePath("init-ls-dir");
 			const filePath = `${dirPath}/file.txt`;
 			const tmp = await withRetry(() => config.createSandbox({ initialFiles: { [filePath]: "ls test content" } }));
 			try {
-				expect((await tmp.lsInfo(dirPath)).map((e) => e.path.replace(/\/$/, ""))).toContain(filePath);
+				const lsResult = await adaptSandboxInstance(tmp).ls(dirPath);
+				expect(lsResult.error).toBeUndefined();
+				expect((lsResult.files || []).map((e) => e.path.replace(/\/$/, ""))).toContain(filePath);
 			} finally {
 				await config.closeSandbox?.(tmp);
 			}
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/tests/integration.ts
 /**
@@ -999,34 +1068,37 @@ function registerIntegrationTests(getShared, config, timeout) {
 	const { describe, it, expect } = config.runner;
 	describe("integration workflows", () => {
 		it("should complete a write-read-edit-read workflow", async () => {
-			const shared = getShared();
+			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)).toContain("Original content");
+			expect((await shared.read(filePath)).content).toContain("Original content");
 			expect((await shared.edit(filePath, "Original", "Modified")).error).toBeUndefined();
 			const updatedContent = await shared.read(filePath);
-			expect(updatedContent).toContain("Modified content");
-			expect(updatedContent).not.toContain("Original");
+			expect(updatedContent.content).toContain("Modified content");
+			expect(updatedContent.content).not.toContain("Original");
 		}, timeout);
 		it("should handle complex directory operations", async () => {
-			const shared = getShared();
+			const shared = adaptSandboxInstance(getShared());
 			const baseDir = config.resolvePath("intg-complex");
 			await shared.write(`${baseDir}/root.txt`, "root file");
 			await shared.write(`${baseDir}/subdir1/file1.txt`, "file 1");
 			await shared.write(`${baseDir}/subdir1/file2.py`, "file 2");
 			await shared.write(`${baseDir}/subdir2/file3.txt`, "file 3");
-			const lsPaths = (await shared.lsInfo(baseDir)).map((info) => info.path.replace(/\/$/, ""));
+			const lsResult = await shared.ls(baseDir);
+			expect(lsResult.error).toBeUndefined();
+			const lsPaths = (lsResult.files || []).map((info) => info.path.replace(/\/$/, ""));
 			expect(lsPaths).toContain(`${baseDir}/root.txt`);
 			expect(lsPaths).toContain(`${baseDir}/subdir1`);
 			expect(lsPaths).toContain(`${baseDir}/subdir2`);
-			expect((await shared.globInfo("**/*.txt", baseDir)).length).toBe(3);
-			const grepResult = await shared.grepRaw("file", baseDir);
-			expect(Array.isArray(grepResult)).toBe(true);
-			expect(grepResult.length).toBeGreaterThanOrEqual(3);
+			const globResult = await shared.glob("**/*.txt", baseDir);
+			expect(globResult.error).toBeUndefined();
+			expect((globResult.files || []).length).toBe(3);
+			const grepResult = await shared.grep("file", baseDir);
+			expect(grepResult.error).toBeUndefined();
+			expect(grepResult.matches.length).toBeGreaterThanOrEqual(3);
 		}, timeout);
 	});
 }
-
 //#endregion
 //#region src/sandbox.ts
 /**
@@ -1051,9 +1123,9 @@ function registerIntegrationTests(getShared, config, timeout) {
 * - write() (new file, parent dirs, existing file, 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)
-* - lsInfo() (basic listing, empty dir, hidden files, large dir, absolute paths)
-* - grepRaw() (basic search, glob filter, case sensitivity, nested dirs, unicode)
-* - globInfo() (wildcard, recursive, extension filter, character classes, deeply nested)
+* - ls() (basic listing, empty dir, hidden files, large dir, absolute paths)
+* - grep() (basic search, glob filter, case sensitivity, nested dirs, unicode)
+* - glob() (wildcard, recursive, extension filter, character classes, deeply nested)
 * - Initial files support (basic, nested, empty)
 * - Integration workflows (write-read-edit, complex directory operations)
 * - Error handling (file not found, non-existent command)
@@ -1152,18 +1224,18 @@ function sandboxStandardTests(config) {
 		registerIntegrationTests(getShared, config, timeout);
 	});
 }
-
 //#endregion
-Object.defineProperty(exports, 'sandboxStandardTests', {
-  enumerable: true,
-  get: function () {
-    return sandboxStandardTests;
-  }
+Object.defineProperty(exports, "sandboxStandardTests", {
+	enumerable: true,
+	get: function() {
+		return sandboxStandardTests;
+	}
 });
-Object.defineProperty(exports, 'withRetry', {
-  enumerable: true,
-  get: function () {
-    return withRetry;
-  }
+Object.defineProperty(exports, "withRetry", {
+	enumerable: true,
+	get: function() {
+		return withRetry;
+	}
 });
-//# sourceMappingURL=sandbox-C22TOwhI.cjs.map
+
+//# sourceMappingURL=sandbox-D7MiOPSd.cjs.map