@coderook/cli 0.7.0 → 0.9.0

package/dist/cli/src/cli.js

@@ -430,6 +430,12 @@ The connection failed: ${text}`));
             ` or ${accent("coderook merges")} to see everything waiting.`);
         return 0;
     }
+    /*
+      The version exists on the account. Stopping before the line below is the
+      crash that leaves this machine not knowing that — the one the derived
+      attempt name exists to make survivable.
+    */
+    (0, faults_js_1.maybeFail)("submit:after-commit");
     await (0, config_js_1.writeLink)(folder, {
         repositoryId: result.repositoryId,
         slug: link?.slug ?? node_path_1.default.basename(folder),
@@ -446,7 +452,16 @@ The connection failed: ${text}`));
     }
     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` : "") +
+        /*
+          Three different things, kept apart. Sent is what crossed the wire.
+          Already on the account is content the service turned out to have, which
+          is what makes finishing an interrupted save cheap. Unchanged is what
+          the version keeps without either.
+        */
+        (result.alreadyStoredFiles
+            ? `, ${result.alreadyStoredFiles} already on the account`
+            : "") +
+        (result.reusedFiles ? `, ${result.reusedFiles} unchanged` : "") +
         ` · version holds ${bytes(result.sourceBytes)}`);
     return 0;
 }

package/dist/cli/src/config.js

@@ -42,15 +42,44 @@ function configDirectory() {
 }
 const tokenFile = () => node_path_1.default.join(configDirectory(), "token");
 const linksFile = () => node_path_1.default.join(configDirectory(), "links.json");
-/** Write a file only its owner can read, and atomically. */
+/**
+ * Write a file only its owner can read, and atomically.
+ *
+ * The temporary name carries this process's own identity. Sharing one — as
+ * `${target}.tmp` did — means two runs at once write the same scratch file
+ * and then race to move it, which on Windows fails outright and elsewhere
+ * quietly hands one run the other's bytes.
+ *
+ * The move is retried briefly because Windows refuses a rename while another
+ * process still has the destination open, which during a race is ordinary
+ * rather than exceptional.
+ */
 async function writePrivate(target, body) {
     await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
-    const temporary = `${target}.tmp`;
+    const temporary = `${target}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
     await (0, promises_1.writeFile)(temporary, body, "utf8");
     // Windows ignores the mode; on everything else this is what keeps the
     // token out of other accounts' reach.
     await (0, promises_1.chmod)(temporary, 0o600).catch(() => undefined);
