@coderook/cli 0.4.0 → 0.6.0

package/dist/cli/src/cli.js

@@ -270,9 +270,36 @@ async function commandStatus(parsed) {
 async function commandSubmit(parsed) {
     const folder = folderFor(parsed);
     const message = flagText(parsed, "m", "message") ?? "";
-    const { link, baseline } = await reconcile(folder);
+    const { link, baseline, behind } = await reconcile(folder);
     const rules = await (0, worktree_js_1.readRules)(folder);
     const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline);
+    /*
+      An upgraded folder with no materialisation record and something that
+      differs from its recorded version is ambiguous in the one way that
+      matters: the difference is either work to send, or a copy left behind by
+      somebody's merge. Sending the second reverts their change.
+  
+      While the folder is level with the project the question does not arise —
+      nothing can have merged underneath it — so only a folder that is behind
+      is stopped, and only until somebody says which it is.
+    */
+    if (link && !link.local && files.length && behind) {
+        if (await establishMaterialisation(folder, link)) {
+            link.local = { ...link.manifest };
+            await (0, config_js_1.writeLink)(folder, link);
+        }
+        else if (!hasFlag(parsed, "f", "force")) {
+            console.error(red("This folder was connected by an older version of CodeRook,"));
+            console.error("which did not record what it had received — and somebody");
+            console.error(`has saved since (the project is on v${behind.sequence}).\n`);
+            console.error(`${files.length} file${files.length === 1 ? " differs" : "s differ"} here:`);
+            for (const file of files.slice(0, 20))
+                console.error(`  ${file.path}`);
+            console.error(`\nIf that is your work, send it with ${accent("coderook submit --force")}.` +
+                `\nIf it is an old copy, take theirs with ${accent("coderook get --replace")}.`);
+            return 1;
+        }
+    }
     if (!files.length) {
         // Having nothing to send is not the same as holding the whole version:
         // a merge can leave this folder with an older copy of somebody else's
@@ -415,6 +442,20 @@ The connection failed: ${text}`));
         ` · version holds ${bytes(result.sourceBytes)}`);
     return 0;
 }
+/**
+ * Work out what an upgraded folder actually holds, or admit that it cannot.
+ *
+ * Returns the materialisation when the folder matches its recorded version
+ * exactly — which proves the manifest describes what is here — and null when
+ * anything differs, because a difference is either somebody's unsaved edit or
+ * a copy their merge left stale, and nothing on disk says which.
+ */
+async function establishMaterialisation(folder, link) {
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const against = new Map(Object.entries(link.manifest));
+    const differing = await (0, worktree_js_1.changedFiles)(folder, rules, against);
+    return differing.length ? null : { ...link.manifest };
+}
 async function commandGet(parsed) {
     const folder = folderFor(parsed);
     const { link } = await reconcile(folder);
@@ -422,8 +463,87 @@ 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");
+    /*
+      A folder connected by a client older than the materialisation record has
+      only the Version manifest, which says what the project held — not what
+      was placed here. The two are the same only until somebody's merge makes
+      them differ, so assuming it would be the very guess that lost work in the
+      first place.
+  
+      It can be established rather than assumed: if the folder matches its own
+      recorded version exactly, then it demonstrably holds that version and the
+      manifest is the materialisation. If it does not match, an edit cannot be
+      told from a stale copy, and fetching is refused until somebody says which
+      it is.
+    */
+    if (!link.local) {
+        const settled = await establishMaterialisation(folder, link);
+        if (settled) {
+            link.local = settled;
+            await (0, config_js_1.writeLink)(folder, link);
+        }
+        else if (!replacing) {
+            console.error(red("This folder was connected by an older version of CodeRook,"));
+            console.error("which did not record what it had received, so changed files here");
+            console.error("cannot be told apart from copies left behind by a merge.\n");
+            console.error(`Save them with ${accent("coderook submit")} if they are your work, or ` +
+                `take the\nsaved version exactly with ${accent("coderook get --replace")}.`);
+            return 1;
+        }
+    }
+    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 +570,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 +584,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 +700,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,40 +1,43 @@
-{
-  "name": "@coderook/cli",
-  "version": "0.4.0",
-  "description": "CodeRook from the command line, on any operating system",
-  "license": "SEE LICENSE IN LICENSE.txt",
-  "homepage": "https://coderook.com",
-  "bugs": {
-    "url": "https://coderook.com/contact"
-  },
-  "keywords": [
-    "coderook",
-    "versioning",
-    "backup",
-    "cbx"
-  ],
-  "engines": {
-    "node": ">=20.11.0"
-  },
-  "bin": {
-    "coderook": "dist/cli/src/cli.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "check": "tsc -p tsconfig.json --noEmit",
-    "test": "tsc -p tsconfig.json && node --test --experimental-strip-types test/*.test.ts",
-    "start": "node dist/cli/src/cli.js",
-    "prepublishOnly": "npm run build",
-    "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"
-  },
-  "devDependencies": {
-    "@types/node": "24.10.1",
-    "typescript": "5.9.3"
-  }
-}
+{
+  "name": "@coderook/cli",
+  "version": "0.6.0",
+  "description": "CodeRook from the command line, on any operating system",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "homepage": "https://coderook.com",
+  "bugs": {
+    "url": "https://coderook.com/contact"
+  },
+  "keywords": [
+    "coderook",
+    "versioning",
+    "backup",
+    "cbx"
+  ],
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "bin": {
+    "coderook": "dist/cli/src/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node --test --experimental-strip-types test/*.test.ts",
+    "start": "node dist/cli/src/cli.js",
+    "prepublishOnly": "npm run build",
+    "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: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/upgrade-migration.mjs --allow-production && node test/attempt-identity.mjs --allow-production",
+    "test:getedits": "node test/get-protects-edits.mjs",
+    "test:upgrade": "node test/upgrade-migration.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3"
+  }
+}