@dench.com/cli 2.4.0 → 2.4.1

package/fs-daemon.ts

@@ -15,8 +15,10 @@
  *     `lastSyncedHash`, we download from Convex Storage to /workspace.
  *   • Per-path 300ms trailing debounce on uploads (batches tight write
  *     loops like editor saves).
- *   • Optimistic conflict via `expectedPreviousHash`. On 409, we fetch
- *     latest, write to `<path>.conflicted-<ts>`, surface in UI.
+ *   • Optimistic conflict via `expectedPreviousHash`. On 409, we stash the
+ *     local copy at the next free `<name> (N).<ext>` sibling (reusing an
+ *     existing sibling that already holds the same bytes), then re-pull the
+ *     latest canonical version. Surfaced in UI.
  *   • Per-path circuit breaker: if a path syncs >5 times in 10s, pause
  *     sync on that path and log loudly to stderr (the live state of
  *     active breakers is exposed via `dench fs status`).
@@ -58,7 +60,7 @@ import {
   unlink,
   writeFile,
 } from "node:fs/promises";
-import { dirname, relative } from "node:path";
+import { basename, dirname, extname, join, relative } from "node:path";
 import { ConvexClient, ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 import { decodeInlineTextOrUndefined } from "./fs-daemon-binary";
@@ -149,6 +151,56 @@ function sha256(bytes: Uint8Array): string {
   return createHash("sha256").update(bytes).digest("hex");
 }
 
+// Stash a conflicting local copy at a sibling path, using an incrementing
+// suffix (`foo (1).txt`, `foo (2).txt`, …) instead of a timestamp so
+// repeated conflicts produce a clean, stable series rather than an
+// ever-growing pile of `.conflicted-<ts>` files. The file is written
+// locally; the daemon's normal watcher path syncs it to Convex like any
+// other file. Returns the local path written.
+//
+// Two properties keep the deterministic suffix safe:
+//   • Content-aware reuse — if a `(N)` slot already holds these exact bytes,
+//     the copy is already stashed, so we return it instead of minting yet
+//     another sibling. This is what keeps repeated conflicts on the same
+//     unsynced content from piling up (the whole point of the change), and
+//     it also means an unrelated remote `(N)` file mirrored to local disk is
+//     skipped rather than overwritten.
+//   • Atomic claim — otherwise we write with O_EXCL (`wx`), so two handlers
+//     racing for the same slot can't clobber each other; the loser gets
+//     EEXIST and advances to the next N.
+async function stashConflictCopy(args: {
+  absPath: string;
+  bytes: Uint8Array;
+  hash: string;
+}): Promise<string> {
+  const { absPath, bytes, hash } = args;
+  const dir = dirname(absPath);
+  const ext = extname(absPath);
+  const stem = basename(absPath, ext);
+  for (let i = 1; i <= 1000; i++) {
+    const candidate = join(dir, `${stem} (${i})${ext}`);
+    const existing = await readFile(candidate).catch(() => null);
+    if (existing) {
+      // Already holds our bytes → nothing to do. Different content → this
+      // slot belongs to something else, try the next one.
+      if (sha256(existing) === hash) return candidate;
+      continue;
+    }
+    try {
+      await writeFile(candidate, bytes, { flag: "wx" });
+      return candidate;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") continue;
+      throw error;
+    }
+  }
+  // Every increment up to the cap is taken — fall back to a timestamp, which
+  // is effectively unique, so we still stash the bytes somewhere.
+  const fallback = join(dir, `${stem} (${Date.now()})${ext}`);
+  await writeFile(fallback, bytes);
+  return fallback;
+}
+
 function normalizePosixWorkspacePath(input: string): string {
   let cleaned = input.replace(/\\/g, "/").replace(/\/+/g, "/");
   if (cleaned.startsWith("/workspace/")) {
@@ -772,8 +824,7 @@ async function runDaemon(daemonArgs: Args): Promise<void> {
       if (result.versionConflict) {
         // Stash the local copy in a sibling file, then re-pull the remote
         // version into the canonical path.
-        const conflicted = `${absPath}.conflicted-${Date.now()}`;
-        await writeFile(conflicted, bytes);
+        const conflicted = await stashConflictCopy({ absPath, bytes, hash });
         console.warn(
           `[dench-fs-daemon] version conflict for ${posixPath}; local copy stashed at ${conflicted}`,
         );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Dench agent workspace CLI. v2 unifies auth behind `dench signin`; the legacy `dench login` / `dench onboard` / `dench setup` / `dench what-can-i-do` / `dench register` commands now error with a redirect.",
   "type": "module",
   "bin": {