-    await (0, promises_1.rename)(temporary, target);
+    try {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                await (0, promises_1.rename)(temporary, target);
+                return;
+            }
+            catch (error) {
+                const code = error.code;
+                if (attempt >= 20 || (code !== "EPERM" && code !== "EACCES" && code !== "EBUSY")) {
+                    throw error;
+                }
+                await new Promise((wake) => setTimeout(wake, 10 + attempt * 5));
+            }
+        }
+    }
+    finally {
+        // A failed move must not leave scratch files accumulating beside it.
+        await (0, promises_1.rm)(temporary, { force: true }).catch(() => undefined);
+    }
 }
 async function storeToken(token) {
     await writePrivate(tokenFile(), `${token.trim()}\n`);

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

@@ -16,6 +16,7 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
+const faults_js_1 = require("./faults.js");
 const identify_js_1 = require("./identify.js");
 const worktree_js_1 = require("./worktree.js");
 const publish_name_js_1 = require("./publish_name.js");
@@ -239,6 +240,12 @@ class Uploader {
         // 3. Send the objects.
         const uploaded = [];
         let sentBytes = 0;
+        /*
+          Files whose content the service already had. Counted apart from what was
+          sent, because reporting them as sent would overstate the work and hide
+          the thing worth knowing: an interrupted save costs nothing to finish.
+        */
+        let alreadyOnAccount = 0;
         const startedAt = Date.now();
         const rate = () => {
             const seconds = (Date.now() - startedAt) / 1000;
@@ -256,25 +263,35 @@ class Uploader {
                 percent: 20 + Math.round((sentBytes / Math.max(totalBytes, 1)) * 72),
                 bytesPerSecond: rate(),
             });
-            const result = declaration.size <= DIRECT_LIMIT
-                ? await this.putDirect(repositoryId, declaration).catch((error) => {
-                    // Naming the file turns "it failed" into something actionable.
-                    const reason = error instanceof Error ? error.message : String(error);
-                    throw new Error(`${declaration.path}: ${reason}`);
-                })
-                : await this.putMultipart(repositoryId, declaration, (offset) => {
-                    report({
-                        stage: "upload",
-                        files: index,
-                        totalFiles: declarations.length,
-                        bytes: sentBytes + offset,
-                        totalBytes,
-                        path: declaration.path,
-                        percent: 20 +
-                            Math.round(((sentBytes + offset) / Math.max(totalBytes, 1)) * 72),
-                        bytesPerSecond: rate(),
-                    });
-                });
+            /*
+              Content the service already holds does not need sending. Asking costs
+              one round trip and saves the whole file — which after an interrupted
+              save is the difference between re-uploading a project and re-uploading
+              nothing.
+            */
+            const alreadyStored = await this.findStored(repositoryId, declaration);
+            if (alreadyStored)
+                alreadyOnAccount += 1;
+            const result = alreadyStored ??
+                (declaration.size <= DIRECT_LIMIT
+                    ? await this.putDirect(repositoryId, declaration).catch((error) => {
+                        // Naming the file turns "it failed" into something actionable.
+                        const reason = error instanceof Error ? error.message : String(error);
+                        throw new Error(`${declaration.path}: ${reason}`);
+                    })
+                    : await this.putMultipart(repositoryId, declaration, (offset) => {
+                        report({
+                            stage: "upload",
+                            files: index,
+                            totalFiles: declarations.length,
+                            bytes: sentBytes + offset,
+                            totalBytes,
+                            path: declaration.path,
+                            percent: 20 +
+                                Math.round(((sentBytes + offset) / Math.max(totalBytes, 1)) * 72),
+                            bytesPerSecond: rate(),
+                        });
+                    }));
             uploaded.push({
                 path: declaration.path,
                 objectId: result.objectId,
@@ -327,6 +344,12 @@ class Uploader {
         }
         const sourceBytes = contents.reduce((total, item) => total + item.sourceSize, 0);
         const storedBytes = contents.reduce((total, item) => total + item.storedSize, 0);
+        /*
+          Every object is uploaded and verified; nothing on the account points at
+          them yet. Stopping here has to leave no version and no partial one — the
+          objects are immutable and content-addressed, so a retry reuses them.
+        */
+        (0, faults_js_1.maybeFail)("submit:after-objects");
         const completed = await this.call(`/v1/repositories/${repositoryId}/versions`, {
             method: "POST",
             contentType: "application/json",
@@ -376,8 +399,10 @@ class Uploader {
             sourceBytes,
             storedBytes,
             sentBytes,
-            sentFiles: uploaded.length,
+            sentFiles: uploaded.length - alreadyOnAccount,
             reusedFiles: reused.length,
+            /** Selected, but the service already held the content. */
+            alreadyStoredFiles: alreadyOnAccount,
             // 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.
@@ -440,6 +465,39 @@ class Uploader {
             return null;
         }
     }
+    /**
+     * The stored object for this content, when the service already has it.
+     *
+     * A miss is the ordinary case and must be cheap, so it is one request that
+     * carries no body either way. Any failure answers "not stored" rather than
+     * throwing: this is an optimisation, and it must never be the reason a save
+     * does not happen.
+     */
+    async findStored(repositoryId, declaration) {
+        try {
+            const token = await this.credentials.token();
+            if (!token)
+                return null;
+            const response = await fetch(`${this.credentials.origin()}/v1/repositories/${repositoryId}` +
+                `/stored?sha256=${declaration.sha256}`, {
+                headers: {
+                    accept: "application/json",
+                    authorization: `Bearer ${token}`,
+                    "user-agent": "CodeRook/0.1",
+                    ...(0, identify_js_1.clientHeaders)(),
+                },
+            });
+            if (!response.ok)
+                return null;
+            const body = (await response.json());
+            if (!body.stored || !body.objectId)
+                return null;
+            return { objectId: body.objectId, size: Number(body.storedSize ?? 0) };
+        }
+        catch {
+            return null;
+        }
+    }
     async putDirect(repositoryId, declaration) {
         const body = await (0, promises_1.readFile)(declaration.full);
         // The file was hashed earlier, and a live file — a database, a log — can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",
@@ -32,11 +32,13 @@
     "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/fault-get.mjs --allow-production && node test/version-floor.mjs --allow-production && node test/attempt-identity.mjs --allow-production",
+    "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/fault-get.mjs --allow-production && node test/version-floor.mjs --allow-production && node test/fault-submit.mjs --allow-production && node test/race-attempts.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",
     "test:faultget": "node test/fault-get.mjs",
-    "test:floor": "node test/version-floor.mjs"
+    "test:floor": "node test/version-floor.mjs",
+    "test:faultsubmit": "node test/fault-submit.mjs",
+    "test:race": "node test/race-attempts.mjs"
   },
   "devDependencies": {
     "@types/node": "24.10.1",