@coderook/cli 0.4.0 → 0.5.0

package/dist/cli/src/cli.js

@@ -422,8 +422,59 @@ async function commandGet(parsed) {
         console.error(red("This folder is not linked to a project on your account."));
         return 1;
     }
-    // Only what this folder received may be removed by catching up.
-    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null);
+    /*
+      Fetching writes over what is here. That is the point of it — but a file
+      somebody has edited and not yet saved is not the same as a file sitting
+      where the last fetch left it, and overwriting the first loses work that
+      exists nowhere else.
+  
+      Telling them apart needs the materialisation record: disk differing from
+      what was placed here is an edit, and disk matching it is simply an old
+      copy. Only the edits are worth stopping for, and only when the incoming
+      version would actually change those files.
+    */
+    const replacing = hasFlag(parsed, "replace", "f", "force");
+    if (link.local && !replacing) {
+        const rules = await (0, worktree_js_1.readRules)(folder);
+        const edited = await (0, worktree_js_1.changedFiles)(folder, rules, new Map(Object.entries(link.local)));
+        if (edited.length) {
+            const downloader = new download_js_1.Downloader(config_js_1.credentials);
+            const latest = (await downloader.versions(link.repositoryId))[0];
+            const incoming = new Map(latest
+                ? (await downloader.files(link.repositoryId, latest.id)).map((file) => [
+                    file.path,
+                    file.sha256,
+                ])
+                : []);
+            /*
+              Only a genuine collision stops the fetch: this folder changed the
+              file and so did the incoming version. An edit to a file the version
+              left alone is simply kept — fetching has nothing to say about it —
+              and stopping for those would make the warning something people learn
+              to click past.
+            */
+            const atRisk = edited.filter((file) => !file.deleted &&
+                incoming.has(file.path) &&
+                incoming.get(file.path) !== link.local[file.path]);
+            if (atRisk.length) {
+                console.error(red(`${atRisk.length} file${atRisk.length === 1 ? "" : "s"} here ` +
+                    `${atRisk.length === 1 ? "has" : "have"} changes that fetching would overwrite:`));
+                for (const file of atRisk.slice(0, 20))
+                    console.error(`  ${file.path}`);
+                if (atRisk.length > 20)
+                    console.error(dim(`  …and ${atRisk.length - 20} more`));
+                console.error(`\nSave them first with ${accent("coderook submit")}, or discard them ` +
+                    `with ${accent("coderook get --replace")}.`);
+                return 1;
+            }
+        }
+    }
+    /*
+      Only what this folder received may be removed by catching up, and only
+      what the version actually changed is written over — unless somebody asks
+      for an exact copy, which is how a damaged folder is repaired.
+    */
+    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null, replacing ? "replace" : "reconcile");
 }
 async function commandClone(parsed) {
     const reference = parsed.positional[0];
@@ -450,7 +501,7 @@ async function fetchInto(repositoryId, destination, slug,
   is removed, because "missing from the version" cannot then be told from
   "never came from the version at all".
 */
-held) {
+held, mode = "replace") {
     const downloader = new download_js_1.Downloader(config_js_1.credentials);
     const latest = (await downloader.versions(repositoryId))[0];
     if (!latest) {
@@ -464,7 +515,7 @@ held) {
     }, 
     // What this folder received last time, so a file the project has since
     // dropped is removed while everything untracked is left alone.
-    held);
+    held, mode);
     done(line);
     // Fetching is how a folder catches up, so this is what moves its base.
     await (0, config_js_1.writeLink)(destination, {
@@ -580,7 +631,8 @@ ${bold("Getting started")}
 ${bold("Working with a folder")}
   coderook status [folder]         What is here that is not saved yet
   coderook submit [folder] -m "…"  Send the changes as a new version
-  coderook get [folder]            Fetch the latest version over this folder
+  coderook get [folder]            Bring this folder up to date
+                                   (--replace for an exact copy)
   coderook clone <project> [dir]   Fetch a project into a new folder
   coderook rules [folder]          Show the ignore rules  (--init to start one)
 

package/dist/desktop-app/src/main/download.js

@@ -15,6 +15,24 @@ exports.Downloader = exports.DownloadCancelled = void 0;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
+async function exists(target) {
+    try {
+        await (0, promises_1.stat)(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The digest of what is on disk, or null when nothing is there to read. */
+async function digestOf(target) {
+    try {
+        return (0, node_crypto_1.createHash)("sha256").update(await (0, promises_1.readFile)(target)).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Remove the directories a deletion just emptied, up to but never including
  * the project folder itself. Left alone they accumulate as empty husks of
@@ -115,7 +133,15 @@ class Downloader {
      * itself. A file the version no longer holds is removed only when this
      * folder is known to have received it, which `held` supplies.
      */
-    async run(repositoryId, versionId, destination, report, held) {
+    async run(repositoryId, versionId, destination, report, held, 
+    /*
+      `reconcile` brings the folder up to date without disturbing work in
+      progress: a file the incoming version did not change is left exactly as
+      it is, edits and all. `replace` makes the folder an exact copy of the
+      version, which is what repairs a damaged one — and what discards
+      anything unsaved.
+    */
+    mode = "replace") {
         const files = await this.files(repositoryId, versionId);
         if (!files.length)
             throw new Error("That version has no files");
@@ -165,6 +191,18 @@ class Downloader {
             for (const file of files) {
                 const parts = file.path.split("/").filter(Boolean);
                 const target = node_path_1.default.join(destination, ...parts);
+                /*
+                  Reconciling leaves alone whatever the incoming version did not
+                  change. Writing it anyway would replace an edit in progress with a
+                  copy of what the folder already had — destroying work to achieve
+                  nothing, which is the least defensible way to lose someone's file.
+                */
+                if (mode === "reconcile" &&
+                    held &&
+                    held[file.path] === manifest[file.path] &&
+                    (await exists(target))) {
+                    continue;
+                }
                 await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
                 await (0, promises_1.rm)(target, { recursive: true, force: true });
                 await (0, promises_1.rename)(node_path_1.default.join(staging, ...parts), target);
@@ -175,14 +213,22 @@ class Downloader {
               to remove — and without a record of what it received, nothing is
               removed at all, which is the safe reading of an unknown folder.
             */
-            for (const path_ of Object.keys(held ?? {})) {
-                if (manifest[path_] !== undefined)
+            for (const [gone, digest] of Object.entries(held ?? {})) {
+                if (manifest[gone] !== undefined)
                     continue;
-                const parts = path_.split("/").filter(Boolean);
+                const parts = gone.split("/").filter(Boolean);
                 if (parts.some((part) => part === ".." || part.includes("\0")))
                     continue;
-                await (0, promises_1.rm)(node_path_1.default.join(destination, ...parts), { force: true });
-                await pruneEmpty(destination, node_path_1.default.join(destination, ...parts));
+                const target = node_path_1.default.join(destination, ...parts);
+                /*
+                  The version dropped it — but if the bytes here are no longer the
+                  ones this folder received, somebody has been working on it, and
+                  somebody else's deletion is not permission to throw that away.
+                */
+                if (mode === "reconcile" && (await digestOf(target)) !== digest)
+                    continue;
+                await (0, promises_1.rm)(target, { force: true });
+                await pruneEmpty(destination, target);
             }
             await (0, promises_1.rm)(staging, { recursive: true, force: true });
             report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",
@@ -31,7 +31,9 @@
     "test:e2e": "node test/e2e.mjs",
     "test:matrix": "node test/state-matrix.mjs",
     "test:attempt": "node test/attempt-identity.mjs",
-    "test:get": "node test/get-safety.mjs"
+    "test:get": "node test/get-safety.mjs",
+    "test:live": "node test/e2e.mjs --allow-production && node test/state-matrix.mjs --allow-production && node test/get-safety.mjs --allow-production && node test/get-protects-edits.mjs --allow-production && node test/attempt-identity.mjs --allow-production",
+    "test:getedits": "node test/get-protects-edits.mjs"
   },
   "devDependencies": {
     "@types/node": "24.10.1",