From 1823e8259c0a37fd31dbc497fd0b136aba195ff7 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 20:34:31 +0800 Subject: [PATCH 01/72] split unit U1 of PR 1833 (issue 1375) --- .../__tests__/safeWriteText.spec.ts | 922 ++++++++++++++++++ src/services/file-safety/safeWriteText.ts | 420 ++++++++ 2 files changed, 1342 insertions(+) create mode 100644 src/services/file-safety/__tests__/safeWriteText.spec.ts create mode 100644 src/services/file-safety/safeWriteText.ts diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts new file mode 100644 index 0000000000..e2f947c8bc --- /dev/null +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -0,0 +1,922 @@ +import * as fs from "fs/promises" +import * as fsSync from "fs" +import { execFile } from "child_process" +import type { ChildProcess } from "child_process" +import * as path from "path" + +import { RollbackFailureError, safeWriteText, type SafeWriteTextOptions } from "../safeWriteText" + +// Full mock for fs/promises — all methods are vi.fn() stubs +vi.mock("fs/promises", () => ({ + mkdir: vi.fn(), + access: vi.fn(), + rename: vi.fn(), + unlink: vi.fn(), + rmdir: vi.fn(), + realpath: vi.fn(), + lstat: vi.fn(), +})) + +// Full mock for fs — all sync methods are vi.fn() stubs. Stats is a bare +// class stub so tests can build minimal Stats stand-ins via its prototype. +vi.mock("fs", () => ({ + openSync: vi.fn(), + writeSync: vi.fn(), + closeSync: vi.fn(), + mkdirSync: vi.fn(), + fsyncSync: vi.fn(), + chmodSync: vi.fn(), + fchmodSync: vi.fn(), + statSync: vi.fn(), + Stats: class Stats {}, +})) + +// Mock child_process.execFile (callback-based — must invoke callback to resolve) +vi.mock("child_process", () => ({ + execFile: vi.fn((cmd, args, opts, cb) => { + if (typeof cb === "function") cb(null) + }), +})) + +// Minimal stand-in for the ChildProcess that callback-form execFile returns. +const fakeChild = { kill: () => true } as unknown as ChildProcess + +// Helper that mirrors safeWriteText's path resolution exactly +function _resolvedTarget(filePath: string): string { + return path.resolve(filePath) +} +function _dirPath(filePath: string): string { + return path.dirname(_resolvedTarget(filePath)) +} +// Minimal Stats stand-in: the SUT only reads `.mode` from it. +function _stats(mode: number): fsSync.Stats { + const s = Object.create(fsSync.Stats.prototype) as fsSync.Stats + Object.assign(s, { mode }) + return s +} + +// ── Test 1: staging file created then cleaned after success ──────────────── + +describe("safeWriteText", () => { + beforeEach(() => { + vi.resetAllMocks() + // After resetAllMocks, vi.fn() returns undefined — restore promise defaults. + vi.mocked(fs.mkdir).mockResolvedValue(undefined) + vi.mocked(fs.access).mockResolvedValue(undefined) + vi.mocked(fs.rename).mockResolvedValue(undefined) + vi.mocked(fs.unlink).mockResolvedValue(undefined) + vi.mocked(fs.rmdir).mockResolvedValue(undefined) + // Existing-target default: a regular 0o644 file. + vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o644)) + // Default sync-write behaviour: report that all requested bytes were + // written. The Buffer overload passes (fd, buffer, offset, length), + // so the fourth argument is the requested length. + vi.mocked(fsSync.writeSync).mockImplementation((...args: unknown[]) => + typeof args[3] === "number" ? args[3] : 0, + ) + }) + + describe("staging and cleanup", () => { + it("creates a temp file in the staging dir, fsyncs it, renames to target, and cleans up on success", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) // fd=1 + vi.mocked(fsSync.closeSync).mockReturnValue(undefined) + + await safeWriteText(targetPath, "hello world", { platform: "linux" }) + + // staging dir was created with private permissions — use + // stringContaining to handle Windows path resolution + expect(fsSync.mkdirSync).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), { + recursive: true, + mode: 0o700, + }) + // a pre-existing staging dir is repaired to private permissions too + expect(fsSync.chmodSync).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), 0o700) + + // temp file was opened for writing with the existing target's mode + // (default 0o644 from the statSync default mock) + expect(fsSync.openSync).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), "w", 0o644) + + // content was written as a buffer (partial-write loop, full write) + expect(fsSync.writeSync).toHaveBeenCalledWith(1, Buffer.from("hello world", "utf8"), 0, 11) + + // fsync (sync form) was called on the fd + expect(fsSync.fsyncSync).toHaveBeenCalledWith(1) + + // file was closed + expect(fsSync.closeSync).toHaveBeenCalledWith(1) + + // atomic rename happened — realpath mock returns targetPath, so that's the dest + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + + // no unlink of temp (it's now the committed file; DACL skipped via platform:linux) + expect(fs.unlink).not.toHaveBeenCalled() + }) + + it("removes the now-empty staging directory after a successful self-staged commit", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "hello", { platform: "linux" }) + + // the staging subdir is removed best-effort after the commit rename + // (stringContaining: the SUT and the test helper resolve Windows + // drive-relative paths differently, as in the existing staging tests) + expect(fs.rmdir).toHaveBeenCalledTimes(1) + expect(fs.rmdir).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging")) + // the win32 DACL restore gate must stay closed on other platforms: + // no icacls save or restore is attempted + expect(execFile).not.toHaveBeenCalled() + }) + + it("still removes the staging directory when no options are supplied at all", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + // options is undefined: the self-staged check and the optional-chained + // DACL runner lookup must not dereference it + await expect(safeWriteText(targetPath, "hello")).resolves.toBeUndefined() + + expect(fs.rmdir).toHaveBeenCalledTimes(1) + expect(fs.rmdir).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging")) + if (process.platform === "win32") { + // default platform is win32: the DACL save + restore still ran + // through the default icacls path (options?.execFileRunner must + // not throw when options is undefined) + expect(vi.mocked(execFile)).toHaveBeenCalledTimes(2) + expect(vi.mocked(fs.unlink)).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + } + }) + + it("does not remove the staging directory when the caller supplies its own tempPath", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const callerTemp = "/tmp/test-dir/caller-staged.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "hello", { platform: "linux", tempPath: callerTemp }) + + // the caller owns its temp file's directory; safeWriteText must not + // rmdir a directory it did not create + expect(fs.rmdir).not.toHaveBeenCalled() + }) + + it("a failed staging-dir removal never fails the committed write", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fs.rmdir).mockRejectedValue(Object.assign(new Error("ENOTEMPTY"), { code: "ENOTEMPTY" })) + + await expect(safeWriteText(targetPath, "hello", { platform: "linux" })).resolves.toBeUndefined() + + // the commit rename still happened and the rmdir error was swallowed + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + expect(fs.rmdir).toHaveBeenCalledTimes(1) + expect(fs.rmdir).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging")) + }) + + it("gives each self-staged write its own staging directory so a concurrent write cannot remove it", async () => { + const targetA = "/tmp/test-dir/target-a.txt" + const targetB = "/tmp/test-dir/target-b.txt" + vi.mocked(fs.realpath).mockImplementation((p) => Promise.resolve(p as string)) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetA, "a", { platform: "linux" }) + await safeWriteText(targetB, "b", { platform: "linux" }) + + // Two self-staged writes in the same directory must not share one staging + // directory: the first write's best-effort rmdir would otherwise delete the + // directory the second write had created but not yet opened (ENOENT on openSync). + const created = vi.mocked(fsSync.mkdirSync).mock.calls.map((c) => String(c[0])) + const staging = created.filter((p) => p.includes(".file-safety-staging_")) + expect(staging).toHaveLength(2) + expect(staging[0]).not.toBe(staging[1]) + // Uniqueness comes from the documented name shape + // /.file-safety-staging__: pinning the shape + // keeps the separator and the random suffix meaningful, not just the prefix. + for (const dir of staging) { + expect(dir).toMatch(/\.file-safety-staging_\d+_[a-z0-9]+$/) + } + const removed = vi.mocked(fs.rmdir).mock.calls.map((c) => String(c[0])) + expect(removed).toEqual([staging[0], staging[1]]) + }) + + it("removes its own staging directory when a self-staged write fails", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fs.rename).mockRejectedValue(Object.assign(new Error("EACCES"), { code: "EACCES" })) + + await expect(safeWriteText(targetPath, "hello", { platform: "linux" })).rejects.toThrow("EACCES") + + // The failed write's temp file is unlinked, then the directory it + // created is removed — a failed write must not leave an empty + // .file-safety-staging directory behind. + // mkdirSync created this write's staging directory; the temp file lives + // inside it, so the unlink targets a path under that directory. + const staging = vi.mocked(fsSync.mkdirSync).mock.calls.map((c) => String(c[0])) + expect(staging).toHaveLength(1) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(staging[0])) + expect(fs.rmdir).toHaveBeenCalledWith(staging[0]) + // The directory is only empty after its temp file is gone, so the + // unlink must happen before the rmdir. + expect(vi.mocked(fs.unlink).mock.invocationCallOrder[0]).toBeLessThan( + vi.mocked(fs.rmdir).mock.invocationCallOrder[0], + ) + }) + + it("does not remove a staging directory it did not create when a caller-staged write fails", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const callerTemp = "/tmp/test-dir/caller-staged.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fs.rename).mockRejectedValue(Object.assign(new Error("EACCES"), { code: "EACCES" })) + + await expect( + safeWriteText(targetPath, "hello", { platform: "linux", tempPath: callerTemp }), + ).rejects.toThrow("EACCES") + + // The caller owns that directory: only the caller's temp file is cleaned, + // never a rmdir of a directory safeWriteText never created. + expect(fs.unlink).toHaveBeenCalledWith(callerTemp) + expect(fs.rmdir).not.toHaveBeenCalled() + }) + }) + + // ── Test 2: fsync ordering ─────────────────────────────────────────────── + + describe("fsync ordering", () => { + it("calls fsync on the fd before close, and rename after close", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // Verify call order: openSync(temp) → writeSync → fsyncSync(temp) + // → closeSync(temp) → rename. On POSIX the parent directory is then + // opened and fsynced after the commit rename, so openSync/fsyncSync/ + // closeSync each have a second (directory) call. + expect(vi.mocked(fsSync.openSync).mock.calls.length).toBe(2) + expect(vi.mocked(fsSync.writeSync).mock.calls.length).toBe(1) + expect(vi.mocked(fsSync.fsyncSync).mock.calls.length).toBe(2) + expect(vi.mocked(fsSync.closeSync).mock.calls.length).toBe(2) + + // the temp file was fully closed before the commit rename + expect(vi.mocked(fsSync.closeSync).mock.calls[0][0]).toBe(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + // The title promises the order, so compare the invocations rather than + // only count them: a rename before closeSync, or a close before fsync, + // would not be a durable commit. + const fsyncOrder = vi.mocked(fsSync.fsyncSync).mock.invocationCallOrder[0] + const closeOrder = vi.mocked(fsSync.closeSync).mock.invocationCallOrder[0] + const renameOrder = vi.mocked(fs.rename).mock.invocationCallOrder[0] + expect(fsyncOrder).toBeLessThan(closeOrder) + expect(closeOrder).toBeLessThan(renameOrder) + }) + }) + + // ── Test 3: simulated failure between write and rename leaves target intact ── + + describe("crash/torn-write safety", () => { + it("simulated failure between fsync and rename leaves the target byte-identical and no temp left behind", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fs.rename).mockRejectedValue(new Error("ENOSPC")) + + await expect(safeWriteText(targetPath, "new data", { platform: "linux" })).rejects.toThrow("ENOSPC") + + // rename was attempted (the failure point) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + + // temp file was cleaned up on failure + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + + // backup was NOT created (backup:false by default), so target is untouched + // The only rename call was temp→target, not a rollback rename + expect(fs.rename).toHaveBeenCalledTimes(1) + }) + + it("a post-commit backup cleanup failure is non-fatal: the target stays committed and no temp is left behind", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The post-commit backup unlink (SUT step 6) fails — the write must + // still succeed; an orphaned backup is the documented acceptable + // outcome, so the failure is swallowed instead of rolling back. + vi.mocked(fs.unlink).mockRejectedValueOnce(new Error("EPERM")) + + await safeWriteText(targetPath, "data", { backup: true, platform: "linux" }) + + // the commit rename (temp -> target) still happened + expect(fs.rename).toHaveBeenNthCalledWith(2, expect.stringContaining("safeWriteText_"), targetPath) + + // the failing cleanup was the post-commit backup unlink + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + + // no rollback rename: the committed target is not restored from the backup + expect(fs.rename).toHaveBeenCalledTimes(2) + + // the staging temp was already committed by the rename; nothing + // temp-shaped is unlinked afterwards + expect(fs.unlink).not.toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + }) + }) + + // ── Test 4: backup:true keeps old safeWriteJson semantics incl. rollback ── + + describe("backup:true", () => { + it("renames target -> backup before commit, deletes backup on success", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "new data", { backup: true }) + + // target was accessed (exists check) + expect(fs.access).toHaveBeenCalledWith(targetPath) + + // first rename: target -> backup + expect(fs.rename).toHaveBeenNthCalledWith(1, targetPath, expect.stringContaining("safeWriteText.bak_")) + + // second rename: temp -> target (realpath mock returns targetPath) + expect(fs.rename).toHaveBeenNthCalledWith(2, expect.stringContaining("safeWriteText_"), targetPath) + + // backup was deleted on success + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + }) + + it("rollback: on failure after rename target->backup, restores backup to target", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // first rename (target->backup) succeeds, second fails + let callCount = 0 + vi.mocked(fs.rename).mockImplementation(async () => { + callCount++ + if (callCount === 1) return // target -> backup + if (callCount === 2) throw new Error("ENOSPC") // temp -> target fails + return // the rollback rename succeeds + }) + + await expect(safeWriteText(targetPath, "new data", { backup: true })).rejects.toThrow("ENOSPC") + + // rollback rename is the 3rd call (after target->backup and temp->target failure) + expect(fs.rename).toHaveBeenNthCalledWith(3, expect.stringContaining("safeWriteText.bak_"), targetPath) + + // temp was cleaned up on failure + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + }) + + it("a failed rollback reports the partial state, not only the publish error", async () => { + // The content is still on disk, but only at the backup path. A caller that gets + // just the publish error has data it cannot find at the expected path. + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + let callCount = 0 + vi.mocked(fs.rename).mockImplementation(async () => { + callCount++ + if (callCount === 1) return // target -> backup + if (callCount === 2) throw new Error("ENOSPC") // temp -> target fails + throw new Error("EACCES") // the rollback rename fails too + }) + + let failure: RollbackFailureError | undefined + await safeWriteText(targetPath, "new data", { backup: true }).catch((e: unknown) => { + if (e instanceof RollbackFailureError) { + failure = e + return + } + throw e + }) + + expect(failure).toBeInstanceOf(RollbackFailureError) + expect(failure?.publishError).toBeInstanceOf(Error) + expect((failure?.publishError as Error).message).toBe("ENOSPC") + expect((failure?.rollbackError as Error).message).toBe("EACCES") + expect(failure?.backupPath).toContain("safeWriteText.bak_") + // The backup is what the caller can still recover, so it must stay on disk. + expect(fs.unlink).not.toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + }) + + it("backup:true when target does not exist: no backup created, just commit", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // fs.access resolves for dirPath check, but rejects for target check (backup path) + vi.mocked(fs.access).mockImplementation(async (p) => { + if (typeof p === "string" && p.endsWith("target.txt")) throw { code: "ENOENT" } + }) + + await safeWriteText(targetPath, "new data", { backup: true, platform: "linux" }) + + // no backup rename (target didn't exist) + expect(fs.access).toHaveBeenCalledWith(targetPath) + + // only one rename: temp -> target + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + + // no unlink (no backup to delete; DACL skipped via platform:linux) + expect(fs.unlink).not.toHaveBeenCalled() + }) + }) + + // ── Test 5: win32 DACL path ────────────────────────────────────────────── + + describe("win32 DACL", () => { + it.skipIf(process.platform !== "win32")( + "copies target DACL onto staging file via icacls before rename on Windows", + async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + await safeWriteText(targetPath, "data", { platform: "win32" }) + + // icacls dump + restore were called (execFile is callback-based mock) + expect(execFile).toHaveBeenCalledTimes(2) + }, + ) + + it("non-win32: DACL path is unreachable when platform is not win32", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // icacls was NOT called on non-win32 + expect(execFile).not.toHaveBeenCalled() + }) + + it("win32 DACL failure falls back to plain rename (never fails the write)", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // icacls dump fails — the callback-based mock must invoke cb with an error. + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls error"), "", "") + return fakeChild + }) + + await safeWriteText(targetPath, "data", { platform: "win32" }) + + // write succeeded despite icacls failure (fallback to plain rename) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + // one icacls attempt only: a failed DACL apply must not try to restore + expect(execFile).toHaveBeenCalledTimes(1) + }) + + it("win32 DACL: a partial dump left by a failed save is removed and never restored", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // icacls save fails — a real icacls may have written a partial dump + // before erroring, so the dump path must be cleaned up and must never + // be used for a restore. + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls save error"), "", "") + return fakeChild + }) + + await safeWriteText(targetPath, "data", { platform: "win32" }) + + // write committed; only the save was attempted (no restore from a failed dump) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(execFile).toHaveBeenCalledTimes(1) + const saveArgs = vi.mocked(execFile).mock.calls[0]?.[1] + expect(saveArgs?.[1]).toBe("/save") + // the dump path (possibly partially created by icacls) was unlinked + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + }) + + it("win32 DACL save args are [targetPath, /save, dumpPath, /T] before backup rename", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { backup: true, platform: "win32" }) + + // icacls was called twice (save + restore) + expect(execFile).toHaveBeenCalledTimes(2) + + // First call: save DACL from target before backup rename + const firstCall = vi.mocked(execFile).mock.calls[0] + expect(firstCall[0]).toBe("icacls") + expect(firstCall[1]).toEqual([targetPath, "/save", expect.stringContaining(".acl.tmp"), "/T"]) + + // Second call: restore DACL onto directory after commit rename + const secondCall = vi.mocked(execFile).mock.calls[1] + expect(secondCall[0]).toBe("icacls") + expect(secondCall[1]).toEqual([ + expect.stringContaining("/tmp/test-dir"), + "/restore", + expect.stringContaining(".acl.tmp"), + ]) + + // dump file was unlinked after restore + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + }) + + it("win32 DACL: dump is unlinked even when restore fails", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + // icacls save succeeds, restore fails + let callCount = 0 + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + callCount++ + if (typeof cb === "function") { + cb(callCount === 1 ? null : new Error("icacls restore error"), "", "") + } + return fakeChild + }) + + await safeWriteText(targetPath, "data", { platform: "win32" }) + + // write succeeded despite restore failure (best-effort) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + expect(fs.rename).toHaveBeenCalledTimes(1) + + // dump file was still unlinked in finally + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + }) + + it("win32 DACL: when target does not exist, no save/restore/dump", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + // fs.access rejects for targetPath (ENOENT), but resolves for dirPath + vi.mocked(fs.access).mockImplementation(async (p) => { + if (typeof p === "string" && p.endsWith("target.txt")) throw { code: "ENOENT" } + return undefined + }) + + await safeWriteText(targetPath, "data", { platform: "win32" }) + + // icacls was NOT called (target absent → skip DACL entirely) + expect(execFile).not.toHaveBeenCalled() + + // no dump file created or unlinked + expect(fs.unlink).not.toHaveBeenCalled() + }) + }) + + // ── Test 6: pre-written temp path (tempPath option) ────────────────────── + + describe("pre-written temp path", () => { + it("uses the provided tempPath, fsyncs it, and renames to target", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + const customTempPath = "/tmp/custom-temp.tmp" + + // platform:linux skips DACL entirely so this test focuses on tempPath only + await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) + + // openSync was called on the custom temp path (r+ mode for fsync) + expect(fsSync.openSync).toHaveBeenCalledWith(customTempPath, "r+") + + // fsync was called + expect(fsSync.fsyncSync).toHaveBeenCalledWith(1) + + // rename happened — realpath mock returns targetPath + expect(fs.rename).toHaveBeenCalledWith(customTempPath, targetPath) + + // no unlink of custom temp (caller's concern; DACL skipped via platform:linux) + expect(fs.unlink).not.toHaveBeenCalled() + + // a caller-supplied tempPath must not create the staging directory + expect(fsSync.mkdirSync).not.toHaveBeenCalled() + }) + + it("applies the existing target's mode to a caller-supplied tempPath before publishing", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o600)) + vi.mocked(fsSync.openSync).mockReturnValue(2) + + const customTempPath = "/tmp/custom-temp.tmp" + + await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) + + // the caller-staged temp is fchmod'd to the restrictive target mode so + // the atomic rename cannot widen a 0o600 target (CWE-732 regression) + expect(fsSync.fchmodSync).toHaveBeenCalledWith(2, 0o600) + expect(fsSync.openSync).toHaveBeenCalledWith(customTempPath, "r+") + expect(fs.rename).toHaveBeenCalledWith(customTempPath, targetPath) + }) + + it("keeps the temp's default mode when the target does not exist yet (ENOENT)", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + vi.mocked(fsSync.statSync).mockImplementation(() => { + throw enoent + }) + vi.mocked(fsSync.openSync).mockReturnValue(2) + + const customTempPath = "/tmp/custom-temp.tmp" + + await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) + + // no existing target, so nothing to preserve and no fchmod on the temp + expect(fsSync.fchmodSync).not.toHaveBeenCalled() + expect(fs.rename).toHaveBeenCalledWith(customTempPath, targetPath) + }) + + it("propagates a non-ENOENT stat failure rather than defaulting the mode (caller-staged)", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + const eacces = Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }) + vi.mocked(fsSync.statSync).mockImplementation(() => { + throw eacces + }) + vi.mocked(fsSync.openSync).mockReturnValue(2) + + const customTempPath = "/tmp/custom-temp.tmp" + + // A target that cannot be stat'd is not a fresh target: publishing with + // the default mode would widen a restrictive target through the rename. + await expect( + safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }), + ).rejects.toThrow("EACCES") + expect(fsSync.fchmodSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + }) + + it("propagates a non-ENOENT stat failure rather than defaulting the mode (self-staged)", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + const eio = Object.assign(new Error("EIO: i/o error"), { code: "EIO" }) + vi.mocked(fsSync.statSync).mockImplementation(() => { + throw eio + }) + + // The mode is read before the temp is opened, so a real I/O failure stops + // the write before anything is staged. + await expect(safeWriteText(targetPath, "hello world", { platform: "linux" })).rejects.toThrow("EIO") + expect(fsSync.openSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + }) + + it("opens the temp before applying a read-only target's mode (0o444 does not block the open)", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o444)) + vi.mocked(fsSync.openSync).mockReturnValue(3) + + const customTempPath = "/tmp/custom-temp.tmp" + + await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) + + // a 0o444 target must not make openSync(tempPath, "r+") fail: the mode + // is applied with fchmodSync on the already-open fd, after the open + expect(fsSync.openSync).toHaveBeenCalledWith(customTempPath, "r+") + expect(fsSync.fchmodSync).toHaveBeenCalledWith(3, 0o444) + const openIdx = vi.mocked(fsSync.openSync).mock.invocationCallOrder[0] + const fchmodIdx = vi.mocked(fsSync.fchmodSync).mock.invocationCallOrder[0] + expect(openIdx).toBeLessThan(fchmodIdx) + expect(fs.rename).toHaveBeenCalledWith(customTempPath, targetPath) + }) + + it("applies the existing target's exact mode to the self-staged temp (umask must not narrow it)", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o664)) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // openSync's creation mode is narrowed by the process umask (0o664 -> 0o644 with + // the common 0o022), and the rename publishes the temp's mode onto the target, + // so the existing target's mode must be applied on the fd before the commit. + expect(fsSync.fchmodSync).toHaveBeenCalledWith(1, 0o664) + const openIdx = vi.mocked(fsSync.openSync).mock.invocationCallOrder[0] + const fchmodIdx = vi.mocked(fsSync.fchmodSync).mock.invocationCallOrder[0] + expect(openIdx).toBeLessThan(fchmodIdx) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + }) + + it("does not fchmod the self-staged temp for a fresh target", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + vi.mocked(fsSync.statSync).mockImplementation(() => { + throw enoent + }) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // Nothing exists to preserve: the default creation mode is the intended one. + expect(fsSync.fchmodSync).not.toHaveBeenCalled() + }) + }) + + // ── Test 7: symlink handling (Finding 4 regression test) ───────────────── + + describe("symlink handling", () => { + it("a write through a symlink commits onto the resolved referent, never the link path", async () => { + const linkPath = "/tmp/links/link.txt" + const referentPath = "/tmp/targets/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(referentPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(linkPath, "new-content", { platform: "linux" }) + + // The commit rename must target the realpath result (the referent), never the link itself — + // that is what guarantees a write through a symlink replaces the referent's content + // and preserves the link. + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), referentPath) + expect(fs.rename).not.toHaveBeenCalledWith(expect.anything(), linkPath) + }) + + it("when realpath reports ENOENT (target absent), uses the given path as-is", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" })) + // lstat reports the path itself as absent, so this is a new target and + // the fallback is allowed. + vi.mocked(fs.lstat).mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" })) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // rename still happened with the fallback path (path.resolve on /tmp → C:\tmp) + const resolvedFallback = _resolvedTarget(targetPath) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), resolvedFallback) + }) + + it("propagates a dangling symlink instead of writing through the link path", async () => { + // realpath resolves the referent, so a link whose target is missing reports + // ENOENT. Falling back to the link path would replace the symlink with a + // regular file, so the error must propagate and nothing may be committed. + const linkPath = "/tmp/test-dir/dangling-link.txt" + vi.mocked(fs.realpath).mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" })) + const linkStats = Object.create(fsSync.Stats.prototype) as fsSync.Stats + linkStats.isSymbolicLink = () => true + vi.mocked(fs.lstat).mockResolvedValue(linkStats) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await expect(safeWriteText(linkPath, "data", { platform: "linux" })).rejects.toThrow("ENOENT") + + expect(fs.rename).not.toHaveBeenCalled() + }) + }) + + // ── Test 8: review fixes (permissions, partial writes, resolution, durability) ── + + describe("review fixes", () => { + it("preserves the target's restrictive mode and tolerates a failed staging-dir permission repair", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o600)) + // a pre-existing staging dir may fail its best-effort permission repair + vi.mocked(fsSync.chmodSync).mockImplementationOnce(() => { + throw new Error("EACCES") + }) + + await safeWriteText(targetPath, "secret", { platform: "linux" }) + + // the staging file inherits the target's 0o600 mode and the write commits + expect(fsSync.openSync).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), "w", 0o600) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + }) + + it("falls back to the 0o644 default when the target does not exist yet", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fsSync.statSync).mockImplementation(() => { + throw Object.assign(new Error("ENOENT"), { code: "ENOENT" }) + }) + + await safeWriteText(targetPath, "fresh", { platform: "linux" }) + + expect(fsSync.openSync).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), "w", 0o644) + }) + + it("loops on short writes until the full content is durable before fsync", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const content = "0123456789" // 10 bytes + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + const buffer = Buffer.from(content, "utf8") + // first write (offset 0) reports 4 bytes (short write); the loop continues + vi.mocked(fsSync.writeSync).mockImplementation((...args: unknown[]) => + args[2] === 0 ? 4 : typeof args[3] === "number" ? args[3] : 0, + ) + + await safeWriteText(targetPath, content, { platform: "linux" }) + + // [0,10) reports 4 bytes, then [4,10) writes the remaining 6 + expect(fsSync.writeSync).toHaveBeenCalledTimes(2) + expect(fsSync.writeSync).toHaveBeenNthCalledWith(1, 1, buffer, 0, 10) + expect(fsSync.writeSync).toHaveBeenNthCalledWith(2, 1, buffer, 4, 6) + expect(fsSync.fsyncSync).toHaveBeenCalledWith(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + }) + + it("fsyncs the parent directory after the commit rename on POSIX", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // temp fd=1 then parent-dir fd=2 - distinct fds prove the ordering + vi.mocked(fsSync.openSync).mockReturnValueOnce(1).mockReturnValue(2) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // the directory fsync (fd 2) happens only after the file fsync (fd 1); + // the dir path assertion is path-agnostic (stringContaining) because + // path.dirname renders the same input differently on Windows + expect(fsSync.openSync).toHaveBeenCalledWith(expect.stringContaining("test-dir"), "r") + expect(fsSync.fsyncSync).toHaveBeenNthCalledWith(1, 1) + expect(fsSync.fsyncSync).toHaveBeenNthCalledWith(2, 2) + expect(fsSync.closeSync).toHaveBeenCalledWith(2) + }) + + it("treats a failed parent-directory fsync as best-effort", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync) + .mockReturnValueOnce(1) + .mockImplementationOnce(() => { + throw new Error("EBADF") + }) + + // the content rename already committed; a missing directory fsync is not fatal + await safeWriteText(targetPath, "data", { platform: "linux" }) + + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + }) + + it("propagates realpath errors (EACCES and code-less) instead of the fallback path", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const eacces = Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }) + vi.mocked(fs.realpath).mockRejectedValueOnce(eacces) + await expect(safeWriteText(targetPath, "data", { platform: "linux" })).rejects.toBe(eacces) + expect(fs.rename).not.toHaveBeenCalled() + + const plain = new Error("resolution failed") + vi.mocked(fs.realpath).mockRejectedValueOnce(plain) + await expect(safeWriteText(targetPath, "data", { platform: "linux" })).rejects.toBe(plain) + expect(fs.rename).not.toHaveBeenCalled() + }) + + it("backup:true propagates access errors (EACCES and code-less) instead of skipping the backup", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const eacces = Object.assign(new Error("EACCES"), { code: "EACCES" }) + const plain = new Error("access failed") + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // each write accesses dirPath then target; only the target access rejects + const rejectTarget = (error: Error) => async (p: unknown) => { + if (typeof p === "string" && p.endsWith("target.txt")) throw error + } + vi.mocked(fs.access) + .mockImplementationOnce(rejectTarget(eacces)) + .mockImplementationOnce(rejectTarget(eacces)) + .mockImplementationOnce(rejectTarget(plain)) + .mockImplementationOnce(rejectTarget(plain)) + + await expect(safeWriteText(targetPath, "data", { backup: true, platform: "linux" })).rejects.toEqual( + expect.objectContaining({ code: "EACCES" }), + ) + await expect(safeWriteText(targetPath, "data", { backup: true, platform: "linux" })).rejects.toThrow( + "access failed", + ) + expect(fs.rename).not.toHaveBeenCalled() + }) + }) + describe("content bytes", () => { + const targetPath = "/tmp/enc-dir/target.txt" + + beforeEach(() => { + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + }) + + it("stages UTF-8 bytes for string content", async () => { + await safeWriteText(targetPath, "héllo", { platform: "linux" }) + expect(fsSync.writeSync).toHaveBeenCalledWith(1, Buffer.from("héllo", "utf8"), 0, 6) + }) + + it("publishes caller-supplied bytes unchanged instead of re-encoding them", async () => { + // The extension host encodes a document with VS Code's own codec, which + // covers the legacy code pages and BOMs Node cannot represent, and hands + // the result over: those bytes must reach the commit rename exactly as + // they were given. + const bytes = Buffer.from([0x00, 0x68, 0x00, 0x69]) + await safeWriteText(targetPath, bytes, { platform: "linux" }) + expect(fsSync.writeSync).toHaveBeenCalledWith(1, bytes, 0, 4) + }) + }) +}) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts new file mode 100644 index 0000000000..b5f82a4f81 --- /dev/null +++ b/src/services/file-safety/safeWriteText.ts @@ -0,0 +1,420 @@ +import * as fs from "fs/promises" +import * as fsSync from "fs" +import * as path from "path" +import { execFile } from "child_process" + +export interface SafeWriteTextOptions { + /** + * When true, preserve the old-file semantics: rename target -> backup first, + * after commit rename delete the backup; on failure roll the backup back to + * the target path. When false (default) the atomic rename simply replaces + * the target -- crash-safe window is zero. + */ + backup?: boolean + + /** + * Platform override for testing. When omitted the real process.platform + * value is used. Set to "win32" or "linux" / "darwin" from tests so that + * both branches are reachable without needing a real Windows runner. + */ + platform?: string + + /** + * Custom execFile runner for testing (e.g. vi.fn). When omitted the real + * child_process.execFile is used. + */ + execFileRunner?: typeof execFile + + /** + * Pre-written temp path to use for the commit phase. When provided, + * safeWriteText skips creating its own staging file and uses this path + * instead (it still fsyncs before rename). Useful when a caller has + * already written data to a temp file via a custom stream. + */ + tempPath?: string +} + +/** + * A publish that failed and whose rollback also failed: the content survives only + * at the backup path, not at the canonical target. The publish failure stays the + * cause, and the rollback failure plus the backup location travel with the error so + * the caller can tell what it is looking at. + */ +export class RollbackFailureError extends Error { + readonly publishError: unknown + readonly rollbackError: unknown + readonly backupPath: string + + constructor(publishError: unknown, rollbackError: unknown, backupPath: string) { + super( + "Publish failed and the backup could not be restored to its original path -- the content is preserved at the backup location reported on this error.", + { cause: publishError }, + ) + this.name = "RollbackFailureError" + this.publishError = publishError + this.rollbackError = rollbackError + this.backupPath = backupPath + } +} +// -- helpers --------------------------------------------------------------- + +/** Generate a unique temp file name in the given directory. */ +function _tempName(dir: string, prefix: string): string { + return path.join(dir, "." + prefix + "_" + Date.now() + "_" + Math.random().toString(36).substring(2) + ".tmp") +} + +/** Create a private per-write staging sub-directory inside *dir*. The name is + * unique per write, so concurrent writes never collide on their temp names and + * never remove a staging directory another write is still using: with one shared + * name, one write's best-effort rmdir could delete the directory another write + * had just created but not yet opened, failing its openSync with ENOENT. */ +function _stagingDir(dir: string): string { + const sd = path.join(dir, ".file-safety-staging_" + Date.now() + "_" + Math.random().toString(36).substring(2)) + // mode:0o700 protects a freshly created staging dir; the best-effort chmod + // repairs a pre-existing one (mkdirSync with recursive:true never chmods an + // existing directory), so staged temp files are never group/world readable. + fsSync.mkdirSync(sd, { recursive: true, mode: 0o700 }) + try { + fsSync.chmodSync(sd, 0o700) + } catch { + // best-effort: chmod denied or unavailable; a fresh dir was still + // created with the requested mode + } + return sd +} + +function _fsyncFile(fd: number): void { + fsSync.fsyncSync(fd) +} + +/** Save the DACL of *srcPath* to a dump file on Windows. + * Returns true when the dump was written successfully; false otherwise. + * Never throws — callers treat failure as "skip DACL handling". */ +async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { + const runner = execFileRunner ?? execFile + try { + await new Promise((resolve, reject) => { + runner("icacls", [srcPath, "/save", dumpPath, "/T"], { windowsHide: true }, (err) => + err ? reject(err) : resolve(), + ) + }) + return true + } catch { + return false + } +} + +/** Restore a DACL dump onto *dirPath* on Windows. + * Best-effort: content is already committed, so failure is non-fatal. */ +async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { + const runner = execFileRunner ?? execFile + try { + await new Promise((resolve, reject) => { + runner("icacls", [dirPath, "/restore", dumpPath], { windowsHide: true }, (err) => + err ? reject(err) : resolve(), + ) + }) + } catch { + // best-effort; content already committed + } +} + +// -- public API ------------------------------------------------------------ + +/** + * Resolve the publish target: the symlink referent when the given path is an + * existing symlink, the path itself otherwise. Only ENOENT (target absent yet) + * may fall back to the given path; any other resolution error (EACCES, EIO, ...) + * propagates so a broken or unreadable symlink is never written through its + * link path. Callers that stage a temp file themselves must stage it beside + * the resolved path: the commit is a rename onto the referent, and a rename + * across filesystems fails with EXDEV. + */ +export async function resolvePublishTarget(absoluteFilePath: string): Promise { + return fs.realpath(absoluteFilePath).catch(async (error: unknown) => { + const code = + typeof error === "object" && error !== null && "code" in error + ? (error as { code?: string }).code + : undefined + if (code !== "ENOENT") throw error + // ENOENT also covers a dangling symlink, which must never be written through. + const linkStat = await fs.lstat(absoluteFilePath).catch(() => undefined) + if (linkStat?.isSymbolicLink()) throw error + return absoluteFilePath + }) +} +/** + * Distinguish "the target does not exist" from a real I/O failure (EACCES, + * EIO, ...). The mode-preservation path may only fall back to the fresh-file + * default on ENOENT; any other failure is propagated, otherwise a restrictive + * target (0o600) would be published with the default 0o644 through the rename. + */ +function errorCode(error: unknown): string | undefined { + return typeof error === "object" && error !== null && "code" in error + ? String((error as { code: unknown }).code) + : undefined +} + +/** + * Canonicalize the parent directory and re-join the basename. fs.realpath + * canonicalizes every component, including a symlinked ancestor directory or a + * Windows 8.3 short name, so a lock key must be canonical even when the file + * itself is not there yet -- otherwise the key for one file depends on whether + * the file exists when the key is computed, and two writers take two locks. + */ + +async function canonicalDirKey(absoluteFilePath: string): Promise { + const dirPath = path.dirname(absoluteFilePath) + const canonicalDir = await fs.realpath(dirPath).catch(() => dirPath) + return path.join(canonicalDir, path.basename(absoluteFilePath)) +} + +/** + * Lock key for a publish target: the symlink referent when the path is an + * existing symlink, the path itself otherwise. Unlike resolvePublishTarget this + * tolerates a dangling link, because the lock key has to be computable while a + * peer writer is mid-commit (backup mode renames the referent away and back). + * The walk is bounded so a two-link cycle terminates, and every key it returns is + * canonicalized through canonicalDirKey. + */ +export async function resolveLockKey(absoluteFilePath: string): Promise { + try { + return await canonicalDirKey(await resolvePublishTarget(absoluteFilePath)) + } catch { + // A real readlink throws for anything that is not a link, so a normal chain + // ends the walk. Two links that point at each other never would, so the + // walk is bounded and callers use the key they actually reached. + let key = absoluteFilePath + for (let depth = 0; depth < 8; depth++) { + const target = await fs.readlink(key).catch(() => undefined) + if (target === undefined) return await canonicalDirKey(key) + key = await canonicalDirKey(path.resolve(path.dirname(key), target)) + } + return await canonicalDirKey(key) + } +} + +export async function safeWriteText( + filePath: string, + content: string | Uint8Array, + options?: SafeWriteTextOptions, +): Promise { + const absoluteFilePath = path.resolve(filePath) + + // Resolve the symlink referent (see resolvePublishTarget). + const targetPath = await resolvePublishTarget(absoluteFilePath) + const dirPath = path.dirname(targetPath) + + // Ensure parent directory exists (mirrors safeWriteJson behaviour). + await fs.mkdir(dirPath, { recursive: true }) + await fs.access(dirPath) + + // Create the staging directory only when we generate the temp file there; + // callers supplying their own tempPath (e.g. safeWriteJson) must not be left + // with an empty .file-safety-staging directory behind. Track the directory this + // write created so its cleanup removes its own directory, not a shared one. + let stagingDir: string | null = null + let tempPath: string + if (options?.tempPath) { + tempPath = options.tempPath + } else { + stagingDir = _stagingDir(dirPath) + tempPath = _tempName(stagingDir, "safeWriteText") + } + + let backupPath: string | null = null + let releaseBackupOnSuccess = false + // Non-null only when the win32 step-2 block saved a successful DACL dump: + // it gates the step-5 restore and is tracked for the cleanup unlinks. + let daclDumpPath: string | null = null + + try { + // -- Step 1: write content to staging temp file ------------------- + if (!options?.tempPath) { + // Preserve the existing target's permissions: the staging file must + // not be published wider than the file it replaces (a 0o600 target + // must not become 0o644 through the atomic rename). + // Encode before opening the staging file: an encoding Node cannot + // represent must not leave a half-written temp file behind. + // A string is encoded as UTF-8; bytes handed in by the caller (the + // extension host encodes a document with VS Code's own codec, which + // covers the legacy code pages Node cannot represent) are published + // unchanged. + const buffer = Buffer.from(content) + let targetMode = 0o644 // default for a fresh target + let targetExists = false + try { + targetMode = fsSync.statSync(targetPath).mode & 0o777 + targetExists = true + } catch (error: unknown) { + if (errorCode(error) !== "ENOENT") throw error + // target does not exist yet - keep the default + } + // openSync's creation mode is narrowed by the process umask, so an + // existing 0o664 target would be published as 0o644 through the + // rename. Apply the existing target's exact mode on the fd, as the + // caller-staged branch does; a fresh target keeps the default mode. + const fd = fsSync.openSync(tempPath, "w", targetMode) + try { + if (targetExists) { + fsSync.fchmodSync(fd, targetMode) + } + // Loop until every byte is written: writeSync can report a short + // (partial) write, and publishing a truncated staging file would + // commit corrupt content. + let offset = 0 + while (offset < buffer.length) { + offset += fsSync.writeSync(fd, buffer, offset, buffer.length - offset) + } + _fsyncFile(fd) + } finally { + fsSync.closeSync(fd) + } + } else { + // Preserve the existing target's mode (CWE-732): the caller-staged + // temp carries its own creation mode, and publishing it as-is would + // widen a restrictive target (e.g. 0o600 -> 0o644) through rename. + // The mode is applied with fchmodSync on the open fd (AFTER openSync): + // chmodSync on the path before the open would make a read-only target + // (0o400/0o444) fail openSync(tempPath, "r+") with EACCES. + let targetMode: number | null = null + try { + targetMode = fsSync.statSync(targetPath).mode & 0o777 + } catch (error: unknown) { + if (errorCode(error) !== "ENOENT") throw error + // target does not exist yet - keep the temp's default mode + } + const fd = fsSync.openSync(tempPath, "r+") + try { + if (targetMode !== null) { + fsSync.fchmodSync(fd, targetMode) + } + _fsyncFile(fd) + } finally { + fsSync.closeSync(fd) + } + } + + // -- Step 2 (win32): save DACL BEFORE backup rename --------------- + const platform = options?.platform ?? process.platform + if (platform === "win32") { + try { + await fs.access(targetPath) // target exists? + const dumpPath = targetPath + ".acl.tmp" + const saved = await _saveDaclWindows(targetPath, dumpPath, options?.execFileRunner) + if (saved) { + // Only a successfully saved dump may be restored onto the + // committed file (step 5). + daclDumpPath = dumpPath + } else { + // A failed icacls may have left a partial dump behind; + // remove it now (best-effort) so no partial dump survives and + // no later step can restore from it. + await fs.unlink(dumpPath).catch(() => {}) + } + } catch { + // target does not exist or access failed — no DACL handling + daclDumpPath = null + } + } + + try { + // -- Step 3 (backup:true): rename target -> backup -------------- + if (options?.backup) { + try { + await fs.access(targetPath) + backupPath = _tempName(dirPath, "safeWriteText.bak") + await fs.rename(targetPath, backupPath) + releaseBackupOnSuccess = true + } catch (err: unknown) { + const code = + typeof err === "object" && err !== null && "code" in err + ? (err as { code?: string }).code + : undefined + if (code !== "ENOENT") throw err + } + } + + // -- Step 4: atomic rename temp -> target --------------------- + await fs.rename(tempPath, targetPath) + + // -- Step 4b (POSIX): fsync the parent directory so the directory entry + // changed by the commit rename is durable, not just the file content. + if (platform !== "win32") { + try { + const dirFd = fsSync.openSync(dirPath, "r") + try { + _fsyncFile(dirFd) + } finally { + fsSync.closeSync(dirFd) + } + } catch { + // best-effort: the content rename already committed + } + } + + // -- Step 5 (win32): restore DACL AFTER commit rename --------- + // daclDumpPath is non-null only when the win32 step-2 block saved a + // successful dump, so this gate is closed on every other platform + // and on every failed save. + if (daclDumpPath !== null) { + const restoredDir = path.dirname(targetPath) + await _restoreDaclWindows(restoredDir, daclDumpPath, options?.execFileRunner) + } + + // -- Step 6 (backup:true): delete backup on success ----------- + if (releaseBackupOnSuccess && backupPath) { + try { + await fs.unlink(backupPath) + } catch { + // non-fatal — orphaned backup is acceptable + } + } + } finally { + // Unlink DACL dump regardless of success/failure in this span. + if (daclDumpPath !== null) { + await fs.unlink(daclDumpPath).catch(() => {}) + } + } + + // tempPath is now the committed file; no cleanup needed. + + // Best-effort: remove the now-empty staging directory. Self-staged + // writes only, and only this write's own directory: a per-write directory + // cannot be the one another concurrent write is still using. A failure must + // never un-commit a published file, so the removal swallows all errors. + if (stagingDir) { + await fs.rmdir(stagingDir).catch(() => {}) + } + } catch (originalError: unknown) { + if (backupPath && releaseBackupOnSuccess) { + try { + await fs.rename(backupPath, targetPath) + } catch (rollbackError: unknown) { + // The content survives only at the backup path now, and the canonical + // target is gone. Reporting just the publish failure would leave the + // caller with data it cannot find at the expected path, so the + // partial-failure state travels with the error. + throw new RollbackFailureError(originalError, rollbackError, backupPath) + } + } + try { + await fs.unlink(tempPath).catch(() => {}) + } catch { + // cleanup failure is non-fatal + } + + // A failed self-staged write must not leave its staging directory behind. + // Only the directory this write created, and only after its temp file is + // gone, so the directory is empty and the removal stays best-effort. + if (stagingDir) { + await fs.rmdir(stagingDir).catch(() => {}) + } + + if (daclDumpPath !== null) { + await fs.unlink(daclDumpPath).catch(() => {}) + } + + throw originalError + } +} From bef023d8eab85f45aff5d9205d3a9ca7cc2de946 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 20:49:29 +0800 Subject: [PATCH 02/72] fix(file-safety): close the pre-merge findings on the publish primitive (U1, issue 1375) Split unit U1 of PR 1833. Three changes, each with a test that fails without it: - a caller-supplied staging path is checked for location and file type before anything is written, so an arbitrary path or a symlink cannot be published onto the target; - a failed parent-directory fsync on POSIX is reported as PostCommitDurabilityError instead of being swallowed, so a successful return never claims durability the filesystem did not grant; - the staged file and this write's own staging directory are released before RollbackFailureError is thrown. Focused coverage for resolveLockKey added: canonical parent directory, a dangling-link chain, and termination at the bounded depth on a two-link cycle. --- .../__tests__/safeWriteText.spec.ts | 169 ++++++++++++++++-- src/services/file-safety/safeWriteText.ts | 82 ++++++++- 2 files changed, 229 insertions(+), 22 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index e2f947c8bc..66878d8b9d 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -4,7 +4,14 @@ import { execFile } from "child_process" import type { ChildProcess } from "child_process" import * as path from "path" -import { RollbackFailureError, safeWriteText, type SafeWriteTextOptions } from "../safeWriteText" +import { + PostCommitDurabilityError, + resolveLockKey, + RollbackFailureError, + safeWriteText, + StagingPathError, + type SafeWriteTextOptions, +} from "../safeWriteText" // Full mock for fs/promises — all methods are vi.fn() stubs vi.mock("fs/promises", () => ({ @@ -15,6 +22,7 @@ vi.mock("fs/promises", () => ({ rmdir: vi.fn(), realpath: vi.fn(), lstat: vi.fn(), + readlink: vi.fn(), })) // Full mock for fs — all sync methods are vi.fn() stubs. Stats is a bare @@ -49,6 +57,25 @@ function _dirPath(filePath: string): string { return path.dirname(_resolvedTarget(filePath)) } // Minimal Stats stand-in: the SUT only reads `.mode` from it. +// Async lstat stand-in: the SUT only asks whether the path is a link or a file. +function _fileStats(isLink: boolean) { + return { isSymbolicLink: () => isLink, isFile: () => !isLink } +} + +function mockDefaults(): void { + vi.resetAllMocks() + // After resetAllMocks, vi.fn() returns undefined — restore promise defaults. + vi.mocked(fs.mkdir).mockResolvedValue(undefined) + vi.mocked(fs.access).mockResolvedValue(undefined) + vi.mocked(fs.rename).mockResolvedValue(undefined) + vi.mocked(fs.unlink).mockResolvedValue(undefined) + vi.mocked(fs.rmdir).mockResolvedValue(undefined) + // Existing-target default: a regular 0o644 file. + vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o644)) + // Staged-file default: a regular file, not a link, so a caller-supplied + // tempPath passes the location and file-type check by default. + vi.mocked(fs.lstat).mockResolvedValue(_fileStats(false)) +} function _stats(mode: number): fsSync.Stats { const s = Object.create(fsSync.Stats.prototype) as fsSync.Stats Object.assign(s, { mode }) @@ -59,15 +86,7 @@ function _stats(mode: number): fsSync.Stats { describe("safeWriteText", () => { beforeEach(() => { - vi.resetAllMocks() - // After resetAllMocks, vi.fn() returns undefined — restore promise defaults. - vi.mocked(fs.mkdir).mockResolvedValue(undefined) - vi.mocked(fs.access).mockResolvedValue(undefined) - vi.mocked(fs.rename).mockResolvedValue(undefined) - vi.mocked(fs.unlink).mockResolvedValue(undefined) - vi.mocked(fs.rmdir).mockResolvedValue(undefined) - // Existing-target default: a regular 0o644 file. - vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o644)) + mockDefaults() // Default sync-write behaviour: report that all requested bytes were // written. The Buffer overload passes (fd, buffer, offset, length), // so the fourth argument is the requested length. @@ -577,7 +596,7 @@ describe("safeWriteText", () => { vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) - const customTempPath = "/tmp/custom-temp.tmp" + const customTempPath = "/tmp/test-dir/custom-temp.tmp" // platform:linux skips DACL entirely so this test focuses on tempPath only await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) @@ -604,7 +623,7 @@ describe("safeWriteText", () => { vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o600)) vi.mocked(fsSync.openSync).mockReturnValue(2) - const customTempPath = "/tmp/custom-temp.tmp" + const customTempPath = "/tmp/test-dir/custom-temp.tmp" await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) @@ -624,7 +643,7 @@ describe("safeWriteText", () => { }) vi.mocked(fsSync.openSync).mockReturnValue(2) - const customTempPath = "/tmp/custom-temp.tmp" + const customTempPath = "/tmp/test-dir/custom-temp.tmp" await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) @@ -642,7 +661,7 @@ describe("safeWriteText", () => { }) vi.mocked(fsSync.openSync).mockReturnValue(2) - const customTempPath = "/tmp/custom-temp.tmp" + const customTempPath = "/tmp/test-dir/custom-temp.tmp" // A target that cannot be stat'd is not a fresh target: publishing with // the default mode would widen a restrictive target through the rename. @@ -674,7 +693,7 @@ describe("safeWriteText", () => { vi.mocked(fsSync.statSync).mockReturnValue(_stats(0o444)) vi.mocked(fsSync.openSync).mockReturnValue(3) - const customTempPath = "/tmp/custom-temp.tmp" + const customTempPath = "/tmp/test-dir/custom-temp.tmp" await safeWriteText(targetPath, "", { tempPath: customTempPath, platform: "linux" }) @@ -843,7 +862,7 @@ describe("safeWriteText", () => { expect(fsSync.closeSync).toHaveBeenCalledWith(2) }) - it("treats a failed parent-directory fsync as best-effort", async () => { + it("reports a failed parent-directory fsync instead of claiming a durable write", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync) @@ -852,8 +871,13 @@ describe("safeWriteText", () => { throw new Error("EBADF") }) - // the content rename already committed; a missing directory fsync is not fatal - await safeWriteText(targetPath, "data", { platform: "linux" }) + // The content rename committed, so the caller can still find the data at + // the target; what the write cannot claim is that the directory entry + // reached the disk. Returning success here would claim durability the + // filesystem did not grant. + await expect(safeWriteText(targetPath, "data", { platform: "linux" })).rejects.toThrow( + PostCommitDurabilityError, + ) expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) }) @@ -920,3 +944,112 @@ describe("safeWriteText", () => { }) }) }) + +// ── Test 12: lock key, staging path, and post-commit durability ───────────── + +describe("resolveLockKey", () => { + beforeEach(() => mockDefaults()) + + it("canonicalizes the parent directory, not just the file", async () => { + vi.mocked(fs.realpath).mockImplementation(async (target: string) => { + if (target === "/tmp/linkdir/file.json") return "/real/dir/file.json" + if (target === "/real/dir") return "/real/dir" + return target + }) + + // The key is the canonical directory plus the basename, so a symlinked + // ancestor and its referent share one lock. + await expect(resolveLockKey("/tmp/linkdir/file.json")).resolves.toBe(path.join("/real/dir", "file.json")) + }) + + it("computes a key for a dangling link, which resolvePublishTarget refuses", async () => { + const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + vi.mocked(fs.realpath).mockRejectedValue(enoent) + vi.mocked(fs.lstat).mockResolvedValue(_fileStats(true)) + vi.mocked(fs.readlink).mockImplementation(async (target: string) => + target === "/tmp/linkdir/file.json" ? "referent.json" : undefined, + ) + + // Mid-commit a peer writer renames the referent away and back, so the key + // must still be computable while the link dangles. + await expect(resolveLockKey("/tmp/linkdir/file.json")).resolves.toBe( + path.resolve(path.join("/tmp/linkdir", "referent.json")), + ) + }) + + it("terminates on a two-link cycle instead of walking forever", async () => { + const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + vi.mocked(fs.realpath).mockRejectedValue(enoent) + vi.mocked(fs.lstat).mockResolvedValue(_fileStats(true)) + // Every readlink answers with the same link, so an unbounded walk would + // never end; the bounded walk returns the key it actually reached. + vi.mocked(fs.readlink).mockImplementation(async () => "a.json") + + await expect(resolveLockKey("/tmp/linkdir/a.json")).resolves.toBe( + path.resolve(path.join("/tmp/linkdir", "a.json")), + ) + expect(fs.readlink).toHaveBeenCalledTimes(8) + }) +}) + +describe("caller-supplied staging path", () => { + beforeEach(() => mockDefaults()) + + it("rejects a staging file outside the target's directory before writing anything", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + + // A rename across filesystems fails with EXDEV, and a path elsewhere lets + // a caller publish an unrelated file onto the target. + await expect( + safeWriteText(targetPath, "data", { tempPath: "/tmp/other-dir/x.tmp", platform: "linux" }), + ).rejects.toThrow(StagingPathError) + expect(fsSync.openSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + }) + + it("rejects a staging path that is a symlink", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.lstat).mockResolvedValue(_fileStats(true)) + + // Renaming a link over the target publishes whatever the link points at. + await expect( + safeWriteText(targetPath, "data", { tempPath: "/tmp/test-dir/x.tmp", platform: "linux" }), + ).rejects.toThrow(StagingPathError) + expect(fsSync.openSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + }) +}) + +describe("cleanup before a rollback failure is reported", () => { + beforeEach(() => mockDefaults()) + + it("releases the staged file and its own staging directory before throwing", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + let callCount = 0 + vi.mocked(fs.rename).mockImplementation(async () => { + callCount++ + if (callCount === 1) return // target -> backup + if (callCount === 2) throw new Error("ENOSPC") // temp -> target fails + throw new Error("EACCES") // the rollback rename fails too + }) + + await expect(safeWriteText(targetPath, "data", { backup: true, platform: "linux" })).rejects.toThrow( + RollbackFailureError, + ) + + // The backup is what the caller can still recover, so it stays on disk; the + // staging file and this write's own directory must not leak alongside it. + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + expect(fs.rmdir).toHaveBeenCalled() + + const failingRenameOrder = vi.mocked(fs.rename).mock.invocationCallOrder[2] + const unlinkOrder = vi.mocked(fs.unlink).mock.invocationCallOrder[0] + const rmdirOrder = vi.mocked(fs.rmdir).mock.invocationCallOrder[0] + expect(unlinkOrder).toBeGreaterThan(failingRenameOrder) + expect(rmdirOrder).toBeGreaterThan(failingRenameOrder) + }) +}) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index b5f82a4f81..9f62d2aed4 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -56,6 +56,41 @@ export class RollbackFailureError extends Error { this.backupPath = backupPath } } + +/** + * A caller-supplied staging path that is not a file this write may publish: it + * sits outside the target's directory (so the commit rename would cross + * filesystems) or is not a regular file. Rejecting it before any write keeps the + * target from being replaced by whatever the path points at. + */ +export class StagingPathError extends Error { + readonly stagingPath: string + + constructor(message: string, stagingPath: string) { + super(message) + this.name = "StagingPathError" + this.stagingPath = stagingPath + } +} + +/** + * The commit rename succeeded but the parent-directory fsync did not, so the + * directory entry is not known to be durable. The content is at the target; the + * caller cannot assume it survives a crash. Reported as its own error so a + * successful return never claims durability the filesystem did not grant. + */ +export class PostCommitDurabilityError extends Error { + readonly targetPath: string + + constructor(targetPath: string, cause: unknown) { + super( + "The rename committed but the parent directory could not be fsynced -- the content is at the target path reported on this error, and the directory entry may not be durable.", + { cause }, + ) + this.name = "PostCommitDurabilityError" + this.targetPath = targetPath + } +} // -- helpers --------------------------------------------------------------- /** Generate a unique temp file name in the given directory. */ @@ -216,6 +251,29 @@ export async function safeWriteText( let stagingDir: string | null = null let tempPath: string if (options?.tempPath) { + // A caller-supplied staging file is only safe when it is the file this + // write is staging, not an arbitrary path. Two properties are checked: + // it must sit beside the resolved target (a rename across filesystems + // fails with EXDEV, and a path elsewhere lets a caller publish an + // unrelated file onto the target), and it must be a regular file rather + // than a link — renaming a link over the target publishes whatever the + // link points at, which is the same trust problem as writing through a + // dangling symlink in resolvePublishTarget. + const supplied = path.resolve(options.tempPath) + if (path.dirname(supplied) !== path.resolve(dirPath)) { + throw new StagingPathError( + `Staging file must sit in the target's directory (${dirPath}), got ${supplied}`, + supplied, + ) + } + const stagingStat = await fs.lstat(supplied) + if (stagingStat.isSymbolicLink() || !stagingStat.isFile()) { + throw new StagingPathError( + `Staging file must be a regular file, not ${stagingStat.isSymbolicLink() ? "a symlink" : "another file type"}`, + supplied, + ) + } + // The caller's own path is used as given; only the check is canonical. tempPath = options.tempPath } else { stagingDir = _stagingDir(dirPath) @@ -227,6 +285,9 @@ export async function safeWriteText( // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null + // Set when the rollback itself fails, so cleanup runs before the error that + // reports the partial state is thrown. + let rollbackFailure: unknown = undefined try { // -- Step 1: write content to staging temp file ------------------- @@ -348,8 +409,14 @@ export async function safeWriteText( } finally { fsSync.closeSync(dirFd) } - } catch { - // best-effort: the content rename already committed + } catch (error: unknown) { + // The content rename committed, but the directory entry that + // points at it is not known to be durable. Reporting success + // here would let a caller believe the write survives a crash, + // so the failure is surfaced as its own error: the caller can + // still find the content at the target, it just cannot rely on + // the directory entry having reached the disk. + throw new PostCommitDurabilityError(targetPath, error) } } @@ -394,8 +461,11 @@ export async function safeWriteText( // The content survives only at the backup path now, and the canonical // target is gone. Reporting just the publish failure would leave the // caller with data it cannot find at the expected path, so the - // partial-failure state travels with the error. - throw new RollbackFailureError(originalError, rollbackError, backupPath) + // partial-failure state travels with the error. The staged temp file + // and this write's staging directory are released first: a rollback + // failure is already a hard enough state to reason about without also + // leaking the staging file. + rollbackFailure = rollbackError } } try { @@ -415,6 +485,10 @@ export async function safeWriteText( await fs.unlink(daclDumpPath).catch(() => {}) } + if (rollbackFailure) { + throw new RollbackFailureError(originalError, rollbackFailure, backupPath) + } + throw originalError } } From 12b57c14813d04794f25d11fe7a9d4649b35aa8e Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 21:14:20 +0800 Subject: [PATCH 03/72] fix(file-safety): propagate a non-ENOENT lstat failure in resolvePublishTarget (U1, issue 1375) The resolver may fall back to the given path only when lstat also reports the path as absent. An EACCES or EIO failure says nothing about whether the path is a link, so falling back would publish through a link we were not allowed to inspect. Focused tests added for both branches. --- .../__tests__/safeWriteText.spec.ts | 30 +++++++++++++++++++ src/services/file-safety/safeWriteText.ts | 9 +++++- 2 files changed, 38 insertions(+), 1 deletion(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 66878d8b9d..674df74070 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -1053,3 +1053,33 @@ describe("cleanup before a rollback failure is reported", () => { expect(rmdirOrder).toBeGreaterThan(failingRenameOrder) }) }) + +describe("resolvePublishTarget", () => { + beforeEach(() => mockDefaults()) + + it("propagates an lstat failure that is not ENOENT instead of falling back to the link path", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + const eacces = Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }) + vi.mocked(fs.realpath).mockRejectedValue(enoent) + vi.mocked(fs.lstat).mockRejectedValue(eacces) + + // A failed lstat says nothing about whether the path is a link, so the + // fallback would publish through a link we were not allowed to inspect. + await expect(safeWriteText(targetPath, "data", { platform: "linux" })).rejects.toBe(eacces) + expect(fs.rename).not.toHaveBeenCalled() + }) + + it("still falls back to the given path when lstat also reports the path as absent", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + vi.mocked(fs.realpath).mockRejectedValue(enoent) + vi.mocked(fs.lstat).mockRejectedValue(enoent) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + await safeWriteText(targetPath, "data", { platform: "linux" }) + + // The fallback is the resolved path, not the string that was handed in. + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), path.resolve(targetPath)) + }) +}) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 9f62d2aed4..d2a55ab349 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -173,7 +173,14 @@ export async function resolvePublishTarget(absoluteFilePath: string): Promise undefined) + // Only a lstat that also reports the path as absent may fall back to the + // given path; a real lstat failure (EACCES, EIO) says nothing about whether + // the path is a link, so falling back would write through a link we were + // simply not allowed to inspect. + const linkStat = await fs.lstat(absoluteFilePath).catch((lstatError: unknown) => { + if (errorCode(lstatError) === "ENOENT") return undefined + throw lstatError + }) if (linkStat?.isSymbolicLink()) throw error return absoluteFilePath }) From 984c6eddd49c6e49a035472e177fb3ba00e1051c Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 22:30:44 +0800 Subject: [PATCH 04/72] fix(file-safety): keep the rollback pair typed and the mock stand-ins type-sound compile failed at the unit head on three points: - RollbackFailureError needs a string backupPath, but the throw now happens after cleanup, so the `string | null` narrowing was lost. The failure is now held as { error, backupPath }. - The async lstat stand-in is built on the Stats prototype so it satisfies fsSync.Stats. - The realpath/readlink mocks are typed to the real signatures; the readlink mock answers once because only the link path is read. tsc clean, 50 tests pass, ESLint --max-warnings=0 clean, no suppression change. --- .../__tests__/safeWriteText.spec.ts | 23 +++++++++++-------- src/services/file-safety/safeWriteText.ts | 8 ++++--- 2 files changed, 19 insertions(+), 12 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 674df74070..007ff4d3c5 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -58,8 +58,12 @@ function _dirPath(filePath: string): string { } // Minimal Stats stand-in: the SUT only reads `.mode` from it. // Async lstat stand-in: the SUT only asks whether the path is a link or a file. -function _fileStats(isLink: boolean) { - return { isSymbolicLink: () => isLink, isFile: () => !isLink } +// Built on the Stats prototype so the mock value still satisfies fsSync.Stats. +function _fileStats(isLink: boolean): fsSync.Stats { + const s = Object.create(fsSync.Stats.prototype) as fsSync.Stats + s.isSymbolicLink = () => isLink + s.isFile = () => !isLink + return s } function mockDefaults(): void { @@ -951,10 +955,11 @@ describe("resolveLockKey", () => { beforeEach(() => mockDefaults()) it("canonicalizes the parent directory, not just the file", async () => { - vi.mocked(fs.realpath).mockImplementation(async (target: string) => { - if (target === "/tmp/linkdir/file.json") return "/real/dir/file.json" - if (target === "/real/dir") return "/real/dir" - return target + vi.mocked(fs.realpath).mockImplementation(async (target) => { + const key = String(target) + if (key === "/tmp/linkdir/file.json") return "/real/dir/file.json" + if (key === "/real/dir") return "/real/dir" + return key }) // The key is the canonical directory plus the basename, so a symlinked @@ -966,9 +971,9 @@ describe("resolveLockKey", () => { const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) vi.mocked(fs.realpath).mockRejectedValue(enoent) vi.mocked(fs.lstat).mockResolvedValue(_fileStats(true)) - vi.mocked(fs.readlink).mockImplementation(async (target: string) => - target === "/tmp/linkdir/file.json" ? "referent.json" : undefined, - ) + // Only the link path is read, so a single answer is enough and keeps the mock's + // return type matching fs.promises.readlink. + vi.mocked(fs.readlink).mockResolvedValue("referent.json") // Mid-commit a peer writer renames the referent away and back, so the key // must still be computable while the link dangles. diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index d2a55ab349..e378cbbae8 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -294,7 +294,9 @@ export async function safeWriteText( let daclDumpPath: string | null = null // Set when the rollback itself fails, so cleanup runs before the error that // reports the partial state is thrown. - let rollbackFailure: unknown = undefined + // Held as a pair so the reported error still names the path the content survived at; + // declaring it as `unknown` alone would lose the string narrowing at the throw site. + let rollbackFailure: { error: unknown; backupPath: string } | null = null try { // -- Step 1: write content to staging temp file ------------------- @@ -472,7 +474,7 @@ export async function safeWriteText( // and this write's staging directory are released first: a rollback // failure is already a hard enough state to reason about without also // leaking the staging file. - rollbackFailure = rollbackError + rollbackFailure = { error: rollbackError, backupPath } } } try { @@ -493,7 +495,7 @@ export async function safeWriteText( } if (rollbackFailure) { - throw new RollbackFailureError(originalError, rollbackFailure, backupPath) + throw new RollbackFailureError(originalError, rollbackFailure.error, rollbackFailure.backupPath) } throw originalError From 20136ce3ae71a067ea5d4f0a3b140392caac8048 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 22:34:46 +0800 Subject: [PATCH 05/72] rebuild unit u2 on the fixed chain --- .../__tests__/safeWriteJson.lockKey.spec.ts | 183 ++++++++++++++++ src/utils/__tests__/safeWriteJson.test.ts | 196 ++++++++++++++++-- src/utils/safeWriteJson.ts | 167 +++++++-------- 3 files changed, 432 insertions(+), 114 deletions(-) create mode 100644 src/utils/__tests__/safeWriteJson.lockKey.spec.ts diff --git a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts new file mode 100644 index 0000000000..33989f8b81 --- /dev/null +++ b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts @@ -0,0 +1,183 @@ +// npx vitest run utils/__tests__/safeWriteJson.lockKey.spec.ts + +import * as os from "os" +import path from "path" +import type { BigIntStats } from "fs" +import * as fs from "fs/promises" +import { acquireFileLock } from "../fileLock" +import { safeWriteJson } from "../safeWriteJson" +import { resolveLockKey } from "../../services/file-safety/safeWriteText" + +vi.mock("../fileLock", () => ({ + acquireFileLock: vi.fn(async () => async () => {}), +})) + +vi.mock("fs/promises", async () => { + const actual = await vi.importActual("fs/promises") + return { ...actual, realpath: vi.fn(), lstat: vi.fn(), readlink: vi.fn() } +}) + +const mockedRealpath = vi.mocked(fs.realpath) +const mockedLstat = vi.mocked(fs.lstat) +const mockedReadlink = vi.mocked(fs.readlink) +const mockedAcquireFileLock = vi.mocked(acquireFileLock) + +const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + +// Each test creates a real temp directory so the real fs calls still work. +// doubles between tests so an implementation from one test cannot carry over. +const createdDirs: string[] = [] +async function makeDir(prefix: string): Promise { + const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix)) + createdDirs.push(dir) + return dir +} + +beforeEach(() => { + mockedRealpath.mockReset() + mockedLstat.mockReset() + mockedReadlink.mockReset() + mockedAcquireFileLock.mockReset() +}) + +afterEach(async () => { + for (const dir of createdDirs) { + await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined) + } + createdDirs.length = 0 +}) + +// Only isSymbolicLink() is consulted by the guard, so the double carries just +// that method. The mocks reject asynchronously: a synchronous throw would bypass +// resolvePublishTarget's catch and skip the ENOENT/symlink branch under test. +const symlinkStat = (target: unknown) => ({ + isSymbolicLink: () => target === currentLink, + // The staging-path check in safeWriteText also asks whether the path is a + // regular file, so the double carries that predicate as well. + isFile: () => target !== currentLink, +}) as unknown as BigIntStats +let currentLink = "" + +describe("safeWriteJson lock key under a peer commit", () => { + it("waits for the peer instead of rejecting, and locks the referent", async () => { + const order: string[] = [] + const dir = await makeDir("lockkey-") + const referent = path.join(dir, "history_item.json") + currentLink = path.join(dir, "link.json") + + // The peer writer has renamed the referent away and has not committed yet, + // so the first resolution fails with ENOENT while lstat still reports a + // symbolic link. A strict resolve here rejects the caller before it can ever + // queue behind the peer, and the caller's delta write is lost. + mockedRealpath + .mockImplementationOnce(async () => { + order.push("resolve-failed") + throw enoent + }) + .mockImplementation(async (target) => { + order.push("resolve") + // The second call happens under the lock, where the peer has committed. + return target === currentLink ? referent : String(target) + }) + mockedLstat.mockImplementation(async (target) => { + order.push("lstat") + return symlinkStat(target) + }) + mockedReadlink.mockImplementation(async (target) => + target === currentLink ? referent : Promise.reject(new Error("not a link")), + ) + mockedAcquireFileLock.mockImplementation(async () => { + order.push("lock") + return async () => {} + }) + + await safeWriteJson(currentLink, { id: "task-1" }) + + // The lock key is the key every other writer to this file uses, so the caller + // queued behind the peer instead of failing before the lock. + expect(mockedAcquireFileLock).toHaveBeenCalledWith(referent) + // The trailing lstat is safeWriteText's staging-path check on the temp file + // this write created: it runs after the key was resolved and the lock taken, + // so it does not change which lock the caller queued behind. + expect(order).toEqual(["resolve-failed", "lstat", "resolve", "resolve", "lock", "resolve", "resolve", "lstat"]) + expect(JSON.parse(await fs.readFile(referent, "utf8"))).toEqual({ id: "task-1" }) + }) + + it("releases the lock when the resolution under the lock rejects", async () => { + const order: string[] = [] + let released = false + const dir = await makeDir("lockkey-") + const referent = path.join(dir, "history_item.json") + currentLink = path.join(dir, "link.json") + + // A real dangling link: the walk tolerates it so the caller can queue behind + // the peer, but once the lock is held the strict rejection still applies. A + // rejection outside the protected block would leave the lock held until the + // stale timeout for every other writer to the same file. + mockedRealpath.mockImplementation(async () => { + throw enoent + }) + mockedLstat.mockImplementation(async (target) => { + order.push("lstat") + return symlinkStat(target) + }) + mockedReadlink.mockImplementation(async (target) => + target === currentLink ? referent : Promise.reject(new Error("not a link")), + ) + mockedAcquireFileLock.mockImplementation(async () => { + order.push("lock") + return async () => { + order.push("release") + released = true + } + }) + + await expect(safeWriteJson(currentLink, { id: "task-1" })).rejects.toThrow(enoent) + expect(released).toBe(true) + // The strict rejection is reached through the ENOENT + symlink branch, not + // through a synchronous throw that skips it. + expect(order).toEqual(["lstat", "lock", "lstat", "release"]) + }) + + it("canonicalizes the parent directory when the file itself is not there yet", async () => { + // fs.realpath canonicalizes every component, including a symlinked ancestor + // directory or a Windows 8.3 short name. If the fallback returns the alias + // directory, the key depends on whether the file exists at the moment the key + // is computed, and a writer that resolved the canonical directory takes a + // different lock for the same file. + const aliasDir = path.join(os.tmpdir(), "alias-dir") + const canonicalDir = path.join(os.tmpdir(), "canonical-dir") + const file = path.join(aliasDir, "history_item.json") + mockedRealpath.mockImplementation(async (target) => { + if (target === file) throw enoent + return canonicalDir + }) + mockedLstat.mockImplementation(async () => ({ isSymbolicLink: () => false, isFile: () => true }) as unknown as BigIntStats) + + expect(await resolveLockKey(file)).toBe(path.join(canonicalDir, "history_item.json")) + }) +}) + +it("does not log a cleanup error when the safety net finds the temp file already gone", async () => { + // safeWriteText removes its own temp file on failure, so the safety net in + // safeWriteJson normally finds it gone. That is the expected outcome, not a + // second failure, and it must not be logged as one. + const dir = await makeDir("cleanup-") + const target = path.join(dir, "history_item.json") + currentLink = "" + mockedRealpath.mockImplementation(async (t) => String(t)) + mockedLstat.mockImplementation(async (t) => symlinkStat(t)) + + const renameSpy = vi.spyOn(fs, "rename").mockRejectedValue(new Error("commit rename failed")) + const unlinkSpy = vi.spyOn(fs, "unlink").mockRejectedValue(enoent) + const consoleError = vi.spyOn(console, "error").mockImplementation(() => {}) + + await expect(safeWriteJson(target, { id: "task-1" })).rejects.toThrow("commit rename failed") + + // Only the original failure is reported. + expect(consoleError).toHaveBeenCalledTimes(1) + + renameSpy.mockRestore() + unlinkSpy.mockRestore() + consoleError.mockRestore() +}) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 0ebdea281d..045c425c1b 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -4,6 +4,8 @@ import * as path from "path" import * as os from "os" import { safeWriteJson } from "../safeWriteJson" +import { RollbackFailureError } from "../../services/file-safety/safeWriteText" +import * as lockfile from "proper-lockfile" // Capture actual implementations before the vi.mock factory runs, // so they are never wrapped by vi.fn() — avoids infinite recursion when @@ -312,9 +314,8 @@ describe("safeWriteJson", () => { expect(content).toEqual(newData) }) - // Test for console error suppression during backup deletion - test("should suppress console.error when backup deletion fails", async () => { - const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}) // Suppress console.error + // Test for best-effort backup deletion (the backup lifecycle now lives in safeWriteText) + test("does not fail the write when backup deletion fails (orphaned backup is acceptable)", async () => { const initialData = { message: "Initial" } const newData = { message: "New" } @@ -322,18 +323,23 @@ describe("safeWriteJson", () => { // fs.unlink is already vi.fn() — use vi.mocked to avoid double-wrapping via vi.spyOn vi.mocked(fs.unlink).mockImplementation(async (filePath: any) => { - if (filePath.toString().includes(".bak_")) { + if (filePath.toString().includes("safeWriteText.bak_")) { throw new Error("Backup deletion failed") } return fsPromisesActuals.unlink!(filePath) }) + // The write must still succeed: backup cleanup is best-effort inside + // safeWriteText and never masks the committed content. await safeWriteJson(currentTestFilePath, newData) - // Verify console.error was called with the expected message - expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Successfully wrote"), expect.any(Error)) + const content = await readFileContent(currentTestFilePath) + expect(content).toEqual(newData) + + // The orphaned backup is still on disk because its deletion failed. + const entries = await fs.readdir(tempDir) + expect(entries.some((entry) => entry.includes("safeWriteText.bak_"))).toBe(true) - consoleErrorSpy.mockRestore() vi.mocked(fs.unlink).mockRestore() }) @@ -434,9 +440,9 @@ describe("safeWriteJson", () => { expect(vi.mocked(fs.access)).toHaveBeenCalled() }) - // Test for rollback failure scenario - test("should log error and re-throw original if rollback fails", async () => { - const initialData = { message: "Initial, should be lost if rollback fails" } + // Test for rollback failure scenario (the rollback rename now lives in safeWriteText) + test("re-throws the original error when the rollback rename fails, leaving an orphaned backup", async () => { + const initialData = { message: "Initial, orphaned when rollback fails" } const newData = { message: "New content" } await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify(initialData)) @@ -451,20 +457,34 @@ describe("safeWriteJson", () => { // Second call: tempNewFilePath -> filePath (fail) throw new Error("Primary rename failed") } else if (renameCallCount === 3) { - // Third call: tempBackupFilePath -> filePath (rollback, also fail) + // Third call: backup -> filePath (rollback, also fail) throw new Error("Rollback rename failed") } return fsPromisesActuals.rename!(oldPath, newPath) }) - // Should throw the original error, not the rollback error - await expect(safeWriteJson(currentTestFilePath, newData)).rejects.toThrow("Primary rename failed") + // The original error must propagate, not the rollback error + // The rollback also failed, so the error reports the partial state: the publish + // failure stays the cause and the backup location is named. + let failure: RollbackFailureError | undefined + await safeWriteJson(currentTestFilePath, newData).catch((e: unknown) => { + if (e instanceof RollbackFailureError) { + failure = e + return + } + throw e + }) + + expect(failure).toBeInstanceOf(RollbackFailureError) + expect(failure?.cause).toBeInstanceOf(Error) + expect(failure?.rollbackError).toBeInstanceOf(Error) + expect(failure?.backupPath).toContain("safeWriteText.bak_") - // Verify console.error was called for the rollback failure - expect(consoleErrorSpy).toHaveBeenCalledWith( - expect.stringContaining("Failed to restore backup"), - expect.objectContaining({ message: "Rollback rename failed" }), - ) + // The rollback failed inside safeWriteText, so the target is gone and + // the backup is orphaned on disk. + expect(await fileExists(currentTestFilePath)).toBe(false) + const entries = await fs.readdir(tempDir) + expect(entries.some((entry) => entry.includes("safeWriteText.bak_"))).toBe(true) consoleErrorSpy.mockRestore() }) @@ -542,4 +562,144 @@ describe("safeWriteJson", () => { const content = await readFileContent(currentTestFilePath) expect(content).toEqual({ c: 3 }) }) + + // The commit rename targets the symlink referent. The staged temp file must + // therefore be created beside the RESOLVED target — staging beside the link + // would make the commit rename fail with EXDEV when the referent is on + // another filesystem. (Real symlinks are unavailable in this CI lane, so the + // resolution is simulated by mocking fs.realpath the same way.) + test("stages the temp file beside the symlink referent and commits onto it", async () => { + const referentDir = path.join(tempDir, "referent") + const linkDir = path.join(tempDir, "link") + await fs.mkdir(referentDir, { recursive: true }) + await fs.mkdir(linkDir, { recursive: true }) + // caller-visible path (the link) vs the resolved referent path + const callerPath = path.join(linkDir, "test-file.json") + const referentPath = path.join(referentDir, "test-file.json") + // Seed the RESOLVED referent with real content (via the actual fs) so the + // write exercises replacement of an EXISTING referent: the lock, the + // backup, and the commit all target the resolved referent. + await fsPromisesActuals.writeFile!(referentPath, JSON.stringify({ seed: true })) + + // Only the file resolves through the link; the directory is already canonical, + // so the lock key is the referent rather than the alias directory + basename. + vi.spyOn(fs, "realpath").mockImplementation(async (target) => + target === callerPath ? referentPath : String(target), + ) + + await safeWriteJson(callerPath, { after: true }) + + // the temp file was created next to the resolved referent, NOT beside the link + const tempPaths = vi.mocked(fsSyncActual.createWriteStream).mock.calls.map((call) => String(call[0])) + expect(tempPaths.some((p) => p.startsWith(referentDir + path.sep) && p.includes(".new_"))).toBe(true) + expect(tempPaths.some((p) => p.startsWith(linkDir + path.sep))).toBe(false) + + // the content was committed onto the referent + expect(await readFileContent(referentPath)).toEqual({ after: true }) + }) + + // proper-lockfile with realpath:false keys the lock by the given path, so a + // symlink alias and its referent must coordinate through ONE lock on the + // resolved referent — otherwise a concurrent merge through both aliases + // reads the same JSON and overwrites one update. (Real symlinks are + // unavailable in this CI lane, so the resolution is simulated by mocking + // fs.realpath, the same way as the staging test above.) + test("acquires the lock on the resolved referent, not the caller alias", async () => { + vi.resetModules() // fresh module instances so the doMock below is picked up + + const referentDir = path.join(tempDir, "lock-referent") + const linkDir = path.join(tempDir, "lock-link") + await fs.mkdir(referentDir, { recursive: true }) + await fs.mkdir(linkDir, { recursive: true }) + // caller-visible path (the link) vs the resolved referent path + const callerPath = path.join(linkDir, "locked.json") + const referentPath = path.join(referentDir, "locked.json") + await fsPromisesActuals.writeFile!(referentPath, JSON.stringify({ seed: 1 })) + + // Only the file resolves through the link; the directory is already canonical, + // so the lock key is the referent rather than the alias directory + basename. + const realpathSpy = vi + .spyOn(fs, "realpath") + .mockImplementation(async (target) => (target === callerPath ? referentPath : String(target))) + + // Wrap the real lock in a capturing mock, and drive the two rare error paths + // (the onCompromised callback and a failing release) so they stay covered + // without real lockfile staleness. The callback rethrows by design, so + // the mock swallows that throw and lets the real lock proceed. + const realLockfile = await vi.importActual("proper-lockfile") + const lockMockFn = vi.fn( + async ( + file: Parameters[0], + options?: Parameters[1], + ) => { + try { + options?.onCompromised?.(new Error("lock compromised (test)")) + } catch { + // onCompromised rethrows by design; swallow so the real lock proceeds. + } + const release = await realLockfile.lock(file, options) + return async () => { + await release() + throw new Error("release failed (test)") + } + }, + ) + const lockMock = lockMockFn as unknown as typeof realLockfile.lock + vi.doMock("proper-lockfile", () => ({ + ...realLockfile, + lock: lockMock, + })) + + // Re-import safeWriteJson so it picks up the mocked proper-lockfile. + const { safeWriteJson: mockedSafeWriteJson } = await import("../safeWriteJson") + + const mergeFn = vi.fn((existing: unknown, incoming: unknown) => ({ + ...(existing as Record), + ...(incoming as Record), + })) + + // Capture the compromise + release-failure logs. + const consoleErrorSpy = vi.spyOn(console, "error") + try { + await mockedSafeWriteJson(callerPath, { added: true }, { merge: mergeFn }) + + // The lock was keyed by the resolved referent — every alias shares it. + expect(lockMock).toHaveBeenCalledTimes(1) + expect(String(lockMockFn.mock.calls[0][0])).toBe(referentPath) + // The merge read the referent's content through that single lock. + expect(mergeFn).toHaveBeenCalledWith({ seed: 1 }, { added: true }) + expect(await readFileContent(referentPath)).toEqual({ seed: 1, added: true }) + // The compromise callback and the failed release were logged, not thrown. + expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("was compromised"), expect.any(Error)) + expect(consoleErrorSpy).toHaveBeenCalledWith( + expect.stringContaining("Failed to release lock"), + expect.any(Error), + ) + } finally { + // Cleanup must run even when an assertion fails: a leaked mock + // registration or console spy changes later tests, and vi.unmock + // alone does not reset a module that already imported the mock. + realpathSpy.mockRestore() + vi.unmock("proper-lockfile") + vi.resetModules() + consoleErrorSpy.mockRestore() + } + }) + + // CWE-732 regression: safeWriteJson stages the temp itself and passes it + // via tempPath, so safeWriteText must apply the existing target's mode to + // the staged temp before the atomic rename — otherwise a 0o600 target is + // published as 0o644. POSIX-only assertion (Windows ignores POSIX modes). + test.skipIf(process.platform === "win32")( + "preserves a restrictive 0o600 target mode through the atomic publish", + async () => { + await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify({ before: true })) + fsSyncActual.chmodSync(currentTestFilePath, 0o600) + + await safeWriteJson(currentTestFilePath, { after: true }) + + expect(fsSyncActual.statSync(currentTestFilePath).mode & 0o777).toBe(0o600) + expect(await readFileContent(currentTestFilePath)).toEqual({ after: true }) + }, + ) }) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 7da68b2a7a..bae200dd38 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -4,6 +4,12 @@ import * as path from "path" import { JsonStreamStringify } from "json-stream-stringify" import { acquireFileLock } from "./fileLock" +import { + resolveLockKey, + resolvePublishTarget, + safeWriteText, + type SafeWriteTextOptions, +} from "../services/file-safety/safeWriteText" /** * Options for safeWriteJson function @@ -32,7 +38,7 @@ export interface SafeWriteJsonOptions { * Safely writes JSON data to a file. * - Creates parent directories if they don't exist * - Uses 'proper-lockfile' for inter-process advisory locking to prevent concurrent writes to the same path. - * - Writes to a temporary file first. + * - Writes to a temporary file first via JsonStreamStringify streaming. * - If the target file exists, it's backed up before being replaced. * - Attempts to roll back and clean up in case of errors. * - Supports pretty-printing with indentation while maintaining streaming efficiency. @@ -42,7 +48,6 @@ export interface SafeWriteJsonOptions { * @param {SafeWriteJsonOptions} options - Optional configuration for JSON formatting. * @returns {Promise} */ - async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJsonOptions): Promise { const absoluteFilePath = path.resolve(filePath) let releaseLock = async () => {} // Initialized to a no-op @@ -51,38 +56,46 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso const dirPath = path.dirname(absoluteFilePath) // Ensure directory structure exists with improved reliability + // Declared outside the protected block so the catch and finally can still name + // the target when the resolution itself rejects. + let resolvedTargetPath: string | undefined + try { - // Create directory with recursive option await fs.mkdir(dirPath, { recursive: true }) - - // Verify directory exists after creation attempt await fs.access(dirPath) } catch (dirError: any) { console.error(`Failed to create or access directory for ${absoluteFilePath}:`, dirError) throw dirError } - // Acquire the lock before any file operations. `acquireFileLock` owns the - // shared advisory lock protocol, so callers that lock the same path with - // it (for example task-history deletion) serialize with this write. - // If lock acquisition fails, it throws immediately. The releaseLock - // remains a no-op, so the finally block in the main file operations - // try-catch-finally won't try to release an unacquired lock if this - // path is taken. - releaseLock = await acquireFileLock(absoluteFilePath) + // Lock key: the symlink referent when the path is an existing symlink, so a + // symlink alias and its referent share one lock. The key must be computable + // while a peer writer is mid-commit (backup mode renames the referent away and + // back), so the walk tolerates a dangling link instead of rejecting it here. + const lockKey = await resolveLockKey(absoluteFilePath) - // Variables to hold the actual paths of temp files if they are created. + // Acquire the lock before any file operations. If acquisition fails it throws + // immediately, and releaseLock stays a no-op so the finally block does not try + // to release an unacquired lock. + releaseLock = await acquireFileLock(lockKey) + + // Variables to hold the actual path of the temp file if it is created. let actualTempNewFilePath: string | null = null - let actualTempBackupFilePath: string | null = null try { + // Resolve the publish target under the lock: the peer has committed by now, so + // the strict dangling-link rejection still applies to a real dangling link. It + // must stay inside the protected block, otherwise a rejection here leaves the + // advisory lock held until the stale timeout for every other writer. + resolvedTargetPath = await resolvePublishTarget(absoluteFilePath) + // If a merge callback was provided, read the current file under the lock // and let the caller merge before we write. Must be inside try/finally // so a throwing merge still releases the lock. if (options?.merge) { let existing: unknown = null try { - existing = JSON.parse(await fs.readFile(absoluteFilePath, "utf8")) + existing = JSON.parse(await fs.readFile(resolvedTargetPath, "utf8")) } catch (error: unknown) { const code = error && typeof error === "object" && "code" in error ? (error as { code: string }).code : undefined @@ -93,111 +106,73 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso data = options.merge(existing, data) } - // Step 1: Write data to a new temporary file. + // Step 1: Write data to a new temporary file via JSON streaming. + // Stage it beside the *resolved* target (the symlink referent when the path is + // a symlink; resolvedTargetPath above): safeWriteText commits by renaming + // onto that referent, and a rename across filesystems would fail with EXDEV. actualTempNewFilePath = path.join( - path.dirname(absoluteFilePath), - `.${path.basename(absoluteFilePath)}.new_${Date.now()}_${Math.random().toString(36).substring(2)}.tmp`, + path.dirname(resolvedTargetPath), + ".new_" + Date.now() + "_" + Math.random().toString(36).substring(2) + ".tmp", ) await _streamDataToFile(actualTempNewFilePath, data, options?.prettyPrint) - // Step 2: Check if the target file exists. If so, rename it to a backup path. - try { - // Check for target file existence - await fs.access(absoluteFilePath) - // Target exists, create a backup path and rename. - actualTempBackupFilePath = path.join( - path.dirname(absoluteFilePath), - `.${path.basename(absoluteFilePath)}.bak_${Date.now()}_${Math.random().toString(36).substring(2)}.tmp`, - ) - await fs.rename(absoluteFilePath, actualTempBackupFilePath) - } catch (accessError: any) { - // Explicitly type accessError - if (accessError.code !== "ENOENT") { - // An error other than "file not found" occurred during access check. - throw accessError - } - // Target file does not exist, so no backup is made. actualTempBackupFilePath remains null. + // Step 2: Delegate backup + commit + rollback to safeWriteText with the + // pre-written temp path. backup:true keeps the old safeWriteJson + // semantics (target -> backup before commit, rollback on failure) and + // keeps the target in place until safeWriteText captures its Windows + // DACL (safeWriteText dumps the DACL before its own backup rename and + // restores it onto the directory after the commit rename). + const textOptions: SafeWriteTextOptions = { + tempPath: actualTempNewFilePath, + backup: true, } - // Step 3: Rename the new temporary file to the target file path. - // This is the main "commit" step. - await fs.rename(actualTempNewFilePath, absoluteFilePath) + await safeWriteText(resolvedTargetPath, "", textOptions) - // If we reach here, the new file is successfully in place. - // The original actualTempNewFilePath is now the main file, so we shouldn't try to clean it up as "temp". - // Mark as "used" or "committed" + // If we reach here, the new file is successfully in place and any + // backup has already been handled by safeWriteText. actualTempNewFilePath = null - - // Step 4: If a backup was created, attempt to delete it. - if (actualTempBackupFilePath) { - try { - await fs.unlink(actualTempBackupFilePath) - // Mark backup as handled - actualTempBackupFilePath = null - } catch (unlinkBackupError) { - // Log this error, but do not re-throw. The main operation was successful. - // actualTempBackupFilePath remains set, indicating an orphaned backup. - console.error( - `Successfully wrote ${absoluteFilePath}, but failed to clean up backup ${actualTempBackupFilePath}:`, - unlinkBackupError, - ) - } - } } catch (originalError) { - console.error(`Operation failed for ${absoluteFilePath}: [Original Error Caught]`, originalError) + console.error( + `Operation failed for ${resolvedTargetPath ?? absoluteFilePath}: [Original Error Caught]`, + originalError, + ) const newFileToCleanupWithinCatch = actualTempNewFilePath - const backupFileToRollbackOrCleanupWithinCatch = actualTempBackupFilePath - - // Attempt rollback if a backup was made - if (backupFileToRollbackOrCleanupWithinCatch) { - try { - await fs.rename(backupFileToRollbackOrCleanupWithinCatch, absoluteFilePath) - // Mark as handled, prevent later unlink of this path - actualTempBackupFilePath = null - } catch (rollbackError) { - // actualTempBackupFilePath (outer scope) remains pointing to backupFileToRollbackOrCleanupWithinCatch - console.error( - `[Catch] Failed to restore backup ${backupFileToRollbackOrCleanupWithinCatch} to ${absoluteFilePath}:`, - rollbackError, - ) - } - } - // Cleanup the .new file if it exists + // A failed safeWriteText already rolled the backup (if any) back to + // the target path. Clean up the .new file if it still exists + // (safeWriteText also cleans up its tempPath on failure; this is a + // safety net in case its cleanup missed it). if (newFileToCleanupWithinCatch) { try { await fs.unlink(newFileToCleanupWithinCatch) - } catch (cleanupError) { - console.error( - `[Catch] Failed to clean up temporary new file ${newFileToCleanupWithinCatch}:`, - cleanupError, - ) + } catch (cleanupError: unknown) { + // The expected case: safeWriteText already removed its own temp file, so a + // missing file here is not a cleanup failure worth logging. Returning would + // also swallow the original error the caller needs. + const isAbsent = + typeof cleanupError === "object" && + cleanupError !== null && + "code" in cleanupError && + cleanupError.code === "ENOENT" + if (!isAbsent) { + console.error( + `[Catch] Failed to clean up temporary new file ${newFileToCleanupWithinCatch}:`, + cleanupError, + ) + } } } - // Cleanup the .bak file if it still needs to be (i.e., wasn't successfully restored) - if (actualTempBackupFilePath) { - try { - await fs.unlink(actualTempBackupFilePath) - } catch (cleanupError) { - console.error( - `[Catch] Failed to clean up temporary backup file ${actualTempBackupFilePath}:`, - cleanupError, - ) - } - } throw originalError // This MUST be the error that rejects the promise. } finally { // Release the lock in the main finally block. try { - // releaseLock will be the actual unlock function if lock was acquired, - // or the initial no-op if acquisition failed. await releaseLock() } catch (unlockError) { - // Do not re-throw here, as the originalError from the try/catch (if any) is more important. - console.error(`Failed to release lock for ${absoluteFilePath}:`, unlockError) + console.error(`Failed to release lock for ${resolvedTargetPath ?? absoluteFilePath}:`, unlockError) } } } From b52486392908bf47a38dd297112225be910642c1 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 22:47:25 +0800 Subject: [PATCH 06/72] chore(lint): prune the safeWriteJson suppression this unit earns The any usage this entry covered is gone in the rewritten file, so the count drops 4 -> 3. eslint --prune-suppressions --max-warnings=0 confirms it. --- src/eslint-suppressions.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index f1b2590f7f..671c9f594c 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -1701,7 +1701,7 @@ }, "utils/safeWriteJson.ts": { "@typescript-eslint/no-explicit-any": { - "count": 4 + "count": 3 } }, "vitest.setup.ts": { From 93329bdf8f05c610d3468580d380adbae9acc196 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 22:47:37 +0800 Subject: [PATCH 07/72] rebuild unit u3 on the fixed chain --- .../__tests__/observationRegistry.spec.ts | 108 ++++++++++++++++++ src/core/task/observationRegistry.ts | 59 ++++++++++ 2 files changed, 167 insertions(+) create mode 100644 src/core/task/__tests__/observationRegistry.spec.ts create mode 100644 src/core/task/observationRegistry.ts diff --git a/src/core/task/__tests__/observationRegistry.spec.ts b/src/core/task/__tests__/observationRegistry.spec.ts new file mode 100644 index 0000000000..a3c55ebc6d --- /dev/null +++ b/src/core/task/__tests__/observationRegistry.spec.ts @@ -0,0 +1,108 @@ +import { describe, it, expect, vi } from "vitest" + +import { ObservationRegistry } from "../observationRegistry" + +describe("ObservationRegistry", () => { + it("observe → get returns the recorded version and observedAt", () => { + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "1:2:300:4000000000:5000000000") + + const obs = reg.get("/a/b/c.ts") + expect(obs).toBeDefined() + expect(obs!.version).toBe("1:2:300:4000000000:5000000000") + expect(typeof obs!.observedAt).toBe("number") + }) + + it("re-observe replaces the entry with a fresh observedAt", () => { + vi.useFakeTimers() + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "v1") + const first = reg.get("/a/b/c.ts")! + expect(first.version).toBe("v1") + + vi.advanceTimersByTime(50) + reg.observe("/a/b/c.ts", "v2") + const second = reg.get("/a/b/c.ts")! + expect(second.version).toBe("v2") + expect(second.observedAt).toBeGreaterThan(first.observedAt) + + vi.useRealTimers() + }) + + it("has returns true for observed paths, false otherwise", () => { + const reg = new ObservationRegistry() + reg.observe("/x.ts", "t1") + expect(reg.has("/x.ts")).toBe(true) + expect(reg.has("/y.ts")).toBe(false) + }) + + it("size reflects the number of observed entries", () => { + const reg = new ObservationRegistry() + expect(reg.size).toBe(0) + reg.observe("/a.ts", "t1") + reg.observe("/b.ts", "t2") + expect(reg.size).toBe(2) + }) + + it("clear removes all entries and resets size to 0", () => { + const reg = new ObservationRegistry() + reg.observe("/a.ts", "t1") + reg.observe("/b.ts", "t2") + reg.clear() + expect(reg.size).toBe(0) + expect(reg.get("/a.ts")).toBeUndefined() + expect(reg.has("/b.ts")).toBe(false) + }) + + it("get on empty registry returns undefined", () => { + const reg = new ObservationRegistry() + expect(reg.get("/any.ts")).toBeUndefined() + }) + + it("separate instances are independent — observing in one does not appear in the other", () => { + const regA = new ObservationRegistry() + const regB = new ObservationRegistry() + regA.observe("/shared.ts", "v1") + expect(regA.get("/shared.ts")).toBeDefined() + expect(regB.get("/shared.ts")).toBeUndefined() + regB.observe("/shared.ts", "v2") + expect(regA.get("/shared.ts")!.version).toBe("v1") + expect(regB.get("/shared.ts")!.version).toBe("v2") + }) + + describe("completeness scope (S4b follow-up #46)", () => { + it("defaults to a complete observation when the read scope is not given", () => { + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "v1") + + expect(reg.get("/a/b/c.ts")!.complete).toBe(true) + }) + + it("records a partial observation when the read only returned a view of the file", () => { + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "v1", false) + + expect(reg.get("/a/b/c.ts")!.complete).toBe(false) + }) + + it("re-observing replaces the entry's completeness with the new read's scope", () => { + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "v1", false) + reg.observe("/a/b/c.ts", "v2") + + const obs = reg.get("/a/b/c.ts")! + expect(obs.version).toBe("v2") + expect(obs.complete).toBe(true) + }) + + it("re-observing with a partial scope downgrades a previously complete entry", () => { + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "v1") + reg.observe("/a/b/c.ts", "v2", false) + + const obs = reg.get("/a/b/c.ts")! + expect(obs.version).toBe("v2") + expect(obs.complete).toBe(false) + }) + }) +}) diff --git a/src/core/task/observationRegistry.ts b/src/core/task/observationRegistry.ts new file mode 100644 index 0000000000..0ef9115f21 --- /dev/null +++ b/src/core/task/observationRegistry.ts @@ -0,0 +1,59 @@ +/** + * Per-task file observation registry (upstream epic #1375, phase A2). + * + * Each Task owns its own instance so parent and subtask observations are + * independent. The S4 guarded-write will compare these versions against the + * token recomputed pre-write to detect stale reads or file replacement. + * + * Pure in-memory — zero I/O, no dependencies. The S4 guarded-write consults + * these observations for the version check and for the completeness check that + * gates a full-file replacement. + */ + +export interface FileObservation { + /** Version token derived from on-disk fs.stat (bigint mode). */ + version: string + /** Millisecond timestamp when the observation was recorded. */ + observedAt: number + /** + * Whether the read that produced this observation returned the complete + * file. A slice, line-range, truncated, or indentation-block read returns + * only a view of the file; such an observation authorizes targeted edits + * on the view the model saw, but never a full-file replacement. + */ + complete: boolean +} + +export class ObservationRegistry { + private readonly entries = new Map() + + /** + * Record an observation for a file at its absolute path. + * + * Re-observing replaces the entry with a fresh observedAt timestamp, the + * new version token, and the read's completeness. `complete` defaults to + * true for callers that read the whole file themselves (spec doubles, + * WriteToFileTool). A caller whose read is internal to a targeted edit must + * carry the model's prior completeness instead, so the tool's own read cannot + * upgrade a partial read into authority for a full-file replacement. + */ + observe(absolutePath: string, version: string, complete: boolean = true): void { + this.entries.set(absolutePath, { version, observedAt: Date.now(), complete }) + } + + get(absolutePath: string): FileObservation | undefined { + return this.entries.get(absolutePath) + } + + has(absolutePath: string): boolean { + return this.entries.has(absolutePath) + } + + clear(): void { + this.entries.clear() + } + + get size(): number { + return this.entries.size + } +} From 0f32b3e5253fdab8097313746e552b4e75d3703d Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 22:34:05 +0800 Subject: [PATCH 08/72] fix(task): declare the observation registry on Task in this unit The read tools record the observed on-disk version through task.observationRegistry, but the field was only declared in a later unit, so at this head the call dereferences undefined and the mocked e2e run fails on the read_file smoke tests. The registry is introduced by this unit, so the field belongs here. tsc clean on this unit, 11 observationRegistry tests pass, ESLint --max-warnings=0 clean. --- src/core/task/Task.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index fdcc740998..9ccc2d7968 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -104,6 +104,7 @@ import { buildNativeToolsArrayWithRestrictions } from "./build-tools" import { ToolRepetitionDetector } from "../tools/ToolRepetitionDetector" import { restoreTodoListForTask } from "../tools/UpdateTodoListTool" import { FileContextTracker } from "../context-tracking/FileContextTracker" +import { ObservationRegistry } from "./observationRegistry" import { RooIgnoreController } from "../ignore/RooIgnoreController" import { RooProtectedController } from "../protect/RooProtectedController" import { type AssistantMessageContent, presentAssistantMessage } from "../assistant-message" @@ -282,6 +283,10 @@ export class Task extends EventEmitter implements TaskLike { readonly instanceId: string readonly metadata: TaskMetadata + // The observed on-disk version of each file this task has read. Declared here so the + // read tools can record it; a write guard later compares a token against this registry. + readonly observationRegistry = new ObservationRegistry() + todoList?: TodoItem[] readonly rootTask: Task | undefined = undefined From 83720030b04aea311128924dd2d7416eff231f9d Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Mon, 5 Oct 2026 22:48:10 +0800 Subject: [PATCH 09/72] rebuild unit u4 on the fixed chain --- src/core/tools/ReadFileTool.ts | 93 ++- src/core/tools/__tests__/readFileTool.spec.ts | 786 +++++++++++++++++- .../misc/__tests__/indentation-reader.spec.ts | 43 + src/integrations/misc/indentation-reader.ts | 12 +- 4 files changed, 923 insertions(+), 11 deletions(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index 00fc507692..dd38a47809 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -16,13 +16,14 @@ import type { ReadFileParams, ReadFileMode, ReadFileToolParams, FileEntry, LineR import { isLegacyReadFileParams, type ClineSayTool } from "@roo-code/types" import { Task } from "../task/Task" +import { versionTokenOfStat } from "../../utils/versionToken" import { formatResponse } from "../prompts/responses" import { RecordSource } from "../context-tracking/FileContextTrackerTypes" import { isPathOutsideWorkspace } from "../../utils/pathUtils" import { getReadablePath } from "../../utils/path" import { extractTextFromFile, addLineNumbers, getSupportedBinaryFormats } from "../../integrations/misc/extract-text" import { readWithIndentation, readWithSlice } from "../../integrations/misc/indentation-reader" -import { DEFAULT_LINE_LIMIT } from "../prompts/tools/native-tools/read_file" +import { DEFAULT_LINE_LIMIT, MAX_LINE_LENGTH } from "../prompts/tools/native-tools/read_file" import type { ToolUse, PushToolResult } from "../../shared/tools" import { @@ -214,14 +215,36 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Read text file content with lossy UTF-8 conversion // Reading as Buffer first allows graceful handling of non-UTF8 bytes // (they become U+FFFD replacement characters instead of throwing) + // A2 (epic #1375): capture the on-disk token before the read so a mutation + // landing mid-read is detected by the post-read stat below. + const preReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) const buffer = await fs.readFile(fullPath) const fileContent = buffer.toString("utf-8") - const result = this.processTextFile(fileContent, entry) + // A lossy decode is not the whole file: the model never saw those bytes. + const lossyDecode = !Buffer.from(fileContent).equals(buffer) + // S4b follow-up (#46 / epic #1375): processTextFile reports whether the + // returned content is the whole file; the observation below records that + // scope so the write guard can deny full-file updates built on a partial view. + const processed = this.processTextFile(fileContent, entry) await task.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) + // A2 (plan #33 / epic #1375): record the observed on-disk version for the future write guard. + // The token is captured before AND after the read; the target is observed only + // when both match — a mutation between the two stats means the content the model + // received is not the on-disk state, and observing it would let a later write + // match a token the model never saw. A stat failure leaves the target + // unobserved and never fails the read. + const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) + if (preReadStats && postReadStats) { + const preReadToken = versionTokenOfStat(preReadStats) + if (preReadToken === versionTokenOfStat(postReadStats)) { + task.observationRegistry.observe(fullPath, preReadToken, processed.complete && !lossyDecode) + } + } + updateFileResult(relPath, { - nativeContent: `File: ${relPath}\n${result}`, + nativeContent: `File: ${relPath}\n${processed.content}`, }) } catch (error) { const errorMsg = error instanceof Error ? error.message : String(error) @@ -265,8 +288,14 @@ export class ReadFileTool extends BaseTool<"read_file"> { /** * Process a text file according to the requested mode. + * + * Returns the content string plus whether that content is the complete + * file (S4b follow-up #46 / epic #1375): slice mode is complete only + * when it starts at line 1, returns every line, and was not truncated; + * indentation mode is never complete because it returns semantic blocks + * of the file, not the file itself. */ - private processTextFile(content: string, entry: InternalFileEntry): string { + private processTextFile(content: string, entry: InternalFileEntry): { content: string; complete: boolean } { const mode = entry.mode || "slice" if (mode === "indentation") { @@ -299,7 +328,8 @@ export class ReadFileTool extends BaseTool<"read_file"> { output += `\n\nIncluded ranges: ${rangeStr} (total: ${result.totalLines} lines)` } - return output + // Indentation mode returns semantic blocks: never a complete file view. + return { content: output, complete: false } } // Slice mode (default): simple offset/limit reading @@ -322,11 +352,28 @@ export class ReadFileTool extends BaseTool<"read_file"> { To read more: Use the read_file tool with offset=${nextOffset} and limit=${limit}. ${result.content}` + if (result.hasClippedLines) { + // The slice cut lines off and also clipped long lines inside it, so both + // notices belong to the response. + output += `\nNote: Some lines in this view exceed ${MAX_LINE_LENGTH} characters and were clipped in this view.` + } + } else if (result.hasClippedLines) { + // Every line was returned, so there is no later offset to read: report the + // clipping without a next-offset hint, and keep the read incomplete so a + // full-file replacement cannot be built from a clipped line. + output = `IMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view. The file was read in full, but the clipped lines were not shown in full. + ${result.content}` } else if (result.returnedLines === 0) { output = "Note: File is empty" } - return output + // Complete only when the slice starts at line 1, returned every line, and + // showed every line in full (returnedLines === totalLines follows from the + // first two conditions): a partial start, a truncated tail, or a clipped + // line means the model did not see the whole file. + const complete = offset0 === 0 && !result.wasTruncated && !result.hasClippedLines + + return { content: output, complete } } /** @@ -768,9 +815,20 @@ export class ReadFileTool extends BaseTool<"read_file"> { } // Read text file - const rawContent = await fs.readFile(fullPath, "utf8") + // A2 (epic #1375): capture the on-disk token before the read so a mutation + // landing mid-read is detected by the post-read stat below. + const preReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) + const rawBuffer = await fs.readFile(fullPath) + const rawContent = rawBuffer.toString("utf-8") + // Same contract: a lossy decode is a partial view. + const lossyDecode = !Buffer.from(rawContent).equals(rawBuffer) // Handle line ranges if specified + // S4b follow-up (#46 / epic #1375): a line-range read returns only the requested + // ranges, and a slice truncated to DEFAULT_LINE_LIMIT returns only the head of + // the file — record such observations as partial so the write guard denies a + // full-file update built on them. + let readComplete = false let content: string if (entry.lineRanges && entry.lineRanges.length > 0) { const lines = rawContent.split("\n") @@ -790,8 +848,16 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Read with default limits using slice mode const result = readWithSlice(rawContent, 0, DEFAULT_LINE_LIMIT) content = result.content + readComplete = !result.wasTruncated && !result.hasClippedLines if (result.wasTruncated) { content += `\n\n[File truncated: showing ${result.returnedLines} of ${result.totalLines} total lines]` + if (result.hasClippedLines) { + // Both notices: the slice was truncated and a line inside it was + // clipped. + content += `\n\n[Some lines exceed the per-line length cap and were clipped in this view]` + } + } else if (result.hasClippedLines) { + content += `\n\n[Some lines exceed the per-line length cap and were clipped in this view]` } } @@ -799,6 +865,19 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Track file in context await task.fileContextTracker.trackFileContext(relPath, "read_tool") + + // A2 (plan #33 / epic #1375): mirror the native path — record the observed + // on-disk version so legacy-format reads also feed the future write guard. + // Observe only when the pre-read and post-read tokens match (a mutation between + // them means the returned content is not the on-disk state). A stat failure + // leaves the target unobserved and never fails the read. + const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) + if (preReadStats && postReadStats) { + const preReadToken = versionTokenOfStat(preReadStats) + if (preReadToken === versionTokenOfStat(postReadStats)) { + task.observationRegistry.observe(fullPath, preReadToken, readComplete && !lossyDecode) + } + } } catch (error) { const errorMsg = error instanceof Error ? error.message : String(error) results.push(`File: ${relPath}\nError: ${errorMsg}`) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index a457ff87bc..353e4845cb 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -13,13 +13,19 @@ */ import path from "path" +import type { Stats } from "fs" + +import type { LegacyReadFileParams } from "@roo-code/types" import type { ToolUse } from "../../../shared/tools" import type { Task } from "../../task/Task" import { isBinaryFile } from "isbinaryfile" -import { readFileTool } from "../ReadFileTool" + +import { readFileTool, ReadFileTool } from "../ReadFileTool" +import type { Task } from "../../task/Task" +import { ObservationRegistry } from "../../task/observationRegistry" import { formatResponse } from "../../prompts/responses" import { validateImageForProcessing, processImageFile, isSupportedImageFormat } from "../helpers/imageHelpers" import { extractTextFromFile, getSupportedBinaryFormats } from "../../../integrations/misc/extract-text" @@ -134,6 +140,7 @@ interface MockTaskOptions { rooIgnoreAllowed?: boolean maxImageFileSize?: number maxTotalImageSize?: number + observationRegistry?: ObservationRegistry } function createMockTask(options: MockTaskOptions = {}) { @@ -141,6 +148,9 @@ function createMockTask(options: MockTaskOptions = {}) { return { cwd: "/test/workspace", + // Mirror Task: every task always owns an observation registry (A2, #1375). + // Tests asserting on observations pass their own instance via options. + observationRegistry: options.observationRegistry ?? new ObservationRegistry(), api: { getModel: vi.fn().mockReturnValue({ info: { supportsImages }, @@ -185,7 +195,18 @@ describe("ReadFileTool", () => { vi.clearAllMocks() // Default mock implementations - mockedFsStat.mockResolvedValue({ isDirectory: () => false } as any) + // The stat default carries BigIntStats fields (A2, epic #1375): reads now + // token-ize the pre/post stats, so the default must look like a real bigint stat. + // Tests overriding it do so per-call with mockResolvedValue(Once). + mockedFsStat.mockResolvedValue({ + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats) mockedIsBinaryFile.mockResolvedValue(false) mockedFsReadFile.mockResolvedValue(Buffer.from("test content")) mockedReadWithSlice.mockReturnValue({ @@ -837,7 +858,7 @@ describe("ReadFileTool", () => { mockTask.ask.mockResolvedValue({ response: "yesButtonClicked", text: undefined, images: undefined }) // fs.readFile with "utf8" encoding returns a string, not a Buffer - mockedFsReadFile.mockResolvedValue("line1\nline2\nline3\nline4\nline5" as any) + mockedFsReadFile.mockResolvedValue(Buffer.from("line1\nline2\nline3\nline4\nline5")) await readFileTool.execute( { files: [{ path: "test.ts", lineRanges: [{ start: 2, end: 4 }] }] } as any, @@ -1550,5 +1571,764 @@ describe("ReadFileTool", () => { expect(mockTask.didToolFailInCurrentTurn).toBe(true) }) + + describe("observation registry", () => { + it("records an observation on successful read of an existing file", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + // Override the beforeEach default stat mock with proper BigIntStats. + mockedFsStat.mockResolvedValue({ + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats) + mockedIsBinaryFile.mockResolvedValue(false) + + // Spy on observe to capture the exact key used (Windows path.resolve may use backslashes). + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "existing.ts" }, mockTask as unknown as Task, callbacks) + + // Verify the tool called observe exactly once with a valid token. + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, calledVersion] = observeSpy.mock.calls[0] + expect(calledPath).toContain("existing.ts") + expect(calledVersion).toMatch(/^\d+:\d+:\d+:\d+:\d+$/) + + // Verify get() returns the same data using the spy-captured key. + const obs = reg.get(calledPath) + expect(obs).toBeDefined() + expect(obs!.version).toBe(calledVersion) + }) + + it("a failed read (absent path) leaves the registry size 0 and does not throw", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsReadFile.mockRejectedValue(new Error("ENOENT")) + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "missing.ts" }, mockTask as unknown as Task, callbacks) + + // observationRegistry is guaranteed present because we passed it in createMockTask. + const reg = mockTask.observationRegistry + expect(reg).toBeDefined() + expect(reg!.size).toBe(0) + }) + + it("records an observation for legacy-format reads of existing files", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue({ + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Typed legacy (pre-refactor) params: the multi-file format with the + // _legacyFormat discriminant (see LegacyReadFileParams). + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy.ts" }], + _legacyFormat: true, + } + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, calledVersion] = observeSpy.mock.calls[0] + expect(calledPath).toContain("legacy.ts") + expect(calledVersion).toMatch(/^\d+:\d+:\d+:\d+:\d+$/) + }) + + it("does not observe when the file mutates between the pre-read and post-read stats", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + const preStats = { + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + } + // A mutation lands mid-read: the post-read stat differs. + const postStats = { ...preStats, size: BigInt(301) } + + // Call order: directory check, pre-read stat, post-read stat. + mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) + .mockResolvedValueOnce(preStats as unknown as Stats) + .mockResolvedValueOnce(postStats as unknown as Stats) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "mutated.ts" }, mockTask as unknown as Task, callbacks) + + // The read itself succeeded, but the target stays unobserved: the content the + // model received is not the on-disk state, so observing it would let a later + // write match a token the model never saw. + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + }) + + it("leaves the target unobserved without failing the read when the pre-read stat fails", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + // Directory check OK; the pre-read stat fails (caught, target unobserved). + mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) + .mockRejectedValueOnce(new Error("EACCES")) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "stat-fail.ts" }, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + // The read still succeeds — a stat failure never fails the read. + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + // Assert the pushed payload, not just that something was pushed. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("File: stat-fail.ts") + expect(pushed).toContain("test content") + expect(pushed).not.toContain("Error:") + }) + + it("leaves the target unobserved without failing the read when the post-read stat fails", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + const okStats = { + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + } + // Directory check and pre-read stat OK; the post-read stat fails. + mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) + .mockResolvedValueOnce(okStats as unknown as Stats) + .mockRejectedValueOnce(new Error("EACCES")) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "post-stat-fail.ts" }, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + // Assert the pushed payload, not just that something was pushed. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("File: post-stat-fail.ts") + expect(pushed).toContain("test content") + expect(pushed).not.toContain("Error:") + }) + + it("legacy format: does not observe when the file mutates between the pre-read and post-read stats", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + const preStats = { + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + } + // Call order: directory check, pre-read stat, post-read stat (mutated). + mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) + .mockResolvedValueOnce(preStats as unknown as Stats) + .mockResolvedValueOnce({ ...preStats, size: BigInt(301) } as unknown as Stats) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-mutated.ts" }], + _legacyFormat: true, + } + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + }) + + it("legacy format: leaves the target unobserved when a stat fails without failing the read", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + // Directory check OK; the pre-read stat fails (caught, target unobserved). + mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) + .mockRejectedValueOnce(new Error("EACCES")) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-stat-fail.ts" }], + _legacyFormat: true, + } + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + // Assert the pushed payload, not just that something was pushed. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("File: legacy-stat-fail.ts") + expect(pushed).toContain("test content") + expect(pushed).not.toContain("Error:") + }) + it("legacy format: leaves the target unobserved when the post-read stat fails", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + const okStats = { + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + } + // Directory check and pre-read stat OK; the post-read stat fails. + mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) + .mockResolvedValueOnce(okStats as unknown as Stats) + .mockRejectedValueOnce(new Error("EACCES")) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-post-stat-fail.ts" }], + _legacyFormat: true, + } + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + // Assert the pushed payload, not just that something was pushed. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("File: legacy-post-stat-fail.ts") + expect(pushed).toContain("test content") + expect(pushed).not.toContain("Error:") + }) + it("two separate Task-owned registries are independent", async () => { + const regA = new ObservationRegistry() + const regB = new ObservationRegistry() + regA.observe("/shared.ts", "v1") + expect(regA.get("/shared.ts")!.version).toBe("v1") + expect(regB.get("/shared.ts")).toBeUndefined() + regB.observe("/shared.ts", "v2") + expect(regA.get("/shared.ts")!.version).toBe("v1") + expect(regB.get("/shared.ts")!.version).toBe("v2") + }) + }) + + describe("read completeness scope (S4b follow-up #46)", () => { + // The stat mock only implements the members the tool and versionToken read. + const bigintStats = (): Stats => + ({ + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + }) as unknown as Stats + + it("native: a full, untruncated slice read from line 1 records a complete observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\n")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 2, + wasTruncated: false, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute({ path: "full.ts" }, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, calledVersion, calledComplete] = observeSpy.mock.calls[0] + expect(calledPath).toContain("full.ts") + expect(calledVersion).toMatch(/^\d+:\d+:\d+:\d+:\d+$/) + expect(calledComplete).toBe(true) + expect(reg.get(calledPath)!.complete).toBe(true) + }) + + it("native: a truncated slice read records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc\nd\ne")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a", + returnedLines: 1, + totalLines: 5, + wasTruncated: true, + includedRanges: [[1, 1]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute( + { path: "trunc.ts", offset: 1, limit: 1 }, + mockTask as unknown as Task, + callbacks, + ) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + expect(reg.get(calledPath)!.complete).toBe(false) + }) + + it("native: a full read whose line content was clipped records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\n")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 2, + wasTruncated: false, + hasClippedLines: true, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute({ path: "clipped.ts" }, mockTask as unknown as Task, callbacks) + + const [, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + // Every line was returned, so the notice must not point at a next + // offset that is beyond the file. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("clipped in this view") + expect(pushed).not.toContain("To read more") + // The notice is added on top of the read, it does not replace it. + expect(pushed).toContain("1 | a") + }) + + it("native: a truncated slice that also clipped a line reports both notices", async () => { + // A long line inside a slice that also cut lines off is a plausible case, + // and the response has to say both things. + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 3, + wasTruncated: true, + hasClippedLines: true, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute({ path: "both.ts" }, mockTask as unknown as Task, callbacks) + + const [, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("Showing lines 1-2 of 3 total lines") + expect(pushed).toContain("clipped in this view") + }) + + it("native: an offset read that is not truncated still records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc\nd\ne")) + mockedReadWithSlice.mockReturnValue({ + content: "4 | d\n5 | e", + returnedLines: 2, + totalLines: 5, + wasTruncated: false, + includedRanges: [[4, 5]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute( + { path: "offset.ts", offset: 4, limit: 2 }, + mockTask as unknown as Task, + callbacks, + ) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + }) + + it("native: an indentation-mode block read records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("function f() { return 1 }")) + mockedReadWithIndentation.mockReturnValue({ + content: "10 | function f() {", + wasTruncated: false, + includedRanges: [[10, 20]], + totalLines: 100, + returnedLines: 11, + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute( + { path: "indent.ts", mode: "indentation" }, + mockTask as unknown as Task, + callbacks, + ) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + }) + + it("legacy: a line-range read records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc\nd\ne")) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "ranges.ts", lineRanges: [{ start: 2, end: 4 }] }], + _legacyFormat: true, + } + + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledPath).toContain("ranges.ts") + expect(calledComplete).toBe(false) + }) + + it("legacy: a full, untruncated slice read records a complete observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 2, + wasTruncated: false, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-full.ts" }], + _legacyFormat: true, + } + + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(true) + + // Nothing was omitted and nothing was clipped, so no note is added. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).not.toContain("clipped in this view") + expect(pushed).not.toContain("total lines") + }) + + it("legacy: a full read with a clipped line records a partial observation and reports the clipping", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 2, + wasTruncated: false, + hasClippedLines: true, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-clipped.ts" }], + _legacyFormat: true, + } + + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + const [, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + + // Every line was returned, so the note reports the clipping instead of + // a showing-N-of-N count that would point past the file. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("clipped in this view") + expect(pushed).not.toContain("showing 2 of 2 total lines") + }) + + it("legacy: a truncated slice that also clipped a line reports both notices", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 3, + wasTruncated: true, + hasClippedLines: true, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-both.ts" }], + _legacyFormat: true, + } + + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + const [, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("showing 2 of 3 total lines") + expect(pushed).toContain("clipped in this view") + }) + + it("legacy: a slice truncated to the default limit records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a", + returnedLines: 1, + totalLines: 5000, + wasTruncated: true, + includedRanges: [[1, 1]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-trunc.ts" }], + _legacyFormat: true, + } + + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + + // Lines were omitted here, so the note reports the omitted range rather + // than clipping. + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("showing 1 of 5000 total lines") + }) + + it("native: a read whose bytes did not survive the UTF-8 decode records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + // 0xFF is not valid UTF-8, so the model receives U+FFFD instead of the byte. + const raw = Buffer.from([0x61, 0xff]) + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(raw) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\uFFFD", + returnedLines: 1, + totalLines: 1, + wasTruncated: false, + includedRanges: [[1, 1]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute({ path: "lossy.ts" }, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + expect(reg.get(calledPath)!.complete).toBe(false) + }) + + it("legacy: a read whose bytes did not survive the UTF-8 decode records a partial observation", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + const raw = Buffer.from([0x61, 0xff]) + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(raw) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\uFFFD", + returnedLines: 1, + totalLines: 1, + wasTruncated: false, + includedRanges: [[1, 1]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy-lossy.ts" }], + _legacyFormat: true, + } + + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).toHaveBeenCalledTimes(1) + const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + expect(reg.get(calledPath)!.complete).toBe(false) + }) + }) }) }) diff --git a/src/integrations/misc/__tests__/indentation-reader.spec.ts b/src/integrations/misc/__tests__/indentation-reader.spec.ts index b6c28365aa..fa951ea85e 100644 --- a/src/integrations/misc/__tests__/indentation-reader.spec.ts +++ b/src/integrations/misc/__tests__/indentation-reader.spec.ts @@ -1,4 +1,5 @@ import { describe, it, expect } from "vitest" +import { MAX_LINE_LENGTH } from "../../../core/prompts/tools/native-tools/read_file" import { parseLines, formatWithLineNumbers, @@ -278,11 +279,45 @@ describe("readWithSlice", () => { expect(result.wasTruncated).toBe(true) }) + it("reports a clipped line separately from omitted lines", () => { + // Every line is returned, but formatWithLineNumbers clips a line longer + // than MAX_LINE_LENGTH, so the model did not see the whole file. + const lines = ["x".repeat(MAX_LINE_LENGTH + 10), "short"].join("\n") + const result = readWithSlice(lines, 0, 10) + + expect(result.returnedLines).toBe(2) + expect(result.wasTruncated).toBe(false) + expect(result.hasClippedLines).toBe(true) + }) + + it("keeps a slice complete when a line is exactly at the length cap", () => { + // formatWithLineNumbers clips only lines strictly longer than the cap, so a + // line at exactly MAX_LINE_LENGTH is shown in full and the read is complete. + const lines = ["x".repeat(MAX_LINE_LENGTH), "short"].join("\n") + const result = readWithSlice(lines, 0, 10) + + expect(result.returnedLines).toBe(2) + expect(result.wasTruncated).toBe(false) + expect(result.hasClippedLines).toBe(false) + }) + + it("flags clipping when any line is clipped, not only when every line is", () => { + // The first line is clipped and the second is shown in full: some lines are + // a partial view even though every line was returned. + const lines = ["y".repeat(MAX_LINE_LENGTH + 1), "short"].join("\n") + const result = readWithSlice(lines, 0, 10) + + expect(result.returnedLines).toBe(2) + expect(result.hasClippedLines).toBe(true) + }) + it("should handle offset beyond file end", () => { const result = readWithSlice(SIMPLE_CODE, 1000, 10) expect(result.returnedLines).toBe(0) expect(result.content).toContain("Error") + // No line was returned, so nothing could have been clipped. + expect(result.hasClippedLines).toBe(false) }) it("should handle negative offset", () => { @@ -296,6 +331,14 @@ describe("readWithSlice", () => { // ─── readWithIndentation Tests ──────────────────────────────────────────────── describe("readWithIndentation", () => { + it("reports an out-of-range anchor as an error with no clipping", () => { + const result = readWithIndentation(SIMPLE_CODE, { anchorLine: 1000 }) + + expect(result.content).toContain("out of range") + expect(result.returnedLines).toBe(0) + expect(result.hasClippedLines).toBe(false) + }) + describe("basic block extraction", () => { it("should extract content around the anchor line", () => { const result = readWithIndentation(PYTHON_CODE, { diff --git a/src/integrations/misc/indentation-reader.ts b/src/integrations/misc/indentation-reader.ts index 47ff4593bf..9f521c4358 100644 --- a/src/integrations/misc/indentation-reader.ts +++ b/src/integrations/misc/indentation-reader.ts @@ -58,8 +58,10 @@ export interface IndentationReadResult { totalLines: number /** Lines actually returned */ returnedLines: number - /** Whether output was truncated due to limit */ + /** Whether output was truncated because lines were omitted */ wasTruncated: boolean + /** Whether any returned line was clipped by the per-line length cap */ + hasClippedLines?: boolean } // ─── Constants ──────────────────────────────────────────────────────────────── @@ -244,6 +246,7 @@ export function readWithIndentation(content: string, options: IndentationReadOpt totalLines, returnedLines: 0, wasTruncated: false, + hasClippedLines: false, } } @@ -386,6 +389,7 @@ export function readWithSlice( totalLines, returnedLines: 0, wasTruncated: false, + hasClippedLines: false, } } @@ -393,6 +397,11 @@ export function readWithSlice( const endIdx = Math.min(offset + limit, totalLines) const selectedLines = lines.slice(offset, endIdx) const wasTruncated = endIdx < totalLines + // A returned line can still be a partial view: formatWithLineNumbers clips a + // line longer than MAX_LINE_LENGTH, so a slice that returned every line may + // still hide content. Clipping is reported separately from omission so the + // caller does not suggest a next offset that is beyond the file. + const hasClippedLines = selectedLines.some((line) => line.content.length > MAX_LINE_LENGTH) // Format output const formattedContent = formatWithLineNumbers(selectedLines) @@ -403,5 +412,6 @@ export function readWithSlice( totalLines, returnedLines: selectedLines.length, wasTruncated, + hasClippedLines, } } From 074348e426da8665722e277eaee3b624d7cd8571 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 02:48:43 +0800 Subject: [PATCH 10/72] fix(file-safety): inherit unit 1 committed guard and exact rmdir assertion This unit was rebuilt from the pre-fix content source, so its copy of safeWriteText.ts still restored the backup over a write whose commit rename had already succeeded when the parent-directory fsync failed, and its spec asserted rmdir generically rather than against the staging directory this write created. Both are already settled in unit 1 (fws/u1-atomic-publish). Taking those files here keeps the shared code byte-identical across the units, so merging the chain in order does not overwrite unit 1's fix. Tests: 52 passed in safeWriteText.spec.ts. --- src/services/file-safety/safeWriteText.ts | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index e378cbbae8..2aafd0cce0 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -167,11 +167,7 @@ async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRu */ export async function resolvePublishTarget(absoluteFilePath: string): Promise { return fs.realpath(absoluteFilePath).catch(async (error: unknown) => { - const code = - typeof error === "object" && error !== null && "code" in error - ? (error as { code?: string }).code - : undefined - if (code !== "ENOENT") throw error + if (errorCode(error) !== "ENOENT") throw error // ENOENT also covers a dangling symlink, which must never be written through. // Only a lstat that also reports the path as absent may fall back to the // given path; a real lstat failure (EACCES, EIO) says nothing about whether @@ -289,6 +285,10 @@ export async function safeWriteText( let backupPath: string | null = null let releaseBackupOnSuccess = false + // Set once the commit rename has published the new content. After that point the + // backup is no longer a safe restore source: rolling it back would overwrite + // content the caller can already observe at the target path. + let committed = false // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null @@ -397,16 +397,13 @@ export async function safeWriteText( await fs.rename(targetPath, backupPath) releaseBackupOnSuccess = true } catch (err: unknown) { - const code = - typeof err === "object" && err !== null && "code" in err - ? (err as { code?: string }).code - : undefined - if (code !== "ENOENT") throw err + if (errorCode(err) !== "ENOENT") throw err } } // -- Step 4: atomic rename temp -> target --------------------- await fs.rename(tempPath, targetPath) + committed = true // -- Step 4b (POSIX): fsync the parent directory so the directory entry // changed by the commit rename is durable, not just the file content. @@ -463,7 +460,10 @@ export async function safeWriteText( await fs.rmdir(stagingDir).catch(() => {}) } } catch (originalError: unknown) { - if (backupPath && releaseBackupOnSuccess) { + // Only a pre-commit failure can restore the backup. Once the commit rename + // published, a later failure (for example the post-commit directory fsync) + // must not overwrite the published content with the old file. + if (backupPath && releaseBackupOnSuccess && !committed) { try { await fs.rename(backupPath, targetPath) } catch (rollbackError: unknown) { From aaf2434877d0680ffd00566aa785b32b1791c2a6 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 03:43:00 +0800 Subject: [PATCH 11/72] fix(tools): stop the source indentation leaking into the clipped-lines notice The template literal continued on an indented source line, so the model-facing output carried four leading tabs before the content. Replace the indented newline with an explicit escape so the notice and the content are separated by a single newline and nothing else. Local note: readFileTool.spec.ts cannot run in this worktree (isbinaryfile is not resolvable from either node_modules here); CI covers it. --- src/core/tools/ReadFileTool.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index dd38a47809..8ce2c35c77 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -361,8 +361,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Every line was returned, so there is no later offset to read: report the // clipping without a next-offset hint, and keep the read incomplete so a // full-file replacement cannot be built from a clipped line. - output = `IMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view. The file was read in full, but the clipped lines were not shown in full. - ${result.content}` + output = `IMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view. The file was read in full, but the clipped lines were not shown in full.\n${result.content}` } else if (result.returnedLines === 0) { output = "Note: File is empty" } From d9ee95a37fd90585eaf1e36271706f383d8c2549 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 03:44:19 +0800 Subject: [PATCH 12/72] fix(file-safety): keep the publish error message in RollbackFailureError safeWriteJson rethrows RollbackFailureError and the telemetry callers record only error.message, so the generic wrapper message lost the filesystem errno text of the publish failure. Include the publish error message while keeping the rollback context (publishError, rollbackError, backupPath) unchanged. Tests: 52 passed in safeWriteText.spec.ts, ESLint clean with --max-warnings=0. --- src/services/file-safety/safeWriteText.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 2aafd0cce0..85c6a071ba 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -47,7 +47,7 @@ export class RollbackFailureError extends Error { constructor(publishError: unknown, rollbackError: unknown, backupPath: string) { super( - "Publish failed and the backup could not be restored to its original path -- the content is preserved at the backup location reported on this error.", + `Publish failed (${publishError instanceof Error ? publishError.message : String(publishError)}) and the backup could not be restored to its original path -- the content is preserved at the backup location reported on this error.`, { cause: publishError }, ) this.name = "RollbackFailureError" From fedb77d4058328ff8b51a6835d21be8322bfa259 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 03:45:43 +0800 Subject: [PATCH 13/72] test(file-safety): assert the exact staging directory removed after a rollback failure The assertion accepted any rmdir argument, so a regression that removed a different directory still passed. Read this write's own staging directory from fsSync.mkdirSync and assert that exact path. Tests: 52 passed in safeWriteText.spec.ts, ESLint clean with --max-warnings=0. --- .../__tests__/safeWriteText.spec.ts | 46 ++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 007ff4d3c5..99fd6291fb 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -348,6 +348,26 @@ describe("safeWriteText", () => { // temp-shaped is unlinked afterwards expect(fs.unlink).not.toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) + + it("a failed post-commit directory fsync does not roll the backup back over the published content", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const dirPath = path.dirname(targetPath) + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // The file fd opens normally; the parent-directory open after the commit + // rename fails, which is the post-commit durability failure. + vi.mocked(fsSync.openSync).mockImplementation((target) => { + if (String(target) === dirPath) throw new Error("EBADF") + return 1 + }) + + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow(PostCommitDurabilityError) + + // The commit rename already published the new content, so the backup must + // not be renamed back over it: only target->backup and temp->target run. + expect(fs.rename).toHaveBeenNthCalledWith(1, targetPath, expect.stringContaining("safeWriteText.bak_")) + expect(fs.rename).toHaveBeenNthCalledWith(2, expect.stringContaining("safeWriteText_"), targetPath) + expect(fs.rename).toHaveBeenCalledTimes(2) + }) }) // ── Test 4: backup:true keeps old safeWriteJson semantics incl. rollback ── @@ -546,6 +566,28 @@ describe("safeWriteText", () => { expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) }) + it("win32 DACL save runs before the backup rename, not after it", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + + // The title is about order, so assert the order the mocks were actually + // called in. If the save ran after the backup rename the target would + // already be gone and the dump would describe the wrong file. + await safeWriteText(targetPath, "data", { backup: true, platform: "win32" }) + + const callOrder = vi.mocked(execFile).mock.invocationCallOrder + const renameOrder = vi.mocked(fs.rename).mock.invocationCallOrder + const saveCall = callOrder[0] + const restoreCall = callOrder[1] + const backupRename = renameOrder[0] + const commitRename = renameOrder[1] + + expect(saveCall).toBeLessThan(backupRename) + expect(backupRename).toBeLessThan(commitRename) + expect(commitRename).toBeLessThan(restoreCall) + }) + it("win32 DACL: dump is unlinked even when restore fails", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -1049,7 +1091,9 @@ describe("cleanup before a rollback failure is reported", () => { // The backup is what the caller can still recover, so it stays on disk; the // staging file and this write's own directory must not leak alongside it. expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) - expect(fs.rmdir).toHaveBeenCalled() + const stagingDirs = vi.mocked(fsSync.mkdirSync).mock.calls.map((call) => String(call[0])) + expect(stagingDirs.length).toBe(1) + expect(fs.rmdir).toHaveBeenCalledWith(stagingDirs[0]) const failingRenameOrder = vi.mocked(fs.rename).mock.invocationCallOrder[2] const unlinkOrder = vi.mocked(fs.unlink).mock.invocationCallOrder[0] From 28737beb0b1eecb2cde236f27f9c7eb323877d1a Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 05:21:40 +0800 Subject: [PATCH 14/72] test: re-trigger required checks - the queued runs were cancelled by the Actions queue, no source change From e53a6e0907c3cb73c91f67d08b493476f35b46c7 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 06:47:21 +0800 Subject: [PATCH 15/72] fix(file-safety): give the Windows DACL dump a per-write name The dump path was the fixed sibling .acl.tmp. A pre-existing user file at that path is unlinked by the failed-save branch and by both cleanup paths, and two concurrent writes to the same target share one dump, so one write can restore or delete the other's. Use the per-write unique name like the staging file. Tests: 52 passed in safeWriteText.spec.ts, ESLint clean with --max-warnings=0. --- .../file-safety/__tests__/safeWriteText.spec.ts | 12 ++++++------ src/services/file-safety/safeWriteText.ts | 2 +- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 99fd6291fb..8b76906dda 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -170,7 +170,7 @@ describe("safeWriteText", () => { // through the default icacls path (options?.execFileRunner must // not throw when options is undefined) expect(vi.mocked(execFile)).toHaveBeenCalledTimes(2) - expect(vi.mocked(fs.unlink)).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + expect(vi.mocked(fs.unlink)).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) } }) @@ -535,7 +535,7 @@ describe("safeWriteText", () => { const saveArgs = vi.mocked(execFile).mock.calls[0]?.[1] expect(saveArgs?.[1]).toBe("/save") // the dump path (possibly partially created by icacls) was unlinked - expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) it("win32 DACL save args are [targetPath, /save, dumpPath, /T] before backup rename", async () => { @@ -551,7 +551,7 @@ describe("safeWriteText", () => { // First call: save DACL from target before backup rename const firstCall = vi.mocked(execFile).mock.calls[0] expect(firstCall[0]).toBe("icacls") - expect(firstCall[1]).toEqual([targetPath, "/save", expect.stringContaining(".acl.tmp"), "/T"]) + expect(firstCall[1]).toEqual([targetPath, "/save", expect.stringContaining("safeWriteText.acl"), "/T"]) // Second call: restore DACL onto directory after commit rename const secondCall = vi.mocked(execFile).mock.calls[1] @@ -559,11 +559,11 @@ describe("safeWriteText", () => { expect(secondCall[1]).toEqual([ expect.stringContaining("/tmp/test-dir"), "/restore", - expect.stringContaining(".acl.tmp"), + expect.stringContaining("safeWriteText.acl"), ]) // dump file was unlinked after restore - expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) it("win32 DACL save runs before the backup rename, not after it", async () => { @@ -610,7 +610,7 @@ describe("safeWriteText", () => { expect(fs.rename).toHaveBeenCalledTimes(1) // dump file was still unlinked in finally - expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".acl.tmp")) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) it("win32 DACL: when target does not exist, no save/restore/dump", async () => { diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 85c6a071ba..e548e5c3b5 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -370,7 +370,7 @@ export async function safeWriteText( if (platform === "win32") { try { await fs.access(targetPath) // target exists? - const dumpPath = targetPath + ".acl.tmp" + const dumpPath = _tempName(dirPath, "safeWriteText.acl") const saved = await _saveDaclWindows(targetPath, dumpPath, options?.execFileRunner) if (saved) { // Only a successfully saved dump may be restored onto the From bb349583f77bb30ab33243a87008bc25eb8527de Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Tue, 6 Oct 2026 06:48:25 +0800 Subject: [PATCH 16/72] fix(tools): the clipping notice must describe the slice it actually returned A slice that starts after line 1 and reaches EOF is not truncated, so the branch said "The file was read in full" even though the earlier lines were omitted. Name the slice start when the read did not begin at line 1, and add a focused test for that case. Local note: readFileTool.spec.ts cannot run in this worktree (isbinaryfile is not resolvable from either node_modules here) and ESLint cannot resolve its config here; CI covers both. --- src/core/tools/ReadFileTool.ts | 2 +- src/core/tools/__tests__/readFileTool.spec.ts | 28 +++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index 8ce2c35c77..e5b476f297 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -361,7 +361,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Every line was returned, so there is no later offset to read: report the // clipping without a next-offset hint, and keep the read incomplete so a // full-file replacement cannot be built from a clipped line. - output = `IMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view. The file was read in full, but the clipped lines were not shown in full.\n${result.content}` + output = `IMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view. ${offset1 === 1 ? "The file was read in full" : `The returned slice starts at line ${offset1} and reaches the end of the file`}, but the clipped lines were not shown in full.\n${result.content}` } else if (result.returnedLines === 0) { output = "Note: File is empty" } diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 353e4845cb..b4a3f94956 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -1996,6 +1996,34 @@ describe("ReadFileTool", () => { // The notice is added on top of the read, it does not replace it. expect(pushed).toContain("1 | a") }) + it("native: a clipped slice that starts after line 1 names the slice instead of claiming a full read", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\nc\nd\ne\n")) + mockedReadWithSlice.mockReturnValue({ + content: "3 | c\n4 | d", + returnedLines: 2, + totalLines: 5, + wasTruncated: false, + hasClippedLines: true, + includedRanges: [[3, 4]], + }) + + await readFileTool.execute({ path: "clipped-slice.ts", offset: 3 }, mockTask as unknown as Task, callbacks) + + const pushed = callbacks.pushToolResult.mock.calls[0][0] + expect(pushed).toContain("clipped in this view") + // Lines 1-2 were omitted, so the notice must describe the slice that was + // returned rather than claim the whole file was read. + expect(pushed).toContain("starts at line 3") + expect(pushed).not.toContain("The file was read in full") + expect(pushed).toContain("3 | c") + }) it("native: a truncated slice that also clipped a line reports both notices", async () => { // A long line inside a slice that also cut lines off is a plausible case, From 62705bbbd7054ea1070772ee42909195f80db6f7 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 11:22:26 +0800 Subject: [PATCH 17/72] fix(file-safety): keep the target present while publishing (durable copy backup) Pre-merge review flagged the publication path as non-atomic when backup:true: it renamed the existing target to a backup name and only then renamed the staged file into place, so the canonical path was absent for the whole commit window - readers saw a missing file, and a concurrent writer could create a new target that a later rollback would destroy. The backup is now a copy, never a move: - the destination is created with openSync(backupPath, "wx", 0o600) before any content exists at it, so no content ever sits at a path whose mode fs.copyFile chose (it uses the platform creation mask subject to umask on some platforms, the source's mode and read-only attribute on others); - chmod 0o600 after the copy clears a copied read-only attribute (Windows) that would otherwise make the fsync open fail with EACCES, and keeps a backup of a permissive file private; - the copy is fsynced, then deleted once the commit rename has published; nothing is ever renamed back. safeWriteText also rejects a staging file that is the target itself (same inode/device), which would otherwise let a caller-supplied tempPath silently alias the target. Tests: the safeWriteText spec is replaced with the copy-model spec plus a new integration spec that runs against the real filesystem (no fs mocks) - success publishes and leaves no residue, and a directory target is rejected with the payload bytes unchanged. The safeWriteJson spec moves from the three-rename/rollback model to the copy model, and the lock-key spec accounts for the extra lstat the aliasing guard performs. 83 passed / 1 skipped across safeWriteText.spec + integration spec + safeWriteJson + safeWriteJson.lockKey; tsc and eslint clean, no suppression drift. --- .../safeWriteText.integration.spec.ts | 49 +++++ .../__tests__/safeWriteText.spec.ts | 201 +++++++++++------- src/services/file-safety/safeWriteText.ts | 137 +++++++----- .../__tests__/safeWriteJson.lockKey.spec.ts | 9 +- src/utils/__tests__/safeWriteJson.test.ts | 69 ++---- 5 files changed, 280 insertions(+), 185 deletions(-) create mode 100644 src/services/file-safety/__tests__/safeWriteText.integration.spec.ts diff --git a/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts b/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts new file mode 100644 index 0000000000..81d758349e --- /dev/null +++ b/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts @@ -0,0 +1,49 @@ +import * as fs from "fs/promises" +import * as os from "os" +import * as path from "path" + +import { safeWriteText } from "../safeWriteText" + +// No fs mocks in this file: the point is to assert what a real filesystem ends up +// holding after a publish attempt, which the mocked spec cannot show. The failure is +// provoked with real filesystem semantics rather than with a stubbed call. +describe("safeWriteText against a real filesystem", () => { + let dir: string + + beforeEach(async () => { + dir = await fs.mkdtemp(path.join(os.tmpdir(), "safe-write-text-int-")) + }) + + afterEach(async () => { + await fs.rm(dir, { recursive: true, force: true }) + }) + + it("publishes the new bytes and leaves no staging or backup residue", async () => { + const targetPath = path.join(dir, "target.txt") + await fs.writeFile(targetPath, "old bytes") + + // No platform override: the real platform's own durability and ACL steps run. + // A failed icacls restore in a throwaway temp directory is reported, not thrown, + // so the publish still lands. + await safeWriteText(targetPath, "new bytes", { backup: true }) + + expect(await fs.readFile(targetPath, "utf8")).toBe("new bytes") + expect(await fs.readdir(dir)).toEqual(["target.txt"]) + }) + + it("leaves the target bytes untouched when the commit cannot replace it", async () => { + // A regular file cannot be renamed over a directory, so the backup copy and + // the commit both fail on a real filesystem with no mocking at all. + const targetPath = path.join(dir, "target-dir") + await fs.mkdir(targetPath) + const inside = path.join(targetPath, "payload.txt") + await fs.writeFile(inside, "original bytes") + + await expect(safeWriteText(targetPath, "new data", { backup: true })).rejects.toThrow() + + // The directory and its content are exactly as they were, and no backup copy + // or staging directory was left behind next to them. + expect(await fs.readFile(inside, "utf8")).toBe("original bytes") + expect(await fs.readdir(dir)).toEqual(["target-dir"]) + }) +}) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 8b76906dda..7529305278 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -7,7 +7,6 @@ import * as path from "path" import { PostCommitDurabilityError, resolveLockKey, - RollbackFailureError, safeWriteText, StagingPathError, type SafeWriteTextOptions, @@ -15,6 +14,8 @@ import { // Full mock for fs/promises — all methods are vi.fn() stubs vi.mock("fs/promises", () => ({ + copyFile: vi.fn(), + chmod: vi.fn(), mkdir: vi.fn(), access: vi.fn(), rename: vi.fn(), @@ -335,15 +336,13 @@ describe("safeWriteText", () => { await safeWriteText(targetPath, "data", { backup: true, platform: "linux" }) - // the commit rename (temp -> target) still happened - expect(fs.rename).toHaveBeenNthCalledWith(2, expect.stringContaining("safeWriteText_"), targetPath) + // the commit rename (temp -> target) still happened; it is the only rename + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) // the failing cleanup was the post-commit backup unlink expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) - // no rollback rename: the committed target is not restored from the backup - expect(fs.rename).toHaveBeenCalledTimes(2) - // the staging temp was already committed by the rename; nothing // temp-shaped is unlinked afterwards expect(fs.unlink).not.toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) @@ -362,18 +361,22 @@ describe("safeWriteText", () => { await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow(PostCommitDurabilityError) - // The commit rename already published the new content, so the backup must - // not be renamed back over it: only target->backup and temp->target run. - expect(fs.rename).toHaveBeenNthCalledWith(1, targetPath, expect.stringContaining("safeWriteText.bak_")) - expect(fs.rename).toHaveBeenNthCalledWith(2, expect.stringContaining("safeWriteText_"), targetPath) - expect(fs.rename).toHaveBeenCalledTimes(2) + // The commit rename already published the new content, and the backup was only + // ever a copy: the target was never moved, so there is nothing to rename back. + expect(fs.copyFile).toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + + // The durability failure is reported, not swallowed - and the backup copy is not + // left beside the target where no caller could find it. + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) }) }) - // ── Test 4: backup:true keeps old safeWriteJson semantics incl. rollback ── + // ── Test 4: backup:true keeps old safeWriteJson semantics, copy-based ── describe("backup:true", () => { - it("renames target -> backup before commit, deletes backup on success", async () => { + it("copies target -> backup before commit without moving the target, deletes the copy on success", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) @@ -383,68 +386,94 @@ describe("safeWriteText", () => { // target was accessed (exists check) expect(fs.access).toHaveBeenCalledWith(targetPath) - // first rename: target -> backup - expect(fs.rename).toHaveBeenNthCalledWith(1, targetPath, expect.stringContaining("safeWriteText.bak_")) + // The backup is a copy: the canonical target is never moved away, so readers + // never see a missing file and no later step can clobber a concurrent publish. + expect(fs.copyFile).toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) + expect(fs.rename).not.toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) - // second rename: temp -> target (realpath mock returns targetPath) - expect(fs.rename).toHaveBeenNthCalledWith(2, expect.stringContaining("safeWriteText_"), targetPath) + // the only rename is the atomic commit temp -> target + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) - // backup was deleted on success + // backup copy was deleted on success expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) }) - it("rollback: on failure after rename target->backup, restores backup to target", async () => { + it("a failed commit does not move the target, so nothing has to be rolled back", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) - // first rename (target->backup) succeeds, second fails - let callCount = 0 - vi.mocked(fs.rename).mockImplementation(async () => { - callCount++ - if (callCount === 1) return // target -> backup - if (callCount === 2) throw new Error("ENOSPC") // temp -> target fails - return // the rollback rename succeeds - }) + // The commit rename is the only rename in the flow and it fails. + vi.mocked(fs.rename).mockRejectedValue(new Error("ENOSPC")) await expect(safeWriteText(targetPath, "new data", { backup: true })).rejects.toThrow("ENOSPC") - // rollback rename is the 3rd call (after target->backup and temp->target failure) - expect(fs.rename).toHaveBeenNthCalledWith(3, expect.stringContaining("safeWriteText.bak_"), targetPath) + // The target never left its path, so there is no restore rename and the + // pre-write content is still what a reader sees at targetPath. + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(fs.copyFile).toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) - // temp was cleaned up on failure + // Both the backup copy and the staging temp are cleaned up on failure. + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) - it("a failed rollback reports the partial state, not only the publish error", async () => { - // The content is still on disk, but only at the backup path. A caller that gets - // just the publish error has data it cannot find at the expected path. + it("creates the backup privately before its content exists, then fsyncs it", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) - let callCount = 0 - vi.mocked(fs.rename).mockImplementation(async () => { - callCount++ - if (callCount === 1) return // target -> backup - if (callCount === 2) throw new Error("ENOSPC") // temp -> target fails - throw new Error("EACCES") // the rollback rename fails too + + await safeWriteText(targetPath, "new data", { backup: true }) + + // The destination must exist with a private mode before copyFile writes anything + // into it: copyFile chooses the destination mode itself, so a restrictive target + // could otherwise leave a group/world-readable copy that a later chmod cannot + // undo. "wx" also means a pre-existing path is never silently reused. + const seedOpen = vi.mocked(fsSync.openSync).mock.calls.find(function (call) { + return String(call[0]).includes("safeWriteText.bak_") && call[1] === "wx" }) + expect(seedOpen).toBeDefined() + expect(seedOpen?.[2]).toBe(0o600) + const seedOrder = vi.mocked(fsSync.openSync).mock.invocationCallOrder[vi.mocked(fsSync.openSync).mock.calls.indexOf(seedOpen!)] + expect(seedOrder).toBeLessThan(vi.mocked(fs.copyFile).mock.invocationCallOrder[0]) + + // The chmod keeps a copied read-only attribute (Windows) from breaking the fsync + // open, and keeps a backup of a permissive file private. + expect(fs.copyFile).toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) + expect(fs.chmod).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_"), 0o600) + expect(vi.mocked(fs.chmod).mock.invocationCallOrder[0]).toBeGreaterThan( + vi.mocked(fs.copyFile).mock.invocationCallOrder[0], + ) - let failure: RollbackFailureError | undefined - await safeWriteText(targetPath, "new data", { backup: true }).catch((e: unknown) => { - if (e instanceof RollbackFailureError) { - failure = e - return + // The copy is then opened for fsync with the writable flag. + const backupOpen = vi.mocked(fsSync.openSync).mock.calls.find(function (call) { + return String(call[0]).includes("safeWriteText.bak_") && call[1] === "r+" + }) + expect(backupOpen).toBeDefined() + }) + + it("a failed backup flush is reported and leaves no partial backup behind", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The copy lands, but the fsync of the copy fails: the retained content is not + // known to be durable, so the write must not proceed on a half-written backup. + // The staged temp is fsynced earlier with a different handle, so target the + // backup's fd specifically. + vi.mocked(fsSync.openSync).mockImplementation((p: unknown) => (String(p).includes("safeWriteText.bak_") ? 7 : 1)) + vi.mocked(fsSync.fsyncSync).mockImplementation((fd: unknown) => { + if (fd === 7) { + throw new Error("EIO") } - throw e }) - expect(failure).toBeInstanceOf(RollbackFailureError) - expect(failure?.publishError).toBeInstanceOf(Error) - expect((failure?.publishError as Error).message).toBe("ENOSPC") - expect((failure?.rollbackError as Error).message).toBe("EACCES") - expect(failure?.backupPath).toContain("safeWriteText.bak_") - // The backup is what the caller can still recover, so it must stay on disk. - expect(fs.unlink).not.toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow("EIO") + + // Nothing was published, and the incomplete copy is removed rather than left + // next to the target looking like a usable backup. + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) it("backup:true when target does not exist: no backup created, just commit", async () => { @@ -566,32 +595,34 @@ describe("safeWriteText", () => { expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) - it("win32 DACL save runs before the backup rename, not after it", async () => { + it("win32 DACL save runs before the backup copy, not after it", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) // The title is about order, so assert the order the mocks were actually - // called in. If the save ran after the backup rename the target would - // already be gone and the dump would describe the wrong file. + // called in. If the save ran after the backup copy the dump could describe a + // file that a concurrent publish had already replaced. await safeWriteText(targetPath, "data", { backup: true, platform: "win32" }) const callOrder = vi.mocked(execFile).mock.invocationCallOrder + const copyOrder = vi.mocked(fs.copyFile).mock.invocationCallOrder const renameOrder = vi.mocked(fs.rename).mock.invocationCallOrder const saveCall = callOrder[0] const restoreCall = callOrder[1] - const backupRename = renameOrder[0] - const commitRename = renameOrder[1] + const backupCopy = copyOrder[0] + const commitRename = renameOrder[0] - expect(saveCall).toBeLessThan(backupRename) - expect(backupRename).toBeLessThan(commitRename) + expect(saveCall).toBeLessThan(backupCopy) + expect(backupCopy).toBeLessThan(commitRename) expect(commitRename).toBeLessThan(restoreCall) }) - it("win32 DACL: dump is unlinked even when restore fails", async () => { + it("win32 DACL: a failed restore is reported and the dump is still unlinked", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) + const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {}) // icacls save succeeds, restore fails let callCount = 0 @@ -605,10 +636,15 @@ describe("safeWriteText", () => { await safeWriteText(targetPath, "data", { platform: "win32" }) - // write succeeded despite restore failure (best-effort) + // The content did commit: failing here would break every publish on a machine + // where icacls cannot reapply the saved ACEs. expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) expect(fs.rename).toHaveBeenCalledTimes(1) + // The changed access rights are reported instead of being swallowed. + expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("could not be restored")) + warnSpy.mockRestore() + // dump file was still unlinked in finally expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) @@ -1067,35 +1103,48 @@ describe("caller-supplied staging path", () => { expect(fsSync.openSync).not.toHaveBeenCalled() expect(fs.rename).not.toHaveBeenCalled() }) + + it("rejects a staging path that is the target itself", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // Same inode and device for the supplied staging path and the target: the + // failure handler would unlink the only copy of the content, so a failed + // write would delete the file it was meant to protect. + const stats = _fileStats(false) + stats.ino = 42 + stats.dev = 7 + vi.mocked(fs.lstat).mockResolvedValue(stats) + + await expect( + safeWriteText(targetPath, "data", { tempPath: targetPath, platform: "linux" }), + ).rejects.toThrow(StagingPathError) + expect(fsSync.openSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.unlink).not.toHaveBeenCalled() + }) }) -describe("cleanup before a rollback failure is reported", () => { +describe("cleanup when a backed-up write fails before commit", () => { beforeEach(() => mockDefaults()) - it("releases the staged file and its own staging directory before throwing", async () => { + it("releases the staged file, its copy and its own staging directory before throwing", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) - let callCount = 0 - vi.mocked(fs.rename).mockImplementation(async () => { - callCount++ - if (callCount === 1) return // target -> backup - if (callCount === 2) throw new Error("ENOSPC") // temp -> target fails - throw new Error("EACCES") // the rollback rename fails too - }) + // The commit rename is the only rename in this flow and it fails. + vi.mocked(fs.rename).mockRejectedValue(new Error("ENOSPC")) - await expect(safeWriteText(targetPath, "data", { backup: true, platform: "linux" })).rejects.toThrow( - RollbackFailureError, - ) + await expect(safeWriteText(targetPath, "data", { backup: true, platform: "linux" })).rejects.toThrow("ENOSPC") - // The backup is what the caller can still recover, so it stays on disk; the - // staging file and this write's own directory must not leak alongside it. + // The staging file and this write's own directory must not leak, and neither may + // the backup copy: the target still holds the pre-write content on disk. expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) const stagingDirs = vi.mocked(fsSync.mkdirSync).mock.calls.map((call) => String(call[0])) expect(stagingDirs.length).toBe(1) expect(fs.rmdir).toHaveBeenCalledWith(stagingDirs[0]) - const failingRenameOrder = vi.mocked(fs.rename).mock.invocationCallOrder[2] + const failingRenameOrder = vi.mocked(fs.rename).mock.invocationCallOrder[0] const unlinkOrder = vi.mocked(fs.unlink).mock.invocationCallOrder[0] const rmdirOrder = vi.mocked(fs.rmdir).mock.invocationCallOrder[0] expect(unlinkOrder).toBeGreaterThan(failingRenameOrder) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index e548e5c3b5..de2207e8b5 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -5,10 +5,12 @@ import { execFile } from "child_process" export interface SafeWriteTextOptions { /** - * When true, preserve the old-file semantics: rename target -> backup first, - * after commit rename delete the backup; on failure roll the backup back to - * the target path. When false (default) the atomic rename simply replaces - * the target -- crash-safe window is zero. + * When true, keep the old-file semantics without ever removing the target: the + * previous content is copied to a hidden backup path and flushed before the + * commit rename, the commit rename atomically replaces the target, and on success + * the backup copy is deleted. A failure before the commit leaves the target + * untouched (there is nothing to roll back) and removes the backup copy. When + * false (default) the atomic rename simply replaces the target. */ backup?: boolean @@ -34,29 +36,6 @@ export interface SafeWriteTextOptions { tempPath?: string } -/** - * A publish that failed and whose rollback also failed: the content survives only - * at the backup path, not at the canonical target. The publish failure stays the - * cause, and the rollback failure plus the backup location travel with the error so - * the caller can tell what it is looking at. - */ -export class RollbackFailureError extends Error { - readonly publishError: unknown - readonly rollbackError: unknown - readonly backupPath: string - - constructor(publishError: unknown, rollbackError: unknown, backupPath: string) { - super( - `Publish failed (${publishError instanceof Error ? publishError.message : String(publishError)}) and the backup could not be restored to its original path -- the content is preserved at the backup location reported on this error.`, - { cause: publishError }, - ) - this.name = "RollbackFailureError" - this.publishError = publishError - this.rollbackError = rollbackError - this.backupPath = backupPath - } -} - /** * A caller-supplied staging path that is not a file this write may publish: it * sits outside the target's directory (so the commit rename would cross @@ -140,8 +119,8 @@ async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunne } /** Restore a DACL dump onto *dirPath* on Windows. - * Best-effort: content is already committed, so failure is non-fatal. */ -async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { + * Returns whether icacls succeeded; the caller reports a failure. */ +async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { const runner = execFileRunner ?? execFile try { await new Promise((resolve, reject) => { @@ -149,8 +128,9 @@ async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRu err ? reject(err) : resolve(), ) }) + return true } catch { - // best-effort; content already committed + return false } } @@ -211,7 +191,8 @@ async function canonicalDirKey(absoluteFilePath: string): Promise { * Lock key for a publish target: the symlink referent when the path is an * existing symlink, the path itself otherwise. Unlike resolvePublishTarget this * tolerates a dangling link, because the lock key has to be computable while a - * peer writer is mid-commit (backup mode renames the referent away and back). + * peer writer is mid-commit (a publish renames the staged file onto the referent, + * and backup mode keeps a copy beside it). * The walk is bounded so a two-link cycle terminates, and every key it returns is * canonicalized through canonicalDirKey. */ @@ -276,6 +257,20 @@ export async function safeWriteText( supplied, ) } + // A staging path that is the target would be unlinked by the failure handler + // while it still holds the only copy of the content, so a failed write would + // delete the file it was meant to protect. Compare identities, not spellings: + // an alias of the target is the same hazard. + const targetStat = await fs.lstat(targetPath).catch(() => null) + if ( + targetStat && + typeof stagingStat.ino === "number" && + typeof targetStat.ino === "number" && + stagingStat.ino === targetStat.ino && + stagingStat.dev === targetStat.dev + ) { + throw new StagingPathError("Staging file must not be the target itself", supplied) + } // The caller's own path is used as given; only the check is canonical. tempPath = options.tempPath } else { @@ -292,12 +287,6 @@ export async function safeWriteText( // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null - // Set when the rollback itself fails, so cleanup runs before the error that - // reports the partial state is thrown. - // Held as a pair so the reported error still names the path the content survived at; - // declaring it as `unknown` alone would lose the string narrowing at the throw site. - let rollbackFailure: { error: unknown; backupPath: string } | null = null - try { // -- Step 1: write content to staging temp file ------------------- if (!options?.tempPath) { @@ -365,7 +354,7 @@ export async function safeWriteText( } } - // -- Step 2 (win32): save DACL BEFORE backup rename --------------- + // -- Step 2 (win32): save DACL BEFORE the backup copy ----------- const platform = options?.platform ?? process.platform if (platform === "win32") { try { @@ -389,12 +378,45 @@ export async function safeWriteText( } try { - // -- Step 3 (backup:true): rename target -> backup -------------- + // -- Step 3 (backup:true): durable copy target -> backup ---- if (options?.backup) { try { await fs.access(targetPath) backupPath = _tempName(dirPath, "safeWriteText.bak") - await fs.rename(targetPath, backupPath) + // Copy, never move. Renaming the target away leaves the canonical path absent for + // the whole commit window: readers see a missing file, and a concurrent + // writer can create a new target that a later rollback would destroy. A copy + // keeps the target present, so the step 4 rename is the only change to the + // canonical path. The copy is flushed so the retained content survives a crash. + try { + // Create the destination BEFORE any content exists at it, with the mode fixed + // at open time. fs.copyFile picks the destination mode itself (the platform + // creation mask subject to umask on some platforms, the source's mode - or its + // read-only attribute - on others), so letting it create the file would either + // leave a restrictive target's bytes briefly readable to others, or leave the + // copy unwritable so the fsync open below fails with EACCES. open() ignores its + // mode argument for an existing file, so this 0o600 survives the copy on POSIX; + // the chmod afterwards is what clears a copied read-only attribute on Windows + // and keeps a backup of a permissive file private. + const seedFd = fsSync.openSync(backupPath, "wx", 0o600) + fsSync.closeSync(seedFd) + await fs.copyFile(targetPath, backupPath) + await fs.chmod(backupPath, 0o600) + // "r+" not "r": fsync on a read-only handle is EPERM on Windows, and the same + // flag the staged temp file uses above. + const backupFd = fsSync.openSync(backupPath, "r+") + try { + _fsyncFile(backupFd) + } finally { + fsSync.closeSync(backupFd) + } + } catch (backupError: unknown) { + // A partial backup must not outlive this attempt: it is not a complete copy + // of anything, and once the write fails nothing else removes it. + await fs.unlink(backupPath).catch(() => {}) + backupPath = null + throw backupError + } releaseBackupOnSuccess = true } catch (err: unknown) { if (errorCode(err) !== "ENOENT") throw err @@ -432,7 +454,16 @@ export async function safeWriteText( // and on every failed save. if (daclDumpPath !== null) { const restoredDir = path.dirname(targetPath) - await _restoreDaclWindows(restoredDir, daclDumpPath, options?.execFileRunner) + const restored = await _restoreDaclWindows(restoredDir, daclDumpPath, options?.execFileRunner) + if (!restored) { + // The content is committed, but the published file may carry a different DACL + // from the one that was saved. Failing the write here would break every + // publish on machines where icacls cannot reapply the saved ACEs (a plain + // temp directory restore fails with "Not all privileges or groups referenced + // are assigned to the caller"), so the change of access rights is reported + // rather than thrown. + console.warn(`safeWriteText: content committed at ${targetPath}, but the saved DACL could not be restored from ${daclDumpPath}; the file may carry different access rights than the one it replaced.`) + } } // -- Step 6 (backup:true): delete backup on success ----------- @@ -463,19 +494,13 @@ export async function safeWriteText( // Only a pre-commit failure can restore the backup. Once the commit rename // published, a later failure (for example the post-commit directory fsync) // must not overwrite the published content with the old file. - if (backupPath && releaseBackupOnSuccess && !committed) { - try { - await fs.rename(backupPath, targetPath) - } catch (rollbackError: unknown) { - // The content survives only at the backup path now, and the canonical - // target is gone. Reporting just the publish failure would leave the - // caller with data it cannot find at the expected path, so the - // partial-failure state travels with the error. The staged temp file - // and this write's staging directory are released first: a rollback - // failure is already a hard enough state to reason about without also - // leaking the staging file. - rollbackFailure = { error: rollbackError, backupPath } - } + if (backupPath && releaseBackupOnSuccess) { + // Nothing to restore: the backup is a copy, so the target still holds whatever + // the commit left there - before the commit that is the pre-write content, and + // after it the published content. Either way the copy has served its purpose + // and must not be left beside the target where no caller can find it. + await fs.unlink(backupPath).catch(() => {}) + backupPath = null } try { await fs.unlink(tempPath).catch(() => {}) @@ -494,10 +519,6 @@ export async function safeWriteText( await fs.unlink(daclDumpPath).catch(() => {}) } - if (rollbackFailure) { - throw new RollbackFailureError(originalError, rollbackFailure.error, rollbackFailure.backupPath) - } - throw originalError } } diff --git a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts index 33989f8b81..beddaf9ea9 100644 --- a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts +++ b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts @@ -96,10 +96,11 @@ describe("safeWriteJson lock key under a peer commit", () => { // The lock key is the key every other writer to this file uses, so the caller // queued behind the peer instead of failing before the lock. expect(mockedAcquireFileLock).toHaveBeenCalledWith(referent) - // The trailing lstat is safeWriteText's staging-path check on the temp file - // this write created: it runs after the key was resolved and the lock taken, - // so it does not change which lock the caller queued behind. - expect(order).toEqual(["resolve-failed", "lstat", "resolve", "resolve", "lock", "resolve", "resolve", "lstat"]) + // The two trailing lstat calls are safeWriteText's staging-path checks: the + // regular-file check on the temp file this write created, and the identity check + // that the staging path is not the target. Both run after the key was resolved + // and the lock was taken, so neither changes which lock the caller queued behind. + expect(order).toEqual(["resolve-failed", "lstat", "resolve", "resolve", "lock", "resolve", "resolve", "lstat", "lstat"]) expect(JSON.parse(await fs.readFile(referent, "utf8"))).toEqual({ id: "task-1" }) }) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 045c425c1b..4a7b8aa5d1 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -4,7 +4,6 @@ import * as path from "path" import * as os from "os" import { safeWriteJson } from "../safeWriteJson" -import { RollbackFailureError } from "../../services/file-safety/safeWriteText" import * as lockfile from "proper-lockfile" // Capture actual implementations before the vi.mock factory runs, @@ -160,7 +159,7 @@ describe("safeWriteJson", () => { expect(content).toEqual({ initial: "content" }) }) - test("should handle failure when renaming filePath to tempBackupFilePath (filePath exists)", async () => { + test("should handle failure when the commit rename fails (filePath exists)", async () => { const initialData = { message: "Initial content, should remain" } const newData = { message: "New content, should not be written" } @@ -179,7 +178,7 @@ describe("safeWriteJson", () => { expect(content).toEqual(initialData) }) - test("should handle failure when renaming tempNewFilePath to filePath (filePath exists, backup succeeded)", async () => { + test("should handle failure when renaming tempNewFilePath to filePath (filePath exists, backup copy taken)", async () => { const initialData = { message: "Initial content, should be restored" } const newData = { message: "New content" } @@ -193,14 +192,8 @@ describe("safeWriteJson", () => { vi.mocked(fs.rename).mockImplementation(async (oldPath, newPath) => { renameCallCount++ if (renameCallCount === 1) { - // First call: filePath -> tempBackupFilePath (should succeed) - return fsPromisesActuals.rename!(oldPath, newPath) - } else if (renameCallCount === 2) { - // Second call: tempNewFilePath -> filePath (should fail) + // The commit rename is the only rename in this flow: it fails. throw new Error("Rename from temp to final failed") - } else if (renameCallCount === 3) { - // Third call: tempBackupFilePath -> filePath (rollback, should succeed) - return fsPromisesActuals.rename!(oldPath, newPath) } // Default: use original implementation return fsPromisesActuals.rename!(oldPath, newPath) @@ -351,16 +344,11 @@ describe("safeWriteJson", () => { await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify(initialData)) - // fs.rename is already vi.fn() — use vi.mocked to avoid double-wrapping via vi.spyOn - let renameCallCount = 0 - vi.mocked(fs.rename).mockImplementation(async (oldPath, newPath) => { - renameCallCount++ - if (renameCallCount === 2) { - // Second call: tempNewFilePath -> filePath (should fail) - throw new Error("Rename failed") - } - // For all other calls, use the original implementation - return fsPromisesActuals.rename!(oldPath, newPath) + // fs.rename is already vi.fn() — use vi.mocked to avoid double-wrapping via vi.spyOn. + // Once-only so the override does not leak into later tests: the commit rename is + // the only rename in this flow. + vi.mocked(fs.rename).mockImplementationOnce(async () => { + throw new Error("Rename failed") }) await expect(safeWriteJson(currentTestFilePath, newData)).rejects.toThrow("Rename failed") @@ -440,9 +428,10 @@ describe("safeWriteJson", () => { expect(vi.mocked(fs.access)).toHaveBeenCalled() }) - // Test for rollback failure scenario (the rollback rename now lives in safeWriteText) - test("re-throws the original error when the rollback rename fails, leaving an orphaned backup", async () => { - const initialData = { message: "Initial, orphaned when rollback fails" } + // The backup is a copy taken before the commit, so a failed commit has nothing to + // roll back: the target keeps its previous content and the copy is removed. + test("a failed commit keeps the previous content at the target and removes the backup copy", async () => { + const initialData = { message: "Initial, must survive a failed commit" } const newData = { message: "New content" } await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify(initialData)) @@ -453,38 +442,24 @@ describe("safeWriteJson", () => { let renameCallCount = 0 vi.mocked(fs.rename).mockImplementation(async (oldPath, newPath) => { renameCallCount++ - if (renameCallCount === 2) { - // Second call: tempNewFilePath -> filePath (fail) + if (renameCallCount === 1) { + // The commit rename fails; there is no rollback rename to fail. throw new Error("Primary rename failed") - } else if (renameCallCount === 3) { - // Third call: backup -> filePath (rollback, also fail) - throw new Error("Rollback rename failed") } return fsPromisesActuals.rename!(oldPath, newPath) }) - // The original error must propagate, not the rollback error - // The rollback also failed, so the error reports the partial state: the publish - // failure stays the cause and the backup location is named. - let failure: RollbackFailureError | undefined - await safeWriteJson(currentTestFilePath, newData).catch((e: unknown) => { - if (e instanceof RollbackFailureError) { - failure = e - return - } - throw e - }) + await expect(safeWriteJson(currentTestFilePath, newData)).rejects.toThrow("Primary rename failed") - expect(failure).toBeInstanceOf(RollbackFailureError) - expect(failure?.cause).toBeInstanceOf(Error) - expect(failure?.rollbackError).toBeInstanceOf(Error) - expect(failure?.backupPath).toContain("safeWriteText.bak_") + // Exactly one rename was attempted, and it was the commit. + expect(renameCallCount).toBe(1) - // The rollback failed inside safeWriteText, so the target is gone and - // the backup is orphaned on disk. - expect(await fileExists(currentTestFilePath)).toBe(false) + // The target never left its path, so the previous content is still what a + // reader sees, and no orphaned backup copy is left behind either. + const content = await readFileContent(currentTestFilePath) + expect(content).toEqual(initialData) const entries = await fs.readdir(tempDir) - expect(entries.some((entry) => entry.includes("safeWriteText.bak_"))).toBe(true) + expect(entries.some((entry) => entry.includes("safeWriteText.bak_"))).toBe(false) consoleErrorSpy.mockRestore() }) From b894375f0522962d4ce45910c94a64d3ea24ba2c Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 11:24:07 +0800 Subject: [PATCH 18/72] feat(utils): let a caller confine a write to a directory Pre-merge review flagged that the write path trusts an unvalidated symlink target: safeWriteText resolves an existing link to its referent and safeWriteJson then merges and publishes onto that referent, so a repository that plants its project settings file as a link elsewhere receives the write at the linked path. safeWriteJson now accepts confineTo. The check runs on the resolved publish target, after resolvePublishTarget and before the merge read and before anything is staged, so a rejected write takes no lock and leaves no residue. Both sides are canonicalized the same way: the scope is resolved through symlinks (walking to the nearest existing ancestor when it does not exist yet, and rethrowing anything other than ENOENT), and the target is canonicalized with the same helper because a target that does not exist yet still carries the alias components of the path it was given. Callers that picked a path from a known scope pass that scope; a caller that does not declare one keeps the current behaviour. The MCP settings wiring that uses this is on the async-save series (#1403). Tests: an out-of-scope path is rejected on every platform with no lock and no staged file; a planted link escaping the project is rejected and the linked file keeps its bytes; a link inside the project still publishes to the referent; and a scope declared through a symlinked directory that does not exist yet is accepted. --- src/utils/__tests__/safeWriteJson.test.ts | 89 +++++++++++++++++++++- src/utils/safeWriteJson.ts | 91 +++++++++++++++++++++++ 2 files changed, 179 insertions(+), 1 deletion(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 4a7b8aa5d1..9393774a25 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -3,7 +3,7 @@ import { Writable } from "stream" import * as path from "path" import * as os from "os" -import { safeWriteJson } from "../safeWriteJson" +import { ConfinedPathEscapeError, safeWriteJson } from "../safeWriteJson" import * as lockfile from "proper-lockfile" // Capture actual implementations before the vi.mock factory runs, @@ -665,6 +665,93 @@ describe("safeWriteJson", () => { // via tempPath, so safeWriteText must apply the existing target's mode to // the staged temp before the atomic rename — otherwise a 0o600 target is // published as 0o644. POSIX-only assertion (Windows ignores POSIX modes). + test("rejects a confined write whose target is outside the confined directory", async () => { + const scope = path.join(tempDir, "project") + await fs.mkdir(scope) + const outside = path.join(tempDir, "elsewhere.json") + + // No symlink needed: the check runs on the resolved publish target, so an + // out-of-scope path is rejected on every platform, and it is rejected before the + // lock is taken and before anything is staged. + await expect(safeWriteJson(outside, { mcpServers: {} }, { confineTo: scope })).rejects.toThrow( + ConfinedPathEscapeError, + ) + + const left = await fs.readdir(tempDir) + expect(left).not.toContain("elsewhere.json") + expect(left.filter((entry) => entry.includes(".new_") || entry.endsWith(".lock"))).toEqual([]) + }) + + test.skipIf(process.platform === "win32")( + "rejects a confined write whose symlink resolves outside the confined directory", + async () => { + const projectDir = path.join(tempDir, "project") + await fs.mkdir(projectDir) + const outside = path.join(tempDir, "outside.json") + await fsSyncActual.promises.writeFile(outside, JSON.stringify({ secret: "original" }), "utf8") + // A repository that plants its project settings file as a link to somewhere else + // must not receive the settings write at the linked path. The caller picked + // projectDir/mcp.json from the workspace, so it declares that scope. + const projectConfig = path.join(projectDir, "mcp.json") + await fs.symlink(outside, projectConfig) + + await expect( + safeWriteJson(projectConfig, { mcpServers: {} }, { confineTo: projectDir }), + ).rejects.toThrow(ConfinedPathEscapeError) + + // The linked file is untouched and nothing was staged beside it. + expect(JSON.parse(await fsSyncActual.promises.readFile(outside, "utf8"))).toEqual({ secret: "original" }) + const entries = await fs.readdir(tempDir) + expect(entries).toContain("outside.json") + expect( + entries.filter((entry) => entry.includes(".new_") || entry.includes("safeWriteText") || entry.endsWith(".lock")), + ).toEqual([]) + }, + ) + + test.skipIf(process.platform === "win32")( + "confines a write whose symlink referent stays inside the confined directory", + async () => { + const projectDir = path.join(tempDir, "project-in") + await fs.mkdir(projectDir) + const referent = path.join(projectDir, "real-mcp.json") + await fsSyncActual.promises.writeFile(referent, JSON.stringify({ mcpServers: {} }), "utf8") + const alias = path.join(projectDir, "mcp.json") + await fs.symlink(referent, alias) + + // Confining is about the scope, not about forbidding links: a link that stays + // inside the project still publishes to its referent. + await safeWriteJson(alias, { mcpServers: { local: { url: "http://localhost" } } }, { confineTo: projectDir }) + + expect(JSON.parse(await fsSyncActual.promises.readFile(referent, "utf8"))).toEqual({ + mcpServers: { local: { url: "http://localhost" } }, + }) + }, + ) + + test.skipIf(process.platform === "win32")( + "confines a scope path that itself runs through a symlink and does not exist yet", + async () => { + const real = path.join(tempDir, "real-project") + await fs.mkdir(real) + const alias = path.join(tempDir, "alias-project") + await fs.symlink(real, alias) + // The scope is declared through the alias, and the directory it names does not + // exist yet. Resolving it lexically would compare an unresolved scope against a + // fully resolved target and reject a write that is in fact inside the project - + // the macOS /var -> /private/var shape. The nearest existing ancestor is resolved + // and the remainder re-joined instead. + const nested = path.join(alias, "nested") + const target = path.join(nested, "mcp.json") + + await safeWriteJson(target, { mcpServers: {} }, { confineTo: nested }) + + expect( + JSON.parse(await fsSyncActual.promises.readFile(path.join(real, "nested", "mcp.json"), "utf8")), + ).toEqual({ mcpServers: {} }) + }, + ) + test.skipIf(process.platform === "win32")( "preserves a restrictive 0o600 target mode through the atomic publish", async () => { diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index bae200dd38..ab6f7d145a 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -32,6 +32,78 @@ export interface SafeWriteJsonOptions { * cannot be parsed. */ merge?: (existing: unknown, incoming: unknown) => unknown + + /** + * Restrict the write to a directory. The publish target is resolved through + * symlinks before this check runs, so a caller that picked the path from a + * known scope (a workspace, a project settings directory) can refuse a write + * that a planted symlink would land somewhere else. The check runs before the + * advisory lock is taken and before anything is staged. + */ + confineTo?: string +} + +/** + * Thrown when a write declared with `confineTo` resolves outside that directory. + */ +export class ConfinedPathEscapeError extends Error { + constructor( + readonly requestedPath: string, + readonly resolvedPath: string, + readonly confineTo: string, + ) { + super( + `Refusing to write ${resolvedPath}: it resolves outside the confined directory ${confineTo} (requested ${requestedPath}).`, + ) + this.name = "ConfinedPathEscapeError" + } +} + +/** + * Canonicalize the directory a write is confined to. The publish target is fully + * resolved through symlinks, so the scope has to be resolved the same way or a + * scope path that itself runs through a symlink (macOS /var -> /private/var is the + * common case) would compare lexically against a resolved target and reject every + * legitimate in-scope write. When the scope does not exist yet, the nearest + * existing ancestor is resolved and the remainder re-appended. + */ +async function _resolveScopeRoot(confineTo: string): Promise { + const lexical = path.resolve(confineTo) + try { + return await fs.realpath(lexical) + } catch (error: unknown) { + // Only a missing path means "walk up and re-join". EACCES or ELOOP means the + // scope cannot be canonicalized at all, and continuing would build a partly + // lexical root that can disagree with the canonical target - the failure has to + // surface rather than decide the scope from a guess. + if (_scopeErrorCode(error) !== "ENOENT") { + throw error + } + const missing: string[] = [] + let ancestor = lexical + while (true) { + const parent = path.dirname(ancestor) + if (parent === ancestor) { + return lexical + } + missing.push(path.basename(ancestor)) + ancestor = parent + try { + const real = await fs.realpath(ancestor) + return path.join(real, ...missing.reverse()) + } catch (innerError: unknown) { + if (_scopeErrorCode(innerError) !== "ENOENT") { + throw innerError + } + } + } + } +} + +function _scopeErrorCode(error: unknown): string | undefined { + return typeof error === "object" && error !== null && "code" in error + ? (error as { code?: string }).code + : undefined } /** @@ -89,6 +161,25 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // advisory lock held until the stale timeout for every other writer. resolvedTargetPath = await resolvePublishTarget(absoluteFilePath) + // Confinement, if the caller declared a scope. Both sides are canonicalized the + // same way: the publish target is resolved through symlinks, and a target that + // does not exist yet still carries the alias components of the path it was + // given. This runs before the merge read and before anything is staged, so a + // rejected write leaves nothing behind. + if (options?.confineTo) { + const scopeRoot = await _resolveScopeRoot(options.confineTo) + const resolvedTarget = await _resolveScopeRoot(resolvedTargetPath) + const relative = path.relative(scopeRoot, resolvedTarget) + if ( + relative === "" || + relative === ".." || + relative.startsWith(".." + path.sep) || + path.isAbsolute(relative) + ) { + throw new ConfinedPathEscapeError(absoluteFilePath, resolvedTargetPath, scopeRoot) + } + } + // If a merge callback was provided, read the current file under the lock // and let the caller merge before we write. Must be inside try/finally // so a throwing merge still releases the lock. From b9cfd73dd7a6a053669874a25ede043414eeb6d9 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 12:19:42 +0800 Subject: [PATCH 19/72] fix(file-safety): do not read a failed target lstat as a missing target The staging-identity guard compared the caller-staged file with the target through fs.lstat(targetPath).catch(() => null). Any error other than ENOENT - EACCES, ENOTDIR, ELOOP - was therefore indistinguishable from "there is no target", so a staging path that is a hard link of the target would pass the identity check, reach the commit rename, and let the failure handler unlink the only copy of the content. Only ENOENT now yields "no target"; anything else fails closed with a StagingPathError before anything is opened, staged or renamed. Test: the staging path resolves to a hard link of the target (same ino/dev) and the target lstat rejects with EACCES; the write is rejected with the comparison error and neither openSync nor rename is called. --- .../__tests__/safeWriteText.spec.ts | 25 ++++++++++++++++++- src/services/file-safety/safeWriteText.ts | 10 +++++++- 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 7529305278..8abdbafe8a 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -1122,7 +1122,30 @@ describe("caller-supplied staging path", () => { expect(fs.rename).not.toHaveBeenCalled() expect(fs.unlink).not.toHaveBeenCalled() }) -}) + + + it("rejects when the target identity cannot be compared for a reason other than a missing target", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // A hard-linked staging file shares the target's inode, so the identity comparison is the only thing + // between this write and a rename onto the very file the guard protects. An EACCES from the target + // lstat must not be mistaken for "there is no target". + const stagingStats = _fileStats(false) + stagingStats.ino = 42 + stagingStats.dev = 7 + vi.mocked(fs.lstat).mockImplementation(async (p) => { + if (String(p) === targetPath) { + throw Object.assign(new Error("EACCES"), { code: "EACCES" }) + } + return stagingStats + }) + + await expect( + safeWriteText(targetPath, "data", { tempPath: "/tmp/test-dir/hardlink.txt", platform: "linux" }), + ).rejects.toThrow("Staging file could not be compared with the target") + expect(fsSync.openSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + })}) describe("cleanup when a backed-up write fails before commit", () => { beforeEach(() => mockDefaults()) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index de2207e8b5..b2568524a0 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -261,7 +261,15 @@ export async function safeWriteText( // while it still holds the only copy of the content, so a failed write would // delete the file it was meant to protect. Compare identities, not spellings: // an alias of the target is the same hazard. - const targetStat = await fs.lstat(targetPath).catch(() => null) + // Only a missing target may be skipped. An EACCES/ELOOP/ENOTDIR here means the identity + // comparison could not be made; treating that as "no target" would let a staging alias + // reach the commit rename and let cleanup delete the file the guard protects. + const targetStat = await fs.lstat(targetPath).catch((error: unknown) => { + if (errorCode(error) !== "ENOENT") { + throw new StagingPathError("Staging file could not be compared with the target", supplied) + } + return null + }) if ( targetStat && typeof stagingStat.ino === "number" && From afdd517b20d73f3aa7abbb20c0174a3c30079e3b Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 12:41:08 +0800 Subject: [PATCH 20/72] fix(file-safety): compare staging and target identity with bigint stats The staging-identity guard read fs.Stats.ino/dev as JS numbers. On NTFS and ReFS those identifiers can exceed Number.MAX_SAFE_INTEGER, and the rounding makes two different files look identical - a valid caller-staged file is then rejected with StagingPathError (and a real alias could be missed). Both lstats now request { bigint: true } and the comparison checks for bigint values before comparing them. The spec stand-in carries bigint ino/dev, matching what lstat({ bigint: true }) returns at runtime (fs.BigIntStats is a type-only export, so the double is documented at its single assertion). --- .../__tests__/safeWriteText.spec.ts | 19 +++++++++++++------ src/services/file-safety/safeWriteText.ts | 11 +++++++---- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 8abdbafe8a..a912bb0657 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -67,6 +67,17 @@ function _fileStats(isLink: boolean): fsSync.Stats { return s } +// fs.BigIntStats is a type-only export (fs.BigIntStats is undefined at runtime), so the stand-in is +// a Stats object carrying bigint ino/dev - exactly what fs.lstat(path, { bigint: true }) hands +// back at runtime. +function _fileStatsWithIdentity(ino: bigint, dev: bigint): fsSync.BigIntStats { + // Double assertion: the runtime value is the Stats stand-in, the type is the bigint variant. + const s = _fileStats(false) as unknown as fsSync.BigIntStats + s.ino = ino + s.dev = dev + return s +} + function mockDefaults(): void { vi.resetAllMocks() // After resetAllMocks, vi.fn() returns undefined — restore promise defaults. @@ -1110,9 +1121,7 @@ describe("caller-supplied staging path", () => { // Same inode and device for the supplied staging path and the target: the // failure handler would unlink the only copy of the content, so a failed // write would delete the file it was meant to protect. - const stats = _fileStats(false) - stats.ino = 42 - stats.dev = 7 + const stats = _fileStatsWithIdentity(42n, 7n) vi.mocked(fs.lstat).mockResolvedValue(stats) await expect( @@ -1130,9 +1139,7 @@ describe("caller-supplied staging path", () => { // A hard-linked staging file shares the target's inode, so the identity comparison is the only thing // between this write and a rename onto the very file the guard protects. An EACCES from the target // lstat must not be mistaken for "there is no target". - const stagingStats = _fileStats(false) - stagingStats.ino = 42 - stagingStats.dev = 7 + const stagingStats = _fileStatsWithIdentity(42n, 7n) vi.mocked(fs.lstat).mockImplementation(async (p) => { if (String(p) === targetPath) { throw Object.assign(new Error("EACCES"), { code: "EACCES" }) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index b2568524a0..663af594da 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -250,7 +250,10 @@ export async function safeWriteText( supplied, ) } - const stagingStat = await fs.lstat(supplied) + // BigInt stats: on NTFS/ReFS the file identity can exceed Number.MAX_SAFE_INTEGER, and + // a rounded number makes two different files look identical (rejecting a valid staging + // file) or hides a real alias. + const stagingStat = await fs.lstat(supplied, { bigint: true }) if (stagingStat.isSymbolicLink() || !stagingStat.isFile()) { throw new StagingPathError( `Staging file must be a regular file, not ${stagingStat.isSymbolicLink() ? "a symlink" : "another file type"}`, @@ -264,7 +267,7 @@ export async function safeWriteText( // Only a missing target may be skipped. An EACCES/ELOOP/ENOTDIR here means the identity // comparison could not be made; treating that as "no target" would let a staging alias // reach the commit rename and let cleanup delete the file the guard protects. - const targetStat = await fs.lstat(targetPath).catch((error: unknown) => { + const targetStat = await fs.lstat(targetPath, { bigint: true }).catch((error: unknown) => { if (errorCode(error) !== "ENOENT") { throw new StagingPathError("Staging file could not be compared with the target", supplied) } @@ -272,8 +275,8 @@ export async function safeWriteText( }) if ( targetStat && - typeof stagingStat.ino === "number" && - typeof targetStat.ino === "number" && + typeof stagingStat.ino === "bigint" && + typeof targetStat.ino === "bigint" && stagingStat.ino === targetStat.ino && stagingStat.dev === targetStat.dev ) { From 13c29025816a53c94f94a213b1cab624cfa33828 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 12:58:50 +0800 Subject: [PATCH 21/72] test(file-safety): pin the bigint options in the staging-identity tests The identity stand-in returns bigint identifiers regardless of the options, so the same-file tests could still pass if either lstat dropped { bigint: true } - which is exactly the case that matters on NTFS/ReFS. Both tests now assert that every identity lstat requested bigint stats. The calls are filtered by their options rather than by path spelling: path.resolve prefixes a drive letter to /tmp/... on Windows, so a path filter would only see one of the two reads on that platform. --- .../file-safety/__tests__/safeWriteText.spec.ts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index a912bb0657..b0d08fee7f 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -1129,6 +1129,15 @@ describe("caller-supplied staging path", () => { ).rejects.toThrow(StagingPathError) expect(fsSync.openSync).not.toHaveBeenCalled() expect(fs.rename).not.toHaveBeenCalled() + // The comparison is only sound when both stats are read as bigint: on NTFS/ReFS the file + // identifiers exceed Number.MAX_SAFE_INTEGER. + // Filter on the options, not the spelling: path.resolve prefixes a drive letter on Windows, + // so the two identity reads are the calls that asked for options at all. + const identityLookups = vi.mocked(fs.lstat).mock.calls.filter((c) => c[1] !== undefined) + expect(identityLookups.length).toBeGreaterThanOrEqual(2) + for (const c of identityLookups) { + expect(c[1]).toEqual({ bigint: true }) + } expect(fs.unlink).not.toHaveBeenCalled() }) @@ -1152,6 +1161,13 @@ describe("caller-supplied staging path", () => { ).rejects.toThrow("Staging file could not be compared with the target") expect(fsSync.openSync).not.toHaveBeenCalled() expect(fs.rename).not.toHaveBeenCalled() + // Both identity reads must ask for bigint stats, or the comparison silently falls + // back to rounded numbers on NTFS/ReFS. + const identityLookups = vi.mocked(fs.lstat).mock.calls.filter((c) => c[1] !== undefined) + expect(identityLookups).toHaveLength(2) + for (const c of identityLookups) { + expect(c[1]).toEqual({ bigint: true }) + } })}) describe("cleanup when a backed-up write fails before commit", () => { From 2955c80a1bde50278ad42a00c5070b60a5795a94 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 13:13:27 +0800 Subject: [PATCH 22/72] fix(file-safety): report a Windows replacement whose DACL was not preserved On win32 the DACL of an existing target is saved before the commit rename so it can be reapplied afterwards. Two paths silently skipped that step and still published: - icacls /save failed (saved === false): the dump is cleaned up and the rename proceeds, so the new file inherits different access rights; - fs.access(targetPath) failed with something other than ENOENT (EACCES, ...): the catch treated "cannot check" as "target absent" and skipped DACL handling entirely. Both now report through a new onWarning sink (default console.warn): the write still proceeds - a missing or failing icacls must not leave the user unable to save, which is the documented fallback - but the caller is told the replacement may inherit different access rights instead of discovering it later. Tests: icacls save failure still commits the write and yields exactly one access-rights warning; an EACCES on the target yields the could-not-check warning and no icacls call. Verified as real regression tests - neutralizing the two warn calls makes both fail. 272 passed / 4 skipped locally; tsc and eslint clean. --- .../__tests__/safeWriteText.spec.ts | 37 +++++++++++++++++++ src/services/file-safety/safeWriteText.ts | 36 ++++++++++++++---- 2 files changed, 66 insertions(+), 7 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index b0d08fee7f..a20df2b9f9 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -554,6 +554,43 @@ describe("safeWriteText", () => { expect(execFile).toHaveBeenCalledTimes(1) }) + it("win32: reports that access rights may change when the DACL cannot be saved", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls error"), "", "") + return fakeChild + }) + const warnings: string[] = [] + + await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + + // The write still commits - a failing icacls must not leave the user unable to save - + // but the caller is told the replacement may not carry the old ACL. + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + expect(warnings.filter((m) => m.includes("different access rights"))).toHaveLength(1) + }) + + it("win32: reports when the target cannot be checked for DACL preservation", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The target exists but is not readable: that is not "absent", and skipping DACL + // preservation has to be visible. + vi.mocked(fs.access).mockImplementation(async (p) => { + if (String(p) === targetPath) { + throw Object.assign(new Error("EACCES"), { code: "EACCES" }) + } + }) + const warnings: string[] = [] + + await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + + expect(execFile).not.toHaveBeenCalled() + expect(warnings.filter((m) => m.includes("Could not check"))).toHaveLength(1) + }) + it("win32 DACL: a partial dump left by a failed save is removed and never restored", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 663af594da..fbdd2feaef 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -27,6 +27,14 @@ export interface SafeWriteTextOptions { */ execFileRunner?: typeof execFile + /** + * Sink for non-fatal safety notices. A Windows DACL that could not be captured means the + * committed file may inherit different access rights: the write still proceeds (a missing or + * failing icacls must not block saving), but the caller is told instead of the change being + * silent. Defaults to console.warn. + */ + onWarning?: (message: string) => void + /** * Pre-written temp path to use for the commit phase. When provided, * safeWriteText skips creating its own staging file and uses this path @@ -264,9 +272,10 @@ export async function safeWriteText( // while it still holds the only copy of the content, so a failed write would // delete the file it was meant to protect. Compare identities, not spellings: // an alias of the target is the same hazard. - // Only a missing target may be skipped. An EACCES/ELOOP/ENOTDIR here means the identity - // comparison could not be made; treating that as "no target" would let a staging alias - // reach the commit rename and let cleanup delete the file the guard protects. + // Only a missing target may be skipped: an EACCES/ELOOP/ENOTDIR here means the + // identity comparison could not be made, and treating that as "no target" would let a + // staging alias reach the commit and let cleanup delete the file it was meant to + // protect. const targetStat = await fs.lstat(targetPath, { bigint: true }).catch((error: unknown) => { if (errorCode(error) !== "ENOENT") { throw new StagingPathError("Staging file could not be compared with the target", supplied) @@ -367,9 +376,15 @@ export async function safeWriteText( // -- Step 2 (win32): save DACL BEFORE the backup copy ----------- const platform = options?.platform ?? process.platform + const warn = options?.onWarning ?? ((message: string) => console.warn(message)) if (platform === "win32") { + let accessError: unknown = null try { await fs.access(targetPath) // target exists? + } catch (error: unknown) { + accessError = error + } + if (accessError === null) { const dumpPath = _tempName(dirPath, "safeWriteText.acl") const saved = await _saveDaclWindows(targetPath, dumpPath, options?.execFileRunner) if (saved) { @@ -381,13 +396,20 @@ export async function safeWriteText( // remove it now (best-effort) so no partial dump survives and // no later step can restore from it. await fs.unlink(dumpPath).catch(() => {}) + // The target exists and its DACL could not be captured, so the commit rename + // replaces it with a file that inherits different access rights. The write still + // proceeds - a missing or failing icacls must not leave the user unable to save - + // but the replacement is no longer ACL-identical and that has to be visible + // instead of silent. + warn(`Could not save the DACL of ${targetPath}; the replacement may inherit different access rights.`) } - } catch { - // target does not exist or access failed — no DACL handling - daclDumpPath = null + } else if (errorCode(accessError) !== "ENOENT") { + // Not "absent": the target is there but could not be checked (EACCES, ...), so + // DACL preservation was skipped for a reason the caller cannot infer from the + // successful write alone. + warn(`Could not check ${targetPath} for DACL preservation (${errorCode(accessError) ?? "unknown error"}); the replacement may inherit different access rights.`) } } - try { // -- Step 3 (backup:true): durable copy target -> backup ---- if (options?.backup) { From a6dc245de345741242ac7dd47035f67a6c08a3f4 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 14:47:18 +0800 Subject: [PATCH 23/72] fix(file-safety): keep DACL warning delivery from failing the save onWarning is documented as the sink for non-fatal safety notices, but delivery was not isolated from the write: an onWarning callback that threw propagated to the outer failure handler before fs.rename, turning a non-fatal notice into a failed save. The warn binding now catches callback failures and logs them. The restore-failure notice is routed through the same binding so a caller supplying onWarning receives it. Same fix as the u6 unit, kept aligned across the series. Local: safeWriteText 58/58 green; eslint clean, no suppression growth. --- .../__tests__/safeWriteText.spec.ts | 22 +++++++++++++++++++ src/services/file-safety/safeWriteText.ts | 16 ++++++++++++-- 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index a20df2b9f9..b658cca80a 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -591,6 +591,28 @@ describe("safeWriteText", () => { expect(warnings.filter((m) => m.includes("Could not check"))).toHaveLength(1) }) + // Warning delivery is advisory: it must not be able to fail the save it is reporting on. + it("win32: a throwing onWarning does not abort the write", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls error"), "", "") + return fakeChild + }) + + await expect( + safeWriteText(targetPath, "data", { + platform: "win32", + onWarning: () => { + throw new Error("callback down") + }, + }), + ).resolves.toBeUndefined() + + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + }) + it("win32 DACL: a partial dump left by a failed save is removed and never restored", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index fbdd2feaef..7978b3fa8e 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -376,7 +376,19 @@ export async function safeWriteText( // -- Step 2 (win32): save DACL BEFORE the backup copy ----------- const platform = options?.platform ?? process.platform - const warn = options?.onWarning ?? ((message: string) => console.warn(message)) + // Warning delivery must never abort the write: the notices below describe a + // committed-but-imperfect publish, and a caller whose callback throws (a UI sink, + // a logger that is mid-restart) must not turn that into a failed save. + const warn = (message: string) => { + try { + const sink = options?.onWarning ?? ((m: string) => console.warn(m)) + sink(message) + } catch (error: unknown) { + console.warn( + `safeWriteText: onWarning callback failed: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } if (platform === "win32") { let accessError: unknown = null try { @@ -495,7 +507,7 @@ export async function safeWriteText( // temp directory restore fails with "Not all privileges or groups referenced // are assigned to the caller"), so the change of access rights is reported // rather than thrown. - console.warn(`safeWriteText: content committed at ${targetPath}, but the saved DACL could not be restored from ${daclDumpPath}; the file may carry different access rights than the one it replaced.`) + warn(`safeWriteText: content committed at ${targetPath}, but the saved DACL could not be restored from ${daclDumpPath}; the file may carry different access rights than the one it replaced.`) } } From bfff215ef93bea1460a449108b0a3448da456e44 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 15:44:35 +0800 Subject: [PATCH 24/72] fix(utils): check confinement before taking the advisory lock proper-lockfile creates ${lockKey}.lock beside the lock key, and the key is the symlink referent. A repository that plants .roo/mcp.json -> ~/.ssh/config therefore made a confined write create a lock directory OUTSIDE the declared scope, and when that directory was not writable the caller got a lock-acquisition error after up to five retries instead of ConfinedPathEscapeError. The confinement check now runs on the lock key before acquireFileLock and is repeated on the resolved publish target inside the lock (a peer writer may have moved the referent in between); both checks share _assertWithinScope so they canonicalize identically. Ported across the file-safety unit series so every unit that declares a scope carries the same guarantee (same fix as fws/u3-observation-completeness). --- src/utils/__tests__/safeWriteJson.test.ts | 31 +++++++++++++++++ src/utils/safeWriteJson.ts | 41 +++++++++++++++++------ 2 files changed, 62 insertions(+), 10 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 9393774a25..516d1bd658 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -764,4 +764,35 @@ describe("safeWriteJson", () => { expect(await readFileContent(currentTestFilePath)).toEqual({ after: true }) }, ) + + // Ordering matters for the security guarantee: proper-lockfile creates + // ${lockKey}.lock beside the lock key, and the key is the symlink referent. If + // confinement were checked only after the lock, an out-of-scope target would first + // create a lock directory outside the scope. A lock mock that throws if reached + // proves the check runs first. Written without symlinks so it runs on every lane. + test("rejects an out-of-scope target before the advisory lock is taken", async () => { + vi.resetModules() + const projectDir = path.join(tempDir, "order-project-plain") + await fs.mkdir(projectDir) + const outside = path.join(tempDir, "order-outside-plain.json") + + const realLockfile = await vi.importActual("proper-lockfile") + const lockMockFn = vi.fn(async () => { + throw new Error("lock taken for an out-of-scope target (test)") + }) + vi.doMock("proper-lockfile", () => ({ ...realLockfile, lock: lockMockFn })) + const { safeWriteJson: lockedSafeWriteJson } = await import("../safeWriteJson") + + try { + await expect(lockedSafeWriteJson(outside, { mcpServers: {} }, { confineTo: projectDir })).rejects.toThrow( + /resolves outside the confined directory/, + ) + expect(lockMockFn).not.toHaveBeenCalled() + const entries = await fs.readdir(tempDir) + expect(entries.filter((entry) => entry.endsWith(".lock") || entry.includes(".new_"))).toEqual([]) + } finally { + vi.doUnmock("proper-lockfile") + vi.resetModules() + } + }) }) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index ab6f7d145a..2be5695241 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -100,6 +100,24 @@ async function _resolveScopeRoot(confineTo: string): Promise { } } +/** + * Reject a candidate publish path that escapes the caller's confined scope. + * Shared by the pre-lock check and the in-lock check so both canonicalize the + * same way: the candidate is resolved through symlinks and compared against the + * resolved scope root. + */ +function _assertWithinScope(requestedPath: string, candidatePath: string, scopeRoot: string): void { + const relative = path.relative(scopeRoot, candidatePath) + if ( + relative === "" || + relative === ".." || + relative.startsWith(".." + path.sep) || + path.isAbsolute(relative) + ) { + throw new ConfinedPathEscapeError(requestedPath, candidatePath, scopeRoot) + } +} + function _scopeErrorCode(error: unknown): string | undefined { return typeof error === "object" && error !== null && "code" in error ? (error as { code?: string }).code @@ -146,6 +164,18 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // back), so the walk tolerates a dangling link instead of rejecting it here. const lockKey = await resolveLockKey(absoluteFilePath) + // Confinement, if the caller declared a scope, is checked BEFORE the lock is + // taken: proper-lockfile creates ${lockKey}.lock beside the lock key, and the key + // is the symlink referent, so a repository-planted link out of the scope would + // otherwise create a lock directory outside the scope (and an unwritable referent + // directory would surface a lock-acquisition error after retries instead of + // ConfinedPathEscapeError). Repeated on the resolved publish target inside the + // lock, since a peer writer may move the referent in between. + if (options?.confineTo) { + const scopeRoot = await _resolveScopeRoot(options.confineTo) + _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(lockKey), scopeRoot) + } + // Acquire the lock before any file operations. If acquisition fails it throws // immediately, and releaseLock stays a no-op so the finally block does not try // to release an unacquired lock. @@ -168,16 +198,7 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // rejected write leaves nothing behind. if (options?.confineTo) { const scopeRoot = await _resolveScopeRoot(options.confineTo) - const resolvedTarget = await _resolveScopeRoot(resolvedTargetPath) - const relative = path.relative(scopeRoot, resolvedTarget) - if ( - relative === "" || - relative === ".." || - relative.startsWith(".." + path.sep) || - path.isAbsolute(relative) - ) { - throw new ConfinedPathEscapeError(absoluteFilePath, resolvedTargetPath, scopeRoot) - } + _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(resolvedTargetPath), scopeRoot) } // If a merge callback was provided, read the current file under the lock From 677478fee1727e4f17d713101464147c221545d5 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 16:34:08 +0800 Subject: [PATCH 25/72] fix(file-safety): handle async warning sinks and confine before mkdir Series alignment for the two review findings fixed on fws/u6-apply-patch-wiring: 1. safeWriteText's warn wrapper could not catch a rejection from an async onWarning sink - TypeScript accepts a value-returning callback where a void one is expected - so the rejected promise was left unhandled, which under Node's default mode can end the process after a write that already succeeded. The wrapper now attaches a catch handler without awaiting (awaiting would let warning delivery delay a committed write, or stall it on a hung sink) and reports the rejection through the fallback sink. 2. safeWriteJson created the target's parent directory BEFORE the preflight confinement check, so a confined write to an out-of-scope path with a missing parent still created a directory outside confineTo. resolveLockKey and the check need no directory to exist, so the order is now lock key, confinement, mkdir; the in-lock check on the resolved publish target stays. --- .../__tests__/safeWriteText.spec.ts | 32 +++++++++++++++++++ src/services/file-safety/safeWriteText.ts | 20 +++++++++--- src/utils/__tests__/safeWriteJson.test.ts | 17 ++++++++++ src/utils/safeWriteJson.ts | 21 ++++++------ 4 files changed, 77 insertions(+), 13 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index b658cca80a..351f13c63e 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -281,6 +281,38 @@ describe("safeWriteText", () => { }) }) + it("win32: a rejecting async onWarning does not abort the write or leak an unhandled rejection", async () => { + // TypeScript accepts an async sink where a void callback is expected, so the + // wrapper has to attach a handler to the returned promise: an unhandled + // rejection can end the process under Node's default mode, after a write that + // already succeeded. + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls error"), "", "") + return fakeChild + }) + const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {}) + + await expect( + safeWriteText(targetPath, "data", { + platform: "win32", + onWarning: async () => { + throw new Error("async sink down") + }, + }), + ).resolves.toBeUndefined() + + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + // The rejection is reported through the fallback sink rather than surfacing as an + // unhandled rejection. + expect(consoleWarn).toHaveBeenCalledWith( + expect.stringContaining("onWarning callback rejected"), + ) + consoleWarn.mockRestore() + }) + // ── Test 2: fsync ordering ─────────────────────────────────────────────── describe("fsync ordering", () => { diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 7978b3fa8e..f0295b9c56 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -380,13 +380,25 @@ export async function safeWriteText( // committed-but-imperfect publish, and a caller whose callback throws (a UI sink, // a logger that is mid-restart) must not turn that into a failed save. const warn = (message: string) => { + const report = (label: string, error: unknown) => { + console.warn( + `safeWriteText: onWarning callback ${label}: ${error instanceof Error ? error.message : String(error)}`, + ) + } try { const sink = options?.onWarning ?? ((m: string) => console.warn(m)) - sink(message) + const result: unknown = sink(message) + // A sink may be async - TypeScript accepts a value-returning callback where + // a void one is expected. Awaiting it would let warning delivery delay a + // write that has already committed (and hang it if the sink never settles), + // while leaving the promise unhandled turns a rejection into an unhandled + // rejection, which under Node's default mode can end the process after a + // successful write. Attach a handler without awaiting. + if (result instanceof Promise) { + result.catch((error: unknown) => report("rejected", error)) + } } catch (error: unknown) { - console.warn( - `safeWriteText: onWarning callback failed: ${error instanceof Error ? error.message : String(error)}`, - ) + report("failed", error) } } if (platform === "win32") { diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 516d1bd658..1d124a6c16 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -795,4 +795,21 @@ describe("safeWriteJson", () => { vi.resetModules() } }) + + test("does not create the parent directory of an out-of-scope confined target", async () => { + const projectDir = path.join(tempDir, "scope-dir-project") + await fs.mkdir(projectDir) + // The parent does not exist yet: the mkdir in safeWriteJson would create it - + // a filesystem change outside confineTo - before the confinement check rejected + // the write. + const outside = path.join(tempDir, "scope-missing-parent", "nested.json") + + await expect(safeWriteJson(outside, { mcpServers: {} }, { confineTo: projectDir })).rejects.toThrow( + /resolves outside the confined directory/, + ) + + const entries = await fs.readdir(tempDir) + expect(entries).not.toContain("scope-missing-parent") + expect(entries.filter((entry) => entry.endsWith(".lock") || entry.includes(".new_"))).toEqual([]) + }) }) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 2be5695241..a9d8fd6164 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -150,14 +150,6 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // the target when the resolution itself rejects. let resolvedTargetPath: string | undefined - try { - await fs.mkdir(dirPath, { recursive: true }) - await fs.access(dirPath) - } catch (dirError: any) { - console.error(`Failed to create or access directory for ${absoluteFilePath}:`, dirError) - throw dirError - } - // Lock key: the symlink referent when the path is an existing symlink, so a // symlink alias and its referent share one lock. The key must be computable // while a peer writer is mid-commit (backup mode renames the referent away and @@ -165,6 +157,8 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso const lockKey = await resolveLockKey(absoluteFilePath) // Confinement, if the caller declared a scope, is checked BEFORE the lock is + // Also before the parent-directory creation below: an out-of-scope target with a + // missing parent would otherwise get a directory created outside confineTo. // taken: proper-lockfile creates ${lockKey}.lock beside the lock key, and the key // is the symlink referent, so a repository-planted link out of the scope would // otherwise create a lock directory outside the scope (and an unwritable referent @@ -176,7 +170,16 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(lockKey), scopeRoot) } - // Acquire the lock before any file operations. If acquisition fails it throws + try { + await fs.mkdir(dirPath, { recursive: true }) + await fs.access(dirPath) + } catch (dirError: any) { + console.error(`Failed to create or access directory for ${absoluteFilePath}:`, dirError) + throw dirError + } + + + // immediately, and releaseLock stays a no-op so the finally block does not try // to release an unacquired lock. releaseLock = await acquireFileLock(lockKey) From bcce2c31e5c60db96f7ce4b6e0eda5182178e917 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Wed, 7 Oct 2026 20:40:06 +0800 Subject: [PATCH 26/72] test(file-safety,utils): cover the commit-rename failure and unmock with doUnmock - safeWriteText.integration.spec: the backup:true case bails out in the backup step (copyfile over a directory), so the commit rename never runs and a regression in commit-failure cleanup would pass. Added the backup:false case, which is the shape that reaches Step 4: the rename of the staging file over the target directory fails and the staging file must be cleaned up. - safeWriteJson.test: the finally blocks removed a vi.doMock registration with vi.unmock, which vitest hoists to the top of the file, so the cleanup did not undo the registration where it was written. Both sites now use vi.doUnmock, the non-hoisted counterpart. Verified the two paths are distinct by calling safeWriteText against a real directory target: backup:true fails at copyfile, backup:false fails at rename of the staging file. Local: 29 passed / 4 skipped across the two specs; eslint clean on both files. --- .../__tests__/safeWriteText.integration.spec.ts | 17 +++++++++++++++++ src/utils/__tests__/safeWriteJson.test.ts | 11 ++++++----- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts b/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts index 81d758349e..cfec2e0520 100644 --- a/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts @@ -46,4 +46,21 @@ describe("safeWriteText against a real filesystem", () => { expect(await fs.readFile(inside, "utf8")).toBe("original bytes") expect(await fs.readdir(dir)).toEqual(["target-dir"]) }) + + it("cleans up the staging file when the commit rename itself fails", async () => { + // With backup:false the backup step is skipped, so this is the only shape of + // this scenario that reaches Step 4: the rename of the staging FILE over the + // target DIRECTORY fails (EISDIR / ENOTDIR / EPERM depending on platform), and + // the cleanup must remove the staging file. The backup:true case above bails + // out in the backup step and never exercises the commit-failure path. + const targetPath = path.join(dir, "target-dir") + await fs.mkdir(targetPath) + const inside = path.join(targetPath, "payload.txt") + await fs.writeFile(inside, "original bytes") + + await expect(safeWriteText(targetPath, "new data", { backup: false })).rejects.toThrow() + + expect(await fs.readFile(inside, "utf8")).toBe("original bytes") + expect(await fs.readdir(dir)).toEqual(["target-dir"]) + }) }) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 1d124a6c16..9870fc74c9 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -379,7 +379,7 @@ describe("safeWriteJson", () => { // Clean up await fs.unlink(lockTestFilePath).catch(() => {}) // Ignore errors if file doesn't exist - vi.unmock("proper-lockfile") // Ensure the mock is removed after this test + vi.doUnmock("proper-lockfile") // Non-hoisted counterpart of the vi.doMock above }) test("should release lock even if an error occurs mid-operation", async () => { const data = { message: "test lock release on error" } @@ -651,11 +651,12 @@ describe("safeWriteJson", () => { expect.any(Error), ) } finally { - // Cleanup must run even when an assertion fails: a leaked mock - // registration or console spy changes later tests, and vi.unmock - // alone does not reset a module that already imported the mock. + // Cleanup must run even when an assertion fails: a leaked mock registration + // or console spy changes later tests. vi.doUnmock is the non-hoisted counterpart + // of the vi.doMock above; vi.unmock is hoisted to the top of the file, so it would + // not undo this registration from here. realpathSpy.mockRestore() - vi.unmock("proper-lockfile") + vi.doUnmock("proper-lockfile") vi.resetModules() consoleErrorSpy.mockRestore() } From 4291ced2315685ca72d35972c674852d614caf38 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Thu, 8 Oct 2026 16:36:00 +0800 Subject: [PATCH 27/72] test(task): pin that each Task owns its observation registry Task.ts initializes the registry per Task, but nothing read it off a real Task: the registry tests exercise standalone instances and ReadFileTool's spec injects its own double, so the wiring itself was unverified - a Task that never built a registry, or shared one across Tasks, would pass every existing test while silently dropping read observations. The new test constructs a real Task and asserts observationRegistry is an ObservationRegistry, that a second Task gets a different instance, and that an observation recorded on one Task is invisible to the other (parent and subtask authority over a file must stay separate). Local: Task.dispose.test.ts 15 passed; eslint clean; no new tsc diagnostics in this file. --- src/core/task/__tests__/Task.dispose.test.ts | 28 ++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/core/task/__tests__/Task.dispose.test.ts b/src/core/task/__tests__/Task.dispose.test.ts index 606568b923..c7175e4f8d 100644 --- a/src/core/task/__tests__/Task.dispose.test.ts +++ b/src/core/task/__tests__/Task.dispose.test.ts @@ -3,6 +3,7 @@ import path from "node:path" import { type ProviderSettings, RooCodeEventName } from "@roo-code/types" import { Task } from "../Task" +import { ObservationRegistry } from "../observationRegistry" import { ClineProvider } from "../../webview/ClineProvider" import { OutputInterceptor } from "../../../integrations/terminal/OutputInterceptor" import { providerIdentifiers } from "@roo-code/types/provider-identifiers" @@ -118,6 +119,33 @@ describe("Task dispose method", () => { expect(disposalComplete).toBe(true) }) + test("owns a per-Task observation registry", () => { + // ReadFileTool and the guarded-write path reach the registry only through the Task, + // so a Task that never built one - or shared one across Tasks - would silently drop + // read observations. The registry's own tests only exercise standalone instances, and + // the tool tests inject their own doubles, so nothing else pins this wiring. + expect(task.observationRegistry).toBeInstanceOf(ObservationRegistry) + + const other = new Task({ + provider: mockProvider as unknown as ClineProvider, + apiConfiguration: mockApiConfiguration, + startTask: false, + }) + try { + expect(other.observationRegistry).toBeInstanceOf(ObservationRegistry) + expect(other.observationRegistry).not.toBe(task.observationRegistry) + + // Observing in one Task must not be visible from another: parent and subtask + // authority over a file has to stay separate. + other.observationRegistry.observe("/workspace/a.ts", "v1", true) + expect(other.observationRegistry.get("/workspace/a.ts")?.version).toBe("v1") + expect(task.observationRegistry.has("/workspace/a.ts")).toBe(false) + expect(task.observationRegistry.size).toBe(0) + } finally { + void other.dispose().catch(() => {}) + } + }) + test("should reject the memoized completion promise when disposal cannot start", async () => { const disposalError = new Error("disposal failed") skipCleanup = true From 40b9c3967f43bdb58a085957a1e01585f8b9035e Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Thu, 8 Oct 2026 22:48:31 +0800 Subject: [PATCH 28/72] fix(mcp): confine project MCP writes to the workspace root Security Boundaries: safeWriteJson resolves the publish target through realpath before staging beside it, so a repository that ships .roo/mcp.json as a symlink to a file OUTSIDE the workspace has that outside file replaced as soon as the user edits a project MCP setting, deletes a server, or toggles tool always-allow. The three project-capable write sites passed no confinement option, and the base implementation renamed the link itself, so the external write is introduced here. confineForMcpWrite(source) returns the provider cwd (falling back to getWorkspacePath) for project writes and undefined for global ones - global settings live in the user's own settings directory, which is deliberately not confined. All three sites now pass it, so the write fails closed with ConfinedPathEscapeError instead of touching the referent. This is the same change as 256091d3c on fws/u3-observation-completeness (#1912); the unit branches are not cumulative, so every branch that carries the writer needs its own copy. Regression Evidence: the per-Task registry now fails closed on teardown too - disposeOnce() clears it, so a disposed Task still reachable through a parent/subtask reference cannot hand a token captured before teardown to a guarded write. Two McpHub tests pin the call sites (a project-scoped allowlist write carries confineTo = workspace root, a global one does not) and a Task.dispose test pins the clear. The two-real-Task registry test added in 87986e9b4 already covers the distinctness the checklist row asked for. Local: vitest McpHub + Task.dispose 89 passed. Negative controls: helper mutated to return undefined -> project confine test fails; clear() commented out -> disposal test fails; both restore green. tsc --noEmit 50 errors before and after the change (unchanged branch baseline). eslint 0 errors / 0 warnings on all four files, no suppression entry added or increased. --- src/core/task/Task.ts | 7 +++ src/core/task/__tests__/Task.dispose.test.ts | 15 ++++++ src/services/mcp/McpHub.ts | 32 ++++++++++-- src/services/mcp/__tests__/McpHub.spec.ts | 55 ++++++++++++++++++++ 4 files changed, 106 insertions(+), 3 deletions(-) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index 9ccc2d7968..0fa9f315c6 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -3566,6 +3566,13 @@ export class Task extends EventEmitter implements TaskLike { console.error("Error removing event listeners:", error) } + // A disposed task is no longer authoritative for what it read. The registry holds + // version tokens captured while the task was alive, and a disposed task can still be + // reachable through a parent/subtask reference; a guarded write must not accept one of + // those tokens for a file this task has not re-read since. Clearing also stops a long + // task from pinning every file it ever read. + this.observationRegistry.clear() + // Release any terminals associated with this task. try { // Release any terminals associated with this task. diff --git a/src/core/task/__tests__/Task.dispose.test.ts b/src/core/task/__tests__/Task.dispose.test.ts index c7175e4f8d..08c9d07a5c 100644 --- a/src/core/task/__tests__/Task.dispose.test.ts +++ b/src/core/task/__tests__/Task.dispose.test.ts @@ -146,6 +146,21 @@ describe("Task dispose method", () => { } }) + test("clears the per-Task observation registry on disposal", async () => { + // The registry holds on-disk version tokens for files this task read. Disposal does not + // free the Task object - a parent or subtask reference can outlive it - so a token + // captured before teardown must not survive as authority for a guarded write. + task.observationRegistry.observe("/workspace/a.ts", "v1", true) + task.observationRegistry.observe("/workspace/b.ts", "v2", false) + expect(task.observationRegistry.size).toBe(2) + + await task.dispose() + + expect(task.observationRegistry.size).toBe(0) + expect(task.observationRegistry.has("/workspace/a.ts")).toBe(false) + expect(task.observationRegistry.get("/workspace/b.ts")).toBeUndefined() + }) + test("should reject the memoized completion promise when disposal cannot start", async () => { const disposalError = new Error("disposal failed") skipCleanup = true diff --git a/src/services/mcp/McpHub.ts b/src/services/mcp/McpHub.ts index 5e608fec73..f8f74e1bd0 100644 --- a/src/services/mcp/McpHub.ts +++ b/src/services/mcp/McpHub.ts @@ -633,6 +633,23 @@ export class McpHub { } } + /** + * The root a project-scoped MCP write has to stay inside. + * + * safeWriteJson resolves the publish target with realpath before staging beside it, so a + * repository that ships .roo/mcp.json as a symlink to a file OUTSIDE the workspace would + * have that outside file replaced as soon as the user edits a project MCP setting or + * allowlist. Passing the canonical workspace root as confineTo makes the write fail closed + * instead. Global writes are deliberately unconstrained: they target the user's own + * settings directory, which is not under the workspace. + */ + private confineForMcpWrite(source: "global" | "project"): string | undefined { + if (source !== "project") { + return undefined + } + return this.providerRef.deref()?.cwd ?? getWorkspacePath() + } + // Initialize project-level MCP servers private async initializeProjectMcpServers(): Promise { await this.initializeMcpServers("project") @@ -2066,7 +2083,10 @@ export class McpHub { } this.isProgrammaticUpdate = true try { - await safeWriteJson(configPath, updatedConfig, { prettyPrint: true }) + await safeWriteJson(configPath, updatedConfig, { + prettyPrint: true, + confineTo: this.confineForMcpWrite(source), + }) } finally { // Reset flag after watcher debounce period (non-blocking) this.flagResetTimer = setTimeout(() => { @@ -2151,7 +2171,10 @@ export class McpHub { mcpServers: config.mcpServers, } - await safeWriteJson(configPath, updatedConfig, { prettyPrint: true }) + await safeWriteJson(configPath, updatedConfig, { + prettyPrint: true, + confineTo: this.confineForMcpWrite(serverSource), + }) // Update server connections with the correct source await this.updateServerConnections(config.mcpServers, serverSource) @@ -2360,7 +2383,10 @@ export class McpHub { } this.isProgrammaticUpdate = true try { - await safeWriteJson(normalizedPath, config, { prettyPrint: true }) + await safeWriteJson(normalizedPath, config, { + prettyPrint: true, + confineTo: this.confineForMcpWrite(source), + }) } finally { // Reset flag after watcher debounce period (non-blocking) this.flagResetTimer = setTimeout(() => { diff --git a/src/services/mcp/__tests__/McpHub.spec.ts b/src/services/mcp/__tests__/McpHub.spec.ts index 31ffc0ea60..29fddd2776 100644 --- a/src/services/mcp/__tests__/McpHub.spec.ts +++ b/src/services/mcp/__tests__/McpHub.spec.ts @@ -3,6 +3,8 @@ import * as path from "path" import type { Mock } from "vitest" import type { ExtensionContext, Uri } from "vscode" +import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js" +import { Client } from "@modelcontextprotocol/sdk/client/index.js" import type { ClineProvider } from "../../../core/webview/ClineProvider" @@ -994,6 +996,59 @@ describe("McpHub", () => { }) describe("toggleToolAlwaysAllow", () => { + // A fully typed double: the SDK constructors are mocked at the top of the file, so + // no cast is needed to build a connected connection here. + const projectConnection = (source: "global" | "project" = "project"): ConnectedMcpConnection => ({ + type: "connected", + server: { + name: "test-server", + config: JSON.stringify({ type: "stdio", command: "node", args: ["test.js"], alwaysAllow: [] }), + status: "connected", + source, + errorHistory: [], + }, + client: new Client({ name: "test-client", version: "1.0.0" }), + transport: new StdioClientTransport({ command: "node", args: ["test.js"] }), + }) + + it("confines a project-scoped allowlist write to the workspace root", async () => { + // A repository can ship .roo/mcp.json as a symlink to a file outside the workspace. + // safeWriteJson resolves the publish target before staging, so without confinement an + // allowlist edit would replace that outside file. The workspace root has to be handed + // over as confineTo so the write fails closed instead. + // cwd is a read-only getter on ClineProvider, so the test installs the value. + Object.defineProperty(mockProvider, "cwd", { value: "/mock/workspace", configurable: true }) + vi.mocked(fs.readFile).mockResolvedValueOnce( + JSON.stringify({ + mcpServers: { + "test-server": { type: "stdio", command: "node", args: ["test.js"], alwaysAllow: [] }, + }, + }), + ) + mcpHub.connections = [projectConnection()] + + await mcpHub.toggleToolAlwaysAllow("test-server", "project", "new-tool", true) + + const write = vi.mocked(safeWriteJson).mock.calls.find((call) => String(call[0]).includes("mcp.json")) + expect(write).toBeDefined() + expect(write![2]).toEqual(expect.objectContaining({ confineTo: "/mock/workspace" })) + }) + + it("leaves a global-scoped allowlist write unconstrained", async () => { + // Global settings live in the user's own settings directory, which is not under the + // workspace; confining them would break every global edit. + Object.defineProperty(mockProvider, "cwd", { value: "/mock/workspace", configurable: true }) + mcpHub.connections = [projectConnection("global")] + + await mcpHub.toggleToolAlwaysAllow("test-server", "global", "another-tool", true) + + const write = vi.mocked(safeWriteJson).mock.calls.find((call) => String(call[0]).includes("mcp")) + expect(write).toBeDefined() + // undefined confineTo is the unconstrained case: safeWriteJson only checks the path + // when a confinement root is supplied. + expect(write![2]?.confineTo).toBeUndefined() + }) + it("should add tool to always allow list when enabling", async () => { const mockConfig = { mcpServers: { From d5ff976910b89ab77693f1ffefa866ce60df4716 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Thu, 8 Oct 2026 23:14:48 +0800 Subject: [PATCH 29/72] fix(task,tools): retire the observation registry on disposal and pin every MCP confine site Lifecycle Resource Cleanup: disposeOnce() cleared the registry, but a read that was already awaiting fs.readFile when disposal began resumed afterwards and recorded the file again - the disposed Task was authoritative once more, and it kept doing the new post-read stat work for a turn that will never be acted on. ObservationRegistry.close() now drops the entries AND refuses later observations, Task.disposeOnce() calls close(), and both ReadFileTool paths skip the post-read stat + observe work when task.abort is set (checked before the awaited stat, not after it). Regression Evidence: the confinement fix touched three call sites but only toggleToolAlwaysAllow was pinned. updateServerTimeout and deleteServer now have a project case (confineTo = workspace root) and a global case (confineTo undefined) each; the connection double is shared at describe scope so all four sites use one typed fixture. safeWriteJson is mocked in this file, so a lower-level writer test cannot see a missing MCP argument - each call site has to be pinned here. Tests: 2 closure tests (close drops entries and reports closed; observe is a no-op after close), 2 aborted-task tests (native and legacy path record nothing), 4 call-site confinement tests, and the disposal test extended to assert the registry stays empty when a late observation arrives. Local: 203 passed across readFileTool, McpHub, Task.dispose and observationRegistry. Negative controls, each mutate -> test fails -> restore -> passes: ReadFileTool guard neutered, ObservationRegistry closure guard neutered (fails both the registry spec and the Task disposal test), and close() downgraded to clear() (fails the disposal test). tsc --noEmit 50 errors before and after (unchanged branch baseline, 0 in touched files). eslint 0 errors / 0 warnings across all 8 touched files; no suppression entry changed. --- src/core/task/Task.ts | 2 +- src/core/task/__tests__/Task.dispose.test.ts | 7 ++ .../__tests__/observationRegistry.spec.ts | 24 +++++ src/core/task/observationRegistry.ts | 25 +++++ src/core/tools/ReadFileTool.ts | 29 ++++-- src/core/tools/__tests__/readFileTool.spec.ts | 76 +++++++++++++- src/services/mcp/__tests__/McpHub.spec.ts | 99 ++++++++++++++++--- 7 files changed, 236 insertions(+), 26 deletions(-) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index 0fa9f315c6..5033076200 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -3571,7 +3571,7 @@ export class Task extends EventEmitter implements TaskLike { // reachable through a parent/subtask reference; a guarded write must not accept one of // those tokens for a file this task has not re-read since. Clearing also stops a long // task from pinning every file it ever read. - this.observationRegistry.clear() + this.observationRegistry.close() // Release any terminals associated with this task. try { diff --git a/src/core/task/__tests__/Task.dispose.test.ts b/src/core/task/__tests__/Task.dispose.test.ts index 08c9d07a5c..8bc06c9ff5 100644 --- a/src/core/task/__tests__/Task.dispose.test.ts +++ b/src/core/task/__tests__/Task.dispose.test.ts @@ -159,6 +159,13 @@ describe("Task dispose method", () => { expect(task.observationRegistry.size).toBe(0) expect(task.observationRegistry.has("/workspace/a.ts")).toBe(false) expect(task.observationRegistry.get("/workspace/b.ts")).toBeUndefined() + + // A read that was still awaiting I/O when disposal began resumes afterwards. Its + // observation must not land in a retired registry, or the disposed Task would be + // authoritative for that file again. + expect(task.observationRegistry.closed).toBe(true) + task.observationRegistry.observe("/workspace/late.ts", "v3", true) + expect(task.observationRegistry.size).toBe(0) }) test("should reject the memoized completion promise when disposal cannot start", async () => { diff --git a/src/core/task/__tests__/observationRegistry.spec.ts b/src/core/task/__tests__/observationRegistry.spec.ts index a3c55ebc6d..a7813fc2bb 100644 --- a/src/core/task/__tests__/observationRegistry.spec.ts +++ b/src/core/task/__tests__/observationRegistry.spec.ts @@ -105,4 +105,28 @@ describe("ObservationRegistry", () => { expect(obs.complete).toBe(false) }) }) + + describe("closure on task disposal", () => { + it("close drops every entry and reports the registry closed", () => { + const reg = new ObservationRegistry() + reg.observe("/a/b/c.ts", "v1") + expect(reg.closed).toBe(false) + + reg.close() + + expect(reg.size).toBe(0) + expect(reg.get("/a/b/c.ts")).toBeUndefined() + expect(reg.closed).toBe(true) + }) + + it("observe is a no-op after close, so a read resuming after disposal records nothing", () => { + const reg = new ObservationRegistry() + reg.close() + + reg.observe("/late.ts", "v1") + + expect(reg.size).toBe(0) + expect(reg.has("/late.ts")).toBe(false) + }) + }) }) diff --git a/src/core/task/observationRegistry.ts b/src/core/task/observationRegistry.ts index 0ef9115f21..b3b7a71987 100644 --- a/src/core/task/observationRegistry.ts +++ b/src/core/task/observationRegistry.ts @@ -26,6 +26,10 @@ export interface FileObservation { export class ObservationRegistry { private readonly entries = new Map() + // Set once the owning Task starts disposal. Reads that were already awaiting I/O when + // disposal began resume afterwards, and without this flag they would repopulate a + // registry that disposeOnce() has just retired. + private retired = false /** * Record an observation for a file at its absolute path. @@ -38,6 +42,9 @@ export class ObservationRegistry { * upgrade a partial read into authority for a full-file replacement. */ observe(absolutePath: string, version: string, complete: boolean = true): void { + if (this.retired) { + return + } this.entries.set(absolutePath, { version, observedAt: Date.now(), complete }) } @@ -53,6 +60,24 @@ export class ObservationRegistry { this.entries.clear() } + /** + * Retire the registry: drop every entry and refuse later observations. + * + * Task.disposeOnce() calls this so a task that is being torn down cannot end up holding + * observations again - an awaited read that resumes after disposal would otherwise + * re-record the file it had already read, leaving a disposed Task (still reachable + * through a parent/subtask reference) with authority it no longer deserves. + */ + close(): void { + this.retired = true + this.entries.clear() + } + + /** Whether close() has already run; observations are ignored once this is true. */ + get closed(): boolean { + return this.retired + } + get size(): number { return this.entries.size } diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index e5b476f297..a0b72c18f4 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -235,11 +235,17 @@ export class ReadFileTool extends BaseTool<"read_file"> { // received is not the on-disk state, and observing it would let a later write // match a token the model never saw. A stat failure leaves the target // unobserved and never fails the read. - const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) - if (preReadStats && postReadStats) { - const preReadToken = versionTokenOfStat(preReadStats) - if (preReadToken === versionTokenOfStat(postReadStats)) { - task.observationRegistry.observe(fullPath, preReadToken, processed.complete && !lossyDecode) + // A task that was cancelled or disposed while this read was awaiting I/O must + // not record an observation: disposeOnce() has retired the registry, and the + // content this turn produced will never be acted on. Skipping also drops the + // post-read stat work for a task that no longer has a consumer. + if (!task.abort) { + const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) + if (preReadStats && postReadStats) { + const preReadToken = versionTokenOfStat(preReadStats) + if (preReadToken === versionTokenOfStat(postReadStats)) { + task.observationRegistry.observe(fullPath, preReadToken, processed.complete && !lossyDecode) + } } } @@ -870,11 +876,14 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Observe only when the pre-read and post-read tokens match (a mutation between // them means the returned content is not the on-disk state). A stat failure // leaves the target unobserved and never fails the read. - const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) - if (preReadStats && postReadStats) { - const preReadToken = versionTokenOfStat(preReadStats) - if (preReadToken === versionTokenOfStat(postReadStats)) { - task.observationRegistry.observe(fullPath, preReadToken, readComplete && !lossyDecode) + // Same contract as the native path: an aborted or disposed task records nothing. + if (!task.abort) { + const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) + if (preReadStats && postReadStats) { + const preReadToken = versionTokenOfStat(preReadStats) + if (preReadToken === versionTokenOfStat(postReadStats)) { + task.observationRegistry.observe(fullPath, preReadToken, readComplete && !lossyDecode) + } } } } catch (error) { diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index b4a3f94956..02c46a82f6 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -141,13 +141,22 @@ interface MockTaskOptions { maxImageFileSize?: number maxTotalImageSize?: number observationRegistry?: ObservationRegistry + aborted?: boolean } function createMockTask(options: MockTaskOptions = {}) { - const { supportsImages = false, rooIgnoreAllowed = true, maxImageFileSize = 5, maxTotalImageSize = 20 } = options + const { + supportsImages = false, + rooIgnoreAllowed = true, + maxImageFileSize = 5, + maxTotalImageSize = 20, + aborted = false, + } = options return { cwd: "/test/workspace", + // Mirror Task.abort: disposal and cancellation both set it before the loop resumes. + abort: aborted, // Mirror Task: every task always owns an observation registry (A2, #1375). // Tests asserting on observations pass their own instance via options. observationRegistry: options.observationRegistry ?? new ObservationRegistry(), @@ -1701,6 +1710,71 @@ describe("ReadFileTool", () => { expect(mockTask.didToolFailInCurrentTurn).toBe(false) }) + it("records nothing when the task is aborted before the post-read stat (native path)", async () => { + // Task.disposeOnce() sets abort before an awaited read resumes, and abortTask() + // sets it on cancellation. The read still answers the model, but the observation - + // and the post-read stat work behind it - must not repopulate a retired registry. + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + aborted: true, + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue({ + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "existing.ts" }, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + }) + + it("records nothing when the task is aborted before the post-read stat (legacy path)", async () => { + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + aborted: true, + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue({ + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats) + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy.ts" }], + _legacyFormat: true, + } + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + }) + it("leaves the target unobserved without failing the read when the pre-read stat fails", async () => { const mockTask = createMockTask({ observationRegistry: new ObservationRegistry(), diff --git a/src/services/mcp/__tests__/McpHub.spec.ts b/src/services/mcp/__tests__/McpHub.spec.ts index 29fddd2776..b2e8aa356e 100644 --- a/src/services/mcp/__tests__/McpHub.spec.ts +++ b/src/services/mcp/__tests__/McpHub.spec.ts @@ -144,6 +144,22 @@ describe("McpHub", () => { let mcpHub: McpHubType let mockProvider: Partial + // A fully typed connection double: the SDK constructors are mocked at the top of the + // file, so no cast is needed to build a connected connection here. Shared by the + // write-confinement tests for every project-capable entry point. + const connectionFor = (source: "global" | "project"): ConnectedMcpConnection => ({ + type: "connected", + server: { + name: "test-server", + config: JSON.stringify({ type: "stdio", command: "node", args: ["test.js"], alwaysAllow: [] }), + status: "connected", + source, + errorHistory: [], + }, + client: new Client({ name: "test-client", version: "1.0.0" }), + transport: new StdioClientTransport({ command: "node", args: ["test.js"] }), + }) + // Store original console methods const originalConsoleError = console.error const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform") @@ -995,22 +1011,77 @@ describe("McpHub", () => { }) }) - describe("toggleToolAlwaysAllow", () => { - // A fully typed double: the SDK constructors are mocked at the top of the file, so - // no cast is needed to build a connected connection here. - const projectConnection = (source: "global" | "project" = "project"): ConnectedMcpConnection => ({ - type: "connected", - server: { - name: "test-server", - config: JSON.stringify({ type: "stdio", command: "node", args: ["test.js"], alwaysAllow: [] }), - status: "connected", - source, - errorHistory: [], - }, - client: new Client({ name: "test-client", version: "1.0.0" }), - transport: new StdioClientTransport({ command: "node", args: ["test.js"] }), + describe("project-scoped write confinement at every call site", () => { + // safeWriteJson resolves the publish target with realpath before staging beside it, so + // a project .roo/mcp.json that links outside the workspace would be written THROUGH the + // link unless the caller declares the workspace as the confinement root. Every + // project-capable entry point has to pass it. A lower-level safeWriteJson test cannot + // see a missing MCP argument (the writer is mocked here), so each call site is pinned. + const projectConfigJson = JSON.stringify({ + mcpServers: { "test-server": { type: "stdio", command: "node", args: ["test.js"], timeout: 60 } }, + }) + + it("confines a project-scoped timeout write to the workspace root", async () => { + Object.defineProperty(mockProvider, "cwd", { value: "/mock/workspace", configurable: true }) + vi.mocked(fs.readFile).mockResolvedValueOnce(projectConfigJson) + mcpHub.connections = [connectionFor("project")] + + await mcpHub.updateServerTimeout("test-server", 120) + + const write = vi.mocked(safeWriteJson).mock.calls.find((call) => String(call[0]).includes(".roo")) + expect(write).toBeDefined() + expect(write![2]).toEqual(expect.objectContaining({ confineTo: "/mock/workspace" })) + }) + + it("leaves a global-scoped timeout write unconstrained", async () => { + Object.defineProperty(mockProvider, "cwd", { value: "/mock/workspace", configurable: true }) + // The global path creates the default settings file when it is missing, and that + // write's merge callback reads the file; updateServerConfig then reads it too. + vi.mocked(fs.readFile).mockResolvedValueOnce(projectConfigJson) + vi.mocked(fs.readFile).mockResolvedValueOnce(projectConfigJson) + mcpHub.connections = [connectionFor("global")] + + await mcpHub.updateServerTimeout("test-server", 120) + + const writes = vi.mocked(safeWriteJson).mock.calls.filter((call) => String(call[0]).includes("mcp_settings")) + expect(writes.length).toBeGreaterThan(0) + for (const write of writes) { + expect(write[2]?.confineTo).toBeUndefined() + } }) + it("confines a project-scoped server deletion to the workspace root", async () => { + Object.defineProperty(mockProvider, "cwd", { value: "/mock/workspace", configurable: true }) + vi.mocked(fs.readFile).mockResolvedValueOnce(projectConfigJson) + mcpHub.connections = [connectionFor("project")] + + await mcpHub.deleteServer("test-server", "project") + + const write = vi.mocked(safeWriteJson).mock.calls.find((call) => String(call[0]).includes(".roo")) + expect(write).toBeDefined() + expect(write![2]).toEqual(expect.objectContaining({ confineTo: "/mock/workspace" })) + }) + + it("leaves a global-scoped server deletion unconstrained", async () => { + Object.defineProperty(mockProvider, "cwd", { value: "/mock/workspace", configurable: true }) + vi.mocked(fs.readFile).mockResolvedValueOnce(projectConfigJson) + vi.mocked(fs.readFile).mockResolvedValueOnce(projectConfigJson) + mcpHub.connections = [connectionFor("global")] + + await mcpHub.deleteServer("test-server", "global") + + const writes = vi.mocked(safeWriteJson).mock.calls.filter((call) => String(call[0]).includes("mcp_settings")) + expect(writes.length).toBeGreaterThan(0) + for (const write of writes) { + expect(write[2]?.confineTo).toBeUndefined() + } + }) + }) + + describe("toggleToolAlwaysAllow", () => { + const projectConnection = (source: "global" | "project" = "project"): ConnectedMcpConnection => + connectionFor(source) + it("confines a project-scoped allowlist write to the workspace root", async () => { // A repository can ship .roo/mcp.json as a symlink to a file outside the workspace. // safeWriteJson resolves the publish target before staging, so without confinement an From ae8fda511aebd5cf505a2cf6ba7ea0adbe283754 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Fri, 9 Oct 2026 00:55:59 +0800 Subject: [PATCH 30/72] fix(u4): re-check cancellation after the post-read stat before observing The abort guard sat before the post-read fs.stat, so a cancellation that lands while that stat is in flight still recorded an observation - for a run that will never act on the read, and into a registry that disposal has already retired. Both paths now re-check task.abort after the await and before observe(); the read itself still answers the model. Two tests flip task.abort inside the pending post-read stat, one per path, and assert observe() was never called and the registry stayed empty. --- src/core/tools/ReadFileTool.ts | 9 ++- src/core/tools/__tests__/readFileTool.spec.ts | 74 +++++++++++++++++++ 2 files changed, 81 insertions(+), 2 deletions(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index a0b72c18f4..22c5ff9022 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -241,7 +241,10 @@ export class ReadFileTool extends BaseTool<"read_file"> { // post-read stat work for a task that no longer has a consumer. if (!task.abort) { const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) - if (preReadStats && postReadStats) { + // Re-checked after the await: the guard above cannot see a cancellation + // that lands while the stat is in flight, and that read belongs to a run + // that will never act on it. + if (preReadStats && postReadStats && !task.abort) { const preReadToken = versionTokenOfStat(preReadStats) if (preReadToken === versionTokenOfStat(postReadStats)) { task.observationRegistry.observe(fullPath, preReadToken, processed.complete && !lossyDecode) @@ -879,7 +882,9 @@ export class ReadFileTool extends BaseTool<"read_file"> { // Same contract as the native path: an aborted or disposed task records nothing. if (!task.abort) { const postReadStats = await fs.stat(fullPath, { bigint: true }).catch(() => undefined) - if (preReadStats && postReadStats) { + // Re-checked after the await, as on the native path: a cancel landing + // during the stat must still record nothing. + if (preReadStats && postReadStats && !task.abort) { const preReadToken = versionTokenOfStat(preReadStats) if (preReadToken === versionTokenOfStat(postReadStats)) { task.observationRegistry.observe(fullPath, preReadToken, readComplete && !lossyDecode) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 02c46a82f6..18957c4c9f 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -1775,6 +1775,80 @@ describe("ReadFileTool", () => { expect(reg.size).toBe(0) }) + it("records nothing when the task is cancelled while the post-read stat is in flight (native path)", async () => { + // The guard before the stat cannot see a cancellation that lands DURING the + // stat. The re-check before observe() is what keeps a read that belongs to a + // cancelled run out of the registry - and out of a registry that disposal has + // already retired. + const mockTask = createMockTask({ observationRegistry: new ObservationRegistry() }) + const callbacks = createMockCallbacks() + + const stats = { + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats + mockedFsStat + .mockResolvedValueOnce(stats) // pre-read + .mockImplementationOnce(async () => { + // The cancel lands while this await is pending. + mockTask.abort = true + return stats + }) // post-read + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute({ path: "existing.ts" }, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + // The read itself still answered the model; only the observation is withheld. + expect(mockTask.didToolFailInCurrentTurn).toBe(false) + }) + + it("records nothing when the task is cancelled while the post-read stat is in flight (legacy path)", async () => { + const mockTask = createMockTask({ observationRegistry: new ObservationRegistry() }) + const callbacks = createMockCallbacks() + + const stats = { + isDirectory: () => false, + dev: BigInt(1), + ino: BigInt(2), + size: BigInt(300), + mtimeNs: BigInt(4_000_000_000n), + ctimeNs: BigInt(5_000_000_000n), + // Cast: the mock only implements the members the tool and versionToken read. + } as unknown as Stats + mockedFsStat + .mockResolvedValueOnce(stats) // pre-read + .mockImplementationOnce(async () => { + mockTask.abort = true + return stats + }) // post-read + mockedIsBinaryFile.mockResolvedValue(false) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + const legacyParams: LegacyReadFileParams = { + files: [{ path: "legacy.ts" }], + _legacyFormat: true, + } + + // Cast: the mock task only implements the members ReadFileTool.execute touches. + await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) + + expect(observeSpy).not.toHaveBeenCalled() + expect(reg.size).toBe(0) + }) + it("leaves the target unobserved without failing the read when the pre-read stat fails", async () => { const mockTask = createMockTask({ observationRegistry: new ObservationRegistry(), From 0deb7f44dec3ec05c7c6536905e4f9b571beaad8 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Fri, 9 Oct 2026 01:43:24 +0800 Subject: [PATCH 31/72] fix(file-safety): one lock key whether the parent directory exists yet Port of the #1917 fix into this unit: the unit branches are not cumulative, so this branch carries its own copy of safeWriteText's lock-key helper and the same defect. canonicalDirKey() canonicalized only the immediate parent and fell back to that literal spelling on ENOENT. A writer whose parent directory already existed canonicalized through a symlinked ancestor (or a Windows short name) while a writer racing to create the same directory got the literal path, so the two took different locks for one file and a read-modify-write lost one side. It now walks up to the nearest ancestor that exists, canonicalizes that, and re-joins the missing components; a realpath failure that is not ENOENT is propagated instead of being papered over with a key that may be wrong. Identifiers and comments are kept identical to the other units so the merge resolves trivially. --- .../__tests__/safeWriteText.spec.ts | 46 +++++++++++++++++++ src/services/file-safety/safeWriteText.ts | 30 +++++++++++- 2 files changed, 74 insertions(+), 2 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 351f13c63e..7a86e397eb 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -1318,3 +1318,49 @@ describe("resolvePublishTarget", () => { expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), path.resolve(targetPath)) }) }) + + +describe("resolveLockKey when the parent directory does not exist yet", () => { + beforeEach(() => mockDefaults()) + + it("canonicalizes through the nearest existing ancestor instead of the literal parent", async () => { + // Two writers must take ONE lock: the one whose parent directory is already there, + // and the one racing to create it. Resolving only the immediate parent and falling + // back to its literal spelling on ENOENT gave them different keys whenever an + // ancestor was a symlink or a Windows short name, so a read-modify-write under the + // advisory lock lost one side. + const aliasDir = path.resolve("/tmp/alias-parent") + const canonicalDir = path.resolve("/tmp/real-parent") + const nested = path.join(aliasDir, "nested") + const target = path.join(nested, "history_item.json") + vi.mocked(fs.lstat).mockResolvedValue(_fileStats(false)) + vi.mocked(fs.realpath).mockImplementation(async (p) => { + const s = String(p) + if (s === target || s === nested) { + throw Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) + } + if (s === aliasDir) { + return canonicalDir + } + return s + }) + + expect(await resolveLockKey(target)).toBe(path.join(canonicalDir, "nested", "history_item.json")) + }) + + it("propagates a realpath failure that is not ENOENT instead of guessing a key", async () => { + // A realpath that fails for another reason says nothing about the canonical form; + // returning a literal key would silently put this writer on a different lock. + const target = path.join(path.resolve("/tmp/test-dir"), "history_item.json") + vi.mocked(fs.lstat).mockResolvedValue(_fileStats(false)) + // Not a link: the walk must reach the canonicalization step, which is where the + // non-ENOENT failure has to surface. + vi.mocked(fs.readlink).mockRejectedValue(Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" })) + vi.mocked(fs.realpath).mockImplementation(async (p) => { + if (String(p) === target) return target + throw Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }) + }) + + await expect(resolveLockKey(target)).rejects.toThrow("EACCES") + }) +}) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index f0295b9c56..98507d59b4 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -191,8 +191,34 @@ function errorCode(error: unknown): string | undefined { async function canonicalDirKey(absoluteFilePath: string): Promise { const dirPath = path.dirname(absoluteFilePath) - const canonicalDir = await fs.realpath(dirPath).catch(() => dirPath) - return path.join(canonicalDir, path.basename(absoluteFilePath)) + // Walk up to the nearest ancestor that EXISTS, canonicalize that, and re-join the + // components that are not there yet. Falling back to the unresolved spelling of the + // whole parent - what a single realpath(...).catch(() => dirPath) used to do - makes + // the key depend on whether the directory happens to exist: a writer whose parent is + // already there canonicalizes through a symlinked ancestor (or a short name) while a + // writer racing to create the same directory gets the literal spelling, so the two + // take different locks for one file and a read-modify-write loses one side. + // A realpath failure that is not "not there yet" says nothing about the canonical + // form, so it is propagated rather than papered over with a key that may be wrong. + let cursor = dirPath + const missing: string[] = [] + for (;;) { + const canonical = await fs.realpath(cursor).catch((error: unknown) => { + if (errorCode(error) === "ENOENT") return undefined + throw error + }) + if (canonical !== undefined) { + return path.join(canonical, ...missing.reverse(), path.basename(absoluteFilePath)) + } + missing.push(path.basename(cursor)) + const parent = path.dirname(cursor) + if (parent === cursor) { + // Every component up to the root is missing: there is nothing to canonicalize + // against, and the literal path is the only key left. + return path.join(dirPath, path.basename(absoluteFilePath)) + } + cursor = parent + } } /** From ddae96e2cf152479d8c5bdef507986c14fabb1aa Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Fri, 9 Oct 2026 03:28:18 +0800 Subject: [PATCH 32/72] test(file-safety): a backup copy that fails part-way must not survive the write A defect reported on a sibling PR in the base repo: the backup destination is named before the copy runs, while the rollback cleanup keys off a flag that only becomes true once the copy succeeded - so a copyFile that fails after creating the destination leaves a half-written .bak beside the target forever. This branch does not have that shape. The whole backup creation (seed open with "wx", copyFile, chmod, fsync) is wrapped in a catch that unlinks the destination and clears backupPath before rethrowing, so the cleanup keys off the attempt rather than off the success. What was missing is coverage for the exact case the report describes: copyFile failing with the destination already created. Only the fsync-failure variant was tested. No production change. Negative control: deleting the cleanup unlink inside that catch fails exactly two tests - this one and the existing "a failed backup flush is reported and leaves no partial backup behind" - and restoring it leaves the file byte-identical. --- .../__tests__/safeWriteText.spec.ts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 7a86e397eb..3f55bfad23 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -519,6 +519,25 @@ describe("safeWriteText", () => { expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) + it("a backup copy that fails part-way is removed, not left as a usable-looking backup", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The destination is seeded with openSync("wx") BEFORE any content exists at it, + // and the copy then fails part-way: the name is there, holding a partial copy of + // nothing usable. Cleanup has to key off the attempt, not off a copy that + // succeeded, or this file outlives the failed write beside the target. + vi.mocked(fs.copyFile).mockRejectedValue(Object.assign(new Error("EIO"), { code: "EIO" })) + + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow("EIO") + + // Nothing was published, and the half-written copy is removed rather than left + // next to the target looking like a backup someone could restore. + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + }) + it("backup:true when target does not exist: no backup created, just commit", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) From e12880f81fda8ac0a01e8612e9096c427189fbc4 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Fri, 9 Oct 2026 04:34:23 +0800 Subject: [PATCH 33/72] chore(ci): no-op commit to re-trigger the review for this head No source change. CodeRabbit's change_assessment_commit for this PR has been frozen at 5596f3a6a since 15:30 across three heads (949c2637f, f1fb1b2e9, 7dec01bca): three accepted "@coderabbitai full review" requests (18:42:03, 20:02:18, 20:19:42) each re-rendered the summarize against the OLD assessment and produced no review object at head, while the same pool produced a real at-head verdict for another PR minutes later. The auto-review that a push schedules recomputes the assessment for the new head, which the manual request does not. From 7bcc158bb606475206d6c87a8a88366e3def0cae Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sat, 10 Oct 2026 23:17:13 +0800 Subject: [PATCH 34/72] test(tools,mcp): count the observation stats and name the pinned write Pre-merge table row "Regression Evidence" (ReadFileTool.ts:220-250, 828-890): the native and legacy successful-read tests now count the fs.stat calls that match - correct path AND { bigint: true } - instead of relying on membership, which the read path's plain directory-check stat satisfies on its own. The counted bigint stats must bracket the read (one before, one after), and the plain directory-check stat must stay the only stat without options. In both abort-before-post-stat tests the pre-read observation stat is still counted (1, not 0) and placed before the read, while the post-read bigint stat must never appear. Load-bearing proof, measured per mutant with the full spec: - bigint:true -> false at the native pre-read stat: reds exactly the native success + native abort tests (2). - bigint:true -> false at the native post-read stat: reds exactly the native success test (1). - legacy pre-read / post-read: mirror images (2 and 1). - abort guard removed at each post-read site: reds exactly its abort test (1 each). All six mutants restored byte-for-byte (sha256 verified). Inline thread (McpHub.spec.ts): the global allowlist test picked the first safeWriteJson call whose path contains "mcp", which can be the default-creation write getMcpSettingsFilePath makes when the settings file is missing - it never passes confineTo, so a confinement root added to the real allowlist write would go unnoticed. The test now names the exact call: every write to the settings file (endsWith mcp_settings.json) is checked, matching the timeout and delete tests. Controls: adding confineTo to the production allowlist write reds exactly this test; with a decoy mcp-named write first, the old find went red on the decoy while the fixed matcher stayed green (77/77), proving the selection names the right call. Gates: readFileTool.spec 99 passed; McpHub.spec 77 passed; eslint --max-warnings=0 clean on both files; eslint-suppressions.json untouched. --- src/core/tools/__tests__/readFileTool.spec.ts | 59 +++++++++++++++++++ src/services/mcp/__tests__/McpHub.spec.ts | 17 +++++- 2 files changed, 73 insertions(+), 3 deletions(-) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 18957c4c9f..04de504ae9 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -1582,6 +1582,25 @@ describe("ReadFileTool", () => { }) describe("observation registry", () => { + // Indices of fs.stat calls against a path ending in fileName, filtered by + // whether the call passed { bigint: true }. Counting matching calls is + // the load-bearing form here: toHaveBeenCalledWith asserts membership, + // which the directory-check stat alone satisfies, and it cannot tell a + // skipped stat from one that ran. + const usesBigintOptions = (options: unknown): boolean => + typeof options === "object" && options !== null && (options as { bigint?: unknown }).bigint === true + const statCallsMatching = (fileName: string, bigint: boolean): number[] => + mockedFsStat.mock.calls + .map((_, index) => index) + .filter((index) => { + const [statPath, options] = mockedFsStat.mock.calls[index] + return String(statPath).endsWith(fileName) && usesBigintOptions(options) === bigint + }) + // Vitest records invocationCallOrder parallel to mock.calls; comparing it + // against the readFile call tells the pre-read observation stat from the + // post-read one instead of trusting positional order by eye. + const statOrderBeforeRead = (statIndex: number): boolean => + mockedFsStat.mock.invocationCallOrder[statIndex] < mockedFsReadFile.mock.invocationCallOrder[0] it("records an observation on successful read of an existing file", async () => { const mockTask = createMockTask({ observationRegistry: new ObservationRegistry(), @@ -1617,6 +1636,19 @@ describe("ReadFileTool", () => { const obs = reg.get(calledPath) expect(obs).toBeDefined() expect(obs!.version).toBe(calledVersion) + // Regression evidence: both observation stats must be bigint stats. + // Count the calls that match - correct path AND { bigint: true } - + // because a membership assertion passes on its own: the read path + // also stats the same path without options for the directory check. + const bigintStatIndexes = statCallsMatching("existing.ts", true) + expect(bigintStatIndexes).toHaveLength(2) + // Neither observation stat is a plain stat: the directory check stays + // the only stat without options... + expect(statCallsMatching("existing.ts", false)).toHaveLength(1) + // ...and the two bigint stats bracket the read: exactly one before it + // (pre-read observation) and exactly one after (post-read observation). + expect(bigintStatIndexes.filter((index) => statOrderBeforeRead(index))).toHaveLength(1) + expect(bigintStatIndexes.filter((index) => !statOrderBeforeRead(index))).toHaveLength(1) }) it("a failed read (absent path) leaves the registry size 0 and does not throw", async () => { @@ -1670,6 +1702,15 @@ describe("ReadFileTool", () => { const [calledPath, calledVersion] = observeSpy.mock.calls[0] expect(calledPath).toContain("legacy.ts") expect(calledVersion).toMatch(/^\d+:\d+:\d+:\d+:\d+$/) + // Regression evidence, same contract on the legacy path: count the + // matching calls (correct path AND { bigint: true }) instead of + // asserting membership, which the directory-check stat alone satisfies. + const bigintStatIndexes = statCallsMatching("legacy.ts", true) + expect(bigintStatIndexes).toHaveLength(2) + expect(statCallsMatching("legacy.ts", false)).toHaveLength(1) + // The two bigint stats bracket the read: pre-read before it, post-read after. + expect(bigintStatIndexes.filter((index) => statOrderBeforeRead(index))).toHaveLength(1) + expect(bigintStatIndexes.filter((index) => !statOrderBeforeRead(index))).toHaveLength(1) }) it("does not observe when the file mutates between the pre-read and post-read stats", async () => { @@ -1740,6 +1781,17 @@ describe("ReadFileTool", () => { expect(observeSpy).not.toHaveBeenCalled() expect(reg.size).toBe(0) expect(mockTask.didToolFailInCurrentTurn).toBe(false) + // The abort must skip only the post-read observation: the pre-read + // observation stat is still issued, and no bigint stat follows the + // read. Counted by matching calls (correct path AND { bigint: true }): + // a membership assertion cannot tell "post-stat skipped" from + // "post-stat ran". + const bigintStatIndexes = statCallsMatching("existing.ts", true) + expect(bigintStatIndexes).toHaveLength(1) + // The single bigint stat ran before the read: it is the pre-read one. + expect(statOrderBeforeRead(bigintStatIndexes[0])).toBe(true) + // The directory-check stat is untouched: still exactly one plain stat. + expect(statCallsMatching("existing.ts", false)).toHaveLength(1) }) it("records nothing when the task is aborted before the post-read stat (legacy path)", async () => { @@ -1773,6 +1825,13 @@ describe("ReadFileTool", () => { expect(observeSpy).not.toHaveBeenCalled() expect(reg.size).toBe(0) + // Same contract on the legacy path: the pre-read observation stat is + // still issued and the post-read one is skipped - counted by matching + // calls, not by membership. + const bigintStatIndexes = statCallsMatching("legacy.ts", true) + expect(bigintStatIndexes).toHaveLength(1) + expect(statOrderBeforeRead(bigintStatIndexes[0])).toBe(true) + expect(statCallsMatching("legacy.ts", false)).toHaveLength(1) }) it("records nothing when the task is cancelled while the post-read stat is in flight (native path)", async () => { diff --git a/src/services/mcp/__tests__/McpHub.spec.ts b/src/services/mcp/__tests__/McpHub.spec.ts index b2e8aa356e..40416e7c79 100644 --- a/src/services/mcp/__tests__/McpHub.spec.ts +++ b/src/services/mcp/__tests__/McpHub.spec.ts @@ -1113,11 +1113,22 @@ describe("McpHub", () => { await mcpHub.toggleToolAlwaysAllow("test-server", "global", "another-tool", true) - const write = vi.mocked(safeWriteJson).mock.calls.find((call) => String(call[0]).includes("mcp")) - expect(write).toBeDefined() + // Name the exact call instead of picking any match: a find on the substring + // "mcp" returns the FIRST mcp-named write, which need not be the allowlist + // write - the default-creation write getMcpSettingsFilePath makes when the + // settings file is missing (McpHub.ts:513) also matches, and it never passes + // confineTo, so the assertion could judge that write and stay green while a + // confinement root on the real allowlist write went unnoticed. Check every + // write to the settings file, as the timeout and delete tests above do. + const writes = vi + .mocked(safeWriteJson) + .mock.calls.filter((call) => String(call[0]).endsWith("mcp_settings.json")) + expect(writes.length).toBeGreaterThan(0) // undefined confineTo is the unconstrained case: safeWriteJson only checks the path // when a confinement root is supplied. - expect(write![2]?.confineTo).toBeUndefined() + for (const write of writes) { + expect(write[2]?.confineTo).toBeUndefined() + } }) it("should add tool to always allow list when enabling", async () => { From ce174a2adf3e766b68e56b6dcaeb6e03ab731d63 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sat, 10 Oct 2026 23:20:05 +0800 Subject: [PATCH 35/72] style(test): reflow three pre-existing lines to the repo prettier gate The repo-wide prettier check added on main (commit 667ff5891, run on the merge commit) flags exactly three lines inside this PR's own diff: one execute call in readFileTool.spec.ts and two safeWriteJson filters in McpHub.spec.ts, all introduced by this branch's earlier commits (measured with git blame at the previous head). Each line exceeds printWidth 120 and prettier wraps it; nothing else changes. Pure-formatting proof, per the ratified criteria: byte equality after removing whitespace AND commas holds for both files (McpHub 86088 == 86088 whitespace-only; readFileTool 72964 == 72965 with the single added trailing comma from the call wrap). No file outside this PR's diff is touched. prettier --check now exits 0 on both files in the CI view (LF content, root config); both specs pass (99 and 77) and eslint --max-warnings=0 is clean. --- src/core/tools/__tests__/readFileTool.spec.ts | 6 +++++- src/services/mcp/__tests__/McpHub.spec.ts | 8 ++++++-- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 04de504ae9..d255240def 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -2221,7 +2221,11 @@ describe("ReadFileTool", () => { includedRanges: [[3, 4]], }) - await readFileTool.execute({ path: "clipped-slice.ts", offset: 3 }, mockTask as unknown as Task, callbacks) + await readFileTool.execute( + { path: "clipped-slice.ts", offset: 3 }, + mockTask as unknown as Task, + callbacks, + ) const pushed = callbacks.pushToolResult.mock.calls[0][0] expect(pushed).toContain("clipped in this view") diff --git a/src/services/mcp/__tests__/McpHub.spec.ts b/src/services/mcp/__tests__/McpHub.spec.ts index 40416e7c79..c19e16686c 100644 --- a/src/services/mcp/__tests__/McpHub.spec.ts +++ b/src/services/mcp/__tests__/McpHub.spec.ts @@ -1043,7 +1043,9 @@ describe("McpHub", () => { await mcpHub.updateServerTimeout("test-server", 120) - const writes = vi.mocked(safeWriteJson).mock.calls.filter((call) => String(call[0]).includes("mcp_settings")) + const writes = vi + .mocked(safeWriteJson) + .mock.calls.filter((call) => String(call[0]).includes("mcp_settings")) expect(writes.length).toBeGreaterThan(0) for (const write of writes) { expect(write[2]?.confineTo).toBeUndefined() @@ -1070,7 +1072,9 @@ describe("McpHub", () => { await mcpHub.deleteServer("test-server", "global") - const writes = vi.mocked(safeWriteJson).mock.calls.filter((call) => String(call[0]).includes("mcp_settings")) + const writes = vi + .mocked(safeWriteJson) + .mock.calls.filter((call) => String(call[0]).includes("mcp_settings")) expect(writes.length).toBeGreaterThan(0) for (const write of writes) { expect(write[2]?.confineTo).toBeUndefined() From 25b02ca5dc5881cedd6b07adb5127fd0e843d524 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 01:03:23 +0800 Subject: [PATCH 36/72] style(tools,file-safety,utils): apply the repo prettier gate to the six unit files The compile job starts with pnpm format:check (prettier --check . added to main by commit 667ff5891), and it evaluates the merge commit. CI listed exactly these six files as dirty; all six are inside this pull request's own diff and every offending line traces to commits of this branch (verified with git blame at the previous head). Content is prettier 3.8.4 output only. Proof: for each file, the blob before and after are byte-equal after removing all whitespace characters and all commas (the formatter's reflow adds and removes trailing commas); the only other delta is one redundant pair of grouping parentheses around an arrow-function conditional body in safeWriteText.spec.ts, which prettier itself removes. No token other than whitespace, commas, and that paren pair changed. No behavior change; no production semantics touched. --- src/core/tools/ReadFileTool.ts | 6 +- .../__tests__/safeWriteText.spec.ts | 137 ++++++++++-------- src/services/file-safety/safeWriteText.ts | 18 ++- .../__tests__/safeWriteJson.lockKey.spec.ts | 29 +++- src/utils/__tests__/safeWriteJson.test.ts | 16 +- src/utils/safeWriteJson.ts | 9 +- 6 files changed, 125 insertions(+), 90 deletions(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index 22c5ff9022..67a44cf295 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -247,7 +247,11 @@ export class ReadFileTool extends BaseTool<"read_file"> { if (preReadStats && postReadStats && !task.abort) { const preReadToken = versionTokenOfStat(preReadStats) if (preReadToken === versionTokenOfStat(postReadStats)) { - task.observationRegistry.observe(fullPath, preReadToken, processed.complete && !lossyDecode) + task.observationRegistry.observe( + fullPath, + preReadToken, + processed.complete && !lossyDecode, + ) } } } diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 3f55bfad23..e7bf2767e6 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -307,9 +307,7 @@ describe("safeWriteText", () => { expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) // The rejection is reported through the fallback sink rather than surfacing as an // unhandled rejection. - expect(consoleWarn).toHaveBeenCalledWith( - expect.stringContaining("onWarning callback rejected"), - ) + expect(consoleWarn).toHaveBeenCalledWith(expect.stringContaining("onWarning callback rejected")) consoleWarn.mockRestore() }) @@ -402,7 +400,9 @@ describe("safeWriteText", () => { return 1 }) - await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow(PostCommitDurabilityError) + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow( + PostCommitDurabilityError, + ) // The commit rename already published the new content, and the backup was only // ever a copy: the target was never moved, so there is nothing to rename back. @@ -477,7 +477,9 @@ describe("safeWriteText", () => { }) expect(seedOpen).toBeDefined() expect(seedOpen?.[2]).toBe(0o600) - const seedOrder = vi.mocked(fsSync.openSync).mock.invocationCallOrder[vi.mocked(fsSync.openSync).mock.calls.indexOf(seedOpen!)] + const seedOrder = vi.mocked(fsSync.openSync).mock.invocationCallOrder[ + vi.mocked(fsSync.openSync).mock.calls.indexOf(seedOpen!) + ] expect(seedOrder).toBeLessThan(vi.mocked(fs.copyFile).mock.invocationCallOrder[0]) // The chmod keeps a copied read-only attribute (Windows) from breaking the fsync @@ -503,14 +505,18 @@ describe("safeWriteText", () => { // known to be durable, so the write must not proceed on a half-written backup. // The staged temp is fsynced earlier with a different handle, so target the // backup's fd specifically. - vi.mocked(fsSync.openSync).mockImplementation((p: unknown) => (String(p).includes("safeWriteText.bak_") ? 7 : 1)) + vi.mocked(fsSync.openSync).mockImplementation((p: unknown) => + String(p).includes("safeWriteText.bak_") ? 7 : 1, + ) vi.mocked(fsSync.fsyncSync).mockImplementation((fd: unknown) => { if (fd === 7) { throw new Error("EIO") } }) - await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow("EIO") + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow( + "EIO", + ) // Nothing was published, and the incomplete copy is removed rather than left // next to the target looking like a usable backup. @@ -529,7 +535,9 @@ describe("safeWriteText", () => { // succeeded, or this file outlives the failed write beside the target. vi.mocked(fs.copyFile).mockRejectedValue(Object.assign(new Error("EIO"), { code: "EIO" })) - await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow("EIO") + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow( + "EIO", + ) // Nothing was published, and the half-written copy is removed rather than left // next to the target looking like a backup someone could restore. @@ -605,64 +613,64 @@ describe("safeWriteText", () => { expect(execFile).toHaveBeenCalledTimes(1) }) - it("win32: reports that access rights may change when the DACL cannot be saved", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - if (typeof cb === "function") cb(new Error("icacls error"), "", "") - return fakeChild + it("win32: reports that access rights may change when the DACL cannot be saved", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls error"), "", "") + return fakeChild + }) + const warnings: string[] = [] + + await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + + // The write still commits - a failing icacls must not leave the user unable to save - + // but the caller is told the replacement may not carry the old ACL. + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + expect(warnings.filter((m) => m.includes("different access rights"))).toHaveLength(1) }) - const warnings: string[] = [] - await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + it("win32: reports when the target cannot be checked for DACL preservation", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The target exists but is not readable: that is not "absent", and skipping DACL + // preservation has to be visible. + vi.mocked(fs.access).mockImplementation(async (p) => { + if (String(p) === targetPath) { + throw Object.assign(new Error("EACCES"), { code: "EACCES" }) + } + }) + const warnings: string[] = [] - // The write still commits - a failing icacls must not leave the user unable to save - - // but the caller is told the replacement may not carry the old ACL. - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) - expect(warnings.filter((m) => m.includes("different access rights"))).toHaveLength(1) - }) + await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) - it("win32: reports when the target cannot be checked for DACL preservation", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - // The target exists but is not readable: that is not "absent", and skipping DACL - // preservation has to be visible. - vi.mocked(fs.access).mockImplementation(async (p) => { - if (String(p) === targetPath) { - throw Object.assign(new Error("EACCES"), { code: "EACCES" }) - } + expect(execFile).not.toHaveBeenCalled() + expect(warnings.filter((m) => m.includes("Could not check"))).toHaveLength(1) }) - const warnings: string[] = [] - await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + // Warning delivery is advisory: it must not be able to fail the save it is reporting on. + it("win32: a throwing onWarning does not abort the write", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + if (typeof cb === "function") cb(new Error("icacls error"), "", "") + return fakeChild + }) - expect(execFile).not.toHaveBeenCalled() - expect(warnings.filter((m) => m.includes("Could not check"))).toHaveLength(1) - }) + await expect( + safeWriteText(targetPath, "data", { + platform: "win32", + onWarning: () => { + throw new Error("callback down") + }, + }), + ).resolves.toBeUndefined() - // Warning delivery is advisory: it must not be able to fail the save it is reporting on. - it("win32: a throwing onWarning does not abort the write", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - if (typeof cb === "function") cb(new Error("icacls error"), "", "") - return fakeChild + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) }) - - await expect( - safeWriteText(targetPath, "data", { - platform: "win32", - onWarning: () => { - throw new Error("callback down") - }, - }), - ).resolves.toBeUndefined() - - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) - }) it("win32 DACL: a partial dump left by a failed save is removed and never restored", async () => { const targetPath = "/tmp/test-dir/target.txt" @@ -1234,9 +1242,9 @@ describe("caller-supplied staging path", () => { const stats = _fileStatsWithIdentity(42n, 7n) vi.mocked(fs.lstat).mockResolvedValue(stats) - await expect( - safeWriteText(targetPath, "data", { tempPath: targetPath, platform: "linux" }), - ).rejects.toThrow(StagingPathError) + await expect(safeWriteText(targetPath, "data", { tempPath: targetPath, platform: "linux" })).rejects.toThrow( + StagingPathError, + ) expect(fsSync.openSync).not.toHaveBeenCalled() expect(fs.rename).not.toHaveBeenCalled() // The comparison is only sound when both stats are read as bigint: on NTFS/ReFS the file @@ -1251,7 +1259,6 @@ describe("caller-supplied staging path", () => { expect(fs.unlink).not.toHaveBeenCalled() }) - it("rejects when the target identity cannot be compared for a reason other than a missing target", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -1278,7 +1285,8 @@ describe("caller-supplied staging path", () => { for (const c of identityLookups) { expect(c[1]).toEqual({ bigint: true }) } - })}) + }) +}) describe("cleanup when a backed-up write fails before commit", () => { beforeEach(() => mockDefaults()) @@ -1338,7 +1346,6 @@ describe("resolvePublishTarget", () => { }) }) - describe("resolveLockKey when the parent directory does not exist yet", () => { beforeEach(() => mockDefaults()) @@ -1374,7 +1381,9 @@ describe("resolveLockKey when the parent directory does not exist yet", () => { vi.mocked(fs.lstat).mockResolvedValue(_fileStats(false)) // Not a link: the walk must reach the canonicalization step, which is where the // non-ENOENT failure has to surface. - vi.mocked(fs.readlink).mockRejectedValue(Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" })) + vi.mocked(fs.readlink).mockRejectedValue( + Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }), + ) vi.mocked(fs.realpath).mockImplementation(async (p) => { if (String(p) === target) return target throw Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 98507d59b4..88167a2d06 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -128,7 +128,11 @@ async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunne /** Restore a DACL dump onto *dirPath* on Windows. * Returns whether icacls succeeded; the caller reports a failure. */ -async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { +async function _restoreDaclWindows( + dirPath: string, + dumpPath: string, + execFileRunner?: typeof execFile, +): Promise { const runner = execFileRunner ?? execFile try { await new Promise((resolve, reject) => { @@ -451,13 +455,17 @@ export async function safeWriteText( // proceeds - a missing or failing icacls must not leave the user unable to save - // but the replacement is no longer ACL-identical and that has to be visible // instead of silent. - warn(`Could not save the DACL of ${targetPath}; the replacement may inherit different access rights.`) + warn( + `Could not save the DACL of ${targetPath}; the replacement may inherit different access rights.`, + ) } } else if (errorCode(accessError) !== "ENOENT") { // Not "absent": the target is there but could not be checked (EACCES, ...), so // DACL preservation was skipped for a reason the caller cannot infer from the // successful write alone. - warn(`Could not check ${targetPath} for DACL preservation (${errorCode(accessError) ?? "unknown error"}); the replacement may inherit different access rights.`) + warn( + `Could not check ${targetPath} for DACL preservation (${errorCode(accessError) ?? "unknown error"}); the replacement may inherit different access rights.`, + ) } } try { @@ -545,7 +553,9 @@ export async function safeWriteText( // temp directory restore fails with "Not all privileges or groups referenced // are assigned to the caller"), so the change of access rights is reported // rather than thrown. - warn(`safeWriteText: content committed at ${targetPath}, but the saved DACL could not be restored from ${daclDumpPath}; the file may carry different access rights than the one it replaced.`) + warn( + `safeWriteText: content committed at ${targetPath}, but the saved DACL could not be restored from ${daclDumpPath}; the file may carry different access rights than the one it replaced.`, + ) } } diff --git a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts index beddaf9ea9..c9f2415402 100644 --- a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts +++ b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts @@ -50,12 +50,13 @@ afterEach(async () => { // Only isSymbolicLink() is consulted by the guard, so the double carries just // that method. The mocks reject asynchronously: a synchronous throw would bypass // resolvePublishTarget's catch and skip the ENOENT/symlink branch under test. -const symlinkStat = (target: unknown) => ({ - isSymbolicLink: () => target === currentLink, - // The staging-path check in safeWriteText also asks whether the path is a - // regular file, so the double carries that predicate as well. - isFile: () => target !== currentLink, -}) as unknown as BigIntStats +const symlinkStat = (target: unknown) => + ({ + isSymbolicLink: () => target === currentLink, + // The staging-path check in safeWriteText also asks whether the path is a + // regular file, so the double carries that predicate as well. + isFile: () => target !== currentLink, + }) as unknown as BigIntStats let currentLink = "" describe("safeWriteJson lock key under a peer commit", () => { @@ -100,7 +101,17 @@ describe("safeWriteJson lock key under a peer commit", () => { // regular-file check on the temp file this write created, and the identity check // that the staging path is not the target. Both run after the key was resolved // and the lock was taken, so neither changes which lock the caller queued behind. - expect(order).toEqual(["resolve-failed", "lstat", "resolve", "resolve", "lock", "resolve", "resolve", "lstat", "lstat"]) + expect(order).toEqual([ + "resolve-failed", + "lstat", + "resolve", + "resolve", + "lock", + "resolve", + "resolve", + "lstat", + "lstat", + ]) expect(JSON.parse(await fs.readFile(referent, "utf8"))).toEqual({ id: "task-1" }) }) @@ -153,7 +164,9 @@ describe("safeWriteJson lock key under a peer commit", () => { if (target === file) throw enoent return canonicalDir }) - mockedLstat.mockImplementation(async () => ({ isSymbolicLink: () => false, isFile: () => true }) as unknown as BigIntStats) + mockedLstat.mockImplementation( + async () => ({ isSymbolicLink: () => false, isFile: () => true }) as unknown as BigIntStats, + ) expect(await resolveLockKey(file)).toBe(path.join(canonicalDir, "history_item.json")) }) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 9870fc74c9..05c425346a 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -696,16 +696,18 @@ describe("safeWriteJson", () => { const projectConfig = path.join(projectDir, "mcp.json") await fs.symlink(outside, projectConfig) - await expect( - safeWriteJson(projectConfig, { mcpServers: {} }, { confineTo: projectDir }), - ).rejects.toThrow(ConfinedPathEscapeError) + await expect(safeWriteJson(projectConfig, { mcpServers: {} }, { confineTo: projectDir })).rejects.toThrow( + ConfinedPathEscapeError, + ) // The linked file is untouched and nothing was staged beside it. expect(JSON.parse(await fsSyncActual.promises.readFile(outside, "utf8"))).toEqual({ secret: "original" }) const entries = await fs.readdir(tempDir) expect(entries).toContain("outside.json") expect( - entries.filter((entry) => entry.includes(".new_") || entry.includes("safeWriteText") || entry.endsWith(".lock")), + entries.filter( + (entry) => entry.includes(".new_") || entry.includes("safeWriteText") || entry.endsWith(".lock"), + ), ).toEqual([]) }, ) @@ -722,7 +724,11 @@ describe("safeWriteJson", () => { // Confining is about the scope, not about forbidding links: a link that stays // inside the project still publishes to its referent. - await safeWriteJson(alias, { mcpServers: { local: { url: "http://localhost" } } }, { confineTo: projectDir }) + await safeWriteJson( + alias, + { mcpServers: { local: { url: "http://localhost" } } }, + { confineTo: projectDir }, + ) expect(JSON.parse(await fsSyncActual.promises.readFile(referent, "utf8"))).toEqual({ mcpServers: { local: { url: "http://localhost" } }, diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index a9d8fd6164..a50ca723da 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -108,12 +108,7 @@ async function _resolveScopeRoot(confineTo: string): Promise { */ function _assertWithinScope(requestedPath: string, candidatePath: string, scopeRoot: string): void { const relative = path.relative(scopeRoot, candidatePath) - if ( - relative === "" || - relative === ".." || - relative.startsWith(".." + path.sep) || - path.isAbsolute(relative) - ) { + if (relative === "" || relative === ".." || relative.startsWith(".." + path.sep) || path.isAbsolute(relative)) { throw new ConfinedPathEscapeError(requestedPath, candidatePath, scopeRoot) } } @@ -178,8 +173,6 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso throw dirError } - - // immediately, and releaseLock stays a no-op so the finally block does not try // to release an unacquired lock. releaseLock = await acquireFileLock(lockKey) From cc76cbf071c96fd8b355ea12fb4a81b4796c6f01 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 01:31:21 +0800 Subject: [PATCH 37/72] test(misc): teach the Unicode reader spec the hasClippedLines field The Windows platform-unit-test job failed test:misc on the merge tree: integrations/misc/__tests__/indentation-reader-unicode.spec.ts, added to main by pull 1960 (commit a101c613e), asserts the reader result with toEqual over the exact five-key object. This unit adds hasClippedLines to readWithSlice results and to both readers' error returns, so three of those assertions received a sixth key on the merge commit. The offending expectations came from main, not from this branch; the fix lands in this pull request's own diff because the gate runs on this pull's merge commit. The preceding merge of upstream main is what lets this edit land as a modification: without it the file exists only on main and the same edit would surface as an add/add conflict and make the pull dirty. Assertions updated to the shipped contract: hasClippedLines true for the two clipped-line slice results, false for the empty-input slice result and for both reader error returns. The readWithIndentation success results do not carry the field and their assertions are unchanged. Negative control: replacing the produced value with undefined at the success site reddens the two true-cases, and at the error sites reddens the error test; restoring turns the file green (28 passed). --- .../misc/__tests__/indentation-reader-unicode.spec.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts b/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts index 90d5007f16..64b5fce642 100644 --- a/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts +++ b/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts @@ -74,6 +74,7 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 3, returnedLines: 1, wasTruncated: true, + hasClippedLines: true, }) expect(Buffer.from(result.content).toString("utf8")).toBe(result.content) }) @@ -115,6 +116,7 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 1, returnedLines: 1, wasTruncated: false, + hasClippedLines: true, }) expect(readWithSlice("")).toEqual({ content: "1 | ", @@ -122,6 +124,7 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 1, returnedLines: 1, wasTruncated: false, + hasClippedLines: false, }) }) @@ -132,6 +135,7 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 1, returnedLines: 0, wasTruncated: false, + hasClippedLines: false, }) expect(readWithIndentation(longLine, { anchorLine: 0 })).toEqual({ content: "Error: anchor_line 0 is out of range (1-1)", @@ -139,6 +143,7 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 1, returnedLines: 0, wasTruncated: false, + hasClippedLines: false, }) }) }) From 5a6b43e70c7853d82f8e5e8ce9dcfac9f85b0d36 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 02:07:16 +0800 Subject: [PATCH 38/72] fix(tools): drop the duplicate Task import the merge produced Both main and this branch added the same "import type { Task } from ../../task/Task" line to readFileTool.spec.ts at different positions, so the textual merge kept two copies and the file failed to collect: TS2300 Duplicate identifier 'Task' (vitest reported "Tests no tests"). The Windows job never reached this project because test:misc failed first, so CI had not surfaced it yet. Kept main's copy (the line main owns) and removed this branch's copy. Spec passes after the fix: 106 tests green. --- src/core/tools/__tests__/readFileTool.spec.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index d255240def..6063c06eff 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -24,7 +24,6 @@ import { isBinaryFile } from "isbinaryfile" import { readFileTool, ReadFileTool } from "../ReadFileTool" -import type { Task } from "../../task/Task" import { ObservationRegistry } from "../../task/observationRegistry" import { formatResponse } from "../../prompts/responses" import { validateImageForProcessing, processImageFile, isSupportedImageFormat } from "../helpers/imageHelpers" From f5a2a50a6901c998944c14e33e2f10f9bd67bd86 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 03:11:40 +0800 Subject: [PATCH 39/72] fix(tools): correct the merged no-explicit-any count for the read-file spec Both main and this branch edited readFileTool.spec.ts, and the merged file contains 94 explicit-any occurrences while the merged eslint-suppressions.json still declared 96 (the byte-identical file on the pull's merge ref has the same staleness; CI had not reached the Lint step because the compile job died earlier). The suppression service exits 2 on suppressions that no longer occur, so the merged tree's lint step would have failed. Measured with eslint itself (prune run reported 96 -> 94 for this file only) and applied as a one-line byte-exact edit; the file keeps its TAB indentation and trailing newline. The count decreased, never increased. Full src lint now exits 0 with --max-warnings=0. --- src/eslint-suppressions.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index 671c9f594c..d885b4920a 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -966,7 +966,7 @@ }, "core/tools/__tests__/readFileTool.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 96 + "count": 94 } }, "core/tools/__tests__/runSlashCommandTool.spec.ts": { From ea00f9f770ee9ed1ddae4bb3cd4713be14ac0463 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 07:54:01 +0800 Subject: [PATCH 40/72] fix(utils): keep confinement active for a declared-but-empty confineTo Both confinement checks in safeWriteJson tested options?.confineTo for truthiness, so a caller passing "" skipped both gates and the write followed any symlink with no scope check. The value occurs in practice: McpHub.confineForMcpWrite falls back to getWorkspacePath(), which is "" while no workspace folder is open, so a project-scoped MCP write ran unconfined even though the caller declared a scope. Confinement is now decided once, up front. _declaredScopeRoot returns undefined only when confineTo is absent, rejects a declared root that is empty or whitespace-only with a ConfinedPathEscapeError naming the declared root, and both confinement checks key off the single derived presence value instead of separate truthiness tests. A declared-but-empty root fails closed before the lock key is resolved, before the lock is taken, before any directory is created, and before anything is staged. Tests pin the empty-string case: the rejection names the declared empty root, the write does not proceed, the target parent directory is not created, and a whitespace-only root fails the same way. --- src/utils/__tests__/safeWriteJson.test.ts | 57 +++++++++++++++++++++++ src/utils/safeWriteJson.ts | 38 +++++++++++++-- 2 files changed, 90 insertions(+), 5 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 05c425346a..95608774c0 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -819,4 +819,61 @@ describe("safeWriteJson", () => { expect(entries).not.toContain("scope-missing-parent") expect(entries.filter((entry) => entry.endsWith(".lock") || entry.includes(".new_"))).toEqual([]) }) + + // A caller that declares a scope must never get the unconstrained path: an + // empty confineTo is a declared scope, not an absent one. This value occurs in + // practice - McpHub.confineForMcpWrite returns getWorkspacePath(), which is "" + // while no workspace folder is open. The truthiness checks skipped both + // confinement gates for "", so the write followed any symlink with no scope + // check at all. + test("rejects a declared-but-empty confineTo instead of writing unconstrained", async () => { + const error = await safeWriteJson(currentTestFilePath, { mcpServers: {} }, { confineTo: "" }).then( + () => undefined, + (reason: unknown) => reason, + ) + expect(error).toBeInstanceOf(ConfinedPathEscapeError) + if (error instanceof ConfinedPathEscapeError) { + // The rejection must name the declared empty root: a substituted root + // (path.resolve("") is the process cwd) would mean confining the write + // to a directory nobody declared. + expect(error.confineTo).toBe("") + } + // The write did not proceed: the target keeps its pre-existing content. + expect(await readFileContent(currentTestFilePath)).toEqual({ initial: "content" }) + }) + + test("rejects an empty confineTo before creating the target parent directory", async () => { + // The same fail-closed decision pinned at the ordering the pre-lock check + // guarantees: a rejected confined write must not create the missing parent + // directory of the target. + const outside = path.join(tempDir, "empty-scope-missing-parent", "nested.json") + + const error = await safeWriteJson(outside, { mcpServers: {} }, { confineTo: "" }).then( + () => undefined, + (reason: unknown) => reason, + ) + expect(error).toBeInstanceOf(ConfinedPathEscapeError) + if (error instanceof ConfinedPathEscapeError) { + expect(error.confineTo).toBe("") + } + + const entries = await fs.readdir(tempDir) + expect(entries).not.toContain("empty-scope-missing-parent") + expect(entries.filter((entry) => entry.endsWith(".lock") || entry.includes(".new_"))).toEqual([]) + }) + + test("rejects a whitespace-only confineTo and names the declared root", async () => { + // path.resolve(" ") is a directory named " " under the process cwd - a + // scope nobody declared. Whitespace-only fails closed with the declared + // root, the same decision as the empty string. + const error = await safeWriteJson(currentTestFilePath, { mcpServers: {} }, { confineTo: " " }).then( + () => undefined, + (reason: unknown) => reason, + ) + expect(error).toBeInstanceOf(ConfinedPathEscapeError) + if (error instanceof ConfinedPathEscapeError) { + expect(error.confineTo).toBe(" ") + } + expect(await readFileContent(currentTestFilePath)).toEqual({ initial: "content" }) + }) }) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index a50ca723da..5992467191 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -38,7 +38,9 @@ export interface SafeWriteJsonOptions { * symlinks before this check runs, so a caller that picked the path from a * known scope (a workspace, a project settings directory) can refuse a write * that a planted symlink would land somewhere else. The check runs before the - * advisory lock is taken and before anything is staged. + * advisory lock is taken and before anything is staged. Confinement is active + * whenever this option is DEFINED: a declared root that is empty or + * whitespace-only is rejected rather than silently disabling the checks. */ confineTo?: string } @@ -119,6 +121,26 @@ function _scopeErrorCode(error: unknown): string | undefined { : undefined } +/** + * The scope root a caller declared, or undefined when no scope was declared. + * Confinement is active whenever confineTo is DEFINED: a declared root that is + * empty or whitespace-only cannot contain any canonicalized path - path.resolve("") + * is the process cwd, not the scope the caller named - so it fails closed here + * instead of silently disabling the checks below, which would let the write + * follow any symlink with no scope check at all. Both confinement checks key off + * this single decision, so they can never disagree about whether a scope is + * active. + */ +function _declaredScopeRoot(confineTo: string | undefined, requestedPath: string): string | undefined { + if (confineTo === undefined) { + return undefined + } + if (confineTo.trim() === "") { + throw new ConfinedPathEscapeError(requestedPath, requestedPath, confineTo) + } + return confineTo +} + /** * Safely writes JSON data to a file. * - Creates parent directories if they don't exist @@ -145,6 +167,12 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // the target when the resolution itself rejects. let resolvedTargetPath: string | undefined + // Confinement is decided once, up front, so both checks below agree on whether a + // scope is active: active whenever confineTo is defined, with a declared-but-empty + // root failing closed before the lock key is resolved, before the lock is taken, + // before any directory is created, and before anything is staged. + const confinementRoot = _declaredScopeRoot(options?.confineTo, absoluteFilePath) + // Lock key: the symlink referent when the path is an existing symlink, so a // symlink alias and its referent share one lock. The key must be computable // while a peer writer is mid-commit (backup mode renames the referent away and @@ -160,8 +188,8 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // directory would surface a lock-acquisition error after retries instead of // ConfinedPathEscapeError). Repeated on the resolved publish target inside the // lock, since a peer writer may move the referent in between. - if (options?.confineTo) { - const scopeRoot = await _resolveScopeRoot(options.confineTo) + if (confinementRoot !== undefined) { + const scopeRoot = await _resolveScopeRoot(confinementRoot) _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(lockKey), scopeRoot) } @@ -192,8 +220,8 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // does not exist yet still carries the alias components of the path it was // given. This runs before the merge read and before anything is staged, so a // rejected write leaves nothing behind. - if (options?.confineTo) { - const scopeRoot = await _resolveScopeRoot(options.confineTo) + if (confinementRoot !== undefined) { + const scopeRoot = await _resolveScopeRoot(confinementRoot) _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(resolvedTargetPath), scopeRoot) } From 325a0a26442ce247af7b7c384a105d9d02e1e688 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 20:38:15 +0800 Subject: [PATCH 41/72] docs(file-safety): narrow what confineTo claims to what it can prove confineTo was documented as refusing a write "that a planted symlink would land somewhere else", which reads as containment for the whole write. It is not. Both confinement checks decide from the final component as it resolves at their own instant, and publication is path based - the parent-directory creation and the commit rename both take a path - so an ancestor directory replaced by a link in the window between the last check and the rename redirects the publish. Measured outcomes of that window, on both platform shapes: - the swapped-in directory already has a file at the target name: realpath resolves the target onto it, the staging identity guard rejects the commit with StagingPathError, and nothing is written on either side; - it does not: realpath and lstat both report ENOENT, resolvePublishTarget falls back to the alias spelling, and the rename follows the swapped ancestor, publishing OUTSIDE the declared scope. Handle-relative no-follow publication (openat/renameat over a directory fd) would close the window; this runtime exposes neither call, so the claim is narrowed here instead of being made true. No new option and no second confinement mechanism: the checks, their order and their outcomes are unchanged. The credential-carrying call sites keep the control and state their own limit in the comment on the helper they call: the case a committed tree can actually plant is a link at the settings file itself, which confineTo does refuse, so dropping the option would give up a refusal that works today in order to close a window no unit can close in this runtime. Two tests pin the limit as an executable contract, one per outcome, with the ancestor swapped from the merge callback so it moves inside the window rather than hopefully so. Against a production that honoured the old claim - a confinement re-check at the publish - exactly those two tests are red (2 failed / 29 passed / 4 skipped); against the shipped production they are green, because this change narrows a claim and not a behaviour. Per-call-site mutants of the control each redden only the test that names that call site (pre-lock check 2, declared-but- empty root 3, each McpHub confineTo 1). Local: safeWriteJson, safeWriteJson.lockKey, safeWriteText, safeWriteText.integration and McpHub together 177 passed / 4 skipped; eslint --max-warnings=0 clean on all three files with no suppression drift; tsc --noEmit 137 errors, none in a touched file (junction-donor baseline); prettier --check clean on the three files after the CRLF to LF rewrite. See tracking item 6104592203. --- src/services/mcp/McpHub.ts | 19 ++++- src/utils/__tests__/safeWriteJson.test.ts | 98 +++++++++++++++++++++++ src/utils/safeWriteJson.ts | 31 ++++++- 3 files changed, 141 insertions(+), 7 deletions(-) diff --git a/src/services/mcp/McpHub.ts b/src/services/mcp/McpHub.ts index f8f74e1bd0..13e2dee839 100644 --- a/src/services/mcp/McpHub.ts +++ b/src/services/mcp/McpHub.ts @@ -639,9 +639,22 @@ export class McpHub { * safeWriteJson resolves the publish target with realpath before staging beside it, so a * repository that ships .roo/mcp.json as a symlink to a file OUTSIDE the workspace would * have that outside file replaced as soon as the user edits a project MCP setting or - * allowlist. Passing the canonical workspace root as confineTo makes the write fail closed - * instead. Global writes are deliberately unconstrained: they target the user's own - * settings directory, which is not under the workspace. + * allowlist. Passing the workspace root as confineTo makes that write fail closed instead. + * Global writes are deliberately unconstrained: they target the user's own settings + * directory, which is not under the workspace. + * + * DECISION AND LIMIT - these three call sites carry credentials (MCP server env and + * headers), so the limit of the control they pass is stated here rather than left to the + * option doc: confineTo decides twice from the resolved publish target and stops at its + * final component. If a workspace replaces an ANCESTOR directory - .roo, or the workspace + * directory itself - with a link after the last check, the credential write follows that + * link and can still land outside the workspace; see the confineTo doc in + * src/utils/safeWriteJson.ts for the two outcomes of that window. The control is kept + * anyway, not dropped, because the case a committed tree can actually plant is a link at + * the settings file itself, and that is the case this option does refuse. Closing the + * ancestor window needs a handle-relative no-follow publish, which this runtime does not + * offer, and the alternative reading - removing the control from the credential path - + * would give up the refusal that works today to close a window no unit can close here. */ private confineForMcpWrite(source: "global" | "project"): string | undefined { if (source !== "project") { diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 95608774c0..5976ac5d9a 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -3,6 +3,7 @@ import { Writable } from "stream" import * as path from "path" import * as os from "os" +import { StagingPathError } from "../../services/file-safety/safeWriteText" import { ConfinedPathEscapeError, safeWriteJson } from "../safeWriteJson" import * as lockfile from "proper-lockfile" @@ -876,4 +877,101 @@ describe("safeWriteJson", () => { } expect(await readFileContent(currentTestFilePath)).toEqual({ initial: "content" }) }) + + // The confinement option decides from the resolved publish target and stops at its final + // component. What it does NOT cover is an ancestor DIRECTORY replaced by a link in the + // window between that decision and the commit rename, because publication takes a path + // and re-resolves the tree at rename time. These two tests are that limit as an + // executable contract - one per outcome of the window - so the documented narrowing + // cannot drift back into an unearned guarantee. The swap is driven from the merge + // callback, which safeWriteJson invokes after the in-lock confinement check and before + // anything is staged, so the ancestor moves inside the window rather than hopefully so. + // A directory link needs no privilege on win32 as a junction; "dir" is the POSIX + // spelling. Both make the ancestor itself the link, which is the shape under test. + const ancestorLinkKind = process.platform === "win32" ? ("junction" as const) : ("dir" as const) + + function swapAncestorAfterTheCheck(ancestor: string, pointsAt: string): void { + fsSyncActual.renameSync(ancestor, ancestor + "-moved-aside") + fsSyncActual.symlinkSync(pointsAt, ancestor, ancestorLinkKind) + } + + test("publishes outside the declared scope when an ancestor is swapped after the final confinement check", async () => { + const projectDir = path.join(tempDir, "swap-project") + const ancestor = path.join(projectDir, "settings") + await fs.mkdir(ancestor, { recursive: true }) + const target = path.join(ancestor, "mcp.json") + await fs.writeFile(target, JSON.stringify({ inside: true })) + // The swapped-in directory has no file at the target name yet: this is the half of the + // window in which nothing stops the publish. + const swappedIn = path.join(tempDir, "elsewhere", "settings") + await fs.mkdir(swappedIn, { recursive: true }) + + await safeWriteJson( + target, + { written: "payload" }, + { + confineTo: projectDir, + merge: () => { + swapAncestorAfterTheCheck(ancestor, swappedIn) + return { written: "payload" } + }, + }, + ) + + // The bytes landed OUTSIDE the declared scope: the option confines the target it + // resolved, not the directory tree above it. + expect(JSON.parse(fsSyncActual.readFileSync(path.join(swappedIn, "mcp.json"), "utf8"))).toEqual({ + written: "payload", + }) + // The file that was inside the scope keeps its pre-write bytes - the publish did not + // reach it under the moved-aside name either. + expect(JSON.parse(fsSyncActual.readFileSync(path.join(ancestor + "-moved-aside", "mcp.json"), "utf8"))).toEqual( + { inside: true }, + ) + // The scope was declared and active in this very fixture: with the ancestor left + // alone, the same option refuses an out-of-scope target. Without this contrast the + // escape above would also be the outcome of a confinement check that never ran. + await expect( + safeWriteJson(path.join(tempDir, "elsewhere", "other.json"), { other: true }, { confineTo: projectDir }), + ).rejects.toThrow(ConfinedPathEscapeError) + }) + + test("fails the publish instead of following a swapped ancestor onto an existing target", async () => { + const projectDir = path.join(tempDir, "swap-project-clash") + const ancestor = path.join(projectDir, "settings") + await fs.mkdir(ancestor, { recursive: true }) + const target = path.join(ancestor, "mcp.json") + await fs.writeFile(target, JSON.stringify({ inside: true })) + const swappedIn = path.join(tempDir, "elsewhere-clash", "settings") + await fs.mkdir(swappedIn, { recursive: true }) + await fs.writeFile(path.join(swappedIn, "mcp.json"), JSON.stringify({ outside: true })) + + const error = await safeWriteJson( + target, + { written: "payload" }, + { + confineTo: projectDir, + merge: () => { + swapAncestorAfterTheCheck(ancestor, swappedIn) + return { written: "payload" } + }, + }, + ).then( + () => undefined, + (reason: unknown) => reason, + ) + + // The publish is stopped, but by the staging identity guard of the commit and not by + // confinement: the option does not claim this case, and the two must stay tellable + // apart from the error type alone. + expect(error).toBeInstanceOf(StagingPathError) + expect(error).not.toBeInstanceOf(ConfinedPathEscapeError) + // Nothing was written on either side of the swap. + expect(JSON.parse(fsSyncActual.readFileSync(path.join(swappedIn, "mcp.json"), "utf8"))).toEqual({ + outside: true, + }) + expect(JSON.parse(fsSyncActual.readFileSync(path.join(ancestor + "-moved-aside", "mcp.json"), "utf8"))).toEqual( + { inside: true }, + ) + }) }) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 5992467191..c5ec2aab27 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -38,9 +38,27 @@ export interface SafeWriteJsonOptions { * symlinks before this check runs, so a caller that picked the path from a * known scope (a workspace, a project settings directory) can refuse a write * that a planted symlink would land somewhere else. The check runs before the - * advisory lock is taken and before anything is staged. Confinement is active - * whenever this option is DEFINED: a declared root that is empty or - * whitespace-only is rejected rather than silently disabling the checks. + * advisory lock is taken and before anything is staged, and it is repeated on + * the resolved publish target inside the lock so a peer writer that moved the + * referent in between is caught too. Confinement is active whenever this option + * is DEFINED: a declared root that is empty or whitespace-only is rejected + * rather than silently disabling the checks. + * + * What it does NOT cover: an ancestor DIRECTORY of the target that is replaced + * by a link in the window between the last check and the commit rename. Both + * checks decide from the final component as it resolves at their own instant, + * and publication is path based - the parent-directory creation and the commit + * rename both take a path - so an ancestor swapped after the check redirects the + * publish. What happens then depends on what sits at the swapped-in path: if it + * already has a file at the target name the publish fails in the staging + * identity guard (StagingPathError) and nothing is written; if it does not, the + * write follows the swapped ancestor and lands OUTSIDE the declared scope. This + * option claims neither outcome: it confines the target it resolved, not the + * directory tree above it. Making the claim cover that window needs a publish + * that walks from an already-open directory handle with no-follow semantics + * (openat/renameat over a directory fd); this runtime exposes neither, so the + * claim is narrowed here instead of being made true. A caller that needs + * containment across that window cannot get it from this option. */ confineTo?: string } @@ -219,7 +237,12 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // same way: the publish target is resolved through symlinks, and a target that // does not exist yet still carries the alias components of the path it was // given. This runs before the merge read and before anything is staged, so a - // rejected write leaves nothing behind. + // rejected write leaves nothing behind. It is also the LAST confinement + // decision of this write: it decides the final component as it resolves here, + // and an ancestor directory replaced by a link between this point and the + // commit rename below is outside its reach, because the rename takes a path and + // re-resolves the tree at rename time. See the confineTo option doc for what the + // two outcomes of that window are and why neither is claimed by this option. if (confinementRoot !== undefined) { const scopeRoot = await _resolveScopeRoot(confinementRoot) _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(resolvedTargetPath), scopeRoot) From 0fe578c8081a2fdacab6d7da5cb83522465241e1 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech Date: Sun, 11 Oct 2026 22:02:57 +0800 Subject: [PATCH 42/72] fix(file-safety): refuse a publish whose Windows DACL cannot be preserved The Security Boundaries pre-merge row reports that safeWriteText commits a replacement when the Windows DACL capture fails - it only warns, although the replacement may inherit different access rights - and that the same warn-only shape covers a DACL restore that fails after the commit rename. A project .roo/mcp.json with restrictive ACLs can hold MCP env or header secrets, so a publish that silently widens who can read the file is not a save the caller can trust. Fail closed for an existing target whose DACL cannot be read or preserved, on the shape the chain's earliest unit already ships: - DaclInspectionError (phase "save" | "inspect") is thrown in step 2, before the commit rename, when icacls /save fails or the target exists but its access rights cannot be checked. Nothing is published, so the target keeps its content and its rights, and the failure handler still releases the staged file and this write's own staging directory. - DaclRestoreError is thrown in step 5 when the saved dump cannot be put back, so no caller can observe success for a publish whose DACL was not preserved. - The failure handler keeps the backup copy for a DaclRestoreError instead of removing it: that copy is the only artifact still carrying the access rights of the file the publish replaced, so deleting it would destroy the recovery path for exactly the fact the error reports. Its path is named through onWarning, which now carries only that leftover notice. Tests pin each point at the primitive: the refusal with its phase and target path, no rename and no warning for a write that did not happen, cleanup counted once, the restore failure as an error with the dump still unlinked, the backup copy retained and named, and the caller-staged shape safeWriteJson hands in. Negative controls: four mutants, one per changed production call site, each reddening only the tests that name that behaviour, plus a run of the new tests against the pre-fix production file (10 red, 55 green). --- .../safeWriteText.integration.spec.ts | 10 +- .../__tests__/safeWriteText.spec.ts | 248 ++++++++++++++---- src/services/file-safety/safeWriteText.ts | 162 ++++++++---- 3 files changed, 317 insertions(+), 103 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts b/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts index cfec2e0520..4a3ee6e8e5 100644 --- a/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.integration.spec.ts @@ -22,9 +22,13 @@ describe("safeWriteText against a real filesystem", () => { const targetPath = path.join(dir, "target.txt") await fs.writeFile(targetPath, "old bytes") - // No platform override: the real platform's own durability and ACL steps run. - // A failed icacls restore in a throwaway temp directory is reported, not thrown, - // so the publish still lands. + // No platform override: the real platform's own durability and ACL steps run, and this + // case is the successful restore. A failed restore now throws DaclRestoreError after + // the commit rename has already happened (the focused unit test "win32 DACL: a failed + // restore is an error and the dump is still unlinked" covers that path), so on a + // machine where icacls cannot put a saved ACL back into a throwaway temp directory + // this publish reports that error instead of resolving, and the residue assertions + // below are reached only where the restore worked. await safeWriteText(targetPath, "new bytes", { backup: true }) expect(await fs.readFile(targetPath, "utf8")).toBe("new bytes") diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index e7bf2767e6..189d09bd9d 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -5,6 +5,8 @@ import type { ChildProcess } from "child_process" import * as path from "path" import { + DaclInspectionError, + DaclRestoreError, PostCommitDurabilityError, resolveLockKey, safeWriteText, @@ -281,16 +283,21 @@ describe("safeWriteText", () => { }) }) - it("win32: a rejecting async onWarning does not abort the write or leak an unhandled rejection", async () => { + it("win32: a rejecting async onWarning does not displace the caller's error or leak an unhandled rejection", async () => { // TypeScript accepts an async sink where a void callback is expected, so the // wrapper has to attach a handler to the returned promise: an unhandled - // rejection can end the process under Node's default mode, after a write that - // already succeeded. + // rejection can end the process under Node's default mode. The notice exercised + // here is the retained-backup one - the DACL notices became refusals - so a sink + // failure now has to be reported without displacing the error the caller catches. const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) + // The DACL save succeeds and only the restore fails: the publish commits and + // reports its retained backup copy through the sink. + let icaclsCalls = 0 vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - if (typeof cb === "function") cb(new Error("icacls error"), "", "") + icaclsCalls++ + if (typeof cb === "function") cb(icaclsCalls === 1 ? null : new Error("icacls restore error"), "", "") return fakeChild }) const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {}) @@ -298,13 +305,14 @@ describe("safeWriteText", () => { await expect( safeWriteText(targetPath, "data", { platform: "win32", + backup: true, onWarning: async () => { throw new Error("async sink down") }, }), - ).resolves.toBeUndefined() + ).rejects.toBeInstanceOf(DaclRestoreError) - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) // The rejection is reported through the fallback sink rather than surfacing as an // unhandled rejection. expect(consoleWarn).toHaveBeenCalledWith(expect.stringContaining("onWarning callback rejected")) @@ -595,7 +603,7 @@ describe("safeWriteText", () => { expect(execFile).not.toHaveBeenCalled() }) - it("win32 DACL failure falls back to plain rename (never fails the write)", async () => { + it("win32 DACL failure refuses the publish instead of renaming over the target", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) @@ -605,15 +613,32 @@ describe("safeWriteText", () => { return fakeChild }) - await safeWriteText(targetPath, "data", { platform: "win32" }) + // Captured once: calling safeWriteText twice here would double-count the single + // icacls attempt asserted below. + const refusal = await safeWriteText(targetPath, "data", { platform: "win32" }).catch( + (error: unknown) => error, + ) - // write succeeded despite icacls failure (fallback to plain rename) - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) - // one icacls attempt only: a failed DACL apply must not try to restore + expect(refusal).toBeInstanceOf(DaclInspectionError) + // The class alone does not pin the contract: swapping the phase or dropping the + // target path still satisfies toBeInstanceOf, and both are caller-visible - the + // phase says which check refused, the path names the file the caller must not + // assume was saved. + expect(refusal).toMatchObject({ + name: "DaclInspectionError", + phase: "save", + targetPath, + message: expect.stringContaining("its DACL could not be saved"), + }) + + // Contract change (Security Boundaries row): a target whose DACL could not be + // saved is no longer replaced by a file that inherits different rights. + expect(fs.rename).not.toHaveBeenCalled() + // one icacls attempt only: a failed capture must not try to restore expect(execFile).toHaveBeenCalledTimes(1) }) - it("win32: reports that access rights may change when the DACL cannot be saved", async () => { + it("win32: refuses the publish without an onWarning notice when the DACL cannot be saved", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) @@ -623,20 +648,24 @@ describe("safeWriteText", () => { }) const warnings: string[] = [] - await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + await expect( + safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }), + ).rejects.toBeInstanceOf(DaclInspectionError) - // The write still commits - a failing icacls must not leave the user unable to save - - // but the caller is told the replacement may not carry the old ACL. - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) - expect(warnings.filter((m) => m.includes("different access rights"))).toHaveLength(1) + // Contract change: the refusal replaces the warning. There is no replacement whose + // access rights could have changed, so no notice is emitted for a write that did + // not happen - a warning beside a refused publish would let a caller that ignores + // the error still read the write as a save. + expect(fs.rename).not.toHaveBeenCalled() + expect(warnings).toHaveLength(0) }) - it("win32: reports when the target cannot be checked for DACL preservation", async () => { + it("win32: refuses the publish when the target cannot be checked for DACL preservation", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) // The target exists but is not readable: that is not "absent", and skipping DACL - // preservation has to be visible. + // preservation has to stop the publish rather than be reported beside it. vi.mocked(fs.access).mockImplementation(async (p) => { if (String(p) === targetPath) { throw Object.assign(new Error("EACCES"), { code: "EACCES" }) @@ -644,14 +673,33 @@ describe("safeWriteText", () => { }) const warnings: string[] = [] - await safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }) + // Captured once: a second call would double-count the assertions below. + const refusal = await safeWriteText(targetPath, "data", { + platform: "win32", + onWarning: (m) => warnings.push(m), + }).catch((error: unknown) => error) + + expect(refusal).toBeInstanceOf(DaclInspectionError) + expect(refusal).toMatchObject({ + name: "DaclInspectionError", + phase: "inspect", + targetPath, + message: expect.stringContaining("its access rights could not be checked"), + }) + // Contract change: "there but unreadable" is no longer a reason to publish blind. + // The publish is refused before any icacls runs, and nothing is warned about a + // write that did not happen. expect(execFile).not.toHaveBeenCalled() - expect(warnings.filter((m) => m.includes("Could not check"))).toHaveLength(1) + expect(fs.rename).not.toHaveBeenCalled() + expect(warnings).toHaveLength(0) }) - // Warning delivery is advisory: it must not be able to fail the save it is reporting on. - it("win32: a throwing onWarning does not abort the write", async () => { + // The refusals sit inside the try whose catch performs the cleanup, so a refused + // publish is cleaned up by that handler and by nothing else. Counted, not matched + // with toHaveBeenCalledWith: that matcher passes however many times the same path + // is passed, so it cannot see a cleanup that runs twice. + it("win32: a refused publish removes its staged file and staging directory exactly once", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) @@ -660,16 +708,47 @@ describe("safeWriteText", () => { return fakeChild }) - await expect( - safeWriteText(targetPath, "data", { - platform: "win32", - onWarning: () => { - throw new Error("callback down") - }, - }), - ).resolves.toBeUndefined() + await expect(safeWriteText(targetPath, "data", { platform: "win32" })).rejects.toBeInstanceOf( + DaclInspectionError, + ) - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining(".file-safety-staging"), targetPath) + const unlinkCalls = vi.mocked(fs.unlink).mock.calls.map((call) => String(call[0])) + const rmdirCalls = vi.mocked(fs.rmdir).mock.calls.map((call) => String(call[0])) + expect(unlinkCalls.filter((p) => p.includes("safeWriteText_"))).toHaveLength(1) + expect(rmdirCalls.filter((p) => p.includes(".file-safety-staging"))).toHaveLength(1) + }) + + // Warning delivery is advisory: it must not be able to change what the caller learns. + it("win32: a throwing onWarning does not replace the error the caller receives", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The DACL save succeeds and the restore fails, so the notice this sink throws on + // is the retained-backup one delivered from the failure handler. + let icaclsCalls = 0 + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + icaclsCalls++ + if (typeof cb === "function") cb(icaclsCalls === 1 ? null : new Error("icacls restore error"), "", "") + return fakeChild + }) + const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {}) + + const failure = await safeWriteText(targetPath, "data", { + platform: "win32", + backup: true, + onWarning: () => { + throw new Error("callback down") + }, + }).catch((error: unknown) => error) + + // A broken notice cannot turn a refused publish into an unreported one, and cannot + // swallow the write either: the caller still holds the DACL error. + expect(failure).toBeInstanceOf(DaclRestoreError) + expect(fs.rename).toHaveBeenCalledTimes(1) + // The sink really was reached, so this is not a test that passes because no + // notice was ever delivered. + expect(consoleWarn).toHaveBeenCalledWith(expect.stringContaining("onWarning callback failed")) + consoleWarn.mockRestore() }) it("win32 DACL: a partial dump left by a failed save is removed and never restored", async () => { @@ -684,11 +763,13 @@ describe("safeWriteText", () => { return fakeChild }) - await safeWriteText(targetPath, "data", { platform: "win32" }) + await expect(safeWriteText(targetPath, "data", { platform: "win32" })).rejects.toBeInstanceOf( + DaclInspectionError, + ) - // write committed; only the save was attempted (no restore from a failed dump) - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) - expect(fs.rename).toHaveBeenCalledTimes(1) + // Contract change: the publish is refused, so nothing is renamed. Only the save was + // attempted, and the partial dump is still removed below. + expect(fs.rename).not.toHaveBeenCalled() expect(execFile).toHaveBeenCalledTimes(1) const saveArgs = vi.mocked(execFile).mock.calls[0]?.[1] expect(saveArgs?.[1]).toBe("/save") @@ -747,11 +828,11 @@ describe("safeWriteText", () => { expect(commitRename).toBeLessThan(restoreCall) }) - it("win32 DACL: a failed restore is reported and the dump is still unlinked", async () => { + it("win32 DACL: a failed restore is an error and the dump is still unlinked", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) - const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {}) + const warnings: string[] = [] // icacls save succeeds, restore fails let callCount = 0 @@ -763,21 +844,100 @@ describe("safeWriteText", () => { return fakeChild }) - await safeWriteText(targetPath, "data", { platform: "win32" }) + const failure = await safeWriteText(targetPath, "data", { + platform: "win32", + onWarning: (m) => warnings.push(m), + }).catch((error: unknown) => error) + + expect(failure).toBeInstanceOf(DaclRestoreError) + // The class alone does not pin the contract: the committed path is what a caller + // needs in order to tell which file answers to different rights than it did. + expect(failure).toMatchObject({ + name: "DaclRestoreError", + targetPath, + message: expect.stringContaining("could not be restored"), + }) - // The content did commit: failing here would break every publish on a machine - // where icacls cannot reapply the saved ACEs. + // The content did commit before the restore failed, so the rename happened exactly + // once even though the publish reports an error. expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) expect(fs.rename).toHaveBeenCalledTimes(1) - // The changed access rights are reported instead of being swallowed. - expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("could not be restored")) - warnSpy.mockRestore() + // Contract change: the changed access rights are an error the caller receives, not + // a notice beside a write that resolved. With no backup copy in play there is no + // leftover to name, so this publish stays silent and reports through the error. + expect(warnings).toHaveLength(0) // dump file was still unlinked in finally expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) + it("win32 DACL: a failed restore keeps the backup copy that still carries the original access rights", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + const warnings: string[] = [] + let callCount = 0 + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + callCount++ + if (typeof cb === "function") cb(callCount === 1 ? null : new Error("icacls restore error"), "", "") + return fakeChild + }) + + await expect( + safeWriteText(targetPath, "data", { + platform: "win32", + backup: true, + onWarning: (m) => warnings.push(m), + }), + ).rejects.toBeInstanceOf(DaclRestoreError) + + // The publish committed, and the copy made from the file it replaced is the only + // artifact left holding the access rights that could not be restored. Removing it + // would destroy the recovery path for exactly the fact the error reports, so the + // failure handler must leave it in place. Counted, because toHaveBeenCalledWith + // cannot see a second unlink of the same path. + const unlinks = vi.mocked(fs.unlink).mock.calls.map((call) => String(call[0])) + expect(unlinks.filter((p) => p.includes("safeWriteText.bak_"))).toHaveLength(0) + expect(fs.rename).toHaveBeenCalledTimes(1) + + // The retained path is named to the human: this primitive has no structured result + // to carry it on, and an invisible leftover is worse than a visible one. + expect(warnings.filter((m) => m.includes("safeWriteText.bak_"))).toHaveLength(1) + }) + + it("win32 DACL: a failed restore reaches the caller-staged publish safeWriteJson hands in", async () => { + // safeWriteJson stages its own temp file and calls in with backup:true, so this is + // the shape its callers actually see: the publish must reject rather than resolve + // over a file whose rights changed, and keep the copy that still carries them. + const targetPath = "/tmp/test-dir/target.txt" + const callerTemp = "/tmp/test-dir/caller-staged.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + let callCount = 0 + vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { + callCount++ + if (typeof cb === "function") cb(callCount === 1 ? null : new Error("icacls restore error"), "", "") + return fakeChild + }) + + const outcome = await safeWriteText(targetPath, "", { + platform: "win32", + backup: true, + tempPath: callerTemp, + }).then( + () => "resolved" as const, + (error: unknown) => error, + ) + + // Not "resolved": no caller can observe success for a publish whose DACL was not + // preserved. + expect(outcome).toBeInstanceOf(DaclRestoreError) + expect(fs.rename).toHaveBeenCalledWith(callerTemp, targetPath) + const unlinks = vi.mocked(fs.unlink).mock.calls.map((call) => String(call[0])) + expect(unlinks.filter((p) => p.includes("safeWriteText.bak_"))).toHaveLength(0) + }) + it("win32 DACL: when target does not exist, no save/restore/dump", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 88167a2d06..9bb5545720 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -28,10 +28,12 @@ export interface SafeWriteTextOptions { execFileRunner?: typeof execFile /** - * Sink for non-fatal safety notices. A Windows DACL that could not be captured means the - * committed file may inherit different access rights: the write still proceeds (a missing or - * failing icacls must not block saving), but the caller is told instead of the change being - * silent. Defaults to console.warn. + * Sink for non-fatal safety notices. The notice that still reaches it is a leftover: the backup + * copy kept beside the target after a Windows DACL restore failed, named with its path. A DACL + * that could not be captured is no longer a notice here - the publish is refused with + * DaclInspectionError before anything is committed - and a saved DACL that could not be put back + * after the commit arrives as DaclRestoreError rather than a warning, so neither reaches this + * sink. Defaults to console.warn. */ onWarning?: (message: string) => void @@ -78,6 +80,41 @@ export class PostCommitDurabilityError extends Error { this.targetPath = targetPath } } + +/** + * The target exists but its access rights could not be inspected or saved, so publishing would + * replace it with a file that inherits different rights. On Windows the publish is refused before + * anything is committed: a save that silently widened who can read the file is not a save the + * caller can trust, and nothing has been published yet, so the target still holds its content. + */ +export class DaclInspectionError extends Error { + constructor( + readonly targetPath: string, + readonly phase: "inspect" | "save", + readonly causeError: unknown, + ) { + const detail = phase === "save" ? "its DACL could not be saved" : "its access rights could not be checked" + super(`safeWriteText: refusing to publish over ${targetPath} because ${detail}`) + this.name = "DaclInspectionError" + } +} + +/** + * The content is committed but the saved DACL could not be put back on it, so the file at the + * target answers to different access rights than the one it replaced. Reported as an error rather + * than a warning: no caller can observe success for a publish whose DACL was not preserved. The + * failure handler keeps this write's backup copy for it - that copy is the only artifact still + * carrying the access rights of the file the publish replaced. + */ +export class DaclRestoreError extends Error { + constructor( + readonly targetPath: string, + readonly causeError: unknown, + ) { + super(`safeWriteText: content committed at ${targetPath}, but its saved access rights could not be restored`) + this.name = "DaclRestoreError" + } +} // -- helpers --------------------------------------------------------------- /** Generate a unique temp file name in the given directory. */ @@ -337,6 +374,32 @@ export async function safeWriteText( // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null + // Warning delivery must never abort the write: the notice below describes a leftover + // beside a committed file, and a caller whose callback throws (a UI sink, a logger that is + // mid-restart) must not turn that into a different failure than the one the caller is told + // about. Declared above the try so the failure handler can report a retained backup through it. + const warn = (message: string) => { + const report = (label: string, error: unknown) => { + console.warn( + `safeWriteText: onWarning callback ${label}: ${error instanceof Error ? error.message : String(error)}`, + ) + } + try { + const sink = options?.onWarning ?? ((m: string) => console.warn(m)) + const result: unknown = sink(message) + // A sink may be async - TypeScript accepts a value-returning callback where + // a void one is expected. Awaiting it would let warning delivery delay a + // write that has already committed (and hang it if the sink never settles), + // while leaving the promise unhandled turns a rejection into an unhandled + // rejection, which under Node's default mode can end the process after a + // successful write. Attach a handler without awaiting. + if (result instanceof Promise) { + result.catch((error: unknown) => report("rejected", error)) + } + } catch (error: unknown) { + report("failed", error) + } + } try { // -- Step 1: write content to staging temp file ------------------- if (!options?.tempPath) { @@ -406,31 +469,6 @@ export async function safeWriteText( // -- Step 2 (win32): save DACL BEFORE the backup copy ----------- const platform = options?.platform ?? process.platform - // Warning delivery must never abort the write: the notices below describe a - // committed-but-imperfect publish, and a caller whose callback throws (a UI sink, - // a logger that is mid-restart) must not turn that into a failed save. - const warn = (message: string) => { - const report = (label: string, error: unknown) => { - console.warn( - `safeWriteText: onWarning callback ${label}: ${error instanceof Error ? error.message : String(error)}`, - ) - } - try { - const sink = options?.onWarning ?? ((m: string) => console.warn(m)) - const result: unknown = sink(message) - // A sink may be async - TypeScript accepts a value-returning callback where - // a void one is expected. Awaiting it would let warning delivery delay a - // write that has already committed (and hang it if the sink never settles), - // while leaving the promise unhandled turns a rejection into an unhandled - // rejection, which under Node's default mode can end the process after a - // successful write. Attach a handler without awaiting. - if (result instanceof Promise) { - result.catch((error: unknown) => report("rejected", error)) - } - } catch (error: unknown) { - report("failed", error) - } - } if (platform === "win32") { let accessError: unknown = null try { @@ -451,21 +489,20 @@ export async function safeWriteText( // no later step can restore from it. await fs.unlink(dumpPath).catch(() => {}) // The target exists and its DACL could not be captured, so the commit rename - // replaces it with a file that inherits different access rights. The write still - // proceeds - a missing or failing icacls must not leave the user unable to save - - // but the replacement is no longer ACL-identical and that has to be visible - // instead of silent. - warn( - `Could not save the DACL of ${targetPath}; the replacement may inherit different access rights.`, - ) + // would replace it with a file that inherits different access rights, and nothing + // here can verify an equivalent restrictive ACL on that replacement. The publish is + // refused instead of warned about: a save that silently changed who can read the + // file is not a save the caller can trust. Nothing is committed yet, so the target + // still holds its content, and this throw lands in the handler at the bottom of + // this try - the one place that removes the staged file and this write's own + // staging directory - so a refused publish strands neither. + throw new DaclInspectionError(targetPath, "save", null) } } else if (errorCode(accessError) !== "ENOENT") { - // Not "absent": the target is there but could not be checked (EACCES, ...), so - // DACL preservation was skipped for a reason the caller cannot infer from the - // successful write alone. - warn( - `Could not check ${targetPath} for DACL preservation (${errorCode(accessError) ?? "unknown error"}); the replacement may inherit different access rights.`, - ) + // Not "absent": the target is there but its access rights could not be read + // (EACCES, ...), so publishing would replace a file whose rights this call never + // learned. Same rule as the failed save above: refuse before anything is committed. + throw new DaclInspectionError(targetPath, "inspect", accessError) } } try { @@ -547,15 +584,14 @@ export async function safeWriteText( const restoredDir = path.dirname(targetPath) const restored = await _restoreDaclWindows(restoredDir, daclDumpPath, options?.execFileRunner) if (!restored) { - // The content is committed, but the published file may carry a different DACL - // from the one that was saved. Failing the write here would break every - // publish on machines where icacls cannot reapply the saved ACEs (a plain - // temp directory restore fails with "Not all privileges or groups referenced - // are assigned to the caller"), so the change of access rights is reported - // rather than thrown. - warn( - `safeWriteText: content committed at ${targetPath}, but the saved DACL could not be restored from ${daclDumpPath}; the file may carry different access rights than the one it replaced.`, - ) + // The content is committed, but the published file answers to a different DACL + // from the one that was saved, and nothing here verified an equivalent + // restrictive ACL on the replacement. This reaches the caller as an error rather + // than a warning: no caller can observe success for a publish whose DACL was not + // preserved. The handler at the bottom of this try keeps the backup copy for this + // error instead of rolling the published content back, so the throw reports the + // changed access rights without undoing a write the caller can already observe. + throw new DaclRestoreError(targetPath, null) } } @@ -588,11 +624,25 @@ export async function safeWriteText( // published, a later failure (for example the post-commit directory fsync) // must not overwrite the published content with the old file. if (backupPath && releaseBackupOnSuccess) { - // Nothing to restore: the backup is a copy, so the target still holds whatever - // the commit left there - before the commit that is the pre-write content, and - // after it the published content. Either way the copy has served its purpose - // and must not be left beside the target where no caller can find it. - await fs.unlink(backupPath).catch(() => {}) + if (originalError instanceof DaclRestoreError) { + // The one post-commit failure that keeps its copy. The published file answers to + // the descriptor its staging file was created with, and this copy - made from the + // file the publish replaced, so on Windows it carries that file's security + // attributes - is the only artifact left holding the access rights that could not + // be restored. Deleting it would destroy the only recovery path for exactly the + // fact the error reports, so the copy stays and its path is named to the human: + // the caller already holds the error, and this primitive reports a leftover on + // the warning sink because it has no structured result to carry it on. + warn( + `${originalError.message}; its backup copy is kept at ${backupPath} and still carries the access rights of the file it replaced.`, + ) + } else { + // Nothing to restore: the backup is a copy, so the target still holds whatever + // the commit left there - before the commit that is the pre-write content, and + // after it the published content. Either way the copy has served its purpose + // and must not be left beside the target where no caller can find it. + await fs.unlink(backupPath).catch(() => {}) + } backupPath = null } try { From d73231eb3a5ca31a3d6797333a34f5bf667b6e44 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Wed, 14 Oct 2026 12:40:49 +0800 Subject: [PATCH 43/72] style(tools): keep the merged spec import block prettier-clean --- src/core/tools/__tests__/readFileTool.spec.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 6063c06eff..a172f6edb2 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -22,7 +22,6 @@ import type { Task } from "../../task/Task" import { isBinaryFile } from "isbinaryfile" - import { readFileTool, ReadFileTool } from "../ReadFileTool" import { ObservationRegistry } from "../../task/observationRegistry" import { formatResponse } from "../../prompts/responses" From 56fe7a01fbcb28487d77170fc793e7a03945232a Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Wed, 14 Oct 2026 12:56:06 +0800 Subject: [PATCH 44/72] fix(u4): align the unit with main's unused-vars re-enable #2038 turned @typescript-eslint/no-unused-vars back on in src and removed the tree's dead bindings. Replaying this unit onto that main exposed the bindings this unit's own code left unused once main's deletions landed: drop the ReadFileTool/SafeWriteTextOptions/lockfile imports and the never-read committed flag, prefix the four write-path destructurings whose value no assertion reads, and restore the safeWriteJson import main pruned (main had no reader; this unit's McpHub tests do). No behavior change: 357 tests green across the unit's specs, eslint clean, tsc adds no new errors beyond the pre-existing local donor-package drift. --- .msg-u4.txt | 12 ++++++++++++ src/core/tools/__tests__/readFileTool.spec.ts | 10 +++++----- .../file-safety/__tests__/safeWriteText.spec.ts | 1 - src/services/file-safety/safeWriteText.ts | 2 -- src/services/mcp/__tests__/McpHub.spec.ts | 1 + src/utils/__tests__/safeWriteJson.test.ts | 1 - 6 files changed, 18 insertions(+), 9 deletions(-) create mode 100644 .msg-u4.txt diff --git a/.msg-u4.txt b/.msg-u4.txt new file mode 100644 index 0000000000..3087b8b4e1 --- /dev/null +++ b/.msg-u4.txt @@ -0,0 +1,12 @@ +fix(u4): align the unit with main's unused-vars re-enable + +#2038 turned @typescript-eslint/no-unused-vars back on in src and removed +the tree's dead bindings. Replaying this unit onto that main exposed the +bindings this unit's own code left unused once main's deletions landed: +drop the ReadFileTool/SafeWriteTextOptions/lockfile imports and the +never-read committed flag, prefix the four write-path destructurings whose +value no assertion reads, and restore the safeWriteJson import main pruned +(main had no reader; this unit's McpHub tests do). + +No behavior change: 357 tests green across the unit's specs, eslint clean, +tsc adds no new errors beyond the pre-existing local donor-package drift. diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index a172f6edb2..ae1b4c11b3 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -22,7 +22,7 @@ import type { Task } from "../../task/Task" import { isBinaryFile } from "isbinaryfile" -import { readFileTool, ReadFileTool } from "../ReadFileTool" +import { readFileTool } from "../ReadFileTool" import { ObservationRegistry } from "../../task/observationRegistry" import { formatResponse } from "../../prompts/responses" import { validateImageForProcessing, processImageFile, isSupportedImageFormat } from "../helpers/imageHelpers" @@ -2294,7 +2294,7 @@ describe("ReadFileTool", () => { ) expect(observeSpy).toHaveBeenCalledTimes(1) - const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + const [_calledPath, , calledComplete] = observeSpy.mock.calls[0] expect(calledComplete).toBe(false) }) @@ -2325,7 +2325,7 @@ describe("ReadFileTool", () => { ) expect(observeSpy).toHaveBeenCalledTimes(1) - const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + const [_calledPath, , calledComplete] = observeSpy.mock.calls[0] expect(calledComplete).toBe(false) }) @@ -2383,7 +2383,7 @@ describe("ReadFileTool", () => { await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) expect(observeSpy).toHaveBeenCalledTimes(1) - const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + const [_calledPath, , calledComplete] = observeSpy.mock.calls[0] expect(calledComplete).toBe(true) // Nothing was omitted and nothing was clipped, so no note is added. @@ -2494,7 +2494,7 @@ describe("ReadFileTool", () => { await readFileTool.execute(legacyParams, mockTask as unknown as Task, callbacks) expect(observeSpy).toHaveBeenCalledTimes(1) - const [calledPath, , calledComplete] = observeSpy.mock.calls[0] + const [_calledPath, , calledComplete] = observeSpy.mock.calls[0] expect(calledComplete).toBe(false) // Lines were omitted here, so the note reports the omitted range rather diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 189d09bd9d..fc8f30e212 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -11,7 +11,6 @@ import { resolveLockKey, safeWriteText, StagingPathError, - type SafeWriteTextOptions, } from "../safeWriteText" // Full mock for fs/promises — all methods are vi.fn() stubs diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 9bb5545720..f6e3fb07aa 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -370,7 +370,6 @@ export async function safeWriteText( // Set once the commit rename has published the new content. After that point the // backup is no longer a safe restore source: rolling it back would overwrite // content the caller can already observe at the target path. - let committed = false // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null @@ -553,7 +552,6 @@ export async function safeWriteText( // -- Step 4: atomic rename temp -> target --------------------- await fs.rename(tempPath, targetPath) - committed = true // -- Step 4b (POSIX): fsync the parent directory so the directory entry // changed by the commit rename is durable, not just the file content. diff --git a/src/services/mcp/__tests__/McpHub.spec.ts b/src/services/mcp/__tests__/McpHub.spec.ts index c19e16686c..361e77e138 100644 --- a/src/services/mcp/__tests__/McpHub.spec.ts +++ b/src/services/mcp/__tests__/McpHub.spec.ts @@ -33,6 +33,7 @@ vi.mock("fs/promises", () => { }) // Import safeWriteJson to use in mocks +import { safeWriteJson } from "../../../utils/safeWriteJson" // Mock safeWriteJson vi.mock("../../../utils/safeWriteJson", () => ({ diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 5976ac5d9a..4fccf3cb41 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -5,7 +5,6 @@ import * as os from "os" import { StagingPathError } from "../../services/file-safety/safeWriteText" import { ConfinedPathEscapeError, safeWriteJson } from "../safeWriteJson" -import * as lockfile from "proper-lockfile" // Capture actual implementations before the vi.mock factory runs, // so they are never wrapped by vi.fn() — avoids infinite recursion when From 1f4169eb1e98c2455cf94654b30fe0187f0d568a Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Wed, 14 Oct 2026 14:21:13 +0800 Subject: [PATCH 45/72] chore: drop the commit-message scratch file that slipped into the tree --- .msg-u4.txt | 12 ------------ 1 file changed, 12 deletions(-) delete mode 100644 .msg-u4.txt diff --git a/.msg-u4.txt b/.msg-u4.txt deleted file mode 100644 index 3087b8b4e1..0000000000 --- a/.msg-u4.txt +++ /dev/null @@ -1,12 +0,0 @@ -fix(u4): align the unit with main's unused-vars re-enable - -#2038 turned @typescript-eslint/no-unused-vars back on in src and removed -the tree's dead bindings. Replaying this unit onto that main exposed the -bindings this unit's own code left unused once main's deletions landed: -drop the ReadFileTool/SafeWriteTextOptions/lockfile imports and the -never-read committed flag, prefix the four write-path destructurings whose -value no assertion reads, and restore the safeWriteJson import main pruned -(main had no reader; this unit's McpHub tests do). - -No behavior change: 357 tests green across the unit's specs, eslint clean, -tsc adds no new errors beyond the pre-existing local donor-package drift. From fcadb9194b4e4ad37b8f9575fb2a7692201be85e Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 15 Oct 2026 20:53:08 +0800 Subject: [PATCH 46/72] fix(safe-write): fail closed on confinement escapes and share the lock key Security Boundaries: safeWriteJson's confinement check decides the target as it resolves at check time; publication takes a path and the OS re-resolves the tree at commit time, so an ancestor directory replaced by a link inside that window published mcp.json outside the declared scope. The write now re-resolves the published path after the commit: if the bytes landed outside, the escaped file is removed and the write reports ConfinedPathEscapeError (fail closed + undo). The executable contract test flips from documenting the escape to requiring the refusal; the clash outcome still stops earlier via StagingPathError, so the two remain tellable apart. NC: disabling the post-commit re-check reddens exactly the flipped test. Persistence Integrity: withFileLock locked the RAW path while safeWriteJson locks the canonical key from resolveLockKey, so a task-history deletion through withFileLock and a merge write through safeWriteJson watched different lock files on symlinked paths - the compound read-modify-write was not atomic against deletion. withFileLock now takes the same canonical key (one shared lock-key function) while the operation still receives the caller's own path, so the unlink keeps alias semantics. New spec pins both halves: the locked key equals resolveLockKey(alias), and the operation sees the alias. NC: reverting to the raw key reddens exactly the key test. safeWriteJson.test failure set identical to baseline (12 pre-existing local Windows DaclRestoreError flakes; CI authoritative). --- .../__tests__/fileLock.canonicalKey.spec.ts | 67 +++++++++++++++++++ src/utils/__tests__/safeWriteJson.test.ts | 51 +++++++------- src/utils/fileLock.ts | 13 +++- src/utils/safeWriteJson.ts | 20 ++++++ 4 files changed, 126 insertions(+), 25 deletions(-) create mode 100644 src/utils/__tests__/fileLock.canonicalKey.spec.ts diff --git a/src/utils/__tests__/fileLock.canonicalKey.spec.ts b/src/utils/__tests__/fileLock.canonicalKey.spec.ts new file mode 100644 index 0000000000..1dab157057 --- /dev/null +++ b/src/utils/__tests__/fileLock.canonicalKey.spec.ts @@ -0,0 +1,67 @@ +// npx vitest run utils/__tests__/fileLock.canonicalKey.spec.ts + +import path from "path" +import type { BigIntStats } from "fs" +import * as fs from "fs/promises" +import * as lockfile from "proper-lockfile" +import { withFileLock } from "../fileLock" +import { resolveLockKey } from "../../services/file-safety/safeWriteText" + +vi.mock("proper-lockfile", () => ({ + lock: vi.fn(async () => async () => {}), + unlock: vi.fn(async () => {}), +})) + +vi.mock("fs/promises", async () => { + const actual = await vi.importActual("fs/promises") + return { ...actual, realpath: vi.fn(), lstat: vi.fn(), readlink: vi.fn() } +}) + +const mockedRealpath = vi.mocked(fs.realpath) +const mockedLstat = vi.mocked(fs.lstat) +const mockedReadlink = vi.mocked(fs.readlink) +const mockedLock = vi.mocked(lockfile.lock) + +const dir = path.resolve(path.join(path.sep + "work", "history")) +const referent = path.join(dir, "item.json") +const alias = path.join(dir, "alias.json") + +beforeEach(() => { + mockedRealpath.mockReset() + mockedLstat.mockReset() + mockedReadlink.mockReset() + mockedLock.mockReset() + // alias.json is a symlink to item.json; everything else resolves to itself. + mockedRealpath.mockImplementation(async (target) => (target === alias ? referent : String(target))) + mockedLstat.mockImplementation(async () => ({ isSymbolicLink: () => false }) as unknown as BigIntStats) + mockedReadlink.mockRejectedValue(Object.assign(new Error("not a link"), { code: "EINVAL" })) +}) + +describe("withFileLock lock-key canonicalization", () => { + it("locks the canonical referent that safeWriteJson locks, not the raw alias", async () => { + // The compound-atomicity contract of task-history deletion is that an + // unlink under this helper and a safeWriteJson read-modify-write on the + // same file serialize. That holds only while both compute ONE key: + // safeWriteJson locks resolveLockKey(target), so withFileLock must too. + // Locking the raw alias here would watch a different lock file and let + // the deletion interleave with the merge write. + await withFileLock(alias, async () => undefined) + + expect(mockedLock).toHaveBeenCalledTimes(1) + expect(mockedLock.mock.calls[0][0]).toBe(referent) + // The shared-key contract stated directly: whatever safeWriteJson would + // lock for the same path is exactly what this helper locked. + expect(mockedLock.mock.calls[0][0]).toBe(await resolveLockKey(alias)) + }) + + it("hands the operation the caller's own path so its unlink keeps alias semantics", async () => { + // unlink(alias) removes the link; unlink(referent) removes the target + // file. Deletion must act on the path the caller named, even though the + // lock is taken on the canonical key. + const seen: string[] = [] + await withFileLock(alias, async (absoluteFilePath) => { + seen.push(absoluteFilePath) + }) + expect(seen).toEqual([alias]) + }) +}) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 4fccf3cb41..f2ff502643 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -878,11 +878,11 @@ describe("safeWriteJson", () => { }) // The confinement option decides from the resolved publish target and stops at its final - // component. What it does NOT cover is an ancestor DIRECTORY replaced by a link in the - // window between that decision and the commit rename, because publication takes a path - // and re-resolves the tree at rename time. These two tests are that limit as an - // executable contract - one per outcome of the window - so the documented narrowing - // cannot drift back into an unearned guarantee. The swap is driven from the merge + // component. An ancestor DIRECTORY replaced by a link in the window between that + // decision and the commit rename is caught fail-closed: publication takes a path and + // re-resolves the tree at rename time, so the confinement option re-resolves the + // published path after the commit and undoes an escaped write. These two tests are + // that contract as an executable pair - one per outcome of the window. The swap is driven from the merge // callback, which safeWriteJson invokes after the in-lock confinement check and before // anything is staged, so the ancestor moves inside the window rather than hopefully so. // A directory link needs no privilege on win32 as a junction; "dir" is the POSIX @@ -894,36 +894,39 @@ describe("safeWriteJson", () => { fsSyncActual.symlinkSync(pointsAt, ancestor, ancestorLinkKind) } - test("publishes outside the declared scope when an ancestor is swapped after the final confinement check", async () => { + test("refuses and undoes the publish when an ancestor is swapped after the final check", async () => { const projectDir = path.join(tempDir, "swap-project") const ancestor = path.join(projectDir, "settings") await fs.mkdir(ancestor, { recursive: true }) const target = path.join(ancestor, "mcp.json") await fs.writeFile(target, JSON.stringify({ inside: true })) // The swapped-in directory has no file at the target name yet: this is the half of the - // window in which nothing stops the publish. + // window in which the commit itself succeeds and only the post-commit re-check sees + // the escape. const swappedIn = path.join(tempDir, "elsewhere", "settings") await fs.mkdir(swappedIn, { recursive: true }) - await safeWriteJson( - target, - { written: "payload" }, - { - confineTo: projectDir, - merge: () => { - swapAncestorAfterTheCheck(ancestor, swappedIn) - return { written: "payload" } + // The confinement option now fails closed on the swapped ancestor: the + // post-commit re-check re-resolves the published path, sees it outside the + // declared scope, removes the escaped file, and reports the escape. + await expect( + safeWriteJson( + target, + { written: "payload" }, + { + confineTo: projectDir, + merge: () => { + swapAncestorAfterTheCheck(ancestor, swappedIn) + return { written: "payload" } + }, }, - }, - ) + ), + ).rejects.toBeInstanceOf(ConfinedPathEscapeError) - // The bytes landed OUTSIDE the declared scope: the option confines the target it - // resolved, not the directory tree above it. - expect(JSON.parse(fsSyncActual.readFileSync(path.join(swappedIn, "mcp.json"), "utf8"))).toEqual({ - written: "payload", - }) - // The file that was inside the scope keeps its pre-write bytes - the publish did not - // reach it under the moved-aside name either. + // The escaped publication was undone: nothing remains outside the scope... + expect(fsSyncActual.existsSync(path.join(swappedIn, "mcp.json"))).toBe(false) + // ...and the file that was inside the scope keeps its pre-write bytes - the + // publish did not reach it under the moved-aside name either. expect(JSON.parse(fsSyncActual.readFileSync(path.join(ancestor + "-moved-aside", "mcp.json"), "utf8"))).toEqual( { inside: true }, ) diff --git a/src/utils/fileLock.ts b/src/utils/fileLock.ts index 9f7cad7653..bef8c4c387 100644 --- a/src/utils/fileLock.ts +++ b/src/utils/fileLock.ts @@ -1,5 +1,6 @@ import * as path from "path" import * as lockfile from "proper-lockfile" +import { resolveLockKey } from "../services/file-safety/safeWriteText" /** * Shared staleness window for per-file advisory locks. This module owns the @@ -51,7 +52,17 @@ export async function withFileLock( operation: (absoluteFilePath: string) => Promise, ): Promise { const absoluteFilePath = path.resolve(filePath) - const releaseLock = await acquireFileLock(absoluteFilePath) + // Lock the canonical key - the same one safeWriteJson computes - so a symlink + // alias and its referent take ONE lock. Locking the raw path here would let a + // deletion through this helper run concurrently with a safeWriteJson + // read-modify-write on the referent (the two would watch different lock + // files), breaking the compound atomicity the deletion contract promises. + // The operation still receives the caller's resolved path: its own file + // operations (e.g. the task-history unlink) must keep the caller's alias + // semantics - unlinking the referent instead of the alias would delete a + // different directory entry. + const lockKey = await resolveLockKey(absoluteFilePath) + const releaseLock = await acquireFileLock(lockKey) let result: T try { diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index c5ec2aab27..90cfb76dcc 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -289,6 +289,26 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso await safeWriteText(resolvedTargetPath, "", textOptions) + // Fail-closed confinement re-check. The check above decides the target as it + // resolves at check time; publication takes a path and re-resolves the tree + // at commit time, so an ancestor directory replaced by a link inside that + // window would publish outside the declared scope. Re-resolve after the + // commit: if the bytes landed outside, undo by removing exactly the file + // this write published at the escaped location and report the escape. The + // peer's swap itself is left as the peer made it. (A swapped-in directory + // that already carried a target file is stopped earlier, by the staging + // identity guard inside safeWriteText, so this undo never races a backup.) + if (confinementRoot !== undefined) { + const publishedPath = await _resolveScopeRoot(resolvedTargetPath) + const scopeRoot = await _resolveScopeRoot(confinementRoot) + try { + _assertWithinScope(absoluteFilePath, publishedPath, scopeRoot) + } catch (escapeError) { + await fs.unlink(publishedPath).catch(() => {}) + throw escapeError + } + } + // If we reach here, the new file is successfully in place and any // backup has already been handled by safeWriteText. actualTempNewFilePath = null From a53d162cde4b1dcfeb3630ed37167613b7703d0b Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 16 Oct 2026 11:19:15 +0800 Subject: [PATCH 47/72] fix(read-file): flag clipped lines in indentation reads and report the clipping readWithIndentation set the clipping flag on neither of its return paths: the single-line limit case and the expanded block both ran their lines through formatWithLineNumbers - which truncates anything past the per-line cap - and reported the view as unclipped. The read tool's indentation branch emitted no clipping notice at all, so a block that showed every line it included yet truncated one looked complete. Both paths now derive the flag from the returned lines at the same cap semantics as the slice path, and the tool reports clipping separately from the omitted-lines notice (Linked Issues check on the unit tracking issue). --- src/core/tools/ReadFileTool.ts | 7 +++ src/core/tools/__tests__/readFileTool.spec.ts | 58 +++++++++++++++++++ .../indentation-reader-unicode.spec.ts | 4 ++ .../misc/__tests__/indentation-reader.spec.ts | 39 +++++++++++++ src/integrations/misc/indentation-reader.ts | 7 +++ 5 files changed, 115 insertions(+) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index 67a44cf295..f695b97d51 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -341,6 +341,13 @@ export class ReadFileTool extends BaseTool<"read_file"> { output += `\n\nIncluded ranges: ${rangeStr} (total: ${result.totalLines} lines)` } + if (result.hasClippedLines) { + // A returned line can still be a partial view: clipping is reported + // separately from the omission notice, because the block may show + // every line it includes in truncated form. + output += `\nNote: Some lines in this view exceed ${MAX_LINE_LENGTH} characters and were clipped in this view.` + } + // Indentation mode returns semantic blocks: never a complete file view. return { content: output, complete: false } } diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index ae1b4c11b3..26079ec10b 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -1237,6 +1237,64 @@ describe("ReadFileTool", () => { expect(callbacks.pushToolResult).toHaveBeenCalledWith(expect.stringContaining("To read more")) }) + it("should show a clipping notice in indentation mode separately from the omission notice", async () => { + const mockTask = createMockTask() + const callbacks = createMockCallbacks() + + mockedFsReadFile.mockResolvedValue(Buffer.from("content")) + mockedReadWithIndentation.mockReturnValue({ + content: "1 | block", + returnedLines: 10, + totalLines: 100, + wasTruncated: false, + hasClippedLines: true, + includedRanges: [[1, 10]], + }) + + await readFileTool.execute( + { + path: "test.ts", + mode: "indentation", + indentation: { anchor_line: 1 }, + }, + mockTask as unknown as Task, + callbacks, + ) + + const pushed = callbacks.pushToolResult.mock.calls[0][0] as string + expect(pushed).toContain("clipped in this view") + expect(pushed).not.toContain("File content truncated") + }) + + it("should report clipping alongside truncation in indentation mode", async () => { + const mockTask = createMockTask() + const callbacks = createMockCallbacks() + + mockedFsReadFile.mockResolvedValue(Buffer.from("content")) + mockedReadWithIndentation.mockReturnValue({ + content: "1 | block", + returnedLines: 50, + totalLines: 200, + wasTruncated: true, + hasClippedLines: true, + includedRanges: [[1, 50]], + }) + + await readFileTool.execute( + { + path: "test.ts", + mode: "indentation", + indentation: { anchor_line: 1 }, + }, + mockTask as unknown as Task, + callbacks, + ) + + const pushed = callbacks.pushToolResult.mock.calls[0][0] as string + expect(pushed).toContain("File content truncated") + expect(pushed).toContain("clipped in this view") + }) + it("should include range information in indentation mode when not truncated", async () => { const mockTask = createMockTask() const callbacks = createMockCallbacks() diff --git a/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts b/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts index 64b5fce642..34485be763 100644 --- a/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts +++ b/src/integrations/misc/__tests__/indentation-reader-unicode.spec.ts @@ -90,6 +90,8 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 3, returnedLines: 1, wasTruncated: true, + // The returned line is clipped, so the flag belongs to the result. + hasClippedLines: true, }) expect(Buffer.from(result.content).toString("utf8")).toBe(result.content) }) @@ -105,6 +107,8 @@ describe("Unicode clipping through the existing readers", () => { totalLines: 5, returnedLines: 3, wasTruncated: false, + // The block shows every line it includes, but one is clipped. + hasClippedLines: true, }) expect(Buffer.from(result.content).toString("utf8")).toBe(result.content) }) diff --git a/src/integrations/misc/__tests__/indentation-reader.spec.ts b/src/integrations/misc/__tests__/indentation-reader.spec.ts index fa951ea85e..9a91ba2676 100644 --- a/src/integrations/misc/__tests__/indentation-reader.spec.ts +++ b/src/integrations/misc/__tests__/indentation-reader.spec.ts @@ -339,6 +339,45 @@ describe("readWithIndentation", () => { expect(result.hasClippedLines).toBe(false) }) + it("flags a clipped line in the single-line limit case", () => { + // finalLimit === 1 returns only the anchor line, and formatWithLineNumbers + // clips it when it exceeds the cap: the flag must still be set. + const code = ["short()", `long(${"x".repeat(MAX_LINE_LENGTH + 5)})`, "tail()"].join("\n") + const result = readWithIndentation(code, { anchorLine: 2, limit: 1 }) + + expect(result.returnedLines).toBe(1) + expect(result.hasClippedLines).toBe(true) + }) + + it("keeps the single-line limit case unflagged when the line fits the cap", () => { + // Clipping is strictly-longer-than-cap, so a line at exactly the cap is + // shown in full and the read carries no clipping flag. + const code = ["short()", `fits(${"y".repeat(MAX_LINE_LENGTH - 6)})`, "tail()"].join("\n") + const result = readWithIndentation(code, { anchorLine: 2, limit: 1 }) + + expect(result.returnedLines).toBe(1) + expect(result.hasClippedLines).toBe(false) + }) + + it("flags a clipped line inside an expanded block", () => { + // The expansion returns every line of the block, but the long one is + // clipped in the returned view: the flag must be set even with no + // omission. + const code = ["start()", `long(${"x".repeat(MAX_LINE_LENGTH + 1)})`, "end()"].join("\n") + const result = readWithIndentation(code, { anchorLine: 2, limit: 10 }) + + expect(result.returnedLines).toBeGreaterThan(1) + expect(result.hasClippedLines).toBe(true) + }) + + it("keeps an expanded block unflagged when every line fits the cap", () => { + const code = ["start()", "mid()", "end()"].join("\n") + const result = readWithIndentation(code, { anchorLine: 2, limit: 10 }) + + expect(result.returnedLines).toBeGreaterThan(1) + expect(result.hasClippedLines).toBe(false) + }) + describe("basic block extraction", () => { it("should extract content around the anchor line", () => { const result = readWithIndentation(PYTHON_CODE, { diff --git a/src/integrations/misc/indentation-reader.ts b/src/integrations/misc/indentation-reader.ts index 9f521c4358..fb1a5f3cab 100644 --- a/src/integrations/misc/indentation-reader.ts +++ b/src/integrations/misc/indentation-reader.ts @@ -279,6 +279,9 @@ export function readWithIndentation(content: string, options: IndentationReadOpt totalLines, returnedLines: 1, wasTruncated: totalLines > 1, + // The single-line case is no exception to the clipping contract: + // formatWithLineNumbers clips this line when it exceeds the cap. + hasClippedLines: lines[anchorIdx].content.length > MAX_LINE_LENGTH, } } @@ -361,6 +364,10 @@ export function readWithIndentation(content: string, options: IndentationReadOpt totalLines, returnedLines: result.length, wasTruncated: wasTruncated && result.length < totalLines, + // The expansion path reports clipping like the slice path: a block can + // return every line it includes and still hide content behind the + // per-line length cap. + hasClippedLines: result.some((line) => line.content.length > MAX_LINE_LENGTH), } } From 0cc6a0a333631186496835586d690dd96f7f00a3 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:03:27 +0800 Subject: [PATCH 48/72] fix(file-safety): undo an escaped publish only when the file is still this write's Persistence Integrity (CodeRabbit pre-merge check): after the post-commit confinement re-check found an escape, safeWriteJson unlinked the published path unconditionally. A concurrent writer can replace that path between the commit and the re-check, so the undo could delete a file this write never created. The staged bytes are now captured before publication, and undoEscapedPublish() removes the escaped file only when the bytes on disk still equal the bytes this write staged. A mismatch leaves the peer's file untouched; the escape is still reported as ConfinedPathEscapeError either way. Regression test: undoEscapedPublish leaves a same-named file with different content in place, removes the file when the bytes match, and treats a missing file/unavailable byte record as a no-op. Local evidence (this worktree borrows a sibling's node_modules, so a full Windows suite run is not meaningful): the safeWriteJson suite shows the identical 12 pre-existing Windows DACL failures before and after the change, and the new test passes; prettier blob check on both files is OK. CI lanes remain the authoritative check. --- src/utils/__tests__/safeWriteJson.test.ts | 25 ++++++++++++++- src/utils/safeWriteJson.ts | 37 +++++++++++++++++++++-- 2 files changed, 58 insertions(+), 4 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index f2ff502643..4e0545981c 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -4,7 +4,7 @@ import * as path from "path" import * as os from "os" import { StagingPathError } from "../../services/file-safety/safeWriteText" -import { ConfinedPathEscapeError, safeWriteJson } from "../safeWriteJson" +import { ConfinedPathEscapeError, safeWriteJson, undoEscapedPublish } from "../safeWriteJson" // Capture actual implementations before the vi.mock factory runs, // so they are never wrapped by vi.fn() — avoids infinite recursion when @@ -938,6 +938,29 @@ describe("safeWriteJson", () => { ).rejects.toThrow(ConfinedPathEscapeError) }) + test("undoes an escaped publish only when the bytes on disk are still this write's bytes", async () => { + const outside = path.join(tempDir, "undo-escaped") + await fs.mkdir(outside, { recursive: true }) + const escaped = path.join(outside, "mcp.json") + // A peer wrote its own file at the escaped name after our commit published ours and + // before the post-commit re-check ran. Removing it on the name alone would delete the + // peer's file; the byte comparison must leave it in place. + fsSyncActual.writeFileSync(escaped, JSON.stringify({ peer: true })) + + await undoEscapedPublish(escaped, Buffer.from(JSON.stringify({ ours: true }))) + + expect(fsSyncActual.existsSync(escaped)).toBe(true) + expect(JSON.parse(fsSyncActual.readFileSync(escaped, "utf8"))).toEqual({ peer: true }) + + // The bytes are still ours: the escaped publish is undone. + await undoEscapedPublish(escaped, Buffer.from(JSON.stringify({ peer: true }))) + expect(fsSyncActual.existsSync(escaped)).toBe(false) + + // A missing file and an unreadable byte record are both no-ops, never a throw. + await undoEscapedPublish(escaped, Buffer.from("{}")) + await undoEscapedPublish(path.join(outside, "absent.json"), undefined) + }) + test("fails the publish instead of following a swapped ancestor onto an existing target", async () => { const projectDir = path.join(tempDir, "swap-project-clash") const ancestor = path.join(projectDir, "settings") diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 90cfb76dcc..f7b2855755 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -149,6 +149,30 @@ function _scopeErrorCode(error: unknown): string | undefined { * this single decision, so they can never disagree about whether a scope is * active. */ +/** + * Undo exactly the file this write published at the escaped location. + * + * The path alone cannot prove the file is ours: a concurrent writer can replace it + * between the commit and this re-check, and unlinking on the name would then delete a + * peer's file. The bytes this write staged are therefore compared with the bytes now on + * disk, and a mismatch leaves the peer's file untouched. The escape is reported to the + * caller either way. + * @internal Exported for the escape-undo regression tests. + */ +export async function undoEscapedPublish( + publishedPath: string, + expectedBytes: Buffer | undefined, +): Promise { + if (expectedBytes === undefined) { + return + } + const actualBytes = await fs.readFile(publishedPath).catch(() => undefined) + if (actualBytes === undefined || !actualBytes.equals(expectedBytes)) { + return + } + await fs.unlink(publishedPath).catch(() => {}) +} + function _declaredScopeRoot(confineTo: string | undefined, requestedPath: string): string | undefined { if (confineTo === undefined) { return undefined @@ -275,6 +299,10 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso ) await _streamDataToFile(actualTempNewFilePath, data, options?.prettyPrint) + // The bytes this write is about to publish. They are the identity a post-commit + // escape undo uses to avoid deleting a file a concurrent writer put at the escaped + // path; reading them here keeps the comparison independent of serialization details. + const stagedBytes = await fs.readFile(actualTempNewFilePath).catch(() => undefined) // Step 2: Delegate backup + commit + rollback to safeWriteText with the // pre-written temp path. backup:true keeps the old safeWriteJson @@ -294,8 +322,9 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso // at commit time, so an ancestor directory replaced by a link inside that // window would publish outside the declared scope. Re-resolve after the // commit: if the bytes landed outside, undo by removing exactly the file - // this write published at the escaped location and report the escape. The - // peer's swap itself is left as the peer made it. (A swapped-in directory + // this write published at the escaped location (never a same-named file a peer + // placed there after the commit) and report the escape. The peer's swap itself is + // left as the peer made it. (A swapped-in directory // that already carried a target file is stopped earlier, by the staging // identity guard inside safeWriteText, so this undo never races a backup.) if (confinementRoot !== undefined) { @@ -304,7 +333,9 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso try { _assertWithinScope(absoluteFilePath, publishedPath, scopeRoot) } catch (escapeError) { - await fs.unlink(publishedPath).catch(() => {}) + // Undo only the file this write published, never a same-named file a peer + // placed there after the commit. + await undoEscapedPublish(publishedPath, stagedBytes) throw escapeError } } From e6b9f6554b111a4a2a71effdc13d8adecbcc85bb Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:04:00 +0800 Subject: [PATCH 49/72] style: apply prettier formatting to the escape-undo helper --- src/utils/safeWriteJson.ts | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index f7b2855755..92c7decfba 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -159,10 +159,7 @@ function _scopeErrorCode(error: unknown): string | undefined { * caller either way. * @internal Exported for the escape-undo regression tests. */ -export async function undoEscapedPublish( - publishedPath: string, - expectedBytes: Buffer | undefined, -): Promise { +export async function undoEscapedPublish(publishedPath: string, expectedBytes: Buffer | undefined): Promise { if (expectedBytes === undefined) { return } From 3f8f9d769365fa82eab6c55c9767dfb4b810a334 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Thu, 22 Oct 2026 23:58:50 +0800 Subject: [PATCH 50/72] fix(safety): read the staged identity bytes only when confinement can undo a publish Review thread: the escape-undo byte snapshot is only needed when a confinement scope is declared; guarding the read keeps the non-confined write path from touching the staging file again. Behaviour of the confined path is unchanged (staged bytes are still compared before any escape unlink). --- src/utils/safeWriteJson.ts | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 92c7decfba..1ba256af80 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -296,10 +296,13 @@ async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJso ) await _streamDataToFile(actualTempNewFilePath, data, options?.prettyPrint) - // The bytes this write is about to publish. They are the identity a post-commit - // escape undo uses to avoid deleting a file a concurrent writer put at the escaped - // path; reading them here keeps the comparison independent of serialization details. - const stagedBytes = await fs.readFile(actualTempNewFilePath).catch(() => undefined) + // The bytes this write is about to publish identify the file a post-commit escape + // undo may remove. They are only needed when confinement can trigger that undo, and + // reading them here keeps the comparison independent of serialization details. + let stagedBytes: Buffer | undefined + if (confinementRoot !== undefined) { + stagedBytes = await fs.readFile(actualTempNewFilePath).catch(() => undefined) + } // Step 2: Delegate backup + commit + rollback to safeWriteText with the // pre-written temp path. backup:true keeps the old safeWriteJson From ef1044fee3f87acd78368a25d196171a04def166 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Tue, 27 Oct 2026 03:26:24 +0800 Subject: [PATCH 51/72] chore(lint): drop the unused pathUtils import in the McpHub spec The conflict resolution carried the F5-side pathUtils import into this unit, which does not exercise the workspace-path fallback; eslint no-unused-vars rejects it. Remove the import only. --- src/services/mcp/__tests__/McpHub.spec.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/services/mcp/__tests__/McpHub.spec.ts b/src/services/mcp/__tests__/McpHub.spec.ts index 491f3e0aa8..a39b42ee09 100644 --- a/src/services/mcp/__tests__/McpHub.spec.ts +++ b/src/services/mcp/__tests__/McpHub.spec.ts @@ -3,7 +3,6 @@ import * as path from "path" import type { Mock } from "vitest" import type { ExtensionContext, Uri } from "vscode" -import * as pathUtils from "../../../utils/path" import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js" import { Client } from "@modelcontextprotocol/sdk/client/index.js" import type { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js" From 011451e1d37cab41e14cf77085f7b85719c0b3e2 Mon Sep 17 00:00:00 2001 From: easonLiangWorldedtech <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Fri, 30 Oct 2026 13:34:50 +0800 Subject: [PATCH 52/72] fix(mcp): read the project root once per write; make the cancel tests land on the post-read stat - getProjectMcpPath/confineForMcpWrite share a single workspace-root read per project write, so a workspace refresh cannot split them - the in-flight cancellation tests queue the directory-check stat first, so the abort lands on the post-read stat and the post-read re-check is what withholds the observation --- src/core/tools/__tests__/readFileTool.spec.ts | 3 ++ src/services/mcp/McpHub.ts | 33 ++++++++++++------- 2 files changed, 25 insertions(+), 11 deletions(-) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index a75a239b10..b1ed081ab3 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -1980,6 +1980,7 @@ describe("ReadFileTool", () => { // Cast: the mock only implements the members the tool and versionToken read. } as unknown as Stats mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) // directory check .mockResolvedValueOnce(stats) // pre-read .mockImplementationOnce(async () => { // The cancel lands while this await is pending. @@ -2014,8 +2015,10 @@ describe("ReadFileTool", () => { // Cast: the mock only implements the members the tool and versionToken read. } as unknown as Stats mockedFsStat + .mockResolvedValueOnce({ isDirectory: () => false } as unknown as Stats) // directory check .mockResolvedValueOnce(stats) // pre-read .mockImplementationOnce(async () => { + // The cancel lands while this await is pending. mockTask.abort = true return stats }) // post-read diff --git a/src/services/mcp/McpHub.ts b/src/services/mcp/McpHub.ts index 0e48597f45..50ae26ebb3 100644 --- a/src/services/mcp/McpHub.ts +++ b/src/services/mcp/McpHub.ts @@ -630,8 +630,9 @@ export class McpHub { } // Get project-level MCP configuration path - private async getProjectMcpPath(): Promise { - const workspacePath = this.providerRef.deref()?.cwd ?? getWorkspacePath() + private async getProjectMcpPath( + workspacePath: string | undefined = this.providerRef.deref()?.cwd ?? getWorkspacePath(), + ): Promise { const projectMcpDir = path.join(workspacePath, ".roo") const projectMcpPath = path.join(projectMcpDir, "mcp.json") @@ -666,11 +667,16 @@ export class McpHub { * offer, and the alternative reading - removing the control from the credential path - * would give up the refusal that works today to close a window no unit can close here. */ - private confineForMcpWrite(source: "global" | "project"): string | undefined { + private confineForMcpWrite( + source: "global" | "project", + // The root chosen by the same write: reading it twice lets a workspace refresh between the + // path lookup and this check reject a valid project write with a confinement error. + workspacePath: string | undefined = this.providerRef.deref()?.cwd ?? getWorkspacePath(), + ): string | undefined { if (source !== "project") { return undefined } - return this.providerRef.deref()?.cwd ?? getWorkspacePath() + return workspacePath } // Initialize project-level MCP servers @@ -2068,10 +2074,12 @@ export class McpHub { configUpdate: Record, source: "global" | "project" = "global", ): Promise { - // Determine which config file to update + // Determine which config file to update. The write root is captured once and reused by + // the confinement check below, so a workspace refresh cannot split the two reads. let configPath: string + const writeRoot = source === "project" ? (this.providerRef.deref()?.cwd ?? getWorkspacePath()) : undefined if (source === "project") { - const projectMcpPath = await this.getProjectMcpPath() + const projectMcpPath = await this.getProjectMcpPath(writeRoot) if (!projectMcpPath) { throw new Error("Project MCP configuration file not found") } @@ -2131,7 +2139,7 @@ export class McpHub { try { await safeWriteJson(configPath, updatedConfig, { prettyPrint: true, - confineTo: this.confineForMcpWrite(source), + confineTo: this.confineForMcpWrite(source, writeRoot), }) } finally { // Reset flag after watcher debounce period (non-blocking) @@ -2176,10 +2184,12 @@ export class McpHub { // Determine config file based on server source const isProjectServer = serverSource === "project" let configPath: string + const writeRoot = + serverSource === "project" ? (this.providerRef.deref()?.cwd ?? getWorkspacePath()) : undefined if (isProjectServer) { // Get project MCP config path - const projectMcpPath = await this.getProjectMcpPath() + const projectMcpPath = await this.getProjectMcpPath(writeRoot) if (!projectMcpPath) { throw new Error("Project MCP configuration file not found") } @@ -2219,7 +2229,7 @@ export class McpHub { await safeWriteJson(configPath, updatedConfig, { prettyPrint: true, - confineTo: this.confineForMcpWrite(serverSource), + confineTo: this.confineForMcpWrite(serverSource, writeRoot), }) // Update server connections with the correct source @@ -2378,9 +2388,10 @@ export class McpHub { // Determine the correct config path based on the source let configPath: string + const writeRoot = source === "project" ? (this.providerRef.deref()?.cwd ?? getWorkspacePath()) : undefined if (source === "project") { // Get project MCP config path - const projectMcpPath = await this.getProjectMcpPath() + const projectMcpPath = await this.getProjectMcpPath(writeRoot) if (!projectMcpPath) { throw new Error("Project MCP configuration file not found") } @@ -2431,7 +2442,7 @@ export class McpHub { try { await safeWriteJson(normalizedPath, config, { prettyPrint: true, - confineTo: this.confineForMcpWrite(source), + confineTo: this.confineForMcpWrite(source, writeRoot), }) } finally { // Reset flag after watcher debounce period (non-blocking) From 5e4567150c5a5186ed6fffcea17545243eeb5fdd Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 1 Nov 2026 21:55:45 +0800 Subject: [PATCH 53/72] fix(merge): restore the upstream hunks dropped by the main merge Keep branch clipping/read-scope logic, restore upstream's empty-file condition, specific offset assertion, typed safeWriteJson signature and typed test doubles. --- src/core/tools/ReadFileTool.ts | 2 +- src/eslint-suppressions.json | 65 ------------------- .../misc/__tests__/indentation-reader.spec.ts | 2 +- src/utils/__tests__/safeWriteJson.test.ts | 2 +- src/utils/safeWriteJson.ts | 3 +- 5 files changed, 5 insertions(+), 69 deletions(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index 3a25ed6768..f80212eda8 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -383,7 +383,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { // clipping without a next-offset hint, and keep the read incomplete so a // full-file replacement cannot be built from a clipped line. output = `IMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view. ${offset1 === 1 ? "The file was read in full" : `The returned slice starts at line ${offset1} and reaches the end of the file`}, but the clipped lines were not shown in full.\n${result.content}` - } else if (result.returnedLines === 0) { + } else if (result.returnedLines === 0 && result.totalLines === 0) { output = "Note: File is empty" } diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index ea44474652..277d14b8c0 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -1619,71 +1619,6 @@ "count": 2 } }, - "utils/__tests__/autoImportSettings.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 15 - } - }, - "utils/__tests__/enhance-prompt.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 6 - } - }, - "utils/__tests__/git.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 95 - } - }, - "utils/__tests__/json-schema.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 3 - } - }, - "utils/__tests__/migrateSettings.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 4 - } - }, - "utils/__tests__/outputChannelLogger.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, - "utils/__tests__/safeWriteJson.test.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 27 - } - }, - "utils/__tests__/shell.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 35 - } - }, - "utils/__tests__/storage.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 25 - } - }, - "utils/__tests__/tiktoken.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "utils/config.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "utils/export.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 2 - } - }, - "utils/safeWriteJson.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 3 - } - }, "vitest.setup.ts": { "@typescript-eslint/no-explicit-any": { "count": 1 diff --git a/src/integrations/misc/__tests__/indentation-reader.spec.ts b/src/integrations/misc/__tests__/indentation-reader.spec.ts index 9a91ba2676..622a150235 100644 --- a/src/integrations/misc/__tests__/indentation-reader.spec.ts +++ b/src/integrations/misc/__tests__/indentation-reader.spec.ts @@ -315,7 +315,7 @@ describe("readWithSlice", () => { const result = readWithSlice(SIMPLE_CODE, 1000, 10) expect(result.returnedLines).toBe(0) - expect(result.content).toContain("Error") + expect(result.content).toContain("Error: offset 1001 is beyond file end") // No line was returned, so nothing could have been clipped. expect(result.hasClippedLines).toBe(false) }) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 40c0095fe6..9918fecb83 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -316,7 +316,7 @@ describe("safeWriteJson", () => { await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify(initialData)) // fs.unlink is already vi.fn() — use vi.mocked to avoid double-wrapping via vi.spyOn - vi.mocked(fs.unlink).mockImplementation(async (filePath: any) => { + vi.mocked(fs.unlink).mockImplementation(async (filePath) => { if (filePath.toString().includes("safeWriteText.bak_")) { throw new Error("Backup deletion failed") } diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 11ab8ff44f..172bc115ee 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -194,7 +194,8 @@ function _declaredScopeRoot(confineTo: string | undefined, requestedPath: string * @param {SafeWriteJsonOptions} options - Optional configuration for JSON formatting. * @returns {Promise} */ -async function safeWriteJson(filePath: string, data: any, options?: SafeWriteJsonOptions): Promise { + +async function safeWriteJson(filePath: string, data: unknown, options?: SafeWriteJsonOptions): Promise { const absoluteFilePath = path.resolve(filePath) let releaseLock = async () => {} // Initialized to a no-op From a15ada10a7a55aa01a5f7e50810c01f32bf9a9e7 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:42:24 +0800 Subject: [PATCH 54/72] fix(file-safety): propagate the staged-byte read error before publishing Reading the staged bytes is what lets the post-commit escape undo verify and remove an escaped file; a failed read now aborts instead of silently publishing. --- src/utils/safeWriteJson.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 172bc115ee..e3ea07c3f4 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -302,7 +302,9 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit // reading them here keeps the comparison independent of serialization details. let stagedBytes: Buffer | undefined if (confinementRoot !== undefined) { - stagedBytes = await fs.readFile(actualTempNewFilePath).catch(() => undefined) + // A read failure must abort the write: publishing without the bytes would make + // the post-commit escape undo unable to verify (and remove) an escaped file. + stagedBytes = await fs.readFile(actualTempNewFilePath) } // Step 2: Delegate backup + commit + rollback to safeWriteText with the From 5937180b6efcf6702c37229657c2fcef71fd2df3 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:43:46 +0800 Subject: [PATCH 55/72] fix(file-safety): run the escape re-check after a post-commit teardown failure DaclRestoreError and PostCommitDurabilityError are thrown after the rename published the staged file: the confinement re-check and escaped-publish undo now run before rethrowing, while other failures keep their own error type. --- src/utils/safeWriteJson.ts | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index e3ea07c3f4..b16098848d 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -5,6 +5,8 @@ import { JsonStreamStringify } from "json-stream-stringify" import { acquireFileLock } from "./fileLock" import { + DaclRestoreError, + PostCommitDurabilityError, resolveLockKey, resolvePublishTarget, safeWriteText, @@ -318,7 +320,26 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit backup: true, } - await safeWriteText(resolvedTargetPath, "", textOptions) + try { + await safeWriteText(resolvedTargetPath, "", textOptions) + } catch (committedWriteError) { + // Only the post-commit teardown errors published the staged file. Other failures + // (e.g. StagingPathError) never renamed, and must keep their own error type. + const isPostCommit = + committedWriteError instanceof DaclRestoreError || + committedWriteError instanceof PostCommitDurabilityError + if (isPostCommit && confinementRoot !== undefined) { + const publishedPath = await _resolveScopeRoot(resolvedTargetPath) + const scopeRoot = await _resolveScopeRoot(confinementRoot) + try { + _assertWithinScope(absoluteFilePath, publishedPath, scopeRoot) + } catch (escapeError) { + await undoEscapedPublish(publishedPath, stagedBytes) + throw escapeError + } + } + throw committedWriteError + } // Fail-closed confinement re-check. The check above decides the target as it // resolves at check time; publication takes a path and re-resolves the tree From 9787df6731ecab19e4c4567fddd7a85c7f179775 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:50:21 +0800 Subject: [PATCH 56/72] fix(file-safety): re-derive the lock key once the publish target resolves A symlink retargeted between the pre-lock key computation and the under-lock target resolution made this writer hold the old referent lock and merge into the new one; the write now releases and re-acquires the derived key before staging, and refuses to publish if the target keeps changing. --- src/utils/safeWriteJson.ts | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index b16098848d..d38b27f46f 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -219,7 +219,7 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit // symlink alias and its referent share one lock. The key must be computable // while a peer writer is mid-commit (backup mode renames the referent away and // back), so the walk tolerates a dangling link instead of rejecting it here. - const lockKey = await resolveLockKey(absoluteFilePath) + let lockKey = await resolveLockKey(absoluteFilePath) // Confinement, if the caller declared a scope, is checked BEFORE the lock is // Also before the parent-directory creation below: an out-of-scope target with a @@ -257,6 +257,31 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit // advisory lock held until the stale timeout for every other writer. resolvedTargetPath = await resolvePublishTarget(absoluteFilePath) + // The key was computed before the lock was taken, but the publish target is resolved + // under it: a symlink retargeted in between means this writer holds the OLD referent's + // lock and would merge into the new one. Re-derive the key and move to it before + // staging, so every writer through the current referent queues behind the same lock. + for (let attempt = 0; attempt < 3; attempt++) { + const recomputedLockKey = await resolveLockKey(absoluteFilePath) + if (recomputedLockKey === lockKey) { + break + } + if (confinementRoot !== undefined) { + const scopeRoot = await _resolveScopeRoot(confinementRoot) + _assertWithinScope(absoluteFilePath, await _resolveScopeRoot(recomputedLockKey), scopeRoot) + } + await releaseLock() + releaseLock = async () => {} + lockKey = recomputedLockKey + releaseLock = await acquireFileLock(lockKey) + resolvedTargetPath = await resolvePublishTarget(absoluteFilePath) + } + if ((await resolveLockKey(absoluteFilePath)) !== lockKey) { + throw new Error( + `safeWriteJson: refusing to publish ${absoluteFilePath}: the resolved target kept changing while acquiring the lock`, + ) + } + // Confinement, if the caller declared a scope. Both sides are canonicalized the // same way: the publish target is resolved through symlinks, and a target that // does not exist yet still carries the alias components of the path it was From 9ed41ebc4beb91444a5d71c0bf304cb25e0fbef3 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:51:23 +0800 Subject: [PATCH 57/72] fix(file-safety): confirm the published file identity before the escape undo unlinks it undoEscapedPublish now stats the file before reading and again immediately before unlinking; the delete is skipped when dev/ino/size changed, so a peer that replaced the file in that window keeps its content. --- src/utils/safeWriteJson.ts | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index d38b27f46f..44e53c56a2 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -165,10 +165,20 @@ export async function undoEscapedPublish(publishedPath: string, expectedBytes: B if (expectedBytes === undefined) { return } + const before = await fs.stat(publishedPath, { bigint: true }).catch(() => undefined) + if (!before) { + return + } const actualBytes = await fs.readFile(publishedPath).catch(() => undefined) if (actualBytes === undefined || !actualBytes.equals(expectedBytes)) { return } + // Re-stat immediately before the unlink: a peer may have replaced the file between + // the read and the delete, and unlinking it would remove that peer's content. + const after = await fs.stat(publishedPath, { bigint: true }).catch(() => undefined) + if (!after || after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size) { + return + } await fs.unlink(publishedPath).catch(() => {}) } From e62f198cefe28924db344a171bf247e6a839b9bc Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Tue, 3 Nov 2026 03:02:54 +0800 Subject: [PATCH 58/72] test(file-safety): account for the post-lock key re-derivation in the lock-order test --- src/utils/__tests__/safeWriteJson.lockKey.spec.ts | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts index c9f2415402..e4b82fa857 100644 --- a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts +++ b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts @@ -97,10 +97,12 @@ describe("safeWriteJson lock key under a peer commit", () => { // The lock key is the key every other writer to this file uses, so the caller // queued behind the peer instead of failing before the lock. expect(mockedAcquireFileLock).toHaveBeenCalledWith(referent) - // The two trailing lstat calls are safeWriteText's staging-path checks: the - // regular-file check on the temp file this write created, and the identity check - // that the staging path is not the target. Both run after the key was resolved - // and the lock was taken, so neither changes which lock the caller queued behind. + // Both trailing lstat calls are safeWriteText's staging-path checks (regular-file + // check on the temp file and the identity check that staging is not the target). + // The extra resolves are the post-lock re-derivations: the re-derived lock key is + // recomputed and the publish target re-resolved before staging, plus the final + // stability check. All run after the lock was taken, so they do not change the + // lock the caller queued behind. expect(order).toEqual([ "resolve-failed", "lstat", @@ -109,6 +111,10 @@ describe("safeWriteJson lock key under a peer commit", () => { "lock", "resolve", "resolve", + "resolve", + "resolve", + "resolve", + "resolve", "lstat", "lstat", ]) From 279e77dbb8b440a8d2014cc4ed87ae11d05a30e0 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:38:41 +0800 Subject: [PATCH 59/72] Reconcile the carried lock-key spec with the replacement protocol The merge left two rows in src/utils/__tests__/safeWriteJson.lockKey.spec.ts red, both because they described the delegation flow rather than the write protocol this branch now uses. Each was resolved by keeping the stronger claim, not by loosening a test to fit the merged file: - safeWriteJson no longer logs a cleanup failure when the staged temp file is already gone. The commit rename consumes it, or an earlier teardown removed it, so ENOENT there is the expected outcome of a failed publish rather than a second failure. This is our side's behaviour and it is restored into main's catch block; any other cleanup error is still logged with the same message. - the lock-key order row asserted the resolution passes as the delegation flow made them, including two lstat calls that belonged to the primitive's staging-path checks. Under the replacement protocol those checks do not exist and one re-derivation pass is shorter, so the expected sequence drops one realpath and the two lstat calls. The invariant the row exists for - every resolution pass runs after the lock was taken, so the caller queued behind the peer is unaffected - is asserted unchanged. Verification, pinned node v22.23.4 (box node is 25.9.0): vitest misc shard exit 0 with 2116 passed and 17 skipped; tsc -p src/tsconfig.json exit 0; prettier --check clean on both files. Suppression entries for these paths are absent in both this branch and main, so no count moved. Refs: #1375, #1991, #2019. --- .../__tests__/safeWriteJson.lockKey.spec.ts | 16 +++++++--------- src/utils/safeWriteJson.ts | 14 ++++++++++---- 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts index e4b82fa857..3033fb237c 100644 --- a/src/utils/__tests__/safeWriteJson.lockKey.spec.ts +++ b/src/utils/__tests__/safeWriteJson.lockKey.spec.ts @@ -97,12 +97,13 @@ describe("safeWriteJson lock key under a peer commit", () => { // The lock key is the key every other writer to this file uses, so the caller // queued behind the peer instead of failing before the lock. expect(mockedAcquireFileLock).toHaveBeenCalledWith(referent) - // Both trailing lstat calls are safeWriteText's staging-path checks (regular-file - // check on the temp file and the identity check that staging is not the target). - // The extra resolves are the post-lock re-derivations: the re-derived lock key is - // recomputed and the publish target re-resolved before staging, plus the final - // stability check. All run after the lock was taken, so they do not change the - // lock the caller queued behind. + // The extra resolves are the post-lock passes: the publish target is re-resolved, + // the lock key is re-derived, and every derivation canonicalizes through realpath, + // including the final stability check. All of them run after the lock was taken, so + // they do not change the lock the caller queued behind. The two trailing lstat + // calls belonged to the delegation flow's staging-path checks; the replacement + // protocol stages the temp itself and checks no identity beside it, so they are + // gone with the delegation. expect(order).toEqual([ "resolve-failed", "lstat", @@ -114,9 +115,6 @@ describe("safeWriteJson lock key under a peer commit", () => { "resolve", "resolve", "resolve", - "resolve", - "lstat", - "lstat", ]) expect(JSON.parse(await fs.readFile(referent, "utf8"))).toEqual({ id: "task-1" }) }) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index f39e26718e..936b6dfff0 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -511,10 +511,16 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit try { await fs.unlink(newFileToCleanupWithinCatch) } catch (cleanupError) { - console.error( - `[Catch] Failed to clean up temporary new file ${newFileToCleanupWithinCatch}:`, - cleanupError, - ) + // The staged file is often already gone: the commit rename consumed it, or an + // earlier teardown removed it. Finding it absent is the expected outcome of a + // failed publish, not a second failure, so it is not logged as one. Any other + // cleanup failure is still reported. + if (getErrorCode(cleanupError) !== "ENOENT") { + console.error( + `[Catch] Failed to clean up temporary new file ${newFileToCleanupWithinCatch}:`, + cleanupError, + ) + } } } From c0b57f7fe0bec14e08564b03cff28af599ce57d6 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:42:04 +0800 Subject: [PATCH 60/72] Mark safeWriteText internal now that nothing in production calls it With safeWriteJson on main's replacement protocol, the only production consumers of src/services/file-safety/safeWriteText.ts are resolvePublishTarget and resolveLockKey; the write entry point itself is exercised only by its own specs. knip --production - the step CI runs - reported it as an unused export, so it is tagged @internal rather than adding an ignore entry or editing knip.json: one mechanism, with the reason written next to the tag. Whether main should carry two publish primitives at all is #2350's question, not this branch's. The tag states today's fact without deciding it, and the tag is on this branch's copy of the file, which is one of four copies now. Verification, pinned node v22.23.4 (box node is 25.9.0): knip --production exit 0, previously exit 1 with this single finding; tsc -p src/tsconfig.json exit 0; prettier --check clean on the file. Refs: #1375, #1991, #2019, #2350. --- src/services/file-safety/safeWriteText.ts | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index f6e3fb07aa..7f6c9d6d52 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -288,6 +288,14 @@ export async function resolveLockKey(absoluteFilePath: string): Promise } } +/** + * Publish text by staging beside the resolved target and committing with a rename. + * + * @internal Production callers of this file use resolvePublishTarget and + * resolveLockKey; the write entry point itself has no production caller while #2350 + * decides which primitive main keeps, so it is tagged internal instead of being + * reported as an unused export. + */ export async function safeWriteText( filePath: string, content: string | Uint8Array, From e3d632799dcff94e71d73ff889b59e0878606671 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:45:00 +0800 Subject: [PATCH 61/72] Add the notice-separator row the review asked for on the clipped full read Row 4202836427 asked for a test of the clipped-but-not-truncated branch at offset 1. That branch joins two sentences and then the read, and only the second sentence tells the model that every line was returned. The neighbouring rows assert substrings, so both surviving mutants sat inside the join. The new row pins what the old rows left free: - the header line and the notice are adjacent, and the character cap the notice names is MAX_LINE_LENGTH imported by the test rather than a literal; - the exact separator between the two sentences, quoted verbatim; - the join between the notice and the read, and that nothing follows the read. It also asserts the observation stays incomplete and that the notice does not advertise a next offset, since no later offset exists to read. Written against the tool's real output rather than an expectation: for this fixture the pushed result is 182 characters - the File: header, the notice, then the two returned lines - and MAX_LINE_LENGTH is 2000. Measured on this content with pinned node v22.23.4 (box node is 25.9.0), and the tree is clean at this commit: vitest core shard filtered to readFileTool.spec exit 0 with 116 passed; tsc -p src/tsconfig.json exit 0; prettier --check clean; knip --production exit 0; eslint --max-warnings=0 clean on the three files this branch touches under src. Refs: #1375, #1991, #2019. --- src/core/tools/__tests__/readFileTool.spec.ts | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index af391463eb..b97b17d063 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -23,6 +23,7 @@ import type { Task, ToolExecutionContext } from "../../task/Task" import { isBinaryFile } from "isbinaryfile" +import { MAX_LINE_LENGTH } from "../../prompts/tools/native-tools/read_file" import { readFileTool } from "../ReadFileTool" import { ObservationRegistry } from "../../task/observationRegistry" import { formatResponse } from "../../prompts/responses" @@ -2400,6 +2401,59 @@ describe("ReadFileTool", () => { // The notice is added on top of the read, it does not replace it. expect(pushed).toContain("1 | a") }) + + it("native: a clipped full read joins the notice and the read with the exact separator", async () => { + // Review row 4202836427: in the clipped-but-not-truncated branch the two + // sentences and the read are joined by a specific separator, and that join is + // what tells the model every line was returned but some were cut. Assert the + // separator and both ends of the response rather than a loose substring. + const mockTask = createMockTask({ + observationRegistry: new ObservationRegistry(), + }) + const callbacks = createMockCallbacks() + + mockedFsStat.mockResolvedValue(bigintStats()) + mockedIsBinaryFile.mockResolvedValue(false) + mockedFsReadFile.mockResolvedValue(Buffer.from("a\nb\n")) + mockedReadWithSlice.mockReturnValue({ + content: "1 | a\n2 | b", + returnedLines: 2, + totalLines: 2, + wasTruncated: false, + hasClippedLines: true, + includedRanges: [[1, 2]], + }) + + const reg = mockTask.observationRegistry! + const observeSpy = vi.spyOn(reg, "observe") + + await readFileTool.execute( + { path: "clipped-full.ts", offset: 1 }, + mockTask as unknown as Task, + callbacks, + ) + + const pushed = callbacks.pushToolResult.mock.calls[0][0] + // The header line and the notice are adjacent: the notice is the first thing + // after the file identity, and the character cap it names is the one the tool + // actually applied. + expect( + pushed.startsWith( + `File: clipped-full.ts\nIMPORTANT: Some lines exceed ${MAX_LINE_LENGTH} characters and were clipped in this view.`, + ), + ).toBe(true) + expect(pushed).toContain( + "were clipped in this view. The file was read in full, but the clipped lines were not shown in full.", + ) + expect(pushed.endsWith("were not shown in full.\n1 | a\n2 | b")).toBe(true) + expect(pushed).toContain("The file was read in full") + // Every line was returned, so the notice must not advertise a next offset. + expect(pushed).not.toContain("To read more") + // The read stays incomplete: the clipped tails were never shown, so a + // full-file replacement must not be built from this view. + const [, , calledComplete] = observeSpy.mock.calls[0] + expect(calledComplete).toBe(false) + }) it("native: a clipped slice that starts after line 1 names the slice instead of claiming a full read", async () => { const mockTask = createMockTask({ observationRegistry: new ObservationRegistry(), From 18719934c03201286c0c001c64a19730e5c22334 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:57:25 +0800 Subject: [PATCH 62/72] Read the staged bytes after staging, where the escape undo can use them The escape-undo capture read the staged temp before _streamDataToFile had written it, so every confined write that reached the publish failed with `ENOENT: no such file or directory, open '/..new__.tmp'`. CI's ubuntu leg name is visible in the misc block of platform-unit-test (ubuntu-latest) at e3d632799 on "confines a write whose symlink referent stays inside the confined directory" and "confines a scope path that itself runs through a symlink and does not exist yet". Windows never showed it: both rows are test.skipIf(process.platform === "win32"), and fs.symlinkSync of a file fails EPERM on this box (measured, pinned node v22.23.4), so no local run of the misc shard executes them - local tallies read 2116 passed / 17 skipped before and after. The read now sits after the staging write and before any mode handling, so the bytes compared by a post-commit escape undo are the bytes that were staged and a restrictive target mode cannot turn the capture into a failure. A read failure still aborts the write, which is what the surrounding comment already required. At this commit the third ubuntu failure - "preserves a restrictive 0o600 target mode through the atomic publish", expected 420 to be 384 - is still red by design: it is a separate mechanism and the next commit is the one that answers it. Gates on this commit's tree, pinned node v22.23.4 (box node 25.9.0): misc exit 0 with 2116 passed / 17 skipped (unchanged tallies, and it cannot prove the two rows above); tsc -p src/tsconfig.json exit 0; prettier --check clean; eslint --max-warnings=0 exit 0. Refs: #1375, #1991, #2019. --- src/utils/safeWriteJson.ts | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 936b6dfff0..2d0b62eb0e 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -382,16 +382,18 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit // filesystems, and mixing the two spellings is how a publish ends up beside the link // it meant to replace. - // The bytes this write is about to publish identify the file a post-commit escape - // undo may remove. They are only needed when confinement can trigger that undo, and - // reading them here keeps the comparison independent of serialization details. + await _streamDataToFile(actualTempNewFilePath, data, options?.prettyPrint) + + // The bytes this write publishes identify the file a post-commit escape undo may + // remove. They are read after the staged file is written - before it there is nothing + // to read, and reading early failed with ENOENT on every confined write that reached + // the publish - and before the mode copy below, so a restrictive target mode cannot + // turn this read into a failure. A read failure aborts the write: publishing without + // the bytes would leave the undo unable to verify (and remove) an escaped file. if (confinementRoot !== undefined) { - // A read failure must abort the write: publishing without the bytes would make - // the post-commit escape undo unable to verify (and remove) an escaped file. stagedBytes = await fs.readFile(actualTempNewFilePath) } - await _streamDataToFile(actualTempNewFilePath, data, options?.prettyPrint) await _flushFileToDisk(actualTempNewFilePath) // Step 2: Commit the replacement with a single atomic rename. The @@ -569,7 +571,7 @@ async function _streamDataToFile(targetPath: string, data: unknown, prettyPrint } /** - * Flushes a fully written temp file to storage before it is committed. + * Syncs the directory that holds a freshly committed file. * Best effort: durability against power loss is a bonus here, process-crash * safety comes from the rename protocol itself, and a filesystem that * refuses fsync must not block the write. From 7bf2654b306a2641a6a6d9352a8ef603b61525f2 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:57:39 +0800 Subject: [PATCH 63/72] Copy the target's mode onto the staged file so the publish cannot widen it CWE-732: the commit rename lands the staged file onto the target, so the file that survives carries the staged file's mode. A 0o600 target was being published 0o644 from the umask-derived default, which is the third ubuntu failure at e3d632799 - "preserves a restrictive 0o600 target mode through the atomic publish", AssertionError: expected 420 to be 384 at safeWriteJson.test.ts:1047. The helper is grafted verbatim from the #1912 head 085fbf85e: stat the target, chmod the staged file, log and continue on a stat or chmod failure, nothing to copy for a target that is not there yet. Call site and ordering match 085fbf85e - after the staging write, before the flush - and the call names the same resolved string the staging, the commit rename, the escape re-checks and the rollback rename name, which is the seam rule for this file. That head is not an ancestor of 73931fe8 (git merge-base --is-ancestor, exit 1), so this does not claim main accepted and dropped it - only that the two resolutions differ on a permission property, which is the leftover recorded on the PR rather than a thing to resolve silently inside one unit. Two variants of this helper now exist on the series, both in src/utils/safeWriteJson.ts and nowhere in src/services/file-safety/safeWriteText.ts: log-and-continue here (impl blob 1e4031a7ef6e3e8d9997 92f6547955ebca26c9f5, same as 8fa7d858c) and at 085fbf85e (blob eebd1ffdd7c2c5e6733ecf11d8058fa2b4 30d2bf), and fail-closed at the #1917 head c4bd9a2ec3ab7d2b6944b942fcdd0d5696d34366 (blob fbe8b07563aa34da0d9f2717e397ce2b009fe3b4). Whichever merge lands first supplies the canonical text: merge order, not merit. #2350 plus merge order is the arbiter, and this copy is not being converged onto the fail-closed text. Both failure branches carry rows, because a helper grafted for a permission property with two unexercised error paths is a changed-line coverage hole whatever the mutation gate decides: "logs and still publishes when the target's mode cannot be read" and "logs and still publishes when the staged file's mode cannot be set". They drive fs.stat and fs.chmod through the file's existing fs/promises mock factory (chmod is newly a vi.fn() delegating to the real implementation) rather than a real EACCES/EPERM, which needs privileges neither this box nor a CI runner has, so - unlike the symlink and mode rows above - these two run on every platform. A name-filtered run of this spec selects exactly those two rows and both pass. Gates on this commit's tree, pinned node v22.23.4 (box node 25.9.0): misc exit 0 at 2118 passed / 17 skipped (2135 total, +2 rows); tsc -p src/tsconfig.json exit 0; prettier --check clean; eslint --max-warnings=0 exit 0 on both touched files, run without --prune-suppressions so src/eslint-suppressions.json is untouched; knip --production exit 0 run from the repo root, where knip.json lives. git diff --name-only 8fa7d858c HEAD lists only this spec file, so the implementation is byte-identical to the head whose CI is running and only test rows were added on top of it. The three ubuntu rows themselves remain answered by CI's ubuntu leg, not by this box. Refs: #1375, #1991, #2019. --- src/utils/__tests__/safeWriteJson.test.ts | 43 +++++++++++++++++++++++ src/utils/safeWriteJson.ts | 34 ++++++++++++++++++ 2 files changed, 77 insertions(+) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index a4b528951c..4f50923c5f 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -28,6 +28,7 @@ vi.mock("fs/promises", async () => { unlink: vi.fn(actual.unlink), access: vi.fn(actual.access), stat: vi.fn(actual.stat), + chmod: vi.fn(actual.chmod), open: vi.fn(actual.open), mkdtemp: vi.fn(actual.mkdtemp), rm: vi.fn(actual.rm), @@ -1048,6 +1049,48 @@ describe("safeWriteJson", () => { expect(await readFileContent(currentTestFilePath)).toEqual({ after: true }) }, ) + // The two failure paths of _copyTargetMode: a target whose mode cannot be read, and a staged + // file whose mode cannot be set. Both have to log and let the write finish, because the + // replacement protocol - not the mode - is what makes the publish atomic. They are driven + // through the fs/promises mocks rather than a real EACCES/EPERM, because forcing either one + // for real needs privileges a developer box and a CI runner neither have. That is also why + // these two run on every platform while the symlink and mode rows above skip windows. + test("logs and still publishes when the target's mode cannot be read", async () => { + await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify({ before: true })) + const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}) + // fs.stat is already vi.fn() in the factory above - vi.mocked keeps the real + // implementation reachable once this single call is done. + await vi.mocked(fs.stat).mockImplementationOnce(async () => { + const error: NodeJS.ErrnoException = new Error(`EACCES: permission denied, stat '${currentTestFilePath}'`) + error.code = "EACCES" + throw error + }) + + await safeWriteJson(currentTestFilePath, { after: true }) + + expect(await readFileContent(currentTestFilePath)).toEqual({ after: true }) + expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining(currentTestFilePath), expect.anything()) + consoleErrorSpy.mockRestore() + }, 20_000) + + test("logs and still publishes when the staged file's mode cannot be set", async () => { + await fsPromisesActuals.writeFile!(currentTestFilePath, JSON.stringify({ before: true })) + const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {}) + // chmod is a vi.fn() in the factory above for the same reason. + await vi.mocked(fs.chmod).mockImplementationOnce(async () => { + const error: NodeJS.ErrnoException = new Error( + `EPERM: operation not permitted, chmod '${currentTestFilePath}'`, + ) + error.code = "EPERM" + throw error + }) + + await safeWriteJson(currentTestFilePath, { after: true }) + + expect(await readFileContent(currentTestFilePath)).toEqual({ after: true }) + expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to copy mode"), expect.anything()) + consoleErrorSpy.mockRestore() + }, 20_000) // Ordering matters for the security guarantee: proper-lockfile creates // ${lockKey}.lock beside the lock key, and the key is the symlink referent. If diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 2d0b62eb0e..1e4031a7ef 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -394,6 +394,14 @@ async function safeWriteJson(filePath: string, data: unknown, options?: SafeWrit stagedBytes = await fs.readFile(actualTempNewFilePath) } + // CWE-732: the commit rename below lands the staged file onto the target, so the + // file that survives carries the staged file's mode, not the target's. A 0o600 + // target would otherwise be published 0o644 from the umask-derived default. The + // #1912 head (085fbf85e) carries this step for the same function; the blob main + // brought in does not, and without it the two resolutions differ on a permission + // property and the row that pins it can only pass on one platform. + await _copyTargetMode(resolvedTargetPath, actualTempNewFilePath) + await _flushFileToDisk(actualTempNewFilePath) // Step 2: Commit the replacement with a single atomic rename. The @@ -570,6 +578,32 @@ async function _streamDataToFile(targetPath: string, data: unknown, prettyPrint }) } +/** + * Copies the existing target's permission mode onto the staged file so the publish + * does not silently widen it. A missing target has no mode to copy; a stat or chmod + * that fails for another reason is logged and the write proceeds with the staged + * file's own mode, because the replacement protocol - not the mode - is what makes the + * write atomic. + */ +async function _copyTargetMode(targetPath: string, stagedPath: string): Promise { + let mode: number + try { + const stats = await fs.stat(targetPath) + mode = stats.mode & 0o777 + } catch (statError: unknown) { + const code = getErrorCode(statError) + if (code && code !== "ENOENT" && code !== "ENOTDIR") { + console.error(`Could not read the mode of ${targetPath} before publishing onto it:`, statError) + } + return + } + try { + await fs.chmod(stagedPath, mode) + } catch (chmodError: unknown) { + console.error(`Failed to copy mode ${mode.toString(8)} from ${targetPath} onto ${stagedPath}:`, chmodError) + } +} + /** * Syncs the directory that holds a freshly committed file. * Best effort: durability against power loss is a bonus here, process-crash From f739a5fa31548af6eb446438947ea57ec1e8eab5 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:02:50 +0800 Subject: [PATCH 64/72] Compare the interruption injection against identity so main's rows fire on an aliased temp The file this repairs is main's: src/utils/__tests__/safeWriteJson.interruption.test.ts, blob c9c5993f847b0a6166de801b0da4c37e730423b4 at 73931fe8, and it was absent from this branch before the merge (git cat-file -e e62f198ce:src/utils/__tests__/safeWriteJson.interruption.test.ts exits 128). This is a prerequisite for a test main carries, not unit content: no production file is touched here. Main's kill point is whole-path equality - child line 40, `if (path.resolve(String(newPath)) === targetPath)`, with targetPath = path.resolve(process.env.INTERRUPTION_TARGET_PATH). This PR publishes through a realpath-resolved string, node's async fs.realpath expands an NTFS 8.3 alias, and path.resolve preserves the spelling it is handed. On a runner whose temp path is reported as an alias - the normal windows-latest condition, where the profile is RUNNER~1 - the writer's rename destination and the parent's authorized spelling are two strings naming one file, the injection never matches, the child prints WRITE_COMPLETED, and every row in the file fails. That is exactly what platform-unit-test (windows-latest) reported at 8fa7d858c: 12 failures, all of them `expected 'WRITE_COMPLETED\n' to contain 'EXIT_AT_REPLACEMENT_RENAME'` at that file's line 187, with the leg failing on its own merit (03:53:47 -> 04:00:01) rather than as a cancellation. Measured on this box (pinned node v22.23.4; box node 25.9.0), in both directions: TEMP/TMP at C:\work\Zoo-Code-fork\.tmp-alias-vps2f\long-directory-name-under-alias -> 12 passed; TEMP/TMP at its 8.3 form C:\work\ZOO-CO~1\TMP-AL~2\LONG-D~1 with main's copy -> 12 failed carrying CI's assertion verbatim; the same aliased TEMP with the predicate below -> 12 passed; long spelling with the predicate -> 12 passed, so nothing here is pinned to the alias. This lands the basename plus the containing directory's dev+ino predicate, cited from 1fb5fcc47, which is where the fix exists today (#1912). Measured against that copy, this file differs by 13 insertions and 13 deletions, and every one of those lines is either the local variable name (this file keeps main's `targetPath`, that copy renamed it `targetSpec`) or the re-wrapping of the explanatory comment - so #1912's fix touched nothing else in the file, and the predicate here is the same mechanism written into the copy main carries. That is not a convergence onto #1912's text: it is a second lane grafting the same thing, and the two copies will conflict. Whichever merge lands first supplies the canonical text - merge order, not merit - and the conflict is expected rather than surprising. One disclosure about the previous commit that its own message did not carry: 7bf2654b3 added `chmod: vi.fn(actual.chmod)` to the fs/promises mock factory in safeWriteJson.test.ts. That spec's beforeEach pre-creates the target (line 90), so every row in that file that reaches the publish now calls chmod through the delegating spy where it previously reached the real function through `...actual`; behaviour is unchanged because the spy calls through, and no row before that commit asserted on chmod (`git grep -nE "vi\\.mocked\\(fs\\.chmod\\)" 8fa7d858c` returns nothing). Gates on this commit's tree, pinned 22.23.4: interruption spec 12 passed under both temp spellings; prettier --check clean; eslint --max-warnings=0 exit 0 on the touched file, run without --prune-suppressions so src/eslint-suppressions.json is untouched; tsc -p src/tsconfig.json exit 0. The misc shard was measured on the identical tree at 7bf2654b3 (2118 passed / 17 skipped) and this commit touches only this spec file. Refs: #1375, #1991, #2019. --- .../safeWriteJson.interruption.test.ts | 36 +++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.interruption.test.ts b/src/utils/__tests__/safeWriteJson.interruption.test.ts index c9c5993f84..45fa6a735e 100644 --- a/src/utils/__tests__/safeWriteJson.interruption.test.ts +++ b/src/utils/__tests__/safeWriteJson.interruption.test.ts @@ -32,12 +32,44 @@ const targetPath = path.resolve(process.env.INTERRUPTION_TARGET_PATH) const fsPromises = require("fs/promises") const actualRename = fsPromises.rename +// Identity, not spelling. The writer renames to the publish target it resolved through +// symlinks, and node's async fs.realpath expands an NTFS 8.3 alias, so on a runner whose temp +// path is reported as an alias (the normal windows-latest condition: the profile is RUNNER~1 +// there) the parent's authorized spelling and the writer's rename destination are different +// strings for one file. Text equality here never fires, every case prints WRITE_COMPLETED, and +// the injection silently stops being an injection. Decide what the destination IS: same name, +// and the same directory by dev+ino. The basenames under test are unique inside the storage +// directory, so the pair cannot land on another file. +const targetBase = path.basename(targetPath) +function sameTargetAsAuthorized(candidate) { + if (path.basename(String(candidate)) !== targetBase) { + return false + } + const resolved = path.resolve(String(candidate)) + if (resolved === targetPath) { + return true + } + let candidateDir = null + let authorizedDir = null + try { + candidateDir = fs.statSync(path.dirname(resolved), { bigint: true }) + } catch { + return false + } + try { + authorizedDir = fs.statSync(path.dirname(targetPath), { bigint: true }) + } catch { + return false + } + return candidateDir.dev === authorizedDir.dev && candidateDir.ino === authorizedDir.ino +} + // Fault injection: hard-kill before the replacement lands. Any rename -// whose destination is the canonical path is the commit step, whatever +// whose destination is the publish target is the commit step, whatever // replacement protocol the writer uses; exit before performing it. let commitAttempts = 0 fsPromises.rename = async function interruptionRename(oldPath, newPath) { - if (path.resolve(String(newPath)) === targetPath) { + if (sameTargetAsAuthorized(newPath)) { commitAttempts++ if (process.env.INTERRUPTION_MODE === "fallback" && commitAttempts === 1) { return Promise.reject(Object.assign(new Error("Injected EPERM"), { code: "EPERM" })) From b86511fe567a330f0d12f83d3078a85e1c439d99 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:21:05 +0800 Subject: [PATCH 65/72] Repair the mode-read row I added: it pinned the caller's path spelling The row "logs and still publishes when the target's mode cannot be read", added in 7bf2654b3, asserted that the error log contains the path the test handed safeWriteJson. The helper logs the target it resolved, and on Windows those two spellings differ whenever a component of the path carries an 8.3 name, so this row went red on the windows leg of f739a5fa3 - misc reported 1 failed | 118 passed | 1 skipped with "AssertionError: expected \"error\" to be called with arguments: [ StringContaining{...}, Anything ]" - while the ubuntu leg of the same head passed. Reproduced here on the pinned node v22.23.4 by pointing TEMP at a directory that has an 8.3 name (TEMP=C:\work\ZOO-CO~1\TMP-AL~2): the same row failed with the same assertion, and the printed diff named the mechanism. The test's path was C:\work\ZOO-CO~1\TMP-AL~2\safeWriteJson-test-E6lc0Q\test-file.json and the log named C:\work\Zoo-Code-fork\.tmp-alias-vps2f\safeWriteJson-test-E6lc0Q\ test-file.json: same directory, same file, different spelling. The CI log elides both strings, so what is being named is the class - an assertion that pins the caller's spelling against a writer-resolved spelling - not the runner's direction, which its log does not show. The fix pins what resolution preserves instead: the mkdtemp directory's own name and the file's name, with the original two-argument matcher kept, the target identified by its name. The claim is unchanged - the failure must still be logged, and the log must still name the target - but it is no longer stated as a spelling. Before the change this file's other 52 rows already passed under that aliased TEMP, and this was the only assertion in the file that compared a stringContaining against a path variable, measured from the file itself. Gates below were run after committing, against this tree, on pinned node v22.23.4: the file runs 53 passed / 4 skipped under TEMP=C:\work\ZOO-CO~1\ TMP-AL~2, under TEMP=C:\work\Zoo-Code-fork\.tmp-alias-vps2f and under the default temp; eslint --max-warnings=0 exits 0 with src/eslint-suppressions.json untouched; prettier --check exits 0. Test-only: no implementation line moves. --- src/utils/__tests__/safeWriteJson.test.ts | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 4f50923c5f..50feb7d800 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -1069,7 +1069,20 @@ describe("safeWriteJson", () => { await safeWriteJson(currentTestFilePath, { after: true }) expect(await readFileContent(currentTestFilePath)).toEqual({ after: true }) - expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining(currentTestFilePath), expect.anything()) + // The log must name the target it could not read; it must not be compared against + // the caller's spelling. The writer resolves the target before logging, and on + // Windows a path whose components carry 8.3 aliases resolves to a different + // spelling than the one the caller handed it - measured on this row: a temp under + // C:\work\ZOO-CO~1\TMP-AL~2 logged its target as ...\Zoo-Code-fork\.tmp-alias-vps2f\ + // on the same run. The mkdtemp directory name and the file's own name are the parts + // that survive resolution, so the log is pinned to those. + const loggedTargets = consoleErrorSpy.mock.calls.map((call: unknown[]) => String(call[0])).join("\n") + expect(loggedTargets).toContain(path.basename(path.dirname(currentTestFilePath))) + expect(loggedTargets).toContain(path.basename(currentTestFilePath)) + expect(consoleErrorSpy).toHaveBeenCalledWith( + expect.stringContaining(path.basename(currentTestFilePath)), + expect.anything(), + ) consoleErrorSpy.mockRestore() }, 20_000) From 416179d17de83dfc9bfc1212cc8640da570db90a Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:40:41 +0800 Subject: [PATCH 66/72] refactor(u4): reuse main's errorCode helper and drop a one-line fsync wrapper Two module-private helpers on this branch reimplemented `src/utils/errorCode.ts`, which main already ships and which `safeWriteJson.ts` already imports: - `safeWriteJson._scopeErrorCode` (2 call sites) -> `getErrorCode` - `safeWriteText.errorCode` (8 call sites) -> `getErrorCode` - `safeWriteText._fsyncFile(fd)` wrapped a single `fsSync.fsyncSync(fd)` call; the 4 call sites now call it directly. Equivalence was checked at the call sites rather than assumed. All 10 uses compare the result against a string code literal (`=== "ENOENT"`, `!== "ENOENT"`, and the ENOTDIR variants), so the one real difference between the bodies - main's helper additionally guards `typeof error.code === "string"`, `_scopeErrorCode` casts, and `errorCode` stringifies - cannot change a decision: an absent or non-string code yields `undefined` from `getErrorCode` and either a coerced string or `undefined` from the private helpers, and both take the same branch against a string literal. This is line-count work for the mutation gate, not a behaviour change: no assertion moved, no expectation weakened, nothing dropped to make a number fit. The gate counts changed executable lines per package against main and fails above 500. With the repository's own counting rules applied locally (scripts/stryker-diff.mjs) at b86511fe567a the `extension` package measured 509, which is the number CI reported for that head; after this commit the same selector reports 499 (safeWriteText +272 -> +266, safeWriteJson +135 -> +131). The removals are the duplicate helper bodies and the wrapper only. Measured with pinned node v22.23.4 on this tree: prettier --check on both files exit 0; eslint --max-warnings=0 on both files exit 0 with src/eslint-suppressions json unmodified; tsc -p src/tsconfig.json --noEmit exit 0; misc shard 119 passed / 1 skipped files and 2118 passed / 17 skipped tests; core shard 197 files and 4280 passed / 9 skipped tests; misc shard restricted to the write-protocol proof files (5 exist in this lane) 81 passed / 4 skipped; knip and knip --production, both with --treat-config-hints-as-errors, exit 0; knip-policy test 8 pass / 0 fail. The services shard is unchanged from the pre-commit baseline: the same 6 failures with and without this commit, classed from the messages themselves - 5 `EPERM: operation not permitted, symlink ...` fixture-creation failures in services/rules (unprivileged symlink creation in %TEMP% on this box) and 1 `DaclRestoreError` in safeWriteText.integration.spec.ts (the saved access rights could not be restored here). The hosted windows leg passes both files at b86511fe567a. Local results describe this tree only: pnpm 10.8.1 ignores the `pnpm` field in package.json (onlyBuiltDependencies, overrides), so a resolution difference is the first candidate if a local shard disagrees with a hosted leg. --- src/services/file-safety/safeWriteText.ts | 41 ++++++++--------------- src/utils/safeWriteJson.ts | 10 ++---- 2 files changed, 16 insertions(+), 35 deletions(-) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 7f6c9d6d52..523fa5aaf4 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -3,6 +3,8 @@ import * as fsSync from "fs" import * as path from "path" import { execFile } from "child_process" +import { getErrorCode } from "../../utils/errorCode" + export interface SafeWriteTextOptions { /** * When true, keep the old-file semantics without ever removing the target: the @@ -142,10 +144,6 @@ function _stagingDir(dir: string): string { return sd } -function _fsyncFile(fd: number): void { - fsSync.fsyncSync(fd) -} - /** Save the DACL of *srcPath* to a dump file on Windows. * Returns true when the dump was written successfully; false otherwise. * Never throws — callers treat failure as "skip DACL handling". */ @@ -196,31 +194,20 @@ async function _restoreDaclWindows( */ export async function resolvePublishTarget(absoluteFilePath: string): Promise { return fs.realpath(absoluteFilePath).catch(async (error: unknown) => { - if (errorCode(error) !== "ENOENT") throw error + if (getErrorCode(error) !== "ENOENT") throw error // ENOENT also covers a dangling symlink, which must never be written through. // Only a lstat that also reports the path as absent may fall back to the // given path; a real lstat failure (EACCES, EIO) says nothing about whether // the path is a link, so falling back would write through a link we were // simply not allowed to inspect. const linkStat = await fs.lstat(absoluteFilePath).catch((lstatError: unknown) => { - if (errorCode(lstatError) === "ENOENT") return undefined + if (getErrorCode(lstatError) === "ENOENT") return undefined throw lstatError }) if (linkStat?.isSymbolicLink()) throw error return absoluteFilePath }) } -/** - * Distinguish "the target does not exist" from a real I/O failure (EACCES, - * EIO, ...). The mode-preservation path may only fall back to the fresh-file - * default on ENOENT; any other failure is propagated, otherwise a restrictive - * target (0o600) would be published with the default 0o644 through the rename. - */ -function errorCode(error: unknown): string | undefined { - return typeof error === "object" && error !== null && "code" in error - ? String((error as { code: unknown }).code) - : undefined -} /** * Canonicalize the parent directory and re-join the basename. fs.realpath @@ -245,7 +232,7 @@ async function canonicalDirKey(absoluteFilePath: string): Promise { const missing: string[] = [] for (;;) { const canonical = await fs.realpath(cursor).catch((error: unknown) => { - if (errorCode(error) === "ENOENT") return undefined + if (getErrorCode(error) === "ENOENT") return undefined throw error }) if (canonical !== undefined) { @@ -352,7 +339,7 @@ export async function safeWriteText( // staging alias reach the commit and let cleanup delete the file it was meant to // protect. const targetStat = await fs.lstat(targetPath, { bigint: true }).catch((error: unknown) => { - if (errorCode(error) !== "ENOENT") { + if (getErrorCode(error) !== "ENOENT") { throw new StagingPathError("Staging file could not be compared with the target", supplied) } return null @@ -426,7 +413,7 @@ export async function safeWriteText( targetMode = fsSync.statSync(targetPath).mode & 0o777 targetExists = true } catch (error: unknown) { - if (errorCode(error) !== "ENOENT") throw error + if (getErrorCode(error) !== "ENOENT") throw error // target does not exist yet - keep the default } // openSync's creation mode is narrowed by the process umask, so an @@ -445,7 +432,7 @@ export async function safeWriteText( while (offset < buffer.length) { offset += fsSync.writeSync(fd, buffer, offset, buffer.length - offset) } - _fsyncFile(fd) + fsSync.fsyncSync(fd) } finally { fsSync.closeSync(fd) } @@ -460,7 +447,7 @@ export async function safeWriteText( try { targetMode = fsSync.statSync(targetPath).mode & 0o777 } catch (error: unknown) { - if (errorCode(error) !== "ENOENT") throw error + if (getErrorCode(error) !== "ENOENT") throw error // target does not exist yet - keep the temp's default mode } const fd = fsSync.openSync(tempPath, "r+") @@ -468,7 +455,7 @@ export async function safeWriteText( if (targetMode !== null) { fsSync.fchmodSync(fd, targetMode) } - _fsyncFile(fd) + fsSync.fsyncSync(fd) } finally { fsSync.closeSync(fd) } @@ -505,7 +492,7 @@ export async function safeWriteText( // staging directory - so a refused publish strands neither. throw new DaclInspectionError(targetPath, "save", null) } - } else if (errorCode(accessError) !== "ENOENT") { + } else if (getErrorCode(accessError) !== "ENOENT") { // Not "absent": the target is there but its access rights could not be read // (EACCES, ...), so publishing would replace a file whose rights this call never // learned. Same rule as the failed save above: refuse before anything is committed. @@ -541,7 +528,7 @@ export async function safeWriteText( // flag the staged temp file uses above. const backupFd = fsSync.openSync(backupPath, "r+") try { - _fsyncFile(backupFd) + fsSync.fsyncSync(backupFd) } finally { fsSync.closeSync(backupFd) } @@ -554,7 +541,7 @@ export async function safeWriteText( } releaseBackupOnSuccess = true } catch (err: unknown) { - if (errorCode(err) !== "ENOENT") throw err + if (getErrorCode(err) !== "ENOENT") throw err } } @@ -567,7 +554,7 @@ export async function safeWriteText( try { const dirFd = fsSync.openSync(dirPath, "r") try { - _fsyncFile(dirFd) + fsSync.fsyncSync(dirFd) } finally { fsSync.closeSync(dirFd) } diff --git a/src/utils/safeWriteJson.ts b/src/utils/safeWriteJson.ts index 1e4031a7ef..f4edc7ee9c 100644 --- a/src/utils/safeWriteJson.ts +++ b/src/utils/safeWriteJson.ts @@ -118,7 +118,7 @@ async function _resolveScopeRoot(confineTo: string): Promise { // scope cannot be canonicalized at all, and continuing would build a partly // lexical root that can disagree with the canonical target - the failure has to // surface rather than decide the scope from a guess. - if (_scopeErrorCode(error) !== "ENOENT") { + if (getErrorCode(error) !== "ENOENT") { throw error } const missing: string[] = [] @@ -134,7 +134,7 @@ async function _resolveScopeRoot(confineTo: string): Promise { const real = await fs.realpath(ancestor) return path.join(real, ...missing.reverse()) } catch (innerError: unknown) { - if (_scopeErrorCode(innerError) !== "ENOENT") { + if (getErrorCode(innerError) !== "ENOENT") { throw innerError } } @@ -155,12 +155,6 @@ function _assertWithinScope(requestedPath: string, candidatePath: string, scopeR } } -function _scopeErrorCode(error: unknown): string | undefined { - return typeof error === "object" && error !== null && "code" in error - ? (error as { code?: string }).code - : undefined -} - /** * The scope root a caller declared, or undefined when no scope was declared. * Confinement is active whenever confineTo is DEFINED: a declared root that is From 120cb057a9f0fd2754ed643c7511ccc2609a895e Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 12:52:10 +0800 Subject: [PATCH 67/72] unit(u5b): guard machinery in the writer, with the identity and rights refusals First unit of the #1914 split plan recorded on #1991: this branch's increment over PR #1913's head 416179d17de8 for the writer-side paths (safeWriteText.ts and its spec, fileLock.ts and its spec, Task.ts and Task.spec.ts). guardedWrite.ts and its spec stay in the next unit, because the tool consumes this unit's guard API rather than the reverse. Two refusals that the refresh merge surfaced as divergent between the two copies of safeWriteText.ts are re-added here rather than left as a silent loss, per the lead's ruling on #1991 question 1. Neither is a rival design: the staging-path (dev, ino) refusal applies the contract confirmed on #2356 (identity compared after canonicalisation, consumers compare identity) to the file this write stages through, and the DACL refusal is the same fail-closed principle ruled for _copyTargetMode in #1917 - publishing without knowing the target's access rights can widen who reads the file, and logging-and-continuing was rejected there. Both are recorded as requirements on #2350. 1. Staging identity: the supplied staging path and the target are compared by (dev, ino) read with bigint stats (file identities on NTFS/ReFS exceed Number.MAX_SAFE_INTEGER, and a rounded number either hides an alias or rejects a valid staging file). Only ENOENT may skip the comparison; EACCES/ELOOP/ENOTDIR means the comparison could not be made and is itself a refusal, because otherwise an alias reaches the commit and the failure handler unlinks the only remaining copy of the content - a failed write would delete the file it was meant to protect. Pinned by two tests: the alias itself, and the non-ENOENT reason. 2. Access rights on win32: a target that exists but whose DACL cannot be saved, or whose access rights cannot be read (getErrorCode != ENOENT), now yields DaclInspectionError before anything is committed, with the phase and target path on the error. The class is the one PR #1913's copy already carries; its text is taken unchanged. Contract change, stated because tests move with it: two tests in this branch's spec asserted the opposite behaviour - "win32 DACL failure falls back to plain rename (never fails the write)" and the partial-dump test's assertion that the write commits. Both are replaced with assertions of the refusal (rename never happens, the dump is still unlinked, one icacls attempt, phase and path pinned). A third test covers the inspection refusal; it injects platform win32 and stubs icacls, so it runs on either hosted leg rather than only on the windows one, and the hosted windows leg passes this file. One config line comes with this unit: knip.json declares services/file-safety/safeWriteText.ts as a src workspace entry. Without it, knip --production fails on this unit in isolation - knip does not credit imports from files it reports as unused, and the only production consumer of the exported safeWriteText function arrives with the next unit - and knip is a required status check on main (Protect Main ruleset: check-translations, both platform-unit-test legs, compile, knip, e2e-mock). With the entry declared, both knip modes and the knip-policy test pass on this unit alone. --- knip.json | 7 +- src/core/task/Task.ts | 15 + src/core/task/__tests__/Task.spec.ts | 50 ++ .../__tests__/safeWriteText.spec.ts | 797 +++++++++++------- src/services/file-safety/safeWriteText.ts | 490 ++++++++--- src/utils/__tests__/fileLock.spec.ts | 169 ++++ src/utils/fileLock.ts | 109 ++- 7 files changed, 1196 insertions(+), 441 deletions(-) create mode 100644 src/utils/__tests__/fileLock.spec.ts diff --git a/knip.json b/knip.json index 1f4956faa6..111f022102 100644 --- a/knip.json +++ b/knip.json @@ -16,7 +16,12 @@ "playwright-ct": false, "workspaces": { "src": { - "entry": ["extension.ts!", "extension/api.ts!", "workers/countTokens.ts!"], + "entry": [ + "extension.ts!", + "extension/api.ts!", + "workers/countTokens.ts!", + "services/file-safety/safeWriteText.ts!" + ], "project": [ "**/*.ts!", "!**/__tests__/**!", diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index a8118afa12..2c54050aff 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -398,6 +398,11 @@ export class Task extends EventEmitter implements TaskLike { providerRef: WeakRef private readonly globalStoragePath: string abort: boolean = false + // Monotonic cancellation counter. `requestAbort()` and `requestDispose()` advance + // this fence, and the guarded-write path compares the value it captured when the + // write was queued with the value at publish time, so a queued write cannot publish + // after the task was cancelled or disposed. + cancellationGeneration: number = 0 currentRequestAbortController?: AbortController /** * Controller for the waiter on an in-flight `ensureModelFetched()` call (see @@ -3596,6 +3601,11 @@ export class Task extends EventEmitter implements TaskLike { this.abandoned = true } this.abort = true + // The S4a write guard compares this counter with the value a queued write + // captured when it started, so every cancellation must advance it; it must + // never go backwards because resumeAfterDelegation() clears `abort` (the + // flag alone cannot keep the cancelled run and the resumed run apart). + this.cancellationGeneration++ this.driveRunEvent({ tag: "abortRequested", abandoned: isAbandoned }) } @@ -3606,6 +3616,10 @@ export class Task extends EventEmitter implements TaskLike { requestDispose(): void { this.abort = true + // A host teardown never calls abortTask(): disposal has to raise the same + // counter, or a write still parked on its path chain publishes after the + // task is gone. + this.cancellationGeneration++ this.driveRunEvent({ tag: "disposeRequested" }) } @@ -3634,6 +3648,7 @@ export class Task extends EventEmitter implements TaskLike { public abortTask(isAbandoned = false): Promise { this.requestAbort(isAbandoned) + this.cancelAssistantMessagePersistence() this.abortPromise ??= this.abortTaskOnce() return this.abortPromise diff --git a/src/core/task/__tests__/Task.spec.ts b/src/core/task/__tests__/Task.spec.ts index 481a19d498..68cbba8d1b 100644 --- a/src/core/task/__tests__/Task.spec.ts +++ b/src/core/task/__tests__/Task.spec.ts @@ -4768,6 +4768,56 @@ describe("Cline", () => { ).toHaveLength(1) }) + it("advances the cancellation generation on each cancellation and keeps it advanced across a resume", async () => { + // The S4a write guard compares the cancellation generation a queued write + // captured against the generation at publish time. The abort FLAG cannot do that + // on its own: resumeAfterDelegation() clears it, and a write that belongs to the + // cancelled run would then publish as if nothing had been cancelled. Only the + // generation keeps the two runs apart, so it must never go backwards. + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "test task", + startTask: false, + }) + vi.spyOn(task, "dispose").mockResolvedValue(undefined) + + expect(task.cancellationGeneration).toBe(0) + + await task.abortTask() + expect(task.abort).toBe(true) + expect(task.cancellationGeneration).toBe(1) + + await task.resumeAfterDelegation() + // The run-state model (RSK-06) no longer clears the legacy `abort` flag + // on resume: that is exactly why the generation exists. Only the + // generation keeps the cancelled run and the resumed run apart. + expect(task.cancellationGeneration).toBe(1) + + await task.abortTask() + expect(task.abort).toBe(true) + expect(task.cancellationGeneration).toBe(2) + }) + + it("advances the cancellation generation on disposal, without any explicit cancel", async () => { + // A task torn down by the host never sees abortTask(). Disposal has to raise the + // same generation, or a write still parked on its path chain publishes after the + // task is gone. + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "test task", + startTask: false, + }) + + expect(task.cancellationGeneration).toBe(0) + + await task.dispose() + + expect(task.abort).toBe(true) + expect(task.cancellationGeneration).toBe(1) + }) + it("flushes pending state before TaskAborted and disposal while queue state is intact", async () => { const task = new Task({ provider: mockProvider, diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index fc8f30e212..825abb71e5 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -1,28 +1,36 @@ import * as fs from "fs/promises" +import type { BigIntStats } from "fs" import * as fsSync from "fs" import { execFile } from "child_process" import type { ChildProcess } from "child_process" import * as path from "path" import { - DaclInspectionError, - DaclRestoreError, PostCommitDurabilityError, + DaclInspectionError, resolveLockKey, safeWriteText, StagingPathError, + TargetExistsError, + UnsupportedFilesystemError, + TargetMovedError, + AncestorReplacedError, + OrphanedBackupError, + OrphanedPublishedBackupError, } from "../safeWriteText" // Full mock for fs/promises — all methods are vi.fn() stubs vi.mock("fs/promises", () => ({ - copyFile: vi.fn(), - chmod: vi.fn(), mkdir: vi.fn(), access: vi.fn(), rename: vi.fn(), + link: vi.fn(), + copyFile: vi.fn(), + chmod: vi.fn(), unlink: vi.fn(), rmdir: vi.fn(), realpath: vi.fn(), + stat: vi.fn(), lstat: vi.fn(), readlink: vi.fn(), })) @@ -30,6 +38,8 @@ vi.mock("fs/promises", () => ({ // Full mock for fs — all sync methods are vi.fn() stubs. Stats is a bare // class stub so tests can build minimal Stats stand-ins via its prototype. vi.mock("fs", () => ({ + // Mirrors Node's value; the no-replace fallback passes it to copyFile. + constants: { COPYFILE_EXCL: 1 }, openSync: vi.fn(), writeSync: vi.fn(), closeSync: vi.fn(), @@ -68,23 +78,13 @@ function _fileStats(isLink: boolean): fsSync.Stats { return s } -// fs.BigIntStats is a type-only export (fs.BigIntStats is undefined at runtime), so the stand-in is -// a Stats object carrying bigint ino/dev - exactly what fs.lstat(path, { bigint: true }) hands -// back at runtime. -function _fileStatsWithIdentity(ino: bigint, dev: bigint): fsSync.BigIntStats { - // Double assertion: the runtime value is the Stats stand-in, the type is the bigint variant. - const s = _fileStats(false) as unknown as fsSync.BigIntStats - s.ino = ino - s.dev = dev - return s -} - function mockDefaults(): void { vi.resetAllMocks() // After resetAllMocks, vi.fn() returns undefined — restore promise defaults. vi.mocked(fs.mkdir).mockResolvedValue(undefined) vi.mocked(fs.access).mockResolvedValue(undefined) vi.mocked(fs.rename).mockResolvedValue(undefined) + vi.mocked(fs.link).mockResolvedValue(undefined) vi.mocked(fs.unlink).mockResolvedValue(undefined) vi.mocked(fs.rmdir).mockResolvedValue(undefined) // Existing-target default: a regular 0o644 file. @@ -92,6 +92,21 @@ function mockDefaults(): void { // Staged-file default: a regular file, not a link, so a caller-supplied // tempPath passes the location and file-type check by default. vi.mocked(fs.lstat).mockResolvedValue(_fileStats(false)) + // Ancestor-identity pin: default to one stable directory identity so the pin + // passes unless a test overrides it. + vi.mocked(fs.stat).mockResolvedValue(_dirIdentity(100n)) +} + +// BigIntStats stand-in for the ancestor pin: the SUT reads only dev/ino off it. +// BigIntStats is class-backed with no public constructor, so this is a +// last-resort double assertion (test-local, per AGENTS.md). +function _dirIdentity(ino: bigint): BigIntStats { + return { dev: 1n, ino } as unknown as BigIntStats +} +// BigIntStats stand-in for a regular staging file: the SUT reads dev/ino off it and asks +// whether it is a link. Same last-resort double assertion as _dirIdentity, test-local. +function _fileIdentity(dev: bigint, ino: bigint): BigIntStats { + return { dev, ino, isSymbolicLink: () => false, isFile: () => true } as unknown as BigIntStats } function _stats(mode: number): fsSync.Stats { const s = Object.create(fsSync.Stats.prototype) as fsSync.Stats @@ -282,42 +297,6 @@ describe("safeWriteText", () => { }) }) - it("win32: a rejecting async onWarning does not displace the caller's error or leak an unhandled rejection", async () => { - // TypeScript accepts an async sink where a void callback is expected, so the - // wrapper has to attach a handler to the returned promise: an unhandled - // rejection can end the process under Node's default mode. The notice exercised - // here is the retained-backup one - the DACL notices became refusals - so a sink - // failure now has to be reported without displacing the error the caller catches. - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - // The DACL save succeeds and only the restore fails: the publish commits and - // reports its retained backup copy through the sink. - let icaclsCalls = 0 - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - icaclsCalls++ - if (typeof cb === "function") cb(icaclsCalls === 1 ? null : new Error("icacls restore error"), "", "") - return fakeChild - }) - const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {}) - - await expect( - safeWriteText(targetPath, "data", { - platform: "win32", - backup: true, - onWarning: async () => { - throw new Error("async sink down") - }, - }), - ).rejects.toBeInstanceOf(DaclRestoreError) - - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) - // The rejection is reported through the fallback sink rather than surfacing as an - // unhandled rejection. - expect(consoleWarn).toHaveBeenCalledWith(expect.stringContaining("onWarning callback rejected")) - consoleWarn.mockRestore() - }) - // ── Test 2: fsync ordering ─────────────────────────────────────────────── describe("fsync ordering", () => { @@ -395,35 +374,9 @@ describe("safeWriteText", () => { // temp-shaped is unlinked afterwards expect(fs.unlink).not.toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) - - it("a failed post-commit directory fsync does not roll the backup back over the published content", async () => { - const targetPath = "/tmp/test-dir/target.txt" - const dirPath = path.dirname(targetPath) - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - // The file fd opens normally; the parent-directory open after the commit - // rename fails, which is the post-commit durability failure. - vi.mocked(fsSync.openSync).mockImplementation((target) => { - if (String(target) === dirPath) throw new Error("EBADF") - return 1 - }) - - await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow( - PostCommitDurabilityError, - ) - - // The commit rename already published the new content, and the backup was only - // ever a copy: the target was never moved, so there is nothing to rename back. - expect(fs.copyFile).toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) - expect(fs.rename).toHaveBeenCalledTimes(1) - expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) - - // The durability failure is reported, not swallowed - and the backup copy is not - // left beside the target where no caller could find it. - expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) - }) }) - // ── Test 4: backup:true keeps old safeWriteJson semantics, copy-based ── + // ── Test 4: backup:true keeps old safeWriteJson semantics incl. rollback ── describe("backup:true", () => { it("copies target -> backup before commit without moving the target, deletes the copy on success", async () => { @@ -468,6 +421,51 @@ describe("safeWriteText", () => { expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) + it("retries the post-commit backup removal and succeeds when the retry clears", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + const backupUnlinks: string[] = [] + vi.mocked(fs.unlink).mockImplementation(async (candidate: unknown) => { + const asString = String(candidate) + if (asString.includes("safeWriteText.bak_")) { + backupUnlinks.push(asString) + // The first attempt hits a transient Windows handle; the retry succeeds. + if (backupUnlinks.length === 1) { + throw Object.assign(new Error("EBUSY"), { code: "EBUSY" }) + } + } + }) + + await safeWriteText(targetPath, "new data", { backup: true }) + + expect(backupUnlinks).toHaveLength(2) + }) + + it("surfaces an orphaned pre-write copy instead of returning success", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + vi.mocked(fs.unlink).mockImplementation(async (candidate: unknown) => { + if (String(candidate).includes("safeWriteText.bak_")) { + throw Object.assign(new Error("EPERM"), { code: "EPERM" }) + } + }) + + const error = await safeWriteText(targetPath, "new data", { backup: true }).catch( + (caught: unknown) => caught, + ) + + expect(error).toBeInstanceOf(OrphanedPublishedBackupError) + const orphan = error as OrphanedPublishedBackupError + expect(orphan.orphanedBackupPath).toContain("safeWriteText.bak_") + expect(orphan.publishedPath).toBe(targetPath) + // Two attempts, then the failure is reported instead of swallowed. + expect( + vi.mocked(fs.unlink).mock.calls.filter((call) => String(call[0]).includes("safeWriteText.bak_")), + ).toHaveLength(2) + }) + it("creates the backup privately before its content exists, then fsyncs it", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -532,6 +530,45 @@ describe("safeWriteText", () => { expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) }) + it("carries the leftover path when the partial backup cannot be removed either", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockImplementation((p: unknown) => + String(p).includes("safeWriteText.bak_") ? 7 : 1, + ) + vi.mocked(fsSync.fsyncSync).mockImplementation((fd: unknown) => { + if (fd === 7) { + throw new Error("EIO") + } + }) + let unlinkAttempts = 0 + vi.mocked(fs.unlink).mockImplementation(async (p: unknown) => { + if (String(p).includes("safeWriteText.bak_")) { + unlinkAttempts++ + } + throw Object.assign(new Error("EPERM"), { code: "EPERM" }) + }) + + // The copy failed and the locked leftover could not be unlinked even after the + // retry. Dropping the path would leave a partial copy of the previous content on + // disk with no reference to it anywhere, so the error carries it. + const error = await safeWriteText(targetPath, "new data", { + backup: true, + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(OrphanedBackupError) + const orphan = error as OrphanedBackupError + expect(orphan.orphanedBackupPath).toContain("safeWriteText.bak_") + expect(orphan.message).toContain("safeWriteText.bak_") + expect(orphan.message).toContain("EPERM") + expect(orphan.originalError).toBeInstanceOf(Error) + expect((orphan.originalError as Error).message).toBe("EIO") + expect(orphan.cause).toBe(orphan.originalError) + expect(unlinkAttempts).toBe(2) + expect(fs.rename).not.toHaveBeenCalled() + }) + it("a backup copy that fails part-way is removed, not left as a usable-looking backup", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -637,29 +674,34 @@ describe("safeWriteText", () => { expect(execFile).toHaveBeenCalledTimes(1) }) - it("win32: refuses the publish without an onWarning notice when the DACL cannot be saved", async () => { + it("win32 DACL: a partial dump left by a failed save is removed and the publish is refused", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) + // icacls save fails - a real icacls may have written a partial dump + // before erroring, so the dump path must be cleaned up and must never + // be used for a restore. vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - if (typeof cb === "function") cb(new Error("icacls error"), "", "") + if (typeof cb === "function") cb(new Error("icacls save error"), "", "") return fakeChild }) - const warnings: string[] = [] - await expect( - safeWriteText(targetPath, "data", { platform: "win32", onWarning: (m) => warnings.push(m) }), - ).rejects.toBeInstanceOf(DaclInspectionError) + const refusal = await safeWriteText(targetPath, "data", { platform: "win32" }).catch( + (error: unknown) => error, + ) - // Contract change: the refusal replaces the warning. There is no replacement whose - // access rights could have changed, so no notice is emitted for a write that did - // not happen - a warning beside a refused publish would let a caller that ignores - // the error still read the write as a save. + // The contract changed with the refusal: a target whose DACL could not be captured is + // not replaced by a file that inherits different rights, so no rename happens at all. + expect(refusal).toBeInstanceOf(DaclInspectionError) + expect(refusal).toMatchObject({ name: "DaclInspectionError", phase: "save", targetPath }) expect(fs.rename).not.toHaveBeenCalled() - expect(warnings).toHaveLength(0) + expect(execFile).toHaveBeenCalledTimes(1) + const saveArgs = vi.mocked(execFile).mock.calls[0]?.[1] + expect(saveArgs?.[1]).toBe("/save") + // the dump path (possibly partially created by icacls) was unlinked + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) - - it("win32: refuses the publish when the target cannot be checked for DACL preservation", async () => { + it("win32: refuses the publish when the target exists but its access rights cannot be read", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) @@ -669,16 +711,17 @@ describe("safeWriteText", () => { if (String(p) === targetPath) { throw Object.assign(new Error("EACCES"), { code: "EACCES" }) } + return undefined }) - const warnings: string[] = [] // Captured once: a second call would double-count the assertions below. - const refusal = await safeWriteText(targetPath, "data", { - platform: "win32", - onWarning: (m) => warnings.push(m), - }).catch((error: unknown) => error) + const refusal = await safeWriteText(targetPath, "data", { platform: "win32" }).catch( + (error: unknown) => error, + ) expect(refusal).toBeInstanceOf(DaclInspectionError) + // The class alone does not pin the contract: the phase says which check refused and + // the path names the file the caller must not assume was saved. expect(refusal).toMatchObject({ name: "DaclInspectionError", phase: "inspect", @@ -686,94 +729,9 @@ describe("safeWriteText", () => { message: expect.stringContaining("its access rights could not be checked"), }) - // Contract change: "there but unreadable" is no longer a reason to publish blind. - // The publish is refused before any icacls runs, and nothing is warned about a - // write that did not happen. + // The publish is refused before any icacls runs, and nothing is renamed. expect(execFile).not.toHaveBeenCalled() expect(fs.rename).not.toHaveBeenCalled() - expect(warnings).toHaveLength(0) - }) - - // The refusals sit inside the try whose catch performs the cleanup, so a refused - // publish is cleaned up by that handler and by nothing else. Counted, not matched - // with toHaveBeenCalledWith: that matcher passes however many times the same path - // is passed, so it cannot see a cleanup that runs twice. - it("win32: a refused publish removes its staged file and staging directory exactly once", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - if (typeof cb === "function") cb(new Error("icacls error"), "", "") - return fakeChild - }) - - await expect(safeWriteText(targetPath, "data", { platform: "win32" })).rejects.toBeInstanceOf( - DaclInspectionError, - ) - - const unlinkCalls = vi.mocked(fs.unlink).mock.calls.map((call) => String(call[0])) - const rmdirCalls = vi.mocked(fs.rmdir).mock.calls.map((call) => String(call[0])) - expect(unlinkCalls.filter((p) => p.includes("safeWriteText_"))).toHaveLength(1) - expect(rmdirCalls.filter((p) => p.includes(".file-safety-staging"))).toHaveLength(1) - }) - - // Warning delivery is advisory: it must not be able to change what the caller learns. - it("win32: a throwing onWarning does not replace the error the caller receives", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - // The DACL save succeeds and the restore fails, so the notice this sink throws on - // is the retained-backup one delivered from the failure handler. - let icaclsCalls = 0 - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - icaclsCalls++ - if (typeof cb === "function") cb(icaclsCalls === 1 ? null : new Error("icacls restore error"), "", "") - return fakeChild - }) - const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {}) - - const failure = await safeWriteText(targetPath, "data", { - platform: "win32", - backup: true, - onWarning: () => { - throw new Error("callback down") - }, - }).catch((error: unknown) => error) - - // A broken notice cannot turn a refused publish into an unreported one, and cannot - // swallow the write either: the caller still holds the DACL error. - expect(failure).toBeInstanceOf(DaclRestoreError) - expect(fs.rename).toHaveBeenCalledTimes(1) - // The sink really was reached, so this is not a test that passes because no - // notice was ever delivered. - expect(consoleWarn).toHaveBeenCalledWith(expect.stringContaining("onWarning callback failed")) - consoleWarn.mockRestore() - }) - - it("win32 DACL: a partial dump left by a failed save is removed and never restored", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - // icacls save fails — a real icacls may have written a partial dump - // before erroring, so the dump path must be cleaned up and must never - // be used for a restore. - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - if (typeof cb === "function") cb(new Error("icacls save error"), "", "") - return fakeChild - }) - - await expect(safeWriteText(targetPath, "data", { platform: "win32" })).rejects.toBeInstanceOf( - DaclInspectionError, - ) - - // Contract change: the publish is refused, so nothing is renamed. Only the save was - // attempted, and the partial dump is still removed below. - expect(fs.rename).not.toHaveBeenCalled() - expect(execFile).toHaveBeenCalledTimes(1) - const saveArgs = vi.mocked(execFile).mock.calls[0]?.[1] - expect(saveArgs?.[1]).toBe("/save") - // the dump path (possibly partially created by icacls) was unlinked - expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) it("win32 DACL save args are [targetPath, /save, dumpPath, /T] before backup rename", async () => { @@ -804,34 +762,10 @@ describe("safeWriteText", () => { expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) - it("win32 DACL save runs before the backup copy, not after it", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - - // The title is about order, so assert the order the mocks were actually - // called in. If the save ran after the backup copy the dump could describe a - // file that a concurrent publish had already replaced. - await safeWriteText(targetPath, "data", { backup: true, platform: "win32" }) - - const callOrder = vi.mocked(execFile).mock.invocationCallOrder - const copyOrder = vi.mocked(fs.copyFile).mock.invocationCallOrder - const renameOrder = vi.mocked(fs.rename).mock.invocationCallOrder - const saveCall = callOrder[0] - const restoreCall = callOrder[1] - const backupCopy = copyOrder[0] - const commitRename = renameOrder[0] - - expect(saveCall).toBeLessThan(backupCopy) - expect(backupCopy).toBeLessThan(commitRename) - expect(commitRename).toBeLessThan(restoreCall) - }) - - it("win32 DACL: a failed restore is an error and the dump is still unlinked", async () => { + it("win32 DACL: dump is unlinked even when restore fails", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) vi.mocked(fsSync.openSync).mockReturnValue(1) - const warnings: string[] = [] // icacls save succeeds, restore fails let callCount = 0 @@ -843,100 +777,16 @@ describe("safeWriteText", () => { return fakeChild }) - const failure = await safeWriteText(targetPath, "data", { - platform: "win32", - onWarning: (m) => warnings.push(m), - }).catch((error: unknown) => error) - - expect(failure).toBeInstanceOf(DaclRestoreError) - // The class alone does not pin the contract: the committed path is what a caller - // needs in order to tell which file answers to different rights than it did. - expect(failure).toMatchObject({ - name: "DaclRestoreError", - targetPath, - message: expect.stringContaining("could not be restored"), - }) + await safeWriteText(targetPath, "data", { platform: "win32" }) - // The content did commit before the restore failed, so the rename happened exactly - // once even though the publish reports an error. + // write succeeded despite restore failure (best-effort) expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) expect(fs.rename).toHaveBeenCalledTimes(1) - // Contract change: the changed access rights are an error the caller receives, not - // a notice beside a write that resolved. With no backup copy in play there is no - // leftover to name, so this publish stays silent and reports through the error. - expect(warnings).toHaveLength(0) - // dump file was still unlinked in finally expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.acl")) }) - it("win32 DACL: a failed restore keeps the backup copy that still carries the original access rights", async () => { - const targetPath = "/tmp/test-dir/target.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - const warnings: string[] = [] - let callCount = 0 - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - callCount++ - if (typeof cb === "function") cb(callCount === 1 ? null : new Error("icacls restore error"), "", "") - return fakeChild - }) - - await expect( - safeWriteText(targetPath, "data", { - platform: "win32", - backup: true, - onWarning: (m) => warnings.push(m), - }), - ).rejects.toBeInstanceOf(DaclRestoreError) - - // The publish committed, and the copy made from the file it replaced is the only - // artifact left holding the access rights that could not be restored. Removing it - // would destroy the recovery path for exactly the fact the error reports, so the - // failure handler must leave it in place. Counted, because toHaveBeenCalledWith - // cannot see a second unlink of the same path. - const unlinks = vi.mocked(fs.unlink).mock.calls.map((call) => String(call[0])) - expect(unlinks.filter((p) => p.includes("safeWriteText.bak_"))).toHaveLength(0) - expect(fs.rename).toHaveBeenCalledTimes(1) - - // The retained path is named to the human: this primitive has no structured result - // to carry it on, and an invisible leftover is worse than a visible one. - expect(warnings.filter((m) => m.includes("safeWriteText.bak_"))).toHaveLength(1) - }) - - it("win32 DACL: a failed restore reaches the caller-staged publish safeWriteJson hands in", async () => { - // safeWriteJson stages its own temp file and calls in with backup:true, so this is - // the shape its callers actually see: the publish must reject rather than resolve - // over a file whose rights changed, and keep the copy that still carries them. - const targetPath = "/tmp/test-dir/target.txt" - const callerTemp = "/tmp/test-dir/caller-staged.txt" - vi.mocked(fs.realpath).mockResolvedValue(targetPath) - vi.mocked(fsSync.openSync).mockReturnValue(1) - let callCount = 0 - vi.mocked(execFile).mockImplementation((_cmd, _args, _opts, cb) => { - callCount++ - if (typeof cb === "function") cb(callCount === 1 ? null : new Error("icacls restore error"), "", "") - return fakeChild - }) - - const outcome = await safeWriteText(targetPath, "", { - platform: "win32", - backup: true, - tempPath: callerTemp, - }).then( - () => "resolved" as const, - (error: unknown) => error, - ) - - // Not "resolved": no caller can observe success for a publish whose DACL was not - // preserved. - expect(outcome).toBeInstanceOf(DaclRestoreError) - expect(fs.rename).toHaveBeenCalledWith(callerTemp, targetPath) - const unlinks = vi.mocked(fs.unlink).mock.calls.map((call) => String(call[0])) - expect(unlinks.filter((p) => p.includes("safeWriteText.bak_"))).toHaveLength(0) - }) - it("win32 DACL: when target does not exist, no save/restore/dump", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -1095,6 +945,32 @@ describe("safeWriteText", () => { expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) }) + it("a failed post-commit directory fsync does not roll the backup back over the published content", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const dirPath = path.dirname(targetPath) + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // The file fd opens normally; the parent-directory open after the commit + // rename fails, which is the post-commit durability failure. + vi.mocked(fsSync.openSync).mockImplementation((target) => { + if (String(target) === dirPath) throw new Error("EBADF") + return 1 + }) + + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow( + PostCommitDurabilityError, + ) + + // The commit rename already published the new content, and the backup was only + // ever a copy: the target was never moved, so there is nothing to rename back. + expect(fs.copyFile).toHaveBeenCalledWith(targetPath, expect.stringContaining("safeWriteText.bak_")) + expect(fs.rename).toHaveBeenCalledTimes(1) + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) + + // The durability failure is reported, not swallowed - and the backup copy is not + // left beside the target where no caller could find it. + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText.bak_")) + }) + it("does not fchmod the self-staged temp for a fresh target", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -1290,6 +1166,50 @@ describe("safeWriteText", () => { expect(fs.rename).not.toHaveBeenCalled() }) }) + + it("a failed post-commit directory fsync never unlinks the committed target", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const dirPath = path.dirname(targetPath) + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockImplementation((target) => { + if (String(target) === dirPath) throw new Error("EBADF") + return 1 + }) + + await expect(safeWriteText(targetPath, "new data", { backup: true, platform: "linux" })).rejects.toThrow( + PostCommitDurabilityError, + ) + + // The commit state is what cleanup is allowed to act on: the staging file may be + // unlinked only while it is still the staging file. Once the rename has committed, + // the only path this write owns at the target is the published content itself, and + // removing it would turn a durability warning into data loss. + expect(fs.unlink).not.toHaveBeenCalledWith(targetPath) + }) + + it("a failed post-commit directory fsync does not unlink the staging path this write no longer owns", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const dirPath = path.dirname(targetPath) + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // A caller-supplied staging file: the name is the caller's, not one this write made + // up, so after the commit it is a path another writer may already be using again. + // The caller's staging file sits beside the target, as this contract requires. + const suppliedTemp = path.join(dirPath, "caller.new_data.json") + vi.mocked(fsSync.openSync).mockImplementation((target) => { + if (String(target) === dirPath) throw new Error("EBADF") + return 1 + }) + + await expect( + safeWriteText(targetPath, "new data", { backup: true, platform: "linux", tempPath: suppliedTemp }), + ).rejects.toThrow(PostCommitDurabilityError) + + // The rename consumed the staging file; the commit is what says so. Unlinking the + // staging NAME afterwards is an unlink of whatever now answers to that name. + expect(fs.unlink).not.toHaveBeenCalledWith(suppliedTemp) + expect(fs.unlink).not.toHaveBeenCalledWith(targetPath) + }) + describe("content bytes", () => { const targetPath = "/tmp/enc-dir/target.txt" @@ -1313,6 +1233,275 @@ describe("safeWriteText", () => { expect(fsSync.writeSync).toHaveBeenCalledWith(1, bytes, 0, 4) }) }) + it("a no-replace commit links the staged file into place when the target is absent", async () => { + // Isolate the commit-phase counters from any async cleanup a previous + // test left in flight. + vi.mocked(fs.rename).mockClear() + vi.mocked(fs.unlink).mockClear() + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + + await safeWriteText(targetPath, "new data", { failIfExist: true, platform: "linux" }) + + // link(2) is the only atomic no-replace publish: a rename would displace a + // target that appeared after the caller's absence check. + expect(fs.link).toHaveBeenCalledWith(expect.stringContaining("safeWriteText"), targetPath) + expect(fs.rename).not.toHaveBeenCalled() + // The staged copy is dropped once the name points at it. + expect( + vi.mocked(fs.unlink).mock.calls.some(function (call) { + return String(call[0]).includes("safeWriteText") + }), + ).toBe(true) + }) + + it("a no-replace commit refuses a target that appeared after the caller checked", async () => { + // Isolate the commit-phase counters from any async cleanup a previous + // test left in flight. + vi.mocked(fs.rename).mockClear() + vi.mocked(fs.unlink).mockClear() + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.link).mockRejectedValue(Object.assign(new Error("EEXIST"), { code: "EEXIST" })) + // The failure path still cleans up its staging file and directory; keep those + // promises real so the cleanup does not mask the rejection under test. + vi.mocked(fs.unlink).mockResolvedValue(undefined) + vi.mocked(fs.rmdir).mockResolvedValue(undefined) + + const error = await safeWriteText(targetPath, "new data", { + failIfExist: true, + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(TargetExistsError) + expect((error as TargetExistsError).targetPath).toBe(targetPath) + // Nothing replaced the newer file, and the staged copy is not left behind. + expect(fs.rename).not.toHaveBeenCalled() + expect( + vi.mocked(fs.unlink).mock.calls.some(function (call) { + return String(call[0]).includes("safeWriteText") + }), + ).toBe(true) + }) + + it("resolves an absent target through a symlinked ancestor to the canonical path", async () => { + // The guard pins the publish to the canonical nearest-ancestor path. An absent + // target has to resolve to that same path, or a create through a symlinked + // ancestor aborts with TargetMovedError although nothing moved. + const linkDir = path.resolve("/tmp/link-dir") + const canonicalDir = path.resolve("/real/dir") + const canonical = path.join(canonicalDir, "target.txt") + vi.mocked(fs.realpath).mockImplementation(async (p: unknown) => { + if (String(p) === path.join(linkDir, "target.txt")) { + throw Object.assign(new Error("ENOENT"), { code: "ENOENT" }) + } + if (String(p) === linkDir) return canonicalDir + return String(p) + }) + vi.mocked(fs.lstat).mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" })) + + await safeWriteText(path.join(linkDir, "target.txt"), "new data", { + expectedResolvedPath: canonical, + platform: "linux", + }) + + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText"), canonical) + }) + + it("fails closed when the filesystem has no atomic no-replace primitive", async () => { + // FAT32/exFAT and some SMB mounts reject link(2). Publishing by an exclusive + // copy would put bytes at the final name that readers can observe mid-copy, + // and a crash or an EIO mid-copy leaves damaged bytes there with the + // 'already exists' verdict on retry. No atomic no-replace primitive exists + // on those volumes, so the guarded create refuses to publish at all. + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.link).mockRejectedValue(Object.assign(new Error("ENOTSUP"), { code: "ENOTSUP" })) + + await expect( + safeWriteText(targetPath, "new data", { failIfExist: true, platform: "linux" }), + ).rejects.toBeInstanceOf(UnsupportedFilesystemError) + + // Nothing was published: no copy at the final name, no rename - the name + // stays absent for a retry on a capable volume. + // Every "no hard links here" code takes the same fail-closed path. + for (const code of ["EPERM", "ENOTSUP", "ENOSYS"]) { + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.link).mockRejectedValue(Object.assign(new Error(code), { code })) + + await expect( + safeWriteText(targetPath, "new data", { failIfExist: true, platform: "linux" }), + ).rejects.toBeInstanceOf(UnsupportedFilesystemError) + } + expect(fs.copyFile).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + // Every code reached the link path (the first call plus the three codes + // below), so the loop above really exercised all four refusals. + expect(fs.link).toHaveBeenCalledTimes(4) + // The refusal must not leave its staging file or directory beside the + // target: a regression here would drop a .file-safety-staging_* directory + // on FAT32/exFAT/SMB volumes after every refused create. + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + const stagedDirs = vi.mocked(fsSync.mkdirSync).mock.calls.map((call) => String(call[0])) + expect(vi.mocked(fs.rmdir).mock.calls.map((call) => String(call[0]))).toEqual(stagedDirs) + }) + it("still reports success when the staged copy cannot be unlinked after the link", async () => { + // An antivirus handle on Windows can make unlink fail with EBUSY after link(2) + // published the name. The content is readable at the target, so the write must + // not be reported as a failure the model then retries into an 'already exists'. + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.unlink).mockRejectedValue(Object.assign(new Error("EBUSY"), { code: "EBUSY" })) + + await expect( + safeWriteText(targetPath, "new data", { failIfExist: true, platform: "linux" }), + ).resolves.toBeUndefined() + expect(fs.link).toHaveBeenCalledWith(expect.stringContaining("safeWriteText"), targetPath) + }) + + it("refuses to publish when the path no longer resolves to the authorized target", async () => { + // Isolate the commit-phase counters from any async cleanup a previous test left + // in flight. + vi.mocked(fs.rename).mockClear() + vi.mocked(fs.link).mockClear() + const authorized = "/tmp/test-dir/target.txt" + // The caller authorized this path while it was a real file in the workspace; by the + // time the publish resolves it, a local process has swapped in a link to somewhere + // else. The decision was never made about that other file, so nothing is published. + vi.mocked(fs.realpath).mockResolvedValue("/outside/the-victim.txt") + + const error = await safeWriteText(authorized, "new data", { + expectedResolvedPath: authorized, + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(TargetMovedError) + const moved = error as TargetMovedError + expect(moved.authorizedPath).toBe(authorized) + expect(moved.resolvedPath).toBe("/outside/the-victim.txt") + expect(moved.message).toContain("/outside/the-victim.txt") + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.link).not.toHaveBeenCalled() + // Nothing was staged either: the check runs before the staging directory is made. + expect(fs.mkdir).not.toHaveBeenCalled() + }) + + it("refuses to publish when an authorized parent directory was replaced after the check", async () => { + // expectedResolvedPath pins the NAME being published, so it cannot notice the + // directory the name lives in being swapped for another one (a link to outside the + // workspace looks exactly like this). The recorded ancestor identities are what + // catch it, and the commit is aborted before anything is moved into place. + const dir = path.resolve("/tmp/test-dir") + const targetPath = path.join(dir, "target.txt") + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.rename).mockClear() + vi.mocked(fs.link).mockClear() + vi.mocked(fs.stat).mockResolvedValue(_dirIdentity(999n)) // was 100n when authorized + + const error = await safeWriteText(targetPath, "new data", { + expectedResolvedPath: targetPath, + expectedAncestorIdentities: [{ dir, dev: 1n, ino: 100n }], + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(AncestorReplacedError) + expect((error as AncestorReplacedError).directory).toBe(dir) + expect((error as AncestorReplacedError).message).toContain("no longer the directory that was authorized") + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.link).not.toHaveBeenCalled() + // The staged copy is cleaned up rather than left beside the target. + expect(vi.mocked(fs.unlink).mock.calls.some((call) => String(call[0]).includes("safeWriteText"))).toBe(true) + }) + + it("refuses to publish when an authorized ancestor name was moved and replaced by a link", async () => { + // Moving a directory preserves (dev, ino), and replacing the old name with a + // symlink to the moved location keeps the identity check matching - stat + // follows the link. The commit takes path strings and would follow it too, + // publishing at the moved location outside the chain the caller walked, so + // the authorized name must still RESOLVE to the authorized location. + const dir = path.resolve("/tmp/test-dir") + const movedDir = path.resolve("/outside/workspace") + const targetPath = path.join(dir, "target.txt") + vi.mocked(fs.realpath).mockImplementation(async (p) => + path.resolve(String(p)) === dir ? movedDir : targetPath, + ) + vi.mocked(fs.rename).mockClear() + vi.mocked(fs.link).mockClear() + vi.mocked(fs.stat).mockResolvedValue(_dirIdentity(100n)) // SAME identity as authorized + + const error = await safeWriteText(targetPath, "new data", { + expectedResolvedPath: targetPath, + expectedAncestorIdentities: [{ dir, dev: 1n, ino: 100n }], + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(AncestorReplacedError) + expect((error as AncestorReplacedError).message).toContain("no longer resolves to the authorized location") + // Nothing was published at either location. + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.link).not.toHaveBeenCalled() + }) + + it("propagates a transient realpath failure instead of reporting a replaced ancestor", async () => { + // EACCES/EIO while re-validating the authorized ancestry is not a containment + // violation: reporting AncestorReplacedError would point the user (and the + // model) at a security problem that is not there. + const dir = path.resolve("/tmp/test-dir") + const targetPath = path.join(dir, "target.txt") + const denied = Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }) + vi.mocked(fs.realpath).mockImplementation(async (p) => { + if (path.resolve(String(p)) === dir) throw denied + return targetPath + }) + vi.mocked(fs.stat).mockResolvedValue(_dirIdentity(100n)) + + const error = await safeWriteText(targetPath, "new data", { + expectedResolvedPath: targetPath, + expectedAncestorIdentities: [{ dir, dev: 1n, ino: 100n }], + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBe(denied) + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.link).not.toHaveBeenCalled() + }) + + it("publishes when the recorded ancestor identities are unchanged", async () => { + // The pin must not turn every guarded write into a false rejection: an unchanged + // directory chain publishes normally. + const dir = path.resolve("/tmp/test-dir") + const targetPath = path.join(dir, "target.txt") + // The unchanged chain resolves where it names: the ancestor realpath check + // sees the authorized directory itself, not a moved location. + vi.mocked(fs.realpath).mockImplementation(async (p) => (path.resolve(String(p)) === dir ? dir : targetPath)) + vi.mocked(fs.stat).mockResolvedValue(_dirIdentity(100n)) + + await safeWriteText(targetPath, "new data", { + expectedResolvedPath: targetPath, + expectedAncestorIdentities: [{ dir, dev: 1n, ino: 100n }], + platform: "linux", + }) + + expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText"), targetPath) + }) + + it("refuses the publish when an authorized ancestor disappears before the commit", async () => { + const dir = path.resolve("/tmp/test-dir") + const targetPath = path.join(dir, "target.txt") + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fs.stat).mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" })) + + const error = await safeWriteText(targetPath, "new data", { + expectedResolvedPath: targetPath, + expectedAncestorIdentities: [{ dir, dev: 1n, ino: 100n }], + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(AncestorReplacedError) + expect((error as AncestorReplacedError).message).toContain("no longer exists") + expect(fs.rename).not.toHaveBeenCalled() + expect(fs.link).not.toHaveBeenCalled() + }) }) // ── Test 12: lock key, staging path, and post-commit durability ───────────── @@ -1337,15 +1526,25 @@ describe("resolveLockKey", () => { const enoent = Object.assign(new Error("ENOENT: no such file or directory"), { code: "ENOENT" }) vi.mocked(fs.realpath).mockRejectedValue(enoent) vi.mocked(fs.lstat).mockResolvedValue(_fileStats(true)) - // Only the link path is read, so a single answer is enough and keeps the mock's - // return type matching fs.promises.readlink. - vi.mocked(fs.readlink).mockResolvedValue("referent.json") + // The walk ends when readlink throws, because a plain file is not a link. + // Answering every call with the same value would let a walk that never + // stopped return the same key, so the mock has to distinguish the link from + // the referent and the test has to check that the walk stopped. + const notALink = Object.assign(new Error("EINVAL: not a link"), { code: "EINVAL" }) + vi.mocked(fs.readlink).mockImplementation(async (target) => { + if (String(target) === "/tmp/linkdir/file.json") return "referent.json" + throw notALink + }) // Mid-commit a peer writer renames the referent away and back, so the key // must still be computable while the link dangles. await expect(resolveLockKey("/tmp/linkdir/file.json")).resolves.toBe( path.resolve(path.join("/tmp/linkdir", "referent.json")), ) + // Two calls means the walk stopped at the referent: the link, then one more + // on the referent that reports it is not a link. A walk that never stopped + // would run the full 8 steps. + expect(fs.readlink).toHaveBeenCalledTimes(2) }) it("terminates on a two-link cycle instead of walking forever", async () => { @@ -1398,7 +1597,7 @@ describe("caller-supplied staging path", () => { // Same inode and device for the supplied staging path and the target: the // failure handler would unlink the only copy of the content, so a failed // write would delete the file it was meant to protect. - const stats = _fileStatsWithIdentity(42n, 7n) + const stats = _fileIdentity(42n, 7n) vi.mocked(fs.lstat).mockResolvedValue(stats) await expect(safeWriteText(targetPath, "data", { tempPath: targetPath, platform: "linux" })).rejects.toThrow( @@ -1424,7 +1623,7 @@ describe("caller-supplied staging path", () => { // A hard-linked staging file shares the target's inode, so the identity comparison is the only thing // between this write and a rename onto the very file the guard protects. An EACCES from the target // lstat must not be mistaken for "there is no target". - const stagingStats = _fileStatsWithIdentity(42n, 7n) + const stagingStats = _fileIdentity(42n, 7n) vi.mocked(fs.lstat).mockImplementation(async (p) => { if (String(p) === targetPath) { throw Object.assign(new Error("EACCES"), { code: "EACCES" }) @@ -1447,7 +1646,7 @@ describe("caller-supplied staging path", () => { }) }) -describe("cleanup when a backed-up write fails before commit", () => { +describe("cleanup before a rollback failure is reported", () => { beforeEach(() => mockDefaults()) it("releases the staged file, its copy and its own staging directory before throwing", async () => { diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 523fa5aaf4..3cb32e1fcd 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -7,12 +7,10 @@ import { getErrorCode } from "../../utils/errorCode" export interface SafeWriteTextOptions { /** - * When true, keep the old-file semantics without ever removing the target: the - * previous content is copied to a hidden backup path and flushed before the - * commit rename, the commit rename atomically replaces the target, and on success - * the backup copy is deleted. A failure before the commit leaves the target - * untouched (there is nothing to roll back) and removes the backup copy. When - * false (default) the atomic rename simply replaces the target. + * When true, preserve the old-file semantics: rename target -> backup first, + * after commit rename delete the backup; on failure roll the backup back to + * the target path. When false (default) the atomic rename simply replaces + * the target -- crash-safe window is zero. */ backup?: boolean @@ -29,16 +27,6 @@ export interface SafeWriteTextOptions { */ execFileRunner?: typeof execFile - /** - * Sink for non-fatal safety notices. The notice that still reaches it is a leftover: the backup - * copy kept beside the target after a Windows DACL restore failed, named with its path. A DACL - * that could not be captured is no longer a notice here - the publish is refused with - * DaclInspectionError before anything is committed - and a saved DACL that could not be put back - * after the commit arrives as DaclRestoreError rather than a warning, so neither reaches this - * sink. Defaults to console.warn. - */ - onWarning?: (message: string) => void - /** * Pre-written temp path to use for the commit phase. When provided, * safeWriteText skips creating its own staging file and uses this path @@ -46,6 +34,104 @@ export interface SafeWriteTextOptions { * already written data to a temp file via a custom stream. */ tempPath?: string + + /** + * Commit only if the target name does NOT exist at commit time. + * rename(2) has no no-replace form - it silently displaces a target that another + * writer created after the caller's absence check - so the commit is done with + * link(2) instead, which fails EEXIST for an existing name (and does not follow a + * symlink placed at that name). A conditional create therefore cannot overwrite a + * file it never saw. + */ + failIfExist?: boolean + + /** + * The publish target the caller already authorized. + * A caller that checks workspace containment and then calls this primitive resolves + * the path twice: once for its own decision and once here. If a link is swapped in + * between the two, the decision was about a different file than the one published. + * Passing the authorized value makes that drift fatal instead of silent. + */ + expectedResolvedPath?: string + + /** + * The directories the caller walked when it authorized this target, with the + * (dev, ino) identity each had at that moment. + * + * expectedResolvedPath pins the NAME this write publishes; it cannot see a parent + * directory being replaced by a link between the caller's containment check and the + * commit. Re-checking the ancestor identities immediately before the commit makes a + * swapped parent fatal too: the publish then aborts instead of writing through the new + * link. Node has no descriptor-relative rename, so a swap that lands after this check + * and before the rename is not eliminable here - it narrows the window to the commit + * itself rather than the whole guard. + * The identity check is paired with a realpath comparison: moving a directory + * preserves (dev, ino), and replacing its old name with a symlink to the moved + * location keeps stat() matching while sending the commit to the new location. + * The name must still resolve to the authorized location, not merely to the + * same inode. + */ + expectedAncestorIdentities?: DirectoryIdentity[] +} + +/** One directory's on-disk identity, read with bigint stats so NTFS 64-bit values survive. */ +export type DirectoryIdentity = { + dir: string + dev: bigint + ino: bigint +} + +/** + * The backup copy could not be created AND the partial copy could not be removed. + * The write failed either way, but the leftover is a copy of the previous content that + * is still on disk: its path travels on the error so the caller can remove it, instead + * of the cleanup silently discarding the only reference to it. + */ +export class OrphanedBackupError extends Error { + readonly orphanedBackupPath: string + readonly originalError: unknown + readonly cleanupError: unknown + constructor(backupPath: string, targetPath: string, cause: unknown, cleanupError: unknown) { + super(_orphanedBackupMessage(targetPath, backupPath, cause, cleanupError), { cause }) + this.name = "OrphanedBackupError" + this.orphanedBackupPath = backupPath + this.originalError = cause + this.cleanupError = cleanupError + } +} + +/** + * The write committed and the content is published, but the pre-write backup could not be + * removed after two attempts (a transient handle - antivirus scanner, indexer - usually + * causes this). Returning success would hide a stale copy of the previous content that + * only a recovery tool can find, so the path travels on this error instead. + */ +export class OrphanedPublishedBackupError extends Error { + readonly publishedPath: string + readonly orphanedBackupPath: string + readonly cleanupError: unknown + + constructor(targetPath: string, backupPath: string, cleanupError: unknown) { + const reason = cleanupError instanceof Error ? cleanupError.message : String(cleanupError) + super( + `safeWriteText: the content was published at ${targetPath}, but the pre-write copy at ${backupPath} ` + + `could not be removed (${reason}). The copy is still on disk and should be removed by the caller or a recovery tool.`, + { cause: cleanupError }, + ) + this.name = "OrphanedPublishedBackupError" + this.publishedPath = targetPath + this.orphanedBackupPath = backupPath + this.cleanupError = cleanupError + } +} + +function _orphanedBackupMessage(targetPath: string, backupPath: string, cause: unknown, cleanupError: unknown): string { + const reason = (error: unknown): string => (error instanceof Error ? error.message : String(error)) + return ( + `safeWriteText: could not create the backup of ${targetPath} (${reason(cause)}), and the ` + + `partial copy at ${backupPath} could not be removed (${reason(cleanupError)}). The copy is ` + + `still on disk and must be deleted.` + ) } /** @@ -73,9 +159,11 @@ export class StagingPathError extends Error { export class PostCommitDurabilityError extends Error { readonly targetPath: string - constructor(targetPath: string, cause: unknown) { + constructor(targetPath: string, cause: unknown, copiedTargetFsync = false) { super( - "The rename committed but the parent directory could not be fsynced -- the content is at the target path reported on this error, and the directory entry may not be durable.", + copiedTargetFsync + ? "The exclusive copy committed but the copied target could not be fsynced -- the content is at the target path reported on this error, and it may not survive a crash on a volume without hard links." + : "The rename committed but the parent directory could not be fsynced -- the content is at the target path reported on this error, and the directory entry may not be durable.", { cause }, ) this.name = "PostCommitDurabilityError" @@ -102,19 +190,68 @@ export class DaclInspectionError extends Error { } /** - * The content is committed but the saved DACL could not be put back on it, so the file at the - * target answers to different access rights than the one it replaced. Reported as an error rather - * than a warning: no caller can observe success for a publish whose DACL was not preserved. The - * failure handler keeps this write's backup copy for it - that copy is the only artifact still - * carrying the access rights of the file the publish replaced. + * A conditional create (failIfExist) found a target at commit time. The write is + * refused without touching it: whatever is at the path was created by someone else + * and stays exactly as it is. */ -export class DaclRestoreError extends Error { - constructor( - readonly targetPath: string, - readonly causeError: unknown, - ) { - super(`safeWriteText: content committed at ${targetPath}, but its saved access rights could not be restored`) - this.name = "DaclRestoreError" +export class TargetExistsError extends Error { + readonly targetPath: string + constructor(targetPath: string) { + super(`A file already exists at ${targetPath} -- the no-replace commit refused it.`) + this.name = "TargetExistsError" + this.targetPath = targetPath + } +} + +/** + * A conditional create (failIfExist) found that the volume hosting the target has + * no atomic no-replace primitive: link(2) reported that hard links do not exist + * here, and publishing by copy would put bytes at the final name that readers can + * observe mid-copy. Nothing is published - the write fails closed so a retry on a + * capable volume (or a caller that accepts non-atomic publication) decides. + */ +export class UnsupportedFilesystemError extends Error { + readonly targetPath: string + constructor(targetPath: string, cause: unknown) { + super( + `Filesystem hosting ${targetPath} has no atomic no-replace commit primitive -- the guarded create refused to publish by copy.`, + { cause }, + ) + this.name = "UnsupportedFilesystemError" + this.targetPath = targetPath + } +} + +/** + * The path resolved to something other than the target the caller authorized. + * Nothing is staged or published: a link swapped in after the caller's containment + * check would otherwise send the write to a file that check never covered. + */ +export class TargetMovedError extends Error { + readonly authorizedPath: string + readonly resolvedPath: string + constructor(authorizedPath: string, resolvedPath: string) { + super( + `The write was authorized for ${authorizedPath}, but that path now resolves to ${resolvedPath} -- nothing was published.`, + ) + this.name = "TargetMovedError" + this.authorizedPath = authorizedPath + this.resolvedPath = resolvedPath + } +} + +/** + * A directory the caller walked on its way to the authorized target is no longer the + * directory it was: it was removed, replaced, or turned into a link to somewhere else. + * Publishing through it would act on a decision that was never made about the file now + * reachable there, so the commit is aborted. + */ +export class AncestorReplacedError extends Error { + readonly directory: string + constructor(directory: string, reason: string) { + super(`A directory on the authorized path (${directory}) ${reason} -- nothing was published.`) + this.name = "AncestorReplacedError" + this.directory = directory } } // -- helpers --------------------------------------------------------------- @@ -162,12 +299,8 @@ async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunne } /** Restore a DACL dump onto *dirPath* on Windows. - * Returns whether icacls succeeded; the caller reports a failure. */ -async function _restoreDaclWindows( - dirPath: string, - dumpPath: string, - execFileRunner?: typeof execFile, -): Promise { + * Best-effort: content is already committed, so failure is non-fatal. */ +async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { const runner = execFileRunner ?? execFile try { await new Promise((resolve, reject) => { @@ -175,9 +308,8 @@ async function _restoreDaclWindows( err ? reject(err) : resolve(), ) }) - return true } catch { - return false + // best-effort; content already committed } } @@ -205,7 +337,7 @@ export async function resolvePublishTarget(absoluteFilePath: string): Promise { } } +/** + * Canonicalize the nearest EXISTING ancestor and re-append the missing components. + * The guard hands back a pin produced exactly this way (guardedWrite#realpathNearest), + * so an absent target has to resolve identically here: a lexical fallback differs from + * that pin whenever an ancestor is a symlink, and the create would then abort with + * TargetMovedError even though nothing moved. + */ +async function canonicalizeNearestAncestor(absoluteFilePath: string): Promise { + const missing: string[] = [] + let cursor = absoluteFilePath + for (;;) { + try { + const realPath = await fs.realpath(cursor) + return missing.length > 0 ? path.join(realPath, ...missing.reverse()) : realPath + } catch (error: unknown) { + const code = getErrorCode(error) + if (code !== "ENOENT" && code !== "ENOTDIR") { + // A real inspection failure (EACCES, EIO) says nothing about the path's + // identity. Returning a lexical key here would silently canonicalize a + // different path than the guard's pin, so fail closed instead. + throw error + } + const parent = path.dirname(cursor) + if (parent === cursor) return absoluteFilePath + missing.push(path.basename(cursor)) + cursor = parent + } + } +} + /** * Lock key for a publish target: the symlink referent when the path is an * existing symlink, the path itself otherwise. Unlike resolvePublishTarget this * tolerates a dangling link, because the lock key has to be computable while a - * peer writer is mid-commit (a publish renames the staged file onto the referent, - * and backup mode keeps a copy beside it). + * peer writer is mid-commit (backup mode renames the referent away and back). * The walk is bounded so a two-link cycle terminates, and every key it returns is * canonicalized through canonicalDirKey. */ @@ -275,14 +436,6 @@ export async function resolveLockKey(absoluteFilePath: string): Promise } } -/** - * Publish text by staging beside the resolved target and committing with a rename. - * - * @internal Production callers of this file use resolvePublishTarget and - * resolveLockKey; the write entry point itself has no production caller while #2350 - * decides which primitive main keeps, so it is tagged internal instead of being - * reported as an unused export. - */ export async function safeWriteText( filePath: string, content: string | Uint8Array, @@ -292,6 +445,13 @@ export async function safeWriteText( // Resolve the symlink referent (see resolvePublishTarget). const targetPath = await resolvePublishTarget(absoluteFilePath) + + // The caller authorized a specific resolved path; publishing at a different one + // would act on a decision that was never made about this file. + if (options?.expectedResolvedPath && path.resolve(options.expectedResolvedPath) !== targetPath) { + throw new TargetMovedError(options.expectedResolvedPath, targetPath) + } + const dirPath = path.dirname(targetPath) // Ensure parent directory exists (mirrors safeWriteJson behaviour). @@ -304,6 +464,11 @@ export async function safeWriteText( // write created so its cleanup removes its own directory, not a shared one. let stagingDir: string | null = null let tempPath: string + // Whether the commit rename has consumed the staging file. Cleanup is allowed to unlink + // the staging path only while this write still owns it: after the rename the name belongs to + // whatever is filed under it next, and a caller-supplied staging name is reused by the next + // write to the same target. + let stagingCommitted = false if (options?.tempPath) { // A caller-supplied staging file is only safe when it is the file this // write is staging, not an arbitrary path. Two properties are checked: @@ -362,38 +527,10 @@ export async function safeWriteText( let backupPath: string | null = null let releaseBackupOnSuccess = false - // Set once the commit rename has published the new content. After that point the - // backup is no longer a safe restore source: rolling it back would overwrite - // content the caller can already observe at the target path. // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null - // Warning delivery must never abort the write: the notice below describes a leftover - // beside a committed file, and a caller whose callback throws (a UI sink, a logger that is - // mid-restart) must not turn that into a different failure than the one the caller is told - // about. Declared above the try so the failure handler can report a retained backup through it. - const warn = (message: string) => { - const report = (label: string, error: unknown) => { - console.warn( - `safeWriteText: onWarning callback ${label}: ${error instanceof Error ? error.message : String(error)}`, - ) - } - try { - const sink = options?.onWarning ?? ((m: string) => console.warn(m)) - const result: unknown = sink(message) - // A sink may be async - TypeScript accepts a value-returning callback where - // a void one is expected. Awaiting it would let warning delivery delay a - // write that has already committed (and hang it if the sink never settles), - // while leaving the promise unhandled turns a rejection into an unhandled - // rejection, which under Node's default mode can end the process after a - // successful write. Attach a handler without awaiting. - if (result instanceof Promise) { - result.catch((error: unknown) => report("rejected", error)) - } - } catch (error: unknown) { - report("failed", error) - } - } + try { // -- Step 1: write content to staging temp file ------------------- if (!options?.tempPath) { @@ -461,7 +598,7 @@ export async function safeWriteText( } } - // -- Step 2 (win32): save DACL BEFORE the backup copy ----------- + // -- Step 2 (win32): save DACL BEFORE backup rename --------------- const platform = options?.platform ?? process.platform if (platform === "win32") { let accessError: unknown = null @@ -499,7 +636,48 @@ export async function safeWriteText( throw new DaclInspectionError(targetPath, "inspect", accessError) } } + try { + // -- Step 2b: re-validate the authorized ancestry before committing -- + // The caller decided containment by walking this directory chain. A parent + // swapped for a link to outside that chain would send the commit somewhere the + // caller never authorized, even though expectedResolvedPath still matches (the + // name is unchanged). Compare each recorded identity now, before anything is + // moved into place. + if (options?.expectedAncestorIdentities) { + for (const expected of options.expectedAncestorIdentities) { + const current = await fs.stat(expected.dir, { bigint: true }).catch((error: unknown) => { + if (getErrorCode(error) === "ENOENT") { + throw new AncestorReplacedError(expected.dir, "no longer exists") + } + throw error + }) + if (current.dev !== expected.dev || current.ino !== expected.ino) { + throw new AncestorReplacedError(expected.dir, "is no longer the directory that was authorized") + } + // A move preserves dev+ino, so the identity check above passes for a + // directory that was relocated and whose old name was replaced by a + // symlink to the moved location - stat follows that link. The commit + // below takes path strings and would follow it too, publishing at the + // moved location outside the chain the caller walked. Require that the + // authorized name still resolves to the very location it named. + // Only a vanished name is a containment violation. A transient EACCES + // or EIO would otherwise be reported as a replaced ancestor, pointing + // the user at a security problem that is not there - mirror the stat + // call above, which maps only ENOENT and rethrows the rest. + const resolvedDir = await fs.realpath(expected.dir).catch((error: unknown) => { + const code = getErrorCode(error) + if (code === "ENOENT" || code === "ENOTDIR") { + return undefined + } + throw error + }) + if (resolvedDir === undefined || path.resolve(resolvedDir) !== path.resolve(expected.dir)) { + throw new AncestorReplacedError(expected.dir, "no longer resolves to the authorized location") + } + } + } + // -- Step 3 (backup:true): durable copy target -> backup ---- if (options?.backup) { try { @@ -521,6 +699,11 @@ export async function safeWriteText( // the chmod afterwards is what clears a copied read-only attribute on Windows // and keeps a backup of a permissive file private. const seedFd = fsSync.openSync(backupPath, "wx", 0o600) + // Single close, no retry: on POSIX close(2) can release the descriptor before it + // reports an error (and leaves its state unspecified after EINTR), so a second + // close could release a descriptor some other operation has meanwhile reused. + // The failure propagates; backupPath is already recorded, so the outer cleanup + // removes the seeded file instead of leaving it beside the target. fsSync.closeSync(seedFd) await fs.copyFile(targetPath, backupPath) await fs.chmod(backupPath, 0o600) @@ -534,9 +717,31 @@ export async function safeWriteText( } } catch (backupError: unknown) { // A partial backup must not outlive this attempt: it is not a complete copy - // of anything, and once the write fails nothing else removes it. - await fs.unlink(backupPath).catch(() => {}) + // of anything, and once the write fails nothing else removes it. The unlink is + // retried once (Windows reports EPERM for a file whose handle has not been + // released yet); if it still fails the path is carried on the thrown error + // instead of being dropped where no caller can act on it. + const orphanPath = backupPath + let backupCleanupError: unknown = null + for (let attempt = 0; attempt < 2; attempt++) { + try { + await fs.unlink(orphanPath) + backupCleanupError = null + break + } catch (cleanupError: unknown) { + if (getErrorCode(cleanupError) === "ENOENT") { + // Already gone: that is exactly the outcome the cleanup wanted, so stop + // rather than unlinking the same path a second time. + backupCleanupError = null + break + } + backupCleanupError = cleanupError + } + } backupPath = null + if (backupCleanupError !== null) { + throw new OrphanedBackupError(orphanPath, targetPath, backupError, backupCleanupError) + } throw backupError } releaseBackupOnSuccess = true @@ -545,9 +750,50 @@ export async function safeWriteText( } } - // -- Step 4: atomic rename temp -> target --------------------- - await fs.rename(tempPath, targetPath) + // -- Step 4: atomic commit temp -> target --------------------- + if (options?.failIfExist) { + // No-replace commit: link(2) fails EEXIST when the name already exists, + // where a rename would silently displace whatever a non-participating + // writer put there after the caller checked. The staged copy is removed + // once the name points at it. + try { + await fs.link(tempPath, targetPath) + } catch (error: unknown) { + const code = getErrorCode(error) + if (code === "EEXIST") { + throw new TargetExistsError(targetPath) + } + // FAT32/exFAT volumes and some SMB/network mounts have no hard links, where + // link(2) fails EPERM/ENOTSUP/ENOSYS. The fallback this replaces published by + // an exclusive copy directly at the final name, but a copy is not atomic: + // readers can observe a partial file, and a crash or an EIO mid-copy leaves + // damaged bytes under the final name with the 'already exists' verdict on + // retry. No atomic no-replace primitive exists on those volumes, so the + // guarded create fails closed - nothing is published and the caller learns + // the volume cannot honor the contract. + if (code !== "EPERM" && code !== "ENOTSUP" && code !== "ENOSYS") { + throw error + } + throw new UnsupportedFilesystemError(targetPath, error) + } + } else { + await fs.rename(tempPath, targetPath) + } + + if (options?.failIfExist) { + // The target name is published at this point; the staged name is only a second + // link to the same inode (or a copy of it). Removal is best-effort: on Windows + // an antivirus handle can make unlink fail with EBUSY/EPERM after the content + // is already visible, and the write must not be reported as failed for content + // the caller can now read back. + await fs.unlink(tempPath).catch(() => undefined) + } + // Marked once the commit has consumed the staging name: on the rename path the + // rename consumed it, on the link path the removal just did. Every step after + // this one is a post-commit step, and none of them may remove the staging path + // or the published content. + stagingCommitted = true // -- Step 4b (POSIX): fsync the parent directory so the directory entry // changed by the commit rename is durable, not just the file content. if (platform !== "win32") { @@ -575,25 +821,33 @@ export async function safeWriteText( // and on every failed save. if (daclDumpPath !== null) { const restoredDir = path.dirname(targetPath) - const restored = await _restoreDaclWindows(restoredDir, daclDumpPath, options?.execFileRunner) - if (!restored) { - // The content is committed, but the published file answers to a different DACL - // from the one that was saved, and nothing here verified an equivalent - // restrictive ACL on the replacement. This reaches the caller as an error rather - // than a warning: no caller can observe success for a publish whose DACL was not - // preserved. The handler at the bottom of this try keeps the backup copy for this - // error instead of rolling the published content back, so the throw reports the - // changed access rights without undoing a write the caller can already observe. - throw new DaclRestoreError(targetPath, null) - } + await _restoreDaclWindows(restoredDir, daclDumpPath, options?.execFileRunner) } // -- Step 6 (backup:true): delete backup on success ----------- if (releaseBackupOnSuccess && backupPath) { - try { - await fs.unlink(backupPath) - } catch { - // non-fatal — orphaned backup is acceptable + const orphanedBackupPath = backupPath + let backupCleanupError: unknown = null + // A transient handle (antivirus scanner, indexer) can block the first unlink + // on Windows; one retry usually clears it. + for (let attempt = 0; attempt < 2; attempt++) { + try { + await fs.unlink(orphanedBackupPath) + backupCleanupError = null + break + } catch (cleanupError: unknown) { + if (getErrorCode(cleanupError) === "ENOENT") { + backupCleanupError = null + break + } + backupCleanupError = cleanupError + } + } + backupPath = null + if (backupCleanupError !== null) { + // The content is published: reporting success here would abandon a stale + // copy of the previous content, so the failure travels as its own error. + throw new OrphanedPublishedBackupError(targetPath, orphanedBackupPath, backupCleanupError) } } } finally { @@ -613,35 +867,23 @@ export async function safeWriteText( await fs.rmdir(stagingDir).catch(() => {}) } } catch (originalError: unknown) { - // Only a pre-commit failure can restore the backup. Once the commit rename - // published, a later failure (for example the post-commit directory fsync) - // must not overwrite the published content with the old file. + // The backup is a copy, never a restore source: whether the failure happened before + // or after the commit rename, the copy is removed below so no stale duplicate of the + // previous content survives next to the target. if (backupPath && releaseBackupOnSuccess) { - if (originalError instanceof DaclRestoreError) { - // The one post-commit failure that keeps its copy. The published file answers to - // the descriptor its staging file was created with, and this copy - made from the - // file the publish replaced, so on Windows it carries that file's security - // attributes - is the only artifact left holding the access rights that could not - // be restored. Deleting it would destroy the only recovery path for exactly the - // fact the error reports, so the copy stays and its path is named to the human: - // the caller already holds the error, and this primitive reports a leftover on - // the warning sink because it has no structured result to carry it on. - warn( - `${originalError.message}; its backup copy is kept at ${backupPath} and still carries the access rights of the file it replaced.`, - ) - } else { - // Nothing to restore: the backup is a copy, so the target still holds whatever - // the commit left there - before the commit that is the pre-write content, and - // after it the published content. Either way the copy has served its purpose - // and must not be left beside the target where no caller can find it. - await fs.unlink(backupPath).catch(() => {}) - } + // Nothing to restore: the backup is a copy, so the target still holds whatever + // the commit left there - before the commit that is the pre-write content, and + // after it the published content. Either way the copy has served its purpose + // and must not be left beside the target where no caller can find it. + await fs.unlink(backupPath).catch(() => {}) backupPath = null } - try { - await fs.unlink(tempPath).catch(() => {}) - } catch { - // cleanup failure is non-fatal + if (!stagingCommitted) { + try { + await fs.unlink(tempPath).catch(() => {}) + } catch { + // cleanup failure is non-fatal + } } // A failed self-staged write must not leave its staging directory behind. diff --git a/src/utils/__tests__/fileLock.spec.ts b/src/utils/__tests__/fileLock.spec.ts new file mode 100644 index 0000000000..851094a5f5 --- /dev/null +++ b/src/utils/__tests__/fileLock.spec.ts @@ -0,0 +1,169 @@ +// npx vitest run utils/__tests__/fileLock.spec.ts + +import * as path from "path" + +import * as fsPromises from "fs/promises" + +import * as lockfile from "proper-lockfile" + +import { acquireFileLock, withFileLock } from "../fileLock" + +vi.mock("fs/promises", () => ({ + realpath: vi.fn(async (target: unknown) => { + const asString = String(target) + // A path that does not exist yet reports ENOENT, as the real fs does. + if (asString.includes("missing")) { + throw Object.assign(new Error("ENOENT"), { code: "ENOENT" }) + } + return asString.replace("aliasDir", "realDir") + }), + // A non-link rejects readlink, exactly like the real fs; the link tests + // override this per path. + readlink: vi.fn(async () => { + throw Object.assign(new Error("EINVAL"), { code: "EINVAL" }) + }), +})) + +vi.mock("proper-lockfile", () => ({ + lock: vi.fn(async () => async () => {}), +})) + +/** + * proper-lockfile derives its lock file from the path it is handed, and this module + * turns off the library's own realpath step because the file may not exist yet. Without + * a canonical lock key, a writer that reaches a file through a symlinked directory and a + * deleter that reaches the same file lexically take DIFFERENT locks and silently lose + * updates against each other - the shape a task file under a symlinked task directory + * has against a task-history delete. + */ +const STORE = path.resolve("/tmp/store") + +describe("fileLock - canonical lock keys", () => { + beforeEach(() => { + vi.mocked(lockfile.lock).mockClear() + }) + + test("locks the referent when the path runs through a symlinked directory", async () => { + const releaseLock = await acquireFileLock(path.join(STORE, "aliasDir", "task.json")) + + expect(lockfile.lock).toHaveBeenCalledWith( + path.join(STORE, "realDir", "task.json"), + expect.objectContaining({ realpath: false }), + ) + + await releaseLock() + }) + + test("locks the referent but hands the operation the caller's own path", async () => { + // The mutex key is canonical; the path the caller works on is left alone. On Windows + // realpath can answer with the 8.3 short form, and rewriting the path a caller + // unlinks or compares would change behavior for every caller for no mutex gain. + const callerPath = path.join(STORE, "aliasDir", "task.json") + const seen: string[] = [] + await withFileLock(callerPath, async (absoluteFilePath) => { + seen.push(absoluteFilePath) + }) + + expect(seen).toEqual([callerPath]) + expect(lockfile.lock).toHaveBeenCalledWith( + path.join(STORE, "realDir", "task.json"), + expect.objectContaining({ realpath: false }), + ) + }) + + test("falls back to the lexical path when realpath fails with EACCES", async () => { + // A permission failure says nothing about the path's identity; failing closed to the + // lexical path keeps the lock key stable instead of inventing a canonical form. + vi.mocked(fsPromises.realpath).mockRejectedValueOnce( + Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" }), + ) + const callerPath = path.join(STORE, "aliasDir", "task.json") + + await withFileLock(callerPath, async (absoluteFilePath) => { + expect(absoluteFilePath).toBe(callerPath) + }) + + expect(lockfile.lock).toHaveBeenCalledWith(callerPath, expect.objectContaining({ realpath: false })) + }) + + test("falls back to the lexical path when realpath fails without an error code", async () => { + vi.mocked(fsPromises.realpath).mockRejectedValueOnce(new Error("unknown failure")) + const callerPath = path.join(STORE, "aliasDir", "task.json") + + await withFileLock(callerPath, async (absoluteFilePath) => { + expect(absoluteFilePath).toBe(callerPath) + }) + + expect(lockfile.lock).toHaveBeenCalledWith(callerPath, expect.objectContaining({ realpath: false })) + }) + + test("canonicalizes the nearest existing ancestor when the file does not exist yet", async () => { + // The file and its parent are absent, so realpath reports ENOENT for them; the deepest + // existing ancestor is resolved and the missing components are re-appended. + const seen: string[] = [] + await withFileLock(path.join(STORE, "aliasDir", "missing", "new.json"), async (absoluteFilePath) => { + seen.push(absoluteFilePath) + }) + + expect(seen).toEqual([path.join(STORE, "aliasDir", "missing", "new.json")]) + expect(lockfile.lock).toHaveBeenCalledWith( + path.join(STORE, "realDir", "missing", "new.json"), + expect.objectContaining({ realpath: false }), + ) + }) +}) + +test("locks the referent of a file symlink whose target is temporarily absent", async () => { + // A backup-mode commit renames the referent away and back. During that window the + // link is dangling, realpath fails, and a naive fallback re-appends the LINK's + // basename onto the canonical parent - a different key from the one safeWriteJson + // holds through resolveLockKey, so the two writers stop excluding each other. + const linkPath = path.join(STORE, "link.json") + const referent = path.join(STORE, "referent.json") + vi.mocked(fsPromises.readlink).mockImplementation(async (p: unknown) => { + if (String(p) === linkPath) return referent + throw Object.assign(new Error("EINVAL"), { code: "EINVAL" }) + }) + + const releaseLock = await acquireFileLock(linkPath) + + expect(lockfile.lock).toHaveBeenCalledWith(referent, expect.objectContaining({ realpath: false })) + + await releaseLock() +}) +test("terminates on a three-link cycle instead of recursing forever", async () => { + // a -> b -> c -> a: the cycle length does not divide the per-frame walk bound, + // so a recursion that restarts its hop budget on every frame never terminates - + // each frame walks 8 hops, lands on a different cycle member, and recurses. + // resolveLockKey hands a cycle member to withFileLock, so an unbounded + // canonicalLockPath hangs every guarded writer on the lock path, not just the + // walker. The readlink mock yields to a timer so a regression fails on the + // test timeout instead of starving the event loop. + // Top-level test: clear the shared doubles so the counts below are this test's own. + vi.mocked(lockfile.lock).mockClear() + vi.mocked(fsPromises.readlink).mockClear() + vi.mocked(fsPromises.realpath).mockClear() + + const a = path.join(STORE, "cyc", "a.json") + const b = path.join(STORE, "cyc", "b.json") + const c = path.join(STORE, "cyc", "c.json") + const cycle: Record = { [a]: b, [b]: c, [c]: a } + vi.mocked(fsPromises.readlink).mockImplementation(async (target: unknown) => { + await new Promise((resolve) => setTimeout(resolve, 0)) + const referent = cycle[String(target)] + if (referent === undefined) throw Object.assign(new Error("EINVAL"), { code: "EINVAL" }) + return referent + }) + vi.mocked(fsPromises.realpath).mockImplementation(async () => { + throw Object.assign(new Error("ENOENT"), { code: "ENOENT" }) + }) + + const releaseLock = await acquireFileLock(a) + + // Terminated with exactly one lock acquisition on a cycle member, and the + // total hop budget held across all frames. + expect(lockfile.lock).toHaveBeenCalledTimes(1) + expect(vi.mocked(fsPromises.readlink).mock.calls.length).toBeLessThanOrEqual(64) + + await releaseLock() +}) diff --git a/src/utils/fileLock.ts b/src/utils/fileLock.ts index 6ca7004566..2ab8179b00 100644 --- a/src/utils/fileLock.ts +++ b/src/utils/fileLock.ts @@ -1,7 +1,7 @@ import * as path from "path" import { tracePersistenceEvent } from "../core/task-persistence/persistenceTrace" -import { resolveLockKey } from "../services/file-safety/safeWriteText" import * as lockfile from "proper-lockfile" +import * as fs from "fs/promises" /** * Shared staleness window for per-file advisory locks. This module owns the @@ -20,6 +20,78 @@ export interface FileLockOptions { immediate?: boolean } +/** + * Canonical lock key for a path. + * + * proper-lockfile derives its lock file from the path it is handed, and this module + * turns off the library's own realpath step because the file may not exist yet. Two + * callers that reach the same file by different routes - one lexical, one through a + * symlinked directory - would then take DIFFERENT locks and silently lose updates + * against each other, which is exactly how a task file written through a symlinked + * task directory ends up unlocked against a task-history delete. + * + * The file itself may be absent (a create), so the nearest EXISTING ancestor is + * canonicalized and the missing components are re-appended. If nothing can be + * canonicalized the lexical absolute path is kept: lock keys stay stable and the + * write's own resolution still decides where content lands. + */ +/** + * Total link hops canonicalLockPath may follow across ALL its frames. The + * per-frame walk bound alone does not terminate: a cycle whose length does not + * divide that bound (a 3-link cycle a -> b -> c -> a against a bound of 8) + * makes every frame land on a different cycle member, so the recursion below + * restarts its budget forever. This runs on the lock path - withFileLock and every + * direct acquireFileLock caller hands it a cycle member - so an unbounded walk hangs + * guardedWrite and safeWriteJson, not just the walker. + */ +const MAX_TOTAL_LINK_HOPS = 64 + +async function canonicalLockPath(filePath: string, remainingLinkHops = MAX_TOTAL_LINK_HOPS): Promise { + const absoluteFilePath = path.resolve(filePath) + + // A file symlink has to produce the same key the writer's lock uses + // (resolveLockKey in safeWriteText). Walking readlink even when the referent is + // temporarily absent - which is exactly the window a backup-mode commit creates - + // keeps a raw withFileLock caller on the link path excluding the peer writing + // through the referent; re-appending the link's basename onto the canonical + // parent would take a different lock and the two operations would stop excluding + // each other. The walk is bounded so a two-link cycle terminates. + let linkCursor = absoluteFilePath + const frameBudget = Math.min(8, remainingLinkHops) + for (let depth = 0; depth < frameBudget; depth++) { + const referent = await fs.readlink(linkCursor).catch(() => undefined) + if (referent === undefined) { + break + } + linkCursor = path.resolve(path.dirname(linkCursor), referent) + } + if (linkCursor !== absoluteFilePath) { + // Recurse with the REMAINING hop budget, not a fresh one: once the total + // is spent the next frame walks zero hops and canonicalizes the ancestors + // of the cycle member it stopped on, so a cycle terminates on a stable key + // instead of recursing forever. + return await canonicalLockPath(linkCursor, Math.max(0, remainingLinkHops - frameBudget)) + } + const missing: string[] = [] + let cursor = absoluteFilePath + for (;;) { + try { + const realPath = await fs.realpath(cursor) + return missing.length > 0 ? path.join(realPath, ...missing.reverse()) : realPath + } catch (error) { + const code = + typeof error === "object" && error !== null && "code" in error + ? (error as { code?: string }).code + : undefined + if (code !== "ENOENT" && code !== "ENOTDIR") return absoluteFilePath + const parent = path.dirname(cursor) + if (parent === cursor) return absoluteFilePath + missing.push(path.basename(cursor)) + cursor = parent + } + } +} + /** * Acquire the advisory lock for one file path using the exact protocol * `safeWriteJson` uses, so operations that hold this lock serialize with @@ -28,7 +100,7 @@ export interface FileLockOptions { * while holding it. */ export async function acquireFileLock(filePath: string, options?: FileLockOptions): Promise<() => Promise> { - const absoluteFilePath = path.resolve(filePath) + const absoluteFilePath = await canonicalLockPath(filePath) if (options?.waitForStaleLock) tracePersistenceEvent("json-lock-wait", { filePath: absoluteFilePath }) try { return await lockfile.lock(absoluteFilePath, { @@ -73,29 +145,32 @@ export async function withFileLock( operation: (absoluteFilePath: string) => Promise, options?: FileLockOptions, ): Promise { - const absoluteFilePath = path.resolve(filePath) - // Lock the canonical key - the same one safeWriteJson computes - so a symlink - // alias and its referent take ONE lock. Locking the raw path here would let a - // deletion through this helper run concurrently with a safeWriteJson - // read-modify-write on the referent (the two would watch different lock - // files), breaking the compound atomicity the deletion contract promises. - // The operation still receives the caller's resolved path: its own file - // operations (e.g. the task-history unlink) must keep the caller's alias - // semantics - unlinking the referent instead of the alias would delete a - // different directory entry. - const lockKey = await resolveLockKey(absoluteFilePath) - const releaseLock = await acquireFileLock(lockKey, options) + // The operation receives the caller's own resolved path. On Windows realpath can answer + // with the 8.3 short form (C:\Users\RUNNER~1\... for a temp dir under + // C:\Users\runneradmin\...), and the operation's own file calls (e.g. the task-history + // unlink) must keep the caller's alias semantics: unlinking the referent instead of the + // alias would delete a different directory entry. + const operationPath = path.resolve(filePath) + // The LOCK key is canonical - the same one safeWriteJson computes - so a caller that + // reaches the file through a symlinked directory and one that reaches it lexically + // contend for ONE lock file. Locking the raw path here would let a deletion through this + // helper run concurrently with a safeWriteJson read-modify-write on the referent, breaking + // the compound atomicity the deletion contract promises. The canonicalization runs inside + // acquireFileLock, so the walk happens once and direct acquireFileLock callers (safeWriteJson + // passes an already-canonical key, jsonFileRecovery and the specs pass raw paths) are all + // covered by the same rule. + const releaseLock = await acquireFileLock(operationPath, options) let result: T try { - result = await operation(absoluteFilePath) + result = await operation(operationPath) } catch (operationError) { // The operation error is the primary failure. Release without // reporting a secondary release error over it. try { await releaseLock() } catch (releaseError) { - console.error(`Failed to release lock for ${absoluteFilePath}:`, releaseError) + console.error(`Failed to release lock for ${operationPath}:`, releaseError) } throw operationError } @@ -105,7 +180,7 @@ export async function withFileLock( } catch (releaseError) { // The operation already succeeded, so a release failure is only // logged, matching how `safeWriteJson` handles release failures. - console.error(`Failed to release lock for ${absoluteFilePath}:`, releaseError) + console.error(`Failed to release lock for ${operationPath}:`, releaseError) } return result } From 5841dd232123a288ef67650f077e84d55757ef62 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:40:02 +0800 Subject: [PATCH 68/72] test(utils): key the injected backup-stat failure on the file, not on the spelling of its path The three "should preserve backups when another backup stat fails" cases pick which fs.stat call throws by comparing the argument with a path string they built themselves, while the recovery stats the canonical form of the same file. Those are one file and not necessarily one spelling: resolvePublishTarget hands back whatever fs.realpath reports for the nearest existing ancestor, and a canonical component can differ in case or 8.3 form from the spelling os.tmpdir() returned. When it does, the comparison is false, the injected error is never thrown, and the classification this block exists to exercise is never reached; with both backups then statable and written in the same millisecond, the mtime sort leaves them in readdir order. Those are the two shapes the hosted windows leg reported - `promise resolved "undefined" instead of rejecting`, and the `[{ stale: true }, {}]` merge argument. In production a stat of one spelling and a stat of the other are the same inode and cannot disagree, so the double now matches the leftover's dev+ino. The claim under test is unchanged: an unreadable leftover may not be certified stale, only ENOENT may be skipped, and either the other backup is restored or both are preserved. The implementation is untouched - staging and locking still follow the resolved referent (the realpath-split cases in this file), and an absent target behind a link is still published at the canonical name (safeWriteText.spec.ts:1287). Controls, pinned node v22.23.4 on vitest.misc.config.ts, scratch specs written then deleted: keying on spelling with realpath forced to a flipped drive letter reproduces both hosted shapes against the unmodified implementation - EACCES and EIO resolve instead of rejecting, and an mtime tie restores the directory-order winner rather than the newer backup. Keying on dev+ino gives the invariant behaviour identically with and without the flip, on all four rows including the tie variant. The misc shard on this tree is 2125 passed | 17 skipped (2142) over 120 passed | 1 skipped files - the same denominator the windows leg reported with 3 failures. --- src/utils/__tests__/safeWriteJson.test.ts | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index 50feb7d800..d26aafb81e 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -660,8 +660,21 @@ describe("safeWriteJson", () => { await fs.writeFile(unreadableBackup, JSON.stringify({ stale: true })) await fs.writeFile(readableBackup, JSON.stringify({ committed: true })) const actual = await vi.importActual("fs/promises") + // The injection is keyed on the leftover's inode, not on the spelling of its path: + // the writer stats the canonical form of the same file, which realpath can spell + // differently from os.tmpdir() on the machine running the test. Production cannot tell + // the two spellings apart - they are one file - so the double matches the inode. + const injectedInode = await actual.stat(unreadableBackup) + const isInjectedInode = async (candidate: Parameters[0]) => { + try { + const inode = await actual.stat(candidate) + return inode.dev === injectedInode.dev && inode.ino === injectedInode.ino + } catch { + return false // a candidate that cannot be stat-ed is not the injected leftover + } + } vi.mocked(fs.stat).mockImplementation(async (backupPath) => { - if (backupPath === unreadableBackup) { + if (await isInjectedInode(backupPath)) { throw Object.assign(new Error("Backup stat failed"), { code }) } return actual.stat(backupPath) From b328ded180eed0a1e947e60b2301b113650b8a7a Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 13:49:42 +0800 Subject: [PATCH 69/72] test(u5b): scope the injected stat to the row that installs it vi.restoreAllMocks() in afterEach restores spies; it does not clear an implementation set on the fs/promises factory mocks, so the double installed by the leftover-stat rows stayed in place for the rest of the file. Keyed on the literal backup path that was inert, because beforeEach mkdtemps a fresh directory per test and the captured path cannot recur. Keyed on dev+ino it fires again as soon as the operating system hands a later test's unrelated file the inode an earlier row captured - measured on the hosted ubuntu leg, where six unrelated rows in this file failed and the three leftover rows passed. Five of the six carry this injection's fingerprint; the 0o600 row is skipIf(win32) and so has no local oracle. Restore the previous implementation in a finally, and name in the test what the matcher is keyed on and for how long it lives. --- src/utils/__tests__/safeWriteJson.test.ts | 25 +++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/src/utils/__tests__/safeWriteJson.test.ts b/src/utils/__tests__/safeWriteJson.test.ts index d26aafb81e..2995f26710 100644 --- a/src/utils/__tests__/safeWriteJson.test.ts +++ b/src/utils/__tests__/safeWriteJson.test.ts @@ -673,6 +673,11 @@ describe("safeWriteJson", () => { return false // a candidate that cannot be stat-ed is not the injected leftover } } + // The double is installed for this test only. vi.restoreAllMocks() in afterEach does not + // clear implementations set on the fs/promises factory mocks, and the operating system + // recycles inodes, so a matcher left installed rejects a later test's unrelated file the + // moment that file is handed the inode this row captured. + const previousStat = vi.mocked(fs.stat).getMockImplementation() vi.mocked(fs.stat).mockImplementation(async (backupPath) => { if (await isInjectedInode(backupPath)) { throw Object.assign(new Error("Backup stat failed"), { code }) @@ -681,14 +686,18 @@ describe("safeWriteJson", () => { }) const merge = vi.fn((existing: unknown) => existing) - if (code === "ENOENT") { - await safeWriteJson(currentTestFilePath, {}, { merge }) - expect(merge).toHaveBeenCalledWith({ committed: true }, {}) - } else { - await expect(safeWriteJson(currentTestFilePath, {}, { merge })).rejects.toMatchObject({ code }) - expect(merge).not.toHaveBeenCalled() - expect(await readFileContent(unreadableBackup)).toEqual({ stale: true }) - expect(await readFileContent(readableBackup)).toEqual({ committed: true }) + try { + if (code === "ENOENT") { + await safeWriteJson(currentTestFilePath, {}, { merge }) + expect(merge).toHaveBeenCalledWith({ committed: true }, {}) + } else { + await expect(safeWriteJson(currentTestFilePath, {}, { merge })).rejects.toMatchObject({ code }) + expect(merge).not.toHaveBeenCalled() + expect(await readFileContent(unreadableBackup)).toEqual({ stale: true }) + expect(await readFileContent(readableBackup)).toEqual({ committed: true }) + } + } finally { + vi.mocked(fs.stat).mockImplementation(previousStat ?? actual.stat) } }, ) From 8a9d5b78944b5cc73ec6b1330310e872650b7471 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:12:08 +0800 Subject: [PATCH 70/72] fix(u5b): refuse an exact backup mtime tie instead of trusting readdir order Recovery picks the newest committed backup with `sort((a, b) => b.mtimeMs - a.mtimeMs)` and renames the head of that list, then unlinks the rest. mtime is the only recency signal there, so when two backups share an exact mtime the sort decides nothing and the winner is whatever order readdir happened to return -- and the loser of that coin flip is deleted. That is the same evidence situation as a backup whose stat throws, which recovery already refuses rather than treating as absent, so a tie now resolves as uncheckable: reject, restore nothing, delete nothing, leave both copies for a human to read. The tie is asserted with utimes rather than raced against the clock, and a differing-mtime row rides beside it so the pair is not just a test that two backups means reject. --- src/utils/__tests__/jsonFileRecovery.test.ts | 53 +++++++++++++++++++- src/utils/jsonFileRecovery.ts | 43 +++++++++++++++- 2 files changed, 93 insertions(+), 3 deletions(-) diff --git a/src/utils/__tests__/jsonFileRecovery.test.ts b/src/utils/__tests__/jsonFileRecovery.test.ts index 1bd90d8935..33500cbf09 100644 --- a/src/utils/__tests__/jsonFileRecovery.test.ts +++ b/src/utils/__tests__/jsonFileRecovery.test.ts @@ -4,7 +4,7 @@ import * as path from "path" import { acquireFileLock } from "../fileLock" import { setPersistenceTraceSink } from "../../core/task-persistence/persistenceTrace" -import { deleteJsonFile, recoverMissingJsonFile } from "../jsonFileRecovery" +import { recoverInterruptedReplacement, deleteJsonFile, recoverMissingJsonFile } from "../jsonFileRecovery" import { readFileWithMissingRetry } from "../../core/task-persistence/readFileWithMissingRetry" vi.mock("fs/promises", async () => { @@ -57,6 +57,57 @@ describe("reader recovery", () => { await expect(fs.readFile(backup)).rejects.toMatchObject({ code: "ENOENT" }) }) + // The recency choice is `sort((a, b) => b.mtimeMs - a.mtimeMs)` followed by renaming + // the head of that list. mtime is the only signal recovery has, so an exact tie says + // nothing about which backup holds the committed content - the winner would be readdir + // order, and the loser is unlinked. The tie is set with utimes rather than raced + // against the clock, so the row does not depend on how fast two writes land; the + // second row is the control that keeps this from being a test which merely asserts + // "two backups means reject". + it("refuses an exact mtime tie between two backups instead of picking by directory order", async () => { + const otherBackup = path.join(dir, ".history_item.json.bak_2_other.tmp") + await fs.writeFile(otherBackup, JSON.stringify({ other: true })) + const shared = new Date(1_700_000_000_000) + await fs.utimes(backup, shared, shared) + await fs.utimes(otherBackup, shared, shared) + + const error = await recoverInterruptedReplacement(target).then( + () => undefined, + (reason: unknown) => reason, + ) + expect(error).toMatchObject({ + name: "AmbiguousBackupRecencyError", + code: "AMBIGUOUS_BACKUP_RECENCY", + mtimeMs: 1_700_000_000_000, + }) + // The diagnostic has to name the magnitude it refused to guess about. + expect(String((error as Error).message)).toContain("share mtime 1700000000000") + + // Fail closed: nothing restored, nothing deleted, so both copies survive for a + // human to read. + await expect(fs.access(target)).rejects.toMatchObject({ code: "ENOENT" }) + expect(JSON.parse(await fs.readFile(backup, "utf8"))).toEqual({ committed: true }) + expect(JSON.parse(await fs.readFile(otherBackup, "utf8"))).toEqual({ other: true }) + }) + + it("restores the newer backup when two backups have different mtimes", async () => { + const otherBackup = path.join(dir, ".history_item.json.bak_2_other.tmp") + await fs.writeFile(otherBackup, JSON.stringify({ other: true })) + const older = new Date(1_700_000_000_000) + const newer = new Date(1_700_000_000_001) + await fs.utimes(otherBackup, older, older) + await fs.utimes(backup, newer, newer) + + const recovery = await recoverInterruptedReplacement(target) + + expect(recovery.foundLeftovers).toBe(true) + expect(recovery.restoredFrom).toBe(backup) + expect(JSON.parse(await fs.readFile(target, "utf8"))).toEqual({ committed: true }) + // The loser of a decided race is still garbage-collected, which is the contract the + // tie row must not break. + await expect(fs.access(otherBackup)).rejects.toMatchObject({ code: "ENOENT" }) + }) + it("traces reader restoration and lock waiting", async () => { const sink = vi.fn() setPersistenceTraceSink(sink) diff --git a/src/utils/jsonFileRecovery.ts b/src/utils/jsonFileRecovery.ts index 2350f30685..1dbead2a1a 100644 --- a/src/utils/jsonFileRecovery.ts +++ b/src/utils/jsonFileRecovery.ts @@ -99,6 +99,32 @@ export async function deleteJsonFile(filePath: string): Promise { }) } +/** + * Two leftover backups whose mtimes are exactly equal carry no evidence about which + * one is the newer committed state - mtime is the only recency signal recovery has - + * so choosing between them would be the order readdir happened to list them in, and + * the loser of that order is garbage-collected below. Recovery refuses instead, the + * same fail-closed decision it already makes for a backup it cannot stat: nothing is + * restored and nothing is deleted, so both copies stay on disk for a human to read. + */ +class AmbiguousBackupRecencyError extends Error { + readonly code = "AMBIGUOUS_BACKUP_RECENCY" + readonly targetPath: string + readonly mtimeMs: number + readonly firstBackupPath: string + readonly secondBackupPath: string + constructor(targetPath: string, mtimeMs: number, firstBackupPath: string, secondBackupPath: string) { + super( + `Cannot tell which backup of ${targetPath} is the newest committed state: ${firstBackupPath} and ${secondBackupPath} share mtime ${mtimeMs}. Nothing was restored or deleted.`, + ) + this.name = "AmbiguousBackupRecencyError" + this.targetPath = targetPath + this.mtimeMs = mtimeMs + this.firstBackupPath = firstBackupPath + this.secondBackupPath = secondBackupPath + } +} + /** * Heals the canonical path after an interrupted previous write. Must run * under the advisory lock and before any data is read or written: temp and @@ -112,8 +138,9 @@ export async function deleteJsonFile(filePath: string): Promise { * renamed to its backup but before the replacement landed. A process exit * at that point leaves the canonical path absent, which readers see as a * permanent ENOENT that no retry can repair, so the newest backup is - * restored first. Leftover replacement and backup files are garbage - * collected afterwards. + * restored first, chosen by mtime. Two backups that share an exact mtime are + * refused rather than split by directory order; see AmbiguousBackupRecencyError. + * Leftover replacement and backup files are garbage collected afterwards. * * @returns Whether leftover files were found, and the backup path that was * restored, if any. @@ -181,6 +208,18 @@ export async function recoverInterruptedReplacement( ).filter((entry): entry is { backupPath: string; mtimeMs: number } => entry !== null) if (backupStats.length > 0) { backupStats.sort((a, b) => b.mtimeMs - a.mtimeMs) + if (backupStats.length > 1 && backupStats[1].mtimeMs === backupStats[0].mtimeMs) { + // mtime is the only recency signal here, and an exact tie carries none: the + // winner would be the order readdir happened to list the two in, and the + // loser is unlinked below. Refuse, as recovery already refuses a backup it + // cannot stat. + throw new AmbiguousBackupRecencyError( + absoluteFilePath, + backupStats[0].mtimeMs, + backupStats[0].backupPath, + backupStats[1].backupPath, + ) + } const newestBackupPath = backupStats[0].backupPath try { await fs.rename(newestBackupPath, absoluteFilePath) From 87d4aff039fd51b1d1e5406463a263a33de3cf45 Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:06:33 +0800 Subject: [PATCH 71/72] fix #2357: make the failure path report what it could not clean up - a writeSync that reports zero progress now throws instead of spinning the short-write loop on an offset that never moves - a failed icacls save now travels to DaclInspectionError as causeError instead of being replaced by null - the failure-path backup copy is removed with a retry and, if it still cannot be removed, reported as OrphanedBackupAfterFailedWriteError - after the staged file and staging directory were cleaned - carrying the write's own failure as originalError and cause - the backup cleanup only unlinks a name this write's own seed open created, so an EEXIST collision on another writer's backup no longer deletes it Tests: safeWriteText spec 77 passed; core shard 4282 passed; misc shard green on rerun; tsc --noEmit, eslint (no suppression change), prettier, knip and knip --production and knip-policy all clean. --- .../__tests__/safeWriteText.spec.ts | 103 ++++++++++++ src/services/file-safety/safeWriteText.ts | 153 +++++++++++++++--- 2 files changed, 234 insertions(+), 22 deletions(-) diff --git a/src/services/file-safety/__tests__/safeWriteText.spec.ts b/src/services/file-safety/__tests__/safeWriteText.spec.ts index 825abb71e5..561485da91 100644 --- a/src/services/file-safety/__tests__/safeWriteText.spec.ts +++ b/src/services/file-safety/__tests__/safeWriteText.spec.ts @@ -15,6 +15,7 @@ import { UnsupportedFilesystemError, TargetMovedError, AncestorReplacedError, + OrphanedBackupAfterFailedWriteError, OrphanedBackupError, OrphanedPublishedBackupError, } from "../safeWriteText" @@ -569,6 +570,77 @@ describe("safeWriteText", () => { expect(fs.rename).not.toHaveBeenCalled() }) + it("refuses a backup name another writer already owns instead of unlinking it", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + // The exclusive seed open hits a backup name this write never created. + vi.mocked(fsSync.openSync).mockImplementation((...args: unknown[]) => { + if (typeof args[0] === "string" && args[0].includes("safeWriteText.bak_")) { + throw Object.assign(new Error("EEXIST"), { code: "EEXIST" }) + } + return 1 + }) + + const error = await safeWriteText(targetPath, "new data", { + backup: true, + platform: "linux", + }).catch((caught: unknown) => caught) + + expect((error as Error).message).toContain("EEXIST") + // The name is not this write's orphan: unlinking it on the way out would + // delete another writer's backup to clean up a file this write never made. + const backupUnlinks = vi.mocked(fs.unlink).mock.calls.filter(function (call: unknown[]) { + return typeof call[0] === "string" && call[0].includes("safeWriteText.bak_") + }) + expect(backupUnlinks).toHaveLength(0) + expect(fs.copyFile).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + }) + + it("reports a backup copy it cannot remove after a failed write instead of dropping it", async () => { + const targetPath = "/tmp/test-dir/target.txt" + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // The copy is seeded and flushed fine; only its removal on the failure + // path fails, twice, with the same handle-not-released error Windows + // reports for a fresh file. + vi.mocked(fs.unlink).mockImplementation(async (p: unknown) => { + if (String(p).includes("safeWriteText.bak_")) { + throw Object.assign(new Error("EPERM"), { code: "EPERM" }) + } + }) + // The commit is what fails here, so nothing was published. + vi.mocked(fs.rename).mockRejectedValue(Object.assign(new Error("EIO"), { code: "EIO" })) + + const error = await safeWriteText(targetPath, "new data", { + backup: true, + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(OrphanedBackupAfterFailedWriteError) + const orphan = error as OrphanedBackupAfterFailedWriteError + expect(orphan.orphanedBackupPath).toContain("safeWriteText.bak_") + expect(orphan.message).toContain("safeWriteText.bak_") + expect(orphan.message).toContain("EPERM") + // The write's own failure stays the primary fact: it travels as + // originalError and as the cause, and cleanupError says why the copy + // is still on disk. + expect((orphan.originalError as Error).message).toBe("EIO") + expect((orphan.cleanupError as Error).message).toBe("EPERM") + expect(orphan.cause).toBe(orphan.originalError) + // The commit never succeeded, so the target still holds the previous + // content and the copy duplicates it rather than going stale. + expect(orphan.contentPublished).toBe(false) + const backupUnlinks = vi.mocked(fs.unlink).mock.calls.filter(function (call: unknown[]) { + return typeof call[0] === "string" && call[0].includes("safeWriteText.bak_") + }) + expect(backupUnlinks).toHaveLength(2) + // Reporting the leftover must not skip cleaning the write's own staged + // file and staging directory: both ran before the leftover was reported. + expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_")) + expect(fs.rmdir).toHaveBeenCalled() + }) + it("a backup copy that fails part-way is removed, not left as a usable-looking backup", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) @@ -667,6 +739,13 @@ describe("safeWriteText", () => { message: expect.stringContaining("its DACL could not be saved"), }) + // The refusal names the phase and the path but not what icacls did. The + // platform failure travels on the error so a caller can tell a refused + // icacls from an icacls that could not be started at all. + const cause = (refusal as DaclInspectionError).causeError + expect(cause).toBeInstanceOf(Error) + expect((cause as Error).message).toBe("icacls error") + // Contract change (Security Boundaries row): a target whose DACL could not be // saved is no longer replaced by a file that inherits different rights. expect(fs.rename).not.toHaveBeenCalled() @@ -1091,6 +1170,30 @@ describe("safeWriteText", () => { expect(fs.rename).toHaveBeenCalledWith(expect.stringContaining("safeWriteText_"), targetPath) }) + it("stops instead of looping when a write makes no progress at all", async () => { + const targetPath = "/tmp/test-dir/target.txt" + const content = "abcdefg" // 7 bytes + vi.mocked(fs.realpath).mockResolvedValue(targetPath) + vi.mocked(fsSync.openSync).mockReturnValue(1) + // Every write reports zero bytes. The short-write loop is bounded by + // offset < buffer.length only, so a zero return would spin on the same + // offset forever, holding the fd and the event loop. + vi.mocked(fsSync.writeSync).mockReturnValue(0) + + const error = await safeWriteText(targetPath, content, { + platform: "linux", + }).catch((caught: unknown) => caught) + + expect(error).toBeInstanceOf(Error) + expect((error as Error).message).toContain("stalled after 0 of 7 bytes") + // The stalled staging file never reached durability or the commit. + expect(fsSync.fsyncSync).not.toHaveBeenCalled() + expect(fs.rename).not.toHaveBeenCalled() + // The finally around the write closes the descriptor, so a stalled write + // strands neither the fd nor the process. + expect(fsSync.closeSync).toHaveBeenCalledWith(1) + }) + it("fsyncs the parent directory after the commit rename on POSIX", async () => { const targetPath = "/tmp/test-dir/target.txt" vi.mocked(fs.realpath).mockResolvedValue(targetPath) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 3cb32e1fcd..55efd313fd 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -125,6 +125,46 @@ export class OrphanedPublishedBackupError extends Error { } } +/** + * A write that is already failing left its complete backup copy on disk because removing it + * failed twice. Reported separately from OrphanedPublishedBackupError, which says the write + * SUCCEEDED and only the copy is leftover: here the write's own failure is the primary fact + * and is kept as originalError (and as this error's cause), cleanupError says why the copy is + * still there, and contentPublished says which of the two meanings the leftover has - a stale + * copy beside published content, or a duplicate of the content the target still holds. + */ +export class OrphanedBackupAfterFailedWriteError extends Error { + readonly targetPath: string + readonly orphanedBackupPath: string + readonly originalError: unknown + readonly cleanupError: unknown + readonly contentPublished: boolean + + constructor( + targetPath: string, + backupPath: string, + cause: unknown, + cleanupError: unknown, + contentPublished: boolean, + ) { + const reason = (error: unknown): string => (error instanceof Error ? error.message : String(error)) + super( + `safeWriteText: the write to ${targetPath} failed (${reason(cause)}), and the backup copy at ${backupPath} ` + + `could not be removed (${reason(cleanupError)}). The copy of the previous content is still on disk; ` + + (contentPublished + ? `the target holds the new content, so the copy is stale and must be removed.` + : `the target still holds the previous content, so the copy duplicates it and must be removed.`), + { cause }, + ) + this.name = "OrphanedBackupAfterFailedWriteError" + this.targetPath = targetPath + this.orphanedBackupPath = backupPath + this.originalError = cause + this.cleanupError = cleanupError + this.contentPublished = contentPublished + } +} + function _orphanedBackupMessage(targetPath: string, backupPath: string, cause: unknown, cleanupError: unknown): string { const reason = (error: unknown): string => (error instanceof Error ? error.message : String(error)) return ( @@ -282,9 +322,11 @@ function _stagingDir(dir: string): string { } /** Save the DACL of *srcPath* to a dump file on Windows. - * Returns true when the dump was written successfully; false otherwise. - * Never throws — callers treat failure as "skip DACL handling". */ -async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { + * Returns null when the dump was written, and the runner's error when it was not: the caller + * refuses the publish either way and has to be able to say which failure it is refusing - + * "icacls ran and failed" and "icacls could not be started at all" are different facts to act + * on. Never throws. */ +async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { const runner = execFileRunner ?? execFile try { await new Promise((resolve, reject) => { @@ -292,12 +334,11 @@ async function _saveDaclWindows(srcPath: string, dumpPath: string, execFileRunne err ? reject(err) : resolve(), ) }) - return true - } catch { - return false + return null + } catch (error: unknown) { + return error } } - /** Restore a DACL dump onto *dirPath* on Windows. * Best-effort: content is already committed, so failure is non-fatal. */ async function _restoreDaclWindows(dirPath: string, dumpPath: string, execFileRunner?: typeof execFile): Promise { @@ -527,6 +568,9 @@ export async function safeWriteText( let backupPath: string | null = null let releaseBackupOnSuccess = false + // True only when this write's own seed open created the backup file. A name that already + // existed is not this write's file, and the failure path below must not unlink it. + let backupSeeded = false // Non-null only when the win32 step-2 block saved a successful DACL dump: // it gates the step-5 restore and is tracked for the cleanup unlinks. let daclDumpPath: string | null = null @@ -565,9 +609,21 @@ export async function safeWriteText( // Loop until every byte is written: writeSync can report a short // (partial) write, and publishing a truncated staging file would // commit corrupt content. + // A zero return is not a short write - it means the descriptor made no progress - + // and it is handled below rather than looped on. let offset = 0 while (offset < buffer.length) { - offset += fsSync.writeSync(fd, buffer, offset, buffer.length - offset) + const written = fsSync.writeSync(fd, buffer, offset, buffer.length - offset) + if (written === 0) { + // Not a short write: the descriptor made no progress at all, so looping again + // would hold the fd and the event loop forever without ever reaching fsyncSync + // or the commit. The finally below closes the fd and the outer cleanup removes + // the staged file, so a stalled write strands neither. + throw new Error( + `safeWriteText: write of ${tempPath} stalled after ${offset} of ${buffer.length} bytes`, + ) + } + offset += written } fsSync.fsyncSync(fd) } finally { @@ -609,8 +665,8 @@ export async function safeWriteText( } if (accessError === null) { const dumpPath = _tempName(dirPath, "safeWriteText.acl") - const saved = await _saveDaclWindows(targetPath, dumpPath, options?.execFileRunner) - if (saved) { + const saveFailure = await _saveDaclWindows(targetPath, dumpPath, options?.execFileRunner) + if (saveFailure === null) { // Only a successfully saved dump may be restored onto the // committed file (step 5). daclDumpPath = dumpPath @@ -627,7 +683,10 @@ export async function safeWriteText( // still holds its content, and this throw lands in the handler at the bottom of // this try - the one place that removes the staged file and this write's own // staging directory - so a refused publish strands neither. - throw new DaclInspectionError(targetPath, "save", null) + // The runner's error travels with the refusal: the phase already says which check + // refused, and without the error a caller cannot tell a failed icacls from an + // icacls that could not be started at all. + throw new DaclInspectionError(targetPath, "save", saveFailure) } } else if (getErrorCode(accessError) !== "ENOENT") { // Not "absent": the target is there but its access rights could not be read @@ -699,6 +758,9 @@ export async function safeWriteText( // the chmod afterwards is what clears a copied read-only attribute on Windows // and keeps a backup of a permissive file private. const seedFd = fsSync.openSync(backupPath, "wx", 0o600) + // The name is ours from the moment the exclusive open succeeds, so the failure + // path may remove it even when the close below reports an error. + backupSeeded = true // Single close, no retry: on POSIX close(2) can release the descriptor before it // reports an error (and leaves its state unspecified after EINTR), so a second // close could release a descriptor some other operation has meanwhile reused. @@ -723,22 +785,29 @@ export async function safeWriteText( // instead of being dropped where no caller can act on it. const orphanPath = backupPath let backupCleanupError: unknown = null - for (let attempt = 0; attempt < 2; attempt++) { - try { - await fs.unlink(orphanPath) - backupCleanupError = null - break - } catch (cleanupError: unknown) { - if (getErrorCode(cleanupError) === "ENOENT") { - // Already gone: that is exactly the outcome the cleanup wanted, so stop - // rather than unlinking the same path a second time. + if (backupSeeded) { + for (let attempt = 0; attempt < 2; attempt++) { + try { + await fs.unlink(orphanPath) backupCleanupError = null break + } catch (cleanupError: unknown) { + if (getErrorCode(cleanupError) === "ENOENT") { + // Already gone: that is exactly the outcome the cleanup wanted, so stop + // rather than unlinking the same path a second time. + backupCleanupError = null + break + } + backupCleanupError = cleanupError } - backupCleanupError = cleanupError } } backupPath = null + // When the seed open never succeeded - an EEXIST on a name another writer owns, or a + // failure before anything existed at it - there is nothing here to remove: an entry + // this write did not create is not this write's orphan, and unlinking it would take + // away somebody else's backup on the way out. backupCleanupError stays null, so the + // original failure below is what the caller sees. if (backupCleanupError !== null) { throw new OrphanedBackupError(orphanPath, targetPath, backupError, backupCleanupError) } @@ -870,12 +939,46 @@ export async function safeWriteText( // The backup is a copy, never a restore source: whether the failure happened before // or after the commit rename, the copy is removed below so no stale duplicate of the // previous content survives next to the target. + // Set when a backup copy this write made could not be removed; reported at the end of + // this catch so the staging cleanup above is not skipped for a cleanup failure. + let pendingBackupError: OrphanedBackupAfterFailedWriteError | null = null if (backupPath && releaseBackupOnSuccess) { // Nothing to restore: the backup is a copy, so the target still holds whatever // the commit left there - before the commit that is the pre-write content, and // after it the published content. Either way the copy has served its purpose // and must not be left beside the target where no caller can find it. - await fs.unlink(backupPath).catch(() => {}) + let removalError: unknown = null + for (let attempt = 0; attempt < 2; attempt++) { + try { + await fs.unlink(backupPath) + removalError = null + break + } catch (error: unknown) { + if (getErrorCode(error) === "ENOENT") { + // Already gone: that is exactly the outcome this cleanup wanted. + removalError = null + break + } + // Retry once: Windows reports EPERM for a file whose handle has not been + // released yet, which is the same failure the success-path cleanup retries. + removalError = error + } + } + if (removalError !== null) { + // The copy of the previous content is still on disk and only this function knew + // where. Reporting it is what keeps the original error the primary fact while + // leaving the leftover findable; swallowing the removal left both unreported. + // Constructed, not thrown yet: the staging cleanup below has to run first, so + // the leftover is reported once this catch has finished what it can do about the + // write's own mess. + pendingBackupError = new OrphanedBackupAfterFailedWriteError( + targetPath, + backupPath, + originalError, + removalError, + stagingCommitted, + ) + } backupPath = null } if (!stagingCommitted) { @@ -897,6 +1000,12 @@ export async function safeWriteText( await fs.unlink(daclDumpPath).catch(() => {}) } + if (pendingBackupError) { + // The write's own failure is still the primary fact - it travels on this error as + // originalError and as its cause - and the copy of the previous content now has a + // path a caller can act on instead of being unreported. + throw pendingBackupError + } throw originalError } } From 25a1ad65fde6ac444b3a5ec9f2c12bd44e52309a Mon Sep 17 00:00:00 2001 From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com> Date: Sun, 8 Nov 2026 15:07:20 +0800 Subject: [PATCH 72/72] docs #2357: say what the backup option and a DACL refusal actually promise - the backup option docstring still described the old rename-away-and-rollback flow; it now describes the copy flow, including that the copy is never a rollback source and what happens to it when removal fails - DaclInspectionError's docstring now says causeError carries the platform failure behind the refusal rather than null Comment text only - no executable line changed. parse, prettier, eslint and the safeWriteText spec (77 passed) re-run green on this head. --- src/services/file-safety/safeWriteText.ts | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/services/file-safety/safeWriteText.ts b/src/services/file-safety/safeWriteText.ts index 55efd313fd..d06b5f7035 100644 --- a/src/services/file-safety/safeWriteText.ts +++ b/src/services/file-safety/safeWriteText.ts @@ -7,10 +7,16 @@ import { getErrorCode } from "../../utils/errorCode" export interface SafeWriteTextOptions { /** - * When true, preserve the old-file semantics: rename target -> backup first, - * after commit rename delete the backup; on failure roll the backup back to - * the target path. When false (default) the atomic rename simply replaces - * the target -- crash-safe window is zero. + * + * When true, keep a durable copy of the previous content at a sibling + * safeWriteText.bak_* file for the duration of the write: the target is copied + * before the commit rename and the copy is removed after it. The copy is never + * a rollback source - nothing is restored on failure, because the copy never + * displaced the target: before the commit the target still holds its previous + * content, and after it the target holds the new content and this call removes + * the copy, reporting it as OrphanedBackupAfterFailedWriteError if the removal + * itself fails. When false (default) the atomic rename simply replaces the + * target -- crash-safe window is zero. */ backup?: boolean @@ -216,6 +222,10 @@ export class PostCommitDurabilityError extends Error { * replace it with a file that inherits different rights. On Windows the publish is refused before * anything is committed: a save that silently widened who can read the file is not a save the * caller can trust, and nothing has been published yet, so the target still holds its content. + * causeError carries the platform failure behind the refusal - the access check + * error or the icacls error - so a caller can tell a command that ran and refused + * from one that could not be started at all; it is the runner's own error, not a + * summary of it. */ export class DaclInspectionError extends Error { constructor(