@coderook/cli 0.2.0 → 0.4.0

package/dist/cli/src/api.js

@@ -4,6 +4,11 @@ exports.whoami = whoami;
 exports.projects = projects;
 exports.findProject = findProject;
 exports.health = health;
+exports.mergeTracks = mergeTracks;
+exports.mergeTrack = mergeTrack;
+exports.resolveMergeConflict = resolveMergeConflict;
+exports.applyMerge = applyMerge;
+exports.cancelMerge = cancelMerge;
 /** The small part of the API the command-line tool needs directly. */
 const config_js_1 = require("./config.js");
 async function call(route, options = {}) {
@@ -65,3 +70,22 @@ async function health() {
     });
     return (await response.json());
 }
+async function mergeTracks(repositoryId) {
+    const body = await call(`/v1/repositories/${repositoryId}/merge-tracks`);
+    return body.mergeTracks;
+}
+async function mergeTrack(id) {
+    return call(`/v1/merge-tracks/${id}`);
+}
+async function resolveMergeConflict(mergeTrackId, conflictId, resolution) {
+    await call(`/v1/merge-tracks/${mergeTrackId}/conflicts/${conflictId}`, {
+        method: "PUT",
+        body: { resolution },
+    });
+}
+async function applyMerge(mergeTrackId) {
+    return call(`/v1/merge-tracks/${mergeTrackId}/apply`, { method: "POST" });
+}
+async function cancelMerge(mergeTrackId) {
+    await call(`/v1/merge-tracks/${mergeTrackId}/cancel`, { method: "POST" });
+}

package/dist/cli/src/cli.js

@@ -18,11 +18,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = require("node:readline/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const node_process_1 = __importDefault(require("node:process"));
+const api_js_1 = require("./api.js");
 const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
 const upload_js_1 = require("../../desktop-app/src/main/upload.js");
 const download_js_1 = require("../../desktop-app/src/main/download.js");
 const cbx_js_1 = require("../../desktop-app/src/main/cbx.js");
-const api_js_1 = require("./api.js");
+const api_js_2 = require("./api.js");
 const config_js_1 = require("./config.js");
 /*
   Read from the package rather than written twice. A hardcoded copy had
@@ -122,8 +123,8 @@ async function reconcile(folder, options = {}) {
     const link = await (0, config_js_1.readLink)(folder);
     const reference = link?.slug ?? node_path_1.default.basename(folder);
     const project = link
-        ? (await (0, api_js_1.projects)()).find((candidate) => candidate.id === link.repositoryId)
-        : await (0, api_js_1.findProject)(reference);
+        ? (await (0, api_js_2.projects)()).find((candidate) => candidate.id === link.repositoryId)
+        : await (0, api_js_2.findProject)(reference);
     if (!project?.versionCount) {
         // Nothing saved on the account, so everything here is outstanding.
         return { link: link ?? null, baseline: null, behind: null };
@@ -147,7 +148,13 @@ async function reconcile(folder, options = {}) {
         }
         return {
             link: known,
-            baseline: new Map(Object.entries(known.manifest)),
+            /*
+              The comparison is against what this folder actually holds, not what
+              the version holds. After a merge the two differ, and comparing
+              against the version would read a stale copy as a fresh edit and
+              push it back over the change that replaced it.
+            */
+            baseline: new Map(Object.entries(known.local ?? known.manifest)),
             behind,
         };
     }
@@ -160,6 +167,8 @@ async function reconcile(folder, options = {}) {
         slug: project.slug,
         sequence: latest.sequence,
         versionId: latest.id,
+        // Adopted whole, so the folder is taken to hold what the version holds.
+        local: Object.fromEntries(baseline),
         manifest: Object.fromEntries(baseline),
     };
     await (0, config_js_1.writeLink)(folder, fresh);
