fix(web): retry failed final file saves after editor close

apps/server/src/workspace/WorkspaceFileSystem.test.ts

@@ -6,6 +6,8 @@ import * as NodePath from "@effect/platform-node/NodePath";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { it, describe, expect } from "@effect/vitest";
 import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
@@ -23,7 +25,7 @@ import { vi } from "vite-plus/test";
 
 vi.mock("node:fs/promises", async (importOriginal) => {
   const actual = await importOriginal<typeof NodeFSP>();
-  return { ...actual, realpath: vi.fn(actual.realpath) };
+  return { ...actual, realpath: vi.fn(actual.realpath), writeFile: vi.fn(actual.writeFile) };
 });
 
 const UNKNOWN_WORKSPACE_PREFIX = "t3code-unknown-workspace-";
@@ -181,6 +183,7 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceFileSystemLive", (i
           contents: "# Report\n",
           byteLength: 9,
           truncated: false,
+          supportsConditionalWrite: true,
         });
       }),
     );
@@ -202,6 +205,7 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceFileSystemLive", (i
           contents: "# Notes\n",
           byteLength: 8,
           truncated: false,
+          supportsConditionalWrite: true,
         });
       }),
     );
@@ -369,6 +373,75 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceFileSystemLive", (i
   });
 
   describe("writeFile", () => {
+    it.effect("waits for native writes to settle before cancellation releases the lease", () =>
+      Effect.gen(function* () {
+        const service = yield* WorkspaceFileSystem.WorkspaceFileSystem;
+        const cwd = yield* makeTempDir;
+        const started = yield* Deferred.make<void>();
+        let finishWrite!: () => void;
+        vi.mocked(NodeFSP.writeFile).mockImplementationOnce(
+          () =>
+            new Promise<void>((resolve) => {
+              finishWrite = resolve;
+              queueMicrotask(() => Deferred.doneUnsafe(started, Effect.void));
+            }),
+        );
+        const write = yield* service
+          .writeFile({ cwd, relativePath: "note.txt", contents: "retired" })
+          .pipe(Effect.forkChild);
+        yield* Deferred.await(started);
+        const cancelling = yield* Fiber.interrupt(write).pipe(
+          Effect.forkChild({ startImmediately: true }),
+        );
+        const releasedBeforeNativeWrite = cancelling.pollUnsafe() !== undefined;
+        finishWrite();
+        yield* Fiber.join(cancelling);
+        expect(releasedBeforeNativeWrite).toBe(false);
+      }),
+    );
+
+    it.effect("refuses a retired save after another client has saved newer contents", () =>
+      Effect.gen(function* () {
+        const service = yield* WorkspaceFileSystem.WorkspaceFileSystem;
+        const cwd = yield* makeTempDir;
+        yield* writeTextFile(cwd, "note.txt", "original");
+        yield* service.writeFile({ cwd, relativePath: "note.txt", contents: "newer" });
+        const retry = {
+          cwd,
+          relativePath: "note.txt",
+          contents: "retired",
+          expectedContents: "original",
+        };
+        expect(yield* service.writeFile(retry)).toEqual({
+          relativePath: "note.txt",
+          conflict: true,
+        });
+        expect((yield* service.readFile({ cwd, relativePath: "note.txt" })).contents).toBe("newer");
+      }),
+    );
+
+    it.effect("checks conditional saves in the same critical section as competing writes", () =>
+      Effect.gen(function* () {
+        const service = yield* WorkspaceFileSystem.WorkspaceFileSystem;
+        const cwd = yield* makeTempDir;
+        yield* writeTextFile(cwd, "note.txt", "original");
+        const results = yield* Effect.forEach(
+          ["first", "second"],
+          (contents) => {
+            const input = { cwd, relativePath: "note.txt", contents, expectedContents: "original" };
+            return service.writeFile(input);
+          },
+          { concurrency: "unbounded" },
+        );
+        expect(results).toEqual(
+          expect.arrayContaining([
+            { relativePath: "note.txt" },
+            { relativePath: "note.txt", conflict: true },
+          ]),
+        );
+      }),
+    );
+
     it.effect("rejects writes outside a known workspace", () =>
       Effect.gen(function* () {
         const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;

apps/server/src/workspace/WorkspaceFileSystem.ts

@@ -25,6 +25,7 @@ import * as KnownWorkspaces from "./KnownWorkspaces.ts";
 import * as WorkspaceEntries from "./WorkspaceEntries.ts";
 import * as WorkspacePaths from "./WorkspacePaths.ts";
 import { fileHeaderMimeType } from "./fileHeaderMimeType.ts";
+import { withWorkspaceLease } from "./workspaceLease.ts";
 
 const PROJECT_READ_FILE_MAX_BYTES = 1024 * 1024;
 
@@ -344,6 +345,7 @@ export const make = Effect.gen(function* () {
       byteLength: 0,
       truncated: false,
       exists: false,
+      supportsConditionalWrite: true,
     };
     const realTargetPath = target.realTargetPath;
     if (realTargetPath === null) return absentResult;
@@ -423,6 +425,7 @@ export const make = Effect.gen(function* () {
             contents: new TextDecoder("utf-8").decode(fileBytes),
             byteLength: stat.size,
             truncated: stat.size > PROJECT_READ_FILE_MAX_BYTES,
+            supportsConditionalWrite: true,
           };
         }),
       (handle) =>
@@ -532,41 +535,59 @@ export const make = Effect.gen(function* () {
     const target = yield* resolveWriteTarget(input);
     const realTargetPath = target.realTargetPath;
 
-    yield* fileSystem.makeDirectory(path.dirname(realTargetPath), { recursive: true }).pipe(
-      Effect.mapError(
-        (cause) =>
-          new WorkspaceFileSystemOperationError({
-            workspaceRoot: input.cwd,
+    return yield* withWorkspaceLease(
+      realTargetPath,
+      Effect.gen(function* () {
+        if (input.expectedContents !== undefined) {
+          const current = yield* readFile({
+            cwd: input.cwd,
             relativePath: input.relativePath,
-            resolvedPath: realTargetPath,
-            operationPath: path.dirname(realTargetPath),
-            operation: "make-directory",
-            cause,
-          }),
-      ),
+            allowMissing: true,
+          });
+          if (
+            current.truncated ||
+            (current.exists === false ? null : current.contents) !== input.expectedContents
+          ) {
+            return { relativePath: target.relativePath, conflict: true };
+          }
+        }
+        yield* fileSystem.makeDirectory(path.dirname(realTargetPath), { recursive: true }).pipe(
+          Effect.mapError(
+            (cause) =>
+              new WorkspaceFileSystemOperationError({
+                workspaceRoot: input.cwd,
+                relativePath: input.relativePath,
+                resolvedPath: realTargetPath,
+                operationPath: path.dirname(realTargetPath),
+                operation: "make-directory",
+                cause,
+              }),
+          ),
+        );
+        yield* Effect.tryPromise({
+          // A symlink swapped in after the check is not followed. Windows lacks O_NOFOLLOW.
+          try: () =>
+            NodeFSP.writeFile(realTargetPath, input.contents, {
+              flag:
+                NodeFS.constants.O_WRONLY |
+                NodeFS.constants.O_CREAT |
+                NodeFS.constants.O_TRUNC |
+                (NodeFS.constants.O_NOFOLLOW ?? 0),
+            }),
+          catch: (cause) =>
+            new WorkspaceFileSystemOperationError({
+              workspaceRoot: input.cwd,
+              relativePath: input.relativePath,
+              resolvedPath: realTargetPath,
+              operationPath: realTargetPath,
+              operation: "write-file",
+              cause,
+            }),
+        }).pipe(Effect.uninterruptible);
+        yield* workspaceEntries.refresh(input.cwd);
+        return { relativePath: target.relativePath };
+      }),
     );
-    yield* Effect.tryPromise({
-      // A symlink swapped in after the check is not followed. Windows lacks O_NOFOLLOW.
-      try: () =>
-        NodeFSP.writeFile(realTargetPath, input.contents, {
-          flag:
-            NodeFS.constants.O_WRONLY |
-            NodeFS.constants.O_CREAT |
-            NodeFS.constants.O_TRUNC |
-            (NodeFS.constants.O_NOFOLLOW ?? 0),
-        }),
-      catch: (cause) =>
-        new WorkspaceFileSystemOperationError({
-          workspaceRoot: input.cwd,
-          relativePath: input.relativePath,
-          resolvedPath: realTargetPath,
-          operationPath: realTargetPath,
-          operation: "write-file",
-          cause,
-        }),
-    });
-    yield* workspaceEntries.refresh(input.cwd);
-    return { relativePath: target.relativePath };
   });
 
   return WorkspaceFileSystem.of({ getMetadata, readFile, writeFile });

apps/web/src/components/files/fileSaveCoordinator.test.ts

@@ -5,9 +5,9 @@ import { AsyncResult } from "effect/reactivity";
 
 import { FileSaveCoordinator } from "./fileSaveCoordinator";
 
-function deferred() {
-  let resolve!: (result: AtomCommandResult<void, never>) => void;
-  const promise = new Promise<AtomCommandResult<void, never>>((resolvePromise) => {
+function deferred<E = never>() {
+  let resolve!: (result: AtomCommandResult<void, E>) => void;
+  const promise = new Promise<AtomCommandResult<void, E>>((resolvePromise) => {
     resolve = resolvePromise;
   });
   return { promise, resolve };
@@ -159,6 +159,120 @@ describe("FileSaveCoordinator", () => {
     expect(onPendingChange).not.toHaveBeenCalledWith(false);
   });
 
+  it("retries a close-time flush when the in-flight write fails", async () => {
+    vi.useFakeTimers();
+    const inFlight = deferred<Error>();
+    const persist = vi
+      .fn()
+      .mockReturnValueOnce(inFlight.promise)
+      .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("write failed"))))
+      .mockResolvedValue(AsyncResult.success(undefined));
+    const onPendingChange = vi.fn();
+    const onConfirmed = vi.fn();
+    const coordinator = new FileSaveCoordinator({
+      debounceMs: 500,
+      persist,
+      onPendingChange,
+      onConfirmed,
+    });
+
+    coordinator.change("only");
+    await vi.advanceTimersByTimeAsync(500);
+    expect(persist).toHaveBeenCalledTimes(1);
+
+    coordinator.dispose();
+    inFlight.resolve(AsyncResult.failure(Cause.fail(new Error("write failed"))));
+    await vi.advanceTimersByTimeAsync(500);
+    expect(persist).toHaveBeenCalledTimes(2);
+    expect(persist).toHaveBeenLastCalledWith("only", true);
+
+    await vi.advanceTimersByTimeAsync(999);
+    expect(persist).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(persist).toHaveBeenCalledTimes(3);
+    expect(onConfirmed).toHaveBeenCalledWith("only");
+    expect(onPendingChange.mock.calls.at(-1)).toEqual([false]);
+  });
+
+  it("retries a dispose-time flush that fails after the editor closes", async () => {
+    vi.useFakeTimers();
+    const persist = vi
+      .fn()
+      .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("write failed"))))
+      .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("write failed"))))
+      .mockResolvedValue(AsyncResult.success(undefined));
+    const onPendingChange = vi.fn();
+    const onConfirmed = vi.fn();
+    const coordinator = new FileSaveCoordinator({
+      debounceMs: 500,
+      persist,
+      onPendingChange,
+      onConfirmed,
+    });
+
+    coordinator.change("unsaved");
+    coordinator.dispose();
+    await vi.runAllTimersAsync();
+    expect(persist).toHaveBeenCalledTimes(3);
+    expect(persist).toHaveBeenLastCalledWith("unsaved", true);
+    expect(onConfirmed).toHaveBeenCalledWith("unsaved");
+    expect(onPendingChange.mock.calls.at(-1)).toEqual([false]);
+  });
+
+  it("caps close-time retries with backoff and preserves an unsaved draft", async () => {
+    vi.useFakeTimers();
+    const onPendingChange = vi.fn();
+    const persist = vi
+      .fn()
+      .mockResolvedValue(AsyncResult.failure(Cause.fail(new Error("write unavailable"))));
+    const coordinator = new FileSaveCoordinator({
+      debounceMs: 500,
+      persist,
+      onPendingChange,
+      onConfirmed: vi.fn(),
+    });
+
+    coordinator.change("unsaved");
+    coordinator.dispose();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(persist).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(500);
+    expect(persist).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(999);
+    expect(persist).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(persist).toHaveBeenCalledTimes(3);
+    await vi.advanceTimersByTimeAsync(1_999);
+    expect(persist).toHaveBeenCalledTimes(3);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(persist).toHaveBeenCalledTimes(4);
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(persist).toHaveBeenCalledTimes(4);
+    expect(onPendingChange).toHaveBeenLastCalledWith(true);
+  });
+
+  it("stops retrying if write permission was revoked after the failure", async () => {
+    vi.useFakeTimers();
+    let canWrite = true;
+    const persist = vi.fn().mockImplementation(async () => {
+      canWrite = false;
+      return AsyncResult.failure(Cause.fail(new Error("write forbidden")));
+    });
+    const coordinator = new FileSaveCoordinator({
+      debounceMs: 500,
+      canPersist: () => canWrite,
+      persist,
+      onPendingChange: vi.fn(),
+      onConfirmed: vi.fn(),
+    });
+
+    coordinator.change("unsaved");
+    coordinator.dispose();
+    await vi.runAllTimersAsync();
+    expect(persist).toHaveBeenCalledOnce();
+  });
+
   it("ignores editor changes emitted after disposal", async () => {
     vi.useFakeTimers();
     const persist = vi