feat(web): rename and delete files from the files view

apps/server/src/auth/RpcAuthorization.ts

@@ -81,6 +81,9 @@ export const RPC_REQUIRED_SCOPES = {
   [WS_METHODS.projectsSearchContents]: AuthOrchestrationReadScope,
   [WS_METHODS.projectsSearchEntries]: AuthOrchestrationReadScope,
   [WS_METHODS.projectsWriteFile]: AuthOrchestrationOperateScope,
+  [WS_METHODS.projectsCreateUploadUrl]: AuthOrchestrationOperateScope,
+  [WS_METHODS.projectsRenameEntry]: AuthOrchestrationOperateScope,
+  [WS_METHODS.projectsDeleteEntry]: AuthOrchestrationOperateScope,
   [WS_METHODS.shellOpenInEditor]: AuthOrchestrationOperateScope,
   [WS_METHODS.filesystemBrowse]: AuthOrchestrationReadScope,
   [WS_METHODS.assetsCreateUrl]: AuthOrchestrationReadScope,

apps/server/src/http.ts

@@ -33,6 +33,11 @@ import {
   storeAttachmentUpload,
   validateAttachmentUploadToken,
 } from "./assets/AttachmentUpload.ts";
+import {
+  WORKSPACE_UPLOAD_ROUTE_PREFIX,
+  storeWorkspaceUpload,
+  validateWorkspaceUploadToken,
+} from "./workspace/WorkspaceUpload.ts";
 import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts";
 import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
 import { traceRelayRequest } from "./cloud/traceRelayRequest.ts";
@@ -280,6 +285,55 @@ export const attachmentUploadRouteLayer = HttpRouter.add(
   }),
 );
 
+export const workspaceUploadRouteLayer = HttpRouter.add(
+  "POST",
+  `${WORKSPACE_UPLOAD_ROUTE_PREFIX}/*`,
+  Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const url = HttpServerRequest.toURL(request);
+    if (Option.isNone(url)) {
+      return HttpServerResponse.text("Bad Request", { status: 400 });
+    }
+
+    const token = url.value.pathname.slice(`${WORKSPACE_UPLOAD_ROUTE_PREFIX}/`.length);
+    if (!token) {
+      return HttpServerResponse.text("Not Found", { status: 404 });
+    }
+    const claims = yield* validateWorkspaceUploadToken(token);
+    if (!claims) {
+      return HttpServerResponse.text("Not Found", { status: 404 });
+    }
+
+    const contentLengthHeader = request.headers["content-length"];
+    if (
+      contentLengthHeader !== undefined &&
+      (!Number.isInteger(Number(contentLengthHeader)) ||
+        Number(contentLengthHeader) !== claims.sizeBytes)
+    ) {
+      return HttpServerResponse.text("Content-Length must match the upload size.", {
+        status: 400,
+      });
+    }
+
+    // NodeStream.toArrayBuffer treats a falsy maxBytes as "no limit", so a
+    // 0-byte claim (empty files are a valid upload) would otherwise disable
+    // the body limit entirely. Floor it at 1 byte; an empty body still passes.
+    const maxBodySize = FileSystem.Size(Math.max(claims.sizeBytes, 1));
+    const body = yield* request.arrayBuffer.pipe(
+      Effect.provideService(HttpServerRequest.MaxBodySize, maxBodySize),
+      Effect.orElseSucceed(() => null),
+    );
+    if (body === null) {
+      return HttpServerResponse.text("Failed to read the upload body.", { status: 400 });
+    }
+
+    const stored = yield* storeWorkspaceUpload(claims, new Uint8Array(body));
+    return stored.ok
+      ? HttpServerResponse.empty({ status: 204 })
+      : HttpServerResponse.text(stored.detail, { status: stored.status });
+  }),
+);
+
 export const staticAndDevRouteLayer = HttpRouter.add(
   "GET",
   "*",

apps/server/src/server.test.ts

@@ -133,6 +133,7 @@ import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
 import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts";
 import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts";
 import * as WorkspacePaths from "./workspace/WorkspacePaths.ts";
+import { WORKSPACE_UPLOAD_ROUTE_PREFIX } from "./workspace/WorkspaceUpload.ts";
 import * as GitVcsDriver from "./vcs/GitVcsDriver.ts";
 import * as VcsDriver from "./vcs/VcsDriver.ts";
 import * as VcsStatusBroadcaster from "./vcs/VcsStatusBroadcaster.ts";
@@ -5127,6 +5128,125 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
     }).pipe(Effect.provide(NodeHttpServer.layerTest)),
   );
 
