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.ts (1 of 2 files). Show all

Unified · Split

apps/server/src/workspace/WorkspaceFileSystem.ts+39−40

-// @effect-diagnostics nodeBuiltinImport:off
 /**
  * WorkspaceFileSystem - Effect service contract for workspace file mutations.
  *
  *
  * @module WorkspaceFileSystem
  */
-import * as NodeFSP from "node:fs/promises";
 import type {
   ProjectReadFileInput,
   ProjectReadFileResult,
       relativePath: input.relativePath,
     });
-    return yield* Effect.tryPromise({
+    return yield* Effect.scoped(
-      try: async () => {
+      Effect.gen(function* () {
-        const [realWorkspaceRoot, realTargetPath] = await Promise.all([
+        const [realWorkspaceRoot, realTargetPath] = yield* Effect.all([
-          NodeFSP.realpath(input.cwd),
+          fileSystem.realPath(input.cwd),
-          NodeFSP.realpath(target.absolutePath),
+          fileSystem.realPath(target.absolutePath),
         ]);
         const relativeRealPath = path.relative(realWorkspaceRoot, realTargetPath);
         if (
           relativeRealPath === ".." ||
           path.isAbsolute(relativeRealPath)
         ) {
-          throw new Error("Workspace file path resolves outside the project root.");
+          return yield* Effect.fail(
+            new Error("Workspace file path resolves outside the project root."),
+          );
         }
-        const handle = await NodeFSP.open(realTargetPath, "r");
+        const handle = yield* fileSystem.open(realTargetPath, { flag: "r" });
-        try {
+        const stat = yield* handle.stat;
-          const stat = await handle.stat();
+        if (stat.type !== "File") {
-          if (!stat.isFile()) {
+          return yield* Effect.fail(new Error("Workspace path is not a file."));
-            throw new Error("Workspace path is not a file.");
-          }
-          const bytesToRead = Math.min(stat.size, PROJECT_READ_FILE_MAX_BYTES);
-          const buffer = Buffer.alloc(bytesToRead);
-          const { bytesRead } = await handle.read(buffer, 0, bytesToRead, 0);
-          const fileBytes = buffer.subarray(0, bytesRead);
-          if (fileBytes.includes(0)) {
-            throw new Error("Binary files cannot be previewed as text.");
-          }
-          const contents = new TextDecoder("utf-8").decode(fileBytes);
-          return {
-            relativePath: target.relativePath,
-            contents,
-            byteLength: stat.size,
-            truncated: stat.size > PROJECT_READ_FILE_MAX_BYTES,
-          };
-        } finally {
-          await handle.close();
         }
-      },
+        const byteLength = Number(stat.size);
-      catch: (cause) =>
+        const bytesToRead = Math.min(byteLength, PROJECT_READ_FILE_MAX_BYTES);
-        new WorkspaceFileSystemError({
+        const buffer = new Uint8Array(bytesToRead);
-          cwd: input.cwd,
+        const bytesRead = yield* handle.read(buffer);
-          relativePath: input.relativePath,
+        const fileBytes = buffer.subarray(0, Number(bytesRead));
-          operation: "workspaceFileSystem.readFile",
+        if (fileBytes.includes(0)) {
-          cause,
+          return yield* Effect.fail(new Error("Binary files cannot be previewed as text."));
-        }),
+        }
-    });
+        const contents = new TextDecoder("utf-8").decode(fileBytes);
+        return {
+          relativePath: target.relativePath,
+          contents,
+          byteLength,
+          truncated: stat.size > BigInt(PROJECT_READ_FILE_MAX_BYTES),
+        };
+      }),
+    ).pipe(
+      Effect.mapError(
+        (cause) =>
+          new WorkspaceFileSystemError({
+            cwd: input.cwd,
+            relativePath: input.relativePath,
+            operation: "workspaceFileSystem.readFile",
+            cause,
+          }),
+      ),
+    );
   });
   const writeFile: WorkspaceFileSystem["Service"]["writeFile"] = Effect.fn(