@@ -184,7 +193,7 @@ async function commandSignIn(parsed) {
     }
     await (0, config_js_1.storeToken)(token);
     try {
-        const account = await (0, api_js_1.whoami)();
+        const account = await (0, api_js_2.whoami)();
         console.log(`Signed in as ${bold(account.displayName)} ${dim(`<${account.email}>`)} · ${account.plan}`);
         console.log(dim(`Token stored in ${(0, config_js_1.configDirectory)()}`));
         return 0;
@@ -201,12 +210,12 @@ async function commandSignOut() {
     return 0;
 }
 async function commandWhoami() {
-    const account = await (0, api_js_1.whoami)();
+    const account = await (0, api_js_2.whoami)();
     console.log(`${bold(account.displayName)} <${account.email}> · ${account.plan}`);
     return 0;
 }
 async function commandProjects() {
-    const all = await (0, api_js_1.projects)();
+    const all = await (0, api_js_2.projects)();
     if (!all.length) {
         console.log("No projects on this account yet.");
         return 0;
@@ -228,8 +237,26 @@ async function commandStatus(parsed) {
     console.log(link
         ? `Account holds ${accent(`v${link.sequence}`)} · ${Object.keys(link.manifest).length} files ${dim(`(${link.slug})`)}`
         : dim("Not on your account yet — submitting will create it."));
+    /*
+      A folder can have nothing to send and still not hold the whole version:
+      when the service merges somebody else's save into yours, their files
+      join the version without ever arriving here. Saying so is the difference
+      between "you are level" and "you are level with your own work".
+    */
+    const stale = link?.local
+        ? Object.entries(link.manifest).filter(([path, digest]) => link.local[path] !== digest)
+        : [];
+    if (stale.length) {
+        console.log(dim(`${stale.length} file${stale.length === 1 ? "" : "s"} in the saved version ` +
+            `${stale.length === 1 ? "is" : "are"} newer than the cop${stale.length === 1 ? "y" : "ies"} here ` +
+            `— run ${accent("coderook get")} to bring ${stale.length === 1 ? "it" : "them"} down.`));
+        for (const [path] of stale.slice(0, 10))
+            console.log(dim(`  behind  ${path}`));
+    }
     if (!files.length) {
-        console.log("Nothing to submit; this folder matches the saved version.");
+        console.log(stale.length
+            ? "Nothing to submit; your own work is all saved."
+            : "Nothing to submit; this folder matches the saved version.");
         return 0;
     }
     console.log(`\n${files.length} file${files.length === 1 ? "" : "s"} to submit:`);
@@ -247,7 +274,17 @@ async function commandSubmit(parsed) {
     const rules = await (0, worktree_js_1.readRules)(folder);
     const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline);
     if (!files.length) {
-        console.log("Nothing to submit; this folder matches the saved version.");
+        // 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
+        // file. Saying so is what stops "nothing to do" from reading as "level".
+        const behindOn = link?.local
+            ? Object.entries(link.manifest).filter(([path, digest]) => link.local[path] !== digest).length
+            : 0;
+        console.log(behindOn
+            ? `Nothing to submit; your own work is all saved. ${behindOn} file` +
+                `${behindOn === 1 ? "" : "s"} here ${behindOn === 1 ? "is" : "are"} ` +
+                `behind the saved version — run ${accent("coderook get")}.`
+            : "Nothing to submit; this folder matches the saved version.");
         return 0;
     }
     /*
@@ -297,6 +334,12 @@ async function commandSubmit(parsed) {
               nothing rather than guessing, and publishes as it always did.
             */
             ...(link?.versionId ? { expectedHeadVersionId: link.versionId } : {}),
+            /*
+              What this folder believed the project held. It is how the service
+              tells a file this person deleted from one they never had, and
+              without it somebody else's work disappears at the next save.
+            */
+            ...(link ? { known: link.local ?? link.manifest ?? {} } : {}),
         }, (progress) => {
             line(`  ${String(progress.percent).padStart(3)}%  ${progress.stage.padEnd(7)} ` +
                 `${progress.files}/${progress.totalFiles}  ${progress.path.slice(-48)}`);
@@ -305,6 +348,21 @@ async function commandSubmit(parsed) {
     catch (error) {
         done(line);
         const code = error.code;
+        const text = error instanceof Error ? error.message : String(error);
+        /*
+          A connection that fails part way through says nothing about whether
+          the work was done. It may well have been — the service records the
+          attempt, so running the same command again is answered with the
+          version it already made rather than a second one. Saying so is the
+          difference between a person retrying and a person wondering.
+        */
+        if (!code && /fetch failed|ECONNRESET|socket hang up|network|ETIMEDOUT/i.test(text)) {
+            console.error(red(`
+The connection failed: ${text}`));
+            console.error(`Your work may already have been saved. Run the same command again —` +
+                ` it will not create a second version.`);
+            return 1;
+        }
         if (code === "merge_required" || code === "track_moved") {
             /*
               Somebody else saved to this project first. Everything that did not
@@ -320,14 +378,37 @@ async function commandSubmit(parsed) {
         throw error;
     }
     done(line);
+    if (result.mergeTrack) {
+        /*
+          The upload is complete and kept, but the project has not changed —
+          calling this "saved" would be false, and the base is deliberately left
+          alone so the folder still knows what it was working from.
+        */
+        console.log(`\nSomebody else saved first, and ${result.mergeTrack.conflicts.length === 1
+            ? "one file overlaps"
+            : `${result.mergeTrack.conflicts.length} files overlap`}.`);
+        console.log(`Your work is complete and kept as ${accent(result.mergeTrack.reference)}:`);
+        for (const conflict of result.mergeTrack.conflicts.slice(0, 20)) {
+            console.log(`  ${red(conflict.path)}  ${dim(conflict.kind)}`);
+        }
+        console.log(`\nRun ${accent(`coderook merge ${result.mergeTrack.reference}`)} to decide,` +
+            ` or ${accent("coderook merges")} to see everything waiting.`);
+        return 0;
+    }
     await (0, config_js_1.writeLink)(folder, {
         repositoryId: result.repositoryId,
         slug: link?.slug ?? node_path_1.default.basename(folder),
         sequence: result.sequence,
         // What this folder is now working from, so the next submit can say so.
         versionId: result.versionId,
+        local: result.local,
         manifest: result.manifest,
     });
+    if (result.repeated) {
+        console.log(`Already saved as ${accent(`v${result.sequence}`)} by an earlier attempt;` +
+            ` nothing was sent again.`);
+        return 0;
+    }
     console.log(`Saved ${accent(`v${result.sequence}`)} · sent ${bytes(result.sentBytes)} in ` +
         `${result.sentFiles} file${result.sentFiles === 1 ? "" : "s"}` +
         (result.reusedFiles ? `, ${result.reusedFiles} already stored` : "") +
@@ -341,7 +422,8 @@ async function commandGet(parsed) {
         console.error(red("This folder is not linked to a project on your account."));
         return 1;
     }
-    return fetchInto(link.repositoryId, folder, link.slug);
+    // Only what this folder received may be removed by catching up.
+    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null);
 }
 async function commandClone(parsed) {
     const reference = parsed.positional[0];
@@ -349,7 +431,7 @@ async function commandClone(parsed) {
         console.error(red("Which project? Try: coderook clone <project>"));
         return 1;
     }
-    const project = await (0, api_js_1.findProject)(reference);
+    const project = await (0, api_js_2.findProject)(reference);
     if (!project) {
         console.error(red(`No project named ${reference} on this account.`));
         return 1;
@@ -361,7 +443,14 @@ async function commandClone(parsed) {
     const destination = node_path_1.default.resolve(parsed.positional[1] ?? project.slug);
     return fetchInto(project.id, destination, project.slug);
 }
-async function fetchInto(repositoryId, destination, slug) {
+async function fetchInto(repositoryId, destination, slug, 
+/*
+  What this folder received before, so a file the project has since dropped
+  is removed. Absent — a clone, or a folder whose record was lost — nothing
+  is removed, because "missing from the version" cannot then be told from
+  "never came from the version at all".
+*/
+held) {
     const downloader = new download_js_1.Downloader(config_js_1.credentials);
     const latest = (await downloader.versions(repositoryId))[0];
     if (!latest) {
@@ -372,7 +461,10 @@ async function fetchInto(repositoryId, destination, slug) {
     const result = await downloader.run(repositoryId, latest.id, destination, (progress) => {
         line(`  ${String(progress.percent).padStart(3)}%  ${progress.files}/${progress.totalFiles}` +
             `  ${progress.path.slice(-48)}`);
-    });
+    }, 
+    // What this folder received last time, so a file the project has since
+    // dropped is removed while everything untracked is left alone.
+    held);
     done(line);
     // Fetching is how a folder catches up, so this is what moves its base.
     await (0, config_js_1.writeLink)(destination, {
@@ -380,6 +472,9 @@ async function fetchInto(repositoryId, destination, slug) {
         slug,
         sequence: latest.sequence,
         versionId: latest.id,
+        // Fetching writes every file, so the folder now holds what the
+        // version holds and the two agree again.
+        local: result.manifest,
         manifest: result.manifest,
     });
     console.log(`${accent(`v${latest.sequence}`)} · ${result.files} files · ${bytes(result.bytes)} into ${destination}`);
@@ -454,7 +549,7 @@ async function commandInspect(parsed) {
     return 0;
 }
 async function commandDoctor() {
-    const service = await (0, api_js_1.health)().catch(() => null);
+    const service = await (0, api_js_2.health)().catch(() => null);
     console.log(`CodeRook CLI ${VERSION} · Node ${node_process_1.default.versions.node} · ${node_process_1.default.platform}`);
     console.log(`Config: ${(0, config_js_1.configDirectory)()}`);
     console.log(service
@@ -467,7 +562,7 @@ async function commandDoctor() {
         return 0;
     }
     try {
-        const account = await (0, api_js_1.whoami)();
+        const account = await (0, api_js_2.whoami)();
         console.log(`Account: ${account.email} · ${account.plan}`);
     }
     catch (error) {
@@ -489,6 +584,10 @@ ${bold("Working with a folder")}
   coderook clone <project> [dir]   Fetch a project into a new folder
   coderook rules [folder]          Show the ignore rules  (--init to start one)
 
+${bold("When somebody saved first")}
+  coderook merges                  Uploads of yours waiting on a decision
+  coderook merge <ref>             Look at one  (--mine --theirs --both --drop)
+
 ${bold("Bundles")}
   coderook bundle [folder] [out]   Pack the project as a .cbx
   coderook unbundle <file> [dir]   Extract a .cbx
@@ -506,6 +605,127 @@ ${bold("Options")}
 
 ${dim("The environment variable CODEROOK_TOKEN is used when set, so automated")}
 ${dim("runs need nothing on disk. CODEROOK_API_URL points at another service.")}`;
+/**
+ * Everything waiting on a decision, for one folder's project.
+ *
+ * A diverted upload is easy to forget about — it is not an error and the
+ * project looks untouched — so this is the way to find out that work of
+ * yours is sitting somewhere, still complete, waiting.
+ */
+async function commandMerges(parsed) {
+    const folder = folderFor(parsed);
+    const link = await (0, config_js_1.readLink)(folder);
+    if (!link) {
+        console.error(red("This folder is not linked to a project on your account."));
+        return 1;
+    }
+    const waiting = (await (0, api_js_1.mergeTracks)(link.repositoryId)).filter((merge) => merge.state === "open");
+    if (!waiting.length) {
+        console.log("Nothing is waiting to be merged.");
+        return 0;
+    }
+    for (const merge of waiting) {
+        const counts = merge.conflicts;
+        console.log(`${accent(merge.reference)}  ${counts ? `${counts.unresolved} of ${counts.total} still to decide` : ""}  ${dim(new Date(merge.createdAt).toLocaleString())}`);
+    }
+    console.log(dim(`
+Run coderook merge <reference> to look at one.`));
+    return 0;
+}
+/** Find a merge by the reference a person would type, such as M-2. */
+async function findMerge(folder, reference) {
+    const link = await (0, config_js_1.readLink)(folder);
+    if (!link)
+        throw new Error("This folder is not linked to a project on your account.");
+    const all = await (0, api_js_1.mergeTracks)(link.repositoryId);
+    const found = all.find((merge) => merge.reference.toLowerCase() === reference.toLowerCase());
+    if (!found)
+        throw new Error(`No merge called ${reference} on this project.`);
+    return found;
+}
+/**
+ * Look at one merge, and optionally finish it.
+ *
+ * Deciding happens here rather than in a command of its own because the
+ * decision only means anything next to the thing it is about.
+ */
+async function commandMerge(parsed) {
+    const reference = parsed.positional[0];
+    if (!reference) {
+        console.error(red("Which merge? Try: coderook merge M-1"));
+        return 1;
+    }
+    const folder = folderFor({ ...parsed, positional: parsed.positional.slice(1) });
+    const summary = await findMerge(folder, reference);
+    const detail = await (0, api_js_1.mergeTrack)(summary.id);
+    if (hasFlag(parsed, "cancel")) {
+        await (0, api_js_1.cancelMerge)(summary.id);
+        console.log(`${summary.reference} cancelled. Your upload is still stored and nothing published was touched.`);
+        return 0;
+    }
+    const outstanding = detail.conflicts.filter((conflict) => !conflict.resolvedAt);
+    const decision = hasFlag(parsed, "mine")
+        ? "take_candidate"
+        : hasFlag(parsed, "theirs")
+            ? "take_target"
+            : hasFlag(parsed, "drop")
+                ? "delete"
+                : hasFlag(parsed, "both", "keep-both")
+                    ? "keep_both"
+                    : null;
+    if (decision) {
+        const only = flagText(parsed, "path");
+        const chosen = only
+            ? outstanding.filter((conflict) => conflict.path === only)
+            : outstanding;
+        if (!chosen.length) {
+            console.error(red(only ? `${only} has no outstanding decision.` : "Nothing left to decide."));
+            return 1;
+        }
+        for (const conflict of chosen) {
+            await (0, api_js_1.resolveMergeConflict)(summary.id, conflict.id, decision);
+            console.log(`  ${conflict.path} → ${decision === "take_candidate"
+                ? "yours"
+                : decision === "take_target"
+                    ? "theirs"
+                    : decision === "keep_both"
+                        ? `both, yours saved beside it`
+                        : "removed"}`);
+        }
+    }
+    const now = await (0, api_js_1.mergeTrack)(summary.id);
+    console.log(`
+${accent(now.mergeTrack.reference)} · ${now.provisional.fileCount} files · ` +
+        (now.provisional.ready
+            ? "ready to apply"
+            : `${now.provisional.unresolvedPaths.length} still to decide`));
+    for (const conflict of now.conflicts) {
+        console.log(`  ${conflict.resolvedAt ? accent("decided") : red("waiting")}  ${conflict.path}` +
+            `  ${dim(conflict.kind)}${conflict.resolution ? dim(` (${conflict.resolution})`) : ""}`);
+    }
+    if (hasFlag(parsed, "apply")) {
+        if (!now.provisional.ready) {
+            console.error(red("\nStill undecided files; nothing was applied."));
+            return 1;
+        }
+        const applied = await (0, api_js_1.applyMerge)(summary.id);
+        console.log(`
+Applied as ${accent(`v${applied.version.sequence}`)}.`);
+        console.log(dim("Run coderook get to bring it down to this folder."));
+        return 0;
+    }
+    if (!decision) {
+        console.log(dim(`
+--mine keeps yours, --theirs keeps what was already saved,` +
+            ` --drop removes the file.
+Add --path <file> for one file, then --apply when ready.`));
+    }
+    else if (now.provisional.ready) {
+        console.log(dim(`
+Run coderook merge ${now.mergeTrack.reference} --apply to publish it.`));
+    }
+    return 0;
+}
 const COMMANDS = {
     "sign-in": commandSignIn,
     login: commandSignIn,
@@ -522,6 +742,8 @@ const COMMANDS = {
     bundle: commandBundle,
     unbundle: commandUnbundle,
     inspect: commandInspect,
+    merges: commandMerges,
+    merge: commandMerge,
     doctor: () => commandDoctor(),
 };
 async function main(argv) {

package/dist/cli/src/config.js

@@ -9,6 +9,7 @@ exports.configDirectory = configDirectory;
 exports.storeToken = storeToken;
 exports.loadToken = loadToken;
 exports.clearToken = clearToken;
+exports.keyFor = keyFor;
 exports.readLink = readLink;
 exports.writeLink = writeLink;
 /**
@@ -19,6 +20,7 @@ exports.writeLink = writeLink;
  * location follows each platform's convention rather than scattering dot
  * directories about.
  */
+const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
@@ -75,9 +77,33 @@ exports.credentials = {
     origin: apiOrigin,
     token: loadToken,
 };
+/**
+ * One name for one folder, whatever route was taken to reach it.
+ *
+ * A folder can be addressed as `C:\project`, through a junction, through a
+ * symlink, or through a mapped drive, and every one of those is a different
+ * string. Keying on the string gives the same folder four independent
+ * connections, four independent records of what it holds, and four chances
+ * for one to overwrite another's work. Resolving to the real path first is
+ * what makes them one workspace.
+ *
+ * A path that does not exist yet — a clone destination — cannot be resolved,
+ * so it falls back to the plain form. It becomes resolvable the moment the
+ * folder is created, which is before anything is ever recorded against it.
+ */
 function keyFor(localPath) {
-    return node_path_1.default.resolve(localPath).toLowerCase();
+    const absolute = node_path_1.default.resolve(localPath);
+    try {
+        // Windows returns an extended-length path here; the prefix is an
+        // addressing detail, not part of the identity, so it comes back off.
+        return node_fs_1.realpathSync.native(absolute).replace(/^\\\\\?\\/, "").toLowerCase();
+    }
+    catch {
+        return absolute.toLowerCase();
+    }
 }
+/** How the key used to be worked out, so existing links keep working. */
+const legacyKeyFor = (localPath) => node_path_1.default.resolve(localPath).toLowerCase();
 async function readLinks() {
     try {
         return JSON.parse(await (0, promises_1.readFile)(linksFile(), "utf8"));
@@ -87,10 +113,14 @@ async function readLinks() {
     }
 }
 async function readLink(localPath) {
-    return (await readLinks())[keyFor(localPath)] ?? null;
+    const links = await readLinks();
+    return links[keyFor(localPath)] ?? links[legacyKeyFor(localPath)] ?? null;
 }
 async function writeLink(localPath, link) {
     const links = await readLinks();
+    // A folder recorded under the old key moves to the new one rather than
+    // being left behind as a second connection to the same place.
+    delete links[legacyKeyFor(localPath)];
     links[keyFor(localPath)] = link;
     await writePrivate(linksFile(), JSON.stringify(links, null, 2));
 }

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

@@ -15,6 +15,27 @@ 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"));
+/**
+ * Remove the directories a deletion just emptied, up to but never including
+ * the project folder itself. Left alone they accumulate as empty husks of
+ * directories the project no longer has; removed too eagerly they would take
+ * a directory holding ignored files with them, so this stops at the first
+ * one that still has something in it.
+ */
+async function pruneEmpty(root, removed) {
+    let directory = node_path_1.default.dirname(removed);
+    while (directory.startsWith(root) && directory !== root) {
+        try {
+            if ((await (0, promises_1.readdir)(directory)).length)
+                return;
+            await (0, promises_1.rm)(directory, { recursive: false, force: true });
+        }
+        catch {
+            return;
+        }
+        directory = node_path_1.default.dirname(directory);
+    }
+}
 class DownloadCancelled extends Error {
     constructor() {
         super("Download cancelled");
@@ -81,11 +102,20 @@ class Downloader {
         }));
     }
     /**
-     * Write a version into `destination`. Files land in a staging directory
-     * and are moved into place only once every one has arrived and verified,
-     * so a failed download never leaves a half-project behind.
+     * Write a version into `destination`.
+     *
+     * Files land in a staging directory and are put in place only once every
+     * one has arrived and verified, so a failed download never leaves a
+     * half-project behind.
+     *
+     * What is put in place is the version's files, one at a time — not the
+     * whole directory. Replacing the directory wholesale also removes
+     * everything the version deliberately does not contain: the dependencies,
+     * the local credentials, the unfinished work and the git repository
+     * 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) {
+    async run(repositoryId, versionId, destination, report, held) {
         const files = await this.files(repositoryId, versionId);
         if (!files.length)
             throw new Error("That version has no files");
@@ -125,9 +155,36 @@ class Downloader {
                 written += 1;
                 bytes += body.length;
             }
-            await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
-            await (0, promises_1.rm)(destination, { recursive: true, force: true });
-            await (0, promises_1.rename)(staging, destination);
+            /*
+              Everything has arrived and verified, so it can go into place. Each
+              file is renamed over its destination individually: a rename within
+              one volume is atomic, so no file is ever seen half-written, and
+              anything the version does not mention is left exactly as it is.
+            */
+            await (0, promises_1.mkdir)(destination, { recursive: true });
+            for (const file of files) {
+                const parts = file.path.split("/").filter(Boolean);
+                const target = node_path_1.default.join(destination, ...parts);
+                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);
+            }
+            /*
+              A file this folder received but the version no longer holds is gone
+              deliberately, so it goes. One it never received is not this fetch's
+              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)
+                    continue;
+                const parts = path_.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));
+            }
+            await (0, promises_1.rm)(staging, { recursive: true, force: true });
             report({
                 files: written,
                 totalFiles: files.length,

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishAttemptName = publishAttemptName;
+/**
+ * A name for one publishing attempt, derived from what is being published.
+ *
+ * It has to be the same across retries of the same attempt and different for
+ * a genuinely new one — and it cannot be kept on disk, because the crash it
+ * exists to survive is exactly the kind that loses whatever was written just
+ * before it. Deriving it from the content solves both: the same files
+ * against the same head produce the same name, and anything else does not.
+ *
+ * Kept apart from the uploader because it depends on nothing, which is what
+ * lets it be tested without a network, a filesystem or an account.
+ */
+const node_crypto_1 = require("node:crypto");
+function publishAttemptName(input) {
+    const shape = [
+        input.repositoryId ?? "new",
+        input.expectedHeadVersionId ?? "none",
+        input.message,
+        // Sorted, so the order the scanner happened to walk the folder in
+        // cannot make the same attempt look like a different one.
+        ...[...input.files].map((file) => `${file.path}:${file.objectId}`).sort(),
+    ].join("\n");
+    return (0, node_crypto_1.createHash)("sha256").update(shape).digest("hex").slice(0, 40);
+}

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

@@ -52,6 +52,19 @@ function globToSource(pattern) {
     let source = "";
     for (let index = 0; index < pattern.length; index += 1) {
         const character = pattern[index];
+        if (character === "\\" && index + 1 < pattern.length) {
+            /*
+              A backslash means the next character is a character, not syntax.
+              It is how a file genuinely called `#notes.txt` or `important!.md`
+              is written, and how a space is kept at the end of a name. Patterns
+              use forward slashes throughout, so a backslash is never a separator
+              here and always an escape.
+            */
+            const literal = pattern[index + 1];
+            source += literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            index += 1;
+            continue;
+        }
         if (character === "*") {
             if (pattern[index + 1] === "*") {
                 source += ".*";

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

@@ -17,6 +17,7 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const worktree_js_1 = require("./worktree.js");
+const publish_name_js_1 = require("./publish_name.js");
 /** Above this the API insists on a multipart session. */
 const DIRECT_LIMIT = 95 * 1024 * 1024;
 const PART_SIZE = 32 * 1024 * 1024;
@@ -123,7 +124,39 @@ class Uploader {
         // Ticked files are sent; everything else the project still has keeps the
         // copy already stored, and a file that is new but unticked is left out.
         const sending = everything.filter((file) => ticked.has(file.path));
-        const reused = everything.filter((file) => !ticked.has(file.path) && prior.has(file.path));
+        const onDiskNow = new Set(everything.map((file) => file.path));
+        /*
+          Everything the version already holds is kept, except what this
+          workspace deliberately removed.
+    
+          "Deliberately removed" means the workspace had the file and it is now
+          gone. A file it never had — because somebody else added it while this
+          person was working — is not theirs to delete, and must survive their
+          next save. Reading this from the disk scan alone is what silently lost
+          other people's files.
+        */
+        const knew = request.known ? new Set(Object.keys(request.known)) : null;
+        const reused = [...prior.entries()]
+            .filter(([path]) => {
+            if (ticked.has(path))
+                return false;
+            if (onDiskNow.has(path))
+                return true;
+            // Missing here. Only a deletion if this workspace ever had it.
+            return knew ? !knew.has(path) : true;
+        })
+            .map(([path, held]) => ({
+            path,
+            sourceSize: held.sourceSize,
+            storedSize: held.storedSize,
+            mediaType: held.mediaType,
+            added: 0,
+            removed: 0,
+            included: true,
+            deleted: false,
+            binary: false,
+            lines: 0,
+        }));
         /*
           A ticked path that the rescan cannot see is either a deletion or a file
           that has gone since the changes list was drawn. Deletions are meant to
@@ -300,6 +333,16 @@ class Uploader {
                 ...(request.expectedHeadVersionId === undefined
                     ? {}
                     : { expectedHeadVersionId: request.expectedHeadVersionId }),
+                /*
+                  Names this attempt so a retry after a lost connection is answered
+                  with the version already made, rather than making a second one.
+                */
+                idempotencyKey: (0, publish_name_js_1.publishAttemptName)({
+                    repositoryId,
+                    expectedHeadVersionId: request.expectedHeadVersionId,
+                    message: request.message,
+                    files: contents,
+                }),
                 sourceSize: sourceBytes,
                 storedSize: storedBytes,
                 files: contents.map((item) => ({
@@ -326,6 +369,8 @@ class Uploader {
             repositoryId,
             versionId: completed.version.id,
             sequence: completed.version.sequence,
+            ...(completed.mergeTrack ? { mergeTrack: completed.mergeTrack } : {}),
+            ...(completed.repeated ? { repeated: true } : {}),
             sourceBytes,
             storedBytes,
             sentBytes,
@@ -334,6 +379,20 @@ class Uploader {
             // A file that kept its old object records the digest of *that* copy,
             // not of the file on disk, so an unticked edit is still pending next
             // time rather than looking as though it had been saved.
+            /*
+              What this folder holds after the save. A file that was sent holds
+              the bytes that were sent. Anything else keeps whatever digest was
+              recorded before: an unticked edit therefore stays pending rather
+              than looking saved, and a copy left stale by somebody else's merge
+              stays recognisably stale rather than looking like a new edit.
+            */
+            local: Object.fromEntries(everything.flatMap((file) => {
+                const sent = declarations.find((one) => one.path === file.path);
+                if (sent)
+                    return [[file.path, sent.sha256]];
+                const before = request.known?.[file.path] ?? prior.get(file.path)?.sha256;
+                return before ? [[file.path, before]] : [];
+            })),
             manifest: {
                 ...Object.fromEntries(reused.map((file) => [file.path, prior.get(file.path).sha256])),
                 ...Object.fromEntries(declarations.map((declaration) => [declaration.path, declaration.sha256])),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",
@@ -27,7 +27,11 @@
     "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"
+    "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",