+  it.effect("uploads workspace file bytes through a signed URL issued by websocket rpc", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspaceDir = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3-ws-project-upload-",
+      });
+
+      yield* buildAppUnderTest();
+
+      const wsUrl = yield* getWsServerUrl("/ws");
+      yield* Effect.scoped(
+        withWsRpcClient(wsUrl, (client) =>
+          Effect.gen(function* () {
+            const issued = yield* client[WS_METHODS.projectsCreateUploadUrl]({
+              cwd: workspaceDir,
+              relativePath: "uploaded/dropped.bin",
+              sizeBytes: 6,
+              overwrite: false,
+            });
+            assert.equal(issued.relativePath, "uploaded/dropped.bin");
+
+            const badContentLength = yield* HttpClient.post(issued.relativeUrl, {
+              body: HttpBody.uint8Array(new Uint8Array([1, 2, 3]), "application/octet-stream"),
+            });
+            assert.equal(badContentLength.status, 400);
+
+            const response = yield* HttpClient.post(issued.relativeUrl, {
+              body: HttpBody.uint8Array(
+                new Uint8Array([1, 2, 3, 4, 5, 6]),
+                "application/octet-stream",
+              ),
+            });
+            assert.equal(response.status, 204);
+
+            const persisted = yield* fs.readFile(
+              path.join(workspaceDir, "uploaded", "dropped.bin"),
+            );
+            assert.deepEqual(Array.from(persisted), [1, 2, 3, 4, 5, 6]);
+
+            const notFoundResponse = yield* HttpClient.post(
+              `${WORKSPACE_UPLOAD_ROUTE_PREFIX}/not-a-real-token`,
+              { body: HttpBody.uint8Array(new Uint8Array([1, 2, 3, 4, 5, 6])) },
+            );
+            assert.equal(notFoundResponse.status, 404);
+
+            const conflictTarget = yield* client[WS_METHODS.projectsCreateUploadUrl]({
+              cwd: workspaceDir,
+              relativePath: "uploaded/conflict.bin",
+              sizeBytes: 6,
+              overwrite: false,
+            });
+            yield* fs.writeFile(
+              path.join(workspaceDir, "uploaded", "conflict.bin"),
+              new Uint8Array([9, 9, 9, 9, 9, 9]),
+            );
+            const conflictResponse = yield* HttpClient.post(conflictTarget.relativeUrl, {
+              body: HttpBody.uint8Array(
+                new Uint8Array([1, 2, 3, 4, 5, 6]),
+                "application/octet-stream",
+              ),
+            });
+            assert.equal(conflictResponse.status, 409);
+          }),
+        ),
+      );
+    }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+  );
+
+  it.effect("floors the workspace upload body limit for zero-byte claims", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const workspaceDir = yield* fs.makeTempDirectoryScoped({
+        prefix: "t3-ws-project-upload-empty-",
+      });
+
+      yield* buildAppUnderTest();
+
+      const wsUrl = yield* getWsServerUrl("/ws");
+      yield* Effect.scoped(
+        withWsRpcClient(wsUrl, (client) =>
+          Effect.gen(function* () {
+            const emptyTarget = yield* client[WS_METHODS.projectsCreateUploadUrl]({
+              cwd: workspaceDir,
+              relativePath: "empty.bin",
+              sizeBytes: 0,
+              overwrite: false,
+            });
+            const emptyResponse = yield* HttpClient.post(emptyTarget.relativeUrl, {
+              body: HttpBody.uint8Array(new Uint8Array(0), "application/octet-stream"),
+            });
+            assert.equal(emptyResponse.status, 204);
+            const emptyPath = path.join(workspaceDir, "empty.bin");
+            assert.isTrue(yield* fs.exists(emptyPath));
+            assert.equal((yield* fs.readFile(emptyPath)).byteLength, 0);
+
+            // Mint a second zero-byte claim and post a chunked body (no
+            // Content-Length, so the header check above is skipped) that
+            // exceeds it. NodeStream.toArrayBuffer treats a falsy maxBytes
+            // as unlimited, so this only fails once the limit is floored at
+            // 1 byte.
+            const oversizedTarget = yield* client[WS_METHODS.projectsCreateUploadUrl]({
+              cwd: workspaceDir,
+              relativePath: "empty-oversized.bin",
+              sizeBytes: 0,
+              overwrite: false,
+            });
+            const oversizedResponse = yield* HttpClient.post(oversizedTarget.relativeUrl, {
+              body: HttpBody.stream(Stream.make(new Uint8Array([1, 2, 3, 4, 5, 6]))),
+            });
+            assert.equal(oversizedResponse.status, 400);
+            assert.isFalse(yield* fs.exists(path.join(workspaceDir, "empty-oversized.bin")));
+          }),
+        ),
+      );
+    }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+  );
+
   it.effect("creates a missing workspace root during websocket project.create dispatch", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;

apps/server/src/server.ts

@@ -18,6 +18,7 @@ import {
   staticAndDevRouteLayer,
   browserApiCorsLayer,
   httpCompressionLayer,
+  workspaceUploadRouteLayer,
 } from "./http.ts";
 import { guardHttpResponseWriteErrors } from "./httpResponseErrorGuard.ts";
 import { fixPath } from "./os-jank.ts";
@@ -458,6 +459,7 @@ export const makeRoutesLayer = Layer.mergeAll(
     otlpTracesProxyRouteLayer,
     assetRouteLayer,
     attachmentUploadRouteLayer,
+    workspaceUploadRouteLayer,
     staticAndDevRouteLayer,
     websocketRpcRouteLayer,
   ),