Use Effect FileSystem for workspace reads

Cursor Agent committed 4 months ago

Commit 05760161 parent 97e5cd32 files · +115 −59Browse files

Showing the changes to apps/server/src/workspace/WorkspaceFileSystem.test.ts (1 of 2 files). Show all

Unified · Split

apps/server/src/workspace/WorkspaceFileSystem.test.ts+76−19

 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { it, describe, expect } from "@effect/vitest";
+import { assert, it, describe } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as WorkspaceFileSystem from "./WorkspaceFileSystem.ts";
 import * as WorkspacePaths from "./WorkspacePaths.ts";
+const PROJECT_READ_FILE_MAX_BYTES = 1024 * 1024;
 const ProjectLayer = WorkspaceFileSystem.layer.pipe(
   Layer.provide(WorkspacePaths.layer),
   Layer.provide(WorkspaceEntries.layer.pipe(Layer.provide(WorkspacePaths.layer))),
   yield* fileSystem.writeFileString(absolutePath, contents).pipe(Effect.orDie);
 });
+const writeBinaryFile = Effect.fn("writeBinaryFile")(function* (
+  cwd: string,
+  relativePath: string,
+  contents: Uint8Array,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const absolutePath = path.join(cwd, relativePath);
+  yield* fileSystem
+    .makeDirectory(path.dirname(absolutePath), { recursive: true })
+    .pipe(Effect.orDie);
+  yield* fileSystem.writeFile(absolutePath, contents).pipe(Effect.orDie);
+});
 it.layer(TestLayer, { excludeTestServices: true })("WorkspaceFileSystemLive", (it) => {
   describe("readFile", () => {
     it.effect("reads UTF-8 files relative to the workspace root", () =>
           relativePath: "src/index.ts",
         });
-        expect(result).toEqual({
+        assert.deepStrictEqual(result, {
           relativePath: "src/index.ts",
           contents: "export const answer = 42;\n",
           byteLength: 26,
           .readFile({ cwd, relativePath: "../escape.md" })
           .pipe(Effect.flip);
-        expect(error.message).toContain(
+        assert.match(
-          "Workspace file path must be relative to the project root: ../escape.md",
+          error.message,
+          /Workspace file path must be relative to the project root: \.\.\/escape\.md/,
+        );
+      }),
+    );
+    it.effect("truncates text files larger than the preview byte limit", () =>
+      Effect.gen(function* () {
+        const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
+        const cwd = yield* makeTempDir;
+        yield* writeTextFile(cwd, "large.txt", `${"a".repeat(PROJECT_READ_FILE_MAX_BYTES)}tail`);
+        const result = yield* workspaceFileSystem.readFile({
+          cwd,
+          relativePath: "large.txt",
+        });
+        assert.strictEqual(result.byteLength, PROJECT_READ_FILE_MAX_BYTES + 4);
+        assert.strictEqual(result.contents.length, PROJECT_READ_FILE_MAX_BYTES);
+        assert.strictEqual(result.contents, "a".repeat(PROJECT_READ_FILE_MAX_BYTES));
+        assert.strictEqual(result.truncated, true);
+      }),
+    );
+    it.effect("rejects binary files before decoding them as text", () =>
+      Effect.gen(function* () {
+        const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
+        const cwd = yield* makeTempDir;
+        yield* writeBinaryFile(cwd, "image.bin", new Uint8Array([0x66, 0x6f, 0x00, 0x6f]));
+        const error = yield* workspaceFileSystem
+          .readFile({ cwd, relativePath: "image.bin" })
+          .pipe(Effect.flip);
+        assert.strictEqual(
+          error.message,
+          `Workspace file operation 'workspaceFileSystem.readFile' failed for 'image.bin' in '${cwd}'.`,
         );
+        assert.ok(error.cause instanceof Error);
+        assert.strictEqual((error.cause as Error).message, "Binary files cannot be previewed as text.");
       }),
     );
           .readFile({ cwd, relativePath: "linked-secret.txt" })
           .pipe(Effect.flip);
-        expect(error.message).toBe(
+        assert.strictEqual(
+          error.message,
           `Workspace file operation 'workspaceFileSystem.readFile' failed for 'linked-secret.txt' in '${cwd}'.`,
         );
-        expect(error.cause).toBeInstanceOf(Error);
+        assert.ok(error.cause instanceof Error);
-        expect((error.cause as Error).message).toBe(
+        assert.strictEqual(
+          (error.cause as Error).message,
           "Workspace file path resolves outside the project root.",
         );
       }),
           .readFileString(path.join(cwd, "plans/effect-rpc.md"))
           .pipe(Effect.orDie);
-        expect(result).toEqual({ relativePath: "plans/effect-rpc.md" });
+        assert.deepStrictEqual(result, { relativePath: "plans/effect-rpc.md" });
-        expect(saved).toBe("# Plan\n");
+        assert.strictEqual(saved, "# Plan\n");
       }),
     );
         yield* writeTextFile(cwd, "src/existing.ts", "export {};\n");
         const beforeWrite = yield* workspaceEntries.list({ cwd });
-        expect(beforeWrite.entries.some((entry) => entry.path === "plans/effect-rpc.md")).toBe(
+        assert.strictEqual(
+          beforeWrite.entries.some((entry) => entry.path === "plans/effect-rpc.md"),
           false,
         );
         });
         const afterWrite = yield* workspaceEntries.list({ cwd });
-        expect(afterWrite.entries).toEqual(
+        assert.strictEqual(
-          expect.arrayContaining([expect.objectContaining({ path: "plans/effect-rpc.md" })]),
+          afterWrite.entries.some((entry) => entry.path === "plans/effect-rpc.md"),
+          true,
         );
-        expect(afterWrite.truncated).toBe(false);
+        assert.strictEqual(afterWrite.truncated, false);
       }),
     );
           })
           .pipe(Effect.flip);
-        expect(error.message).toContain(
+        assert.match(
-          "Workspace file path must be relative to the project root: ../escape.md",
+          error.message,
+          /Workspace file path must be relative to the project root: \.\.\/escape\.md/,
         );
         const escapedPath = path.resolve(cwd, "..", "escape.md");
-        const escapedStat = yield* fileSystem
+        const escapedExists = yield* fileSystem.exists(escapedPath);
-          .stat(escapedPath)
+        assert.strictEqual(escapedExists, false);
-          .pipe(Effect.orElseSucceed(() => null));
-        expect(escapedStat).toBeNull();
       }),
     );
   });