@coderook/cli 0.34.3 → 0.34.4

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "coderook",
   "displayName": "CodeRook",
   "description": "Save, browse and restore whole-snapshot versions of a project on CodeRook, with cbx or plain git, from Claude Code.",
-  "version": "0.34.3",
+  "version": "0.34.4",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cbx/src/core/upload.js

@@ -1081,6 +1081,16 @@ class Uploader {
                 shown = count;
             return shown;
         };
+        /*
+          Identical files are one upload.
+    
+          A folder holding two copies of the same file declares it twice, and both
+          copies used to go up in full: side by side in one batch, or in two lanes
+          at the same moment. The second copy now waits for the first to finish,
+          after which the service already holds the bytes and the copy costs a
+          question rather than a transfer.
+        */
+        const sending = new Map();
         const runSection = async (section) => {
             const declarations = section.files.map((file) => declarationByPath.get(file.path));
             /*
@@ -1151,6 +1161,17 @@ class Uploader {
             */
             const missing = declarations.filter((one) => !alreadyHeld.has(one.sha256));
             const smallOnes = missing.filter((one) => one.size <= BATCH_FILE_LIMIT);
+            /* The first file with each digest is sent; the rest are counted when it lands. */
+            const copiesOf = new Map();
+            const smallUnique = smallOnes.filter((one) => {
+                const copies = copiesOf.get(one.sha256);
+                if (copies) {
+                    copies.push(one);
+                    return false;
+                }
+                copiesOf.set(one.sha256, []);
+                return true;
+            });
             // 3. Send the objects.
             /*
               What was sent, in whichever shape it was sent. A small file is one
@@ -1177,7 +1198,7 @@ class Uploader {
                     (0, profile_js_1.counted)("files sent as deltas", 1);
                 }
             }
-            const smallForPacking = smallOnes.filter((one) => !batched.has(one.sha256));
+            const smallForPacking = smallUnique.filter((one) => !batched.has(one.sha256));
             if (smallForPacking.length > 1) {
                 let pack = [];
                 let packBytes = 0;
@@ -1281,6 +1302,8 @@ class Uploader {
                             if (!batched.has(digest) && !packedInto.has(digest))
                                 continue;
                             progress.finished(item.declaration.size, exactWireBytes === null ? item.encoded.body.byteLength : 0);
+                            for (const copy of copiesOf.get(digest) ?? [])
+                                progress.finished(copy.size, 0);
                         }
                         if (exactWireBytes !== null)
                             progress.finished(0, exactWireBytes);
@@ -1336,121 +1359,51 @@ class Uploader {
             const queue = declarations.entries();
             const runWorker = async () => {
                 for (const [index, declaration] of queue) {
-                    this.check();
-                    report({
-                        stage: "upload",
-                        files: advance(index),
-                        totalFiles: everyDeclaration.length,
-                        bytes: progress.bytes(),
-                        totalBytes,
-                        path: declaration.path,
-                        percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
-                        bytesPerSecond: progress.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.
-                    */
-                    /*
-                      A large file goes up in pieces, cut where its own content says.
-              
-                      This is what CBX is for and what it was never doing on the wire. The
-                      boundaries come from the same chunker the .cbx bundle uses, so an
-                      edit in the middle of a large file leaves the chunks either side of it
-                      untouched — and an untouched chunk is one the service already holds,
-                      which costs a question rather than a transfer. A small file is left
-                      whole: cutting it up would trade one request for several and save
-                      nothing.
-                    */
-                    const chunkProfile = (await this.microchunkAllowed())
-                        ? (0, chunking_js_1.microchunkProfileForFileSize)(declaration.size)
-                        : (0, chunking_js_1.profileForFileSize)(declaration.size);
-                    if (chunkProfile &&
-                        declaration.size >= CHUNK_THRESHOLD &&
-                        (await this.chunkingAllowed())) {
-                        const pieces = await this.putChunked(repositoryId, declaration, chunkProfile, (offset) => {
-                            progress.lane(index, offset);
-                            report({
-                                stage: "upload",
-                                files: advance(index),
-                                totalFiles: everyDeclaration.length,
-                                bytes: progress.bytes(),
-                                totalBytes,
-                                path: declaration.path,
-                                percent: 20 +
-                                    Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
-                                bytesPerSecond: progress.rate(),
-                            });
-                        });
-                        progress.laneDone(index);
-                        /*
-                          A chunk is not a file. Counting every reused piece here made a
-                          one-file save report a negative number of sent files. The selected
-                          file counts as already stored only when every one of its pieces was
-                          reused and no payload crossed the wire.
-                        */
-                        if (pieces.sentBytes === 0)
-                            progress.alreadyHeld();
-                        uploaded.push({
-                            path: declaration.path,
-                            sha256: declaration.sha256,
-                            chunks: pieces.chunks,
-                            sourceSize: declaration.size,
-                            storedSize: pieces.chunks.reduce((sum, one) => sum + one.storedSize, 0),
-                            mediaType: declaration.mediaType,
-                        });
-                        progress.finished(declaration.size, pieces.sentBytes);
-                        continue;
+                    const earlier = sending.get(declaration.sha256);
+                    if (earlier)
+                        await earlier;
+                    let release = () => { };
+                    if (!earlier) {
+                        sending.set(declaration.sha256, new Promise((done) => {
+                            release = done;
+                        }));
                     }
-                    const fromPack = packedInto.get(declaration.sha256);
-                    if (fromPack) {
-                        uploaded.push({
-                            path: declaration.path,
-                            sha256: declaration.sha256,
-                            pack: fromPack,
-                            sourceSize: declaration.size,
-                            /* Its share of the pack, so the version's totals stay honest. */
-                            storedSize: fromPack.storedSize,
-                            mediaType: declaration.mediaType,
-                        });
-                        continue;
-                    }
-                    const fromBatch = batched.get(declaration.sha256);
-                    if (fromBatch) {
-                        uploaded.push({
+                    try {
+                        this.check();
+                        report({
+                            stage: "upload",
+                            files: advance(index),
+                            totalFiles: everyDeclaration.length,
+                            bytes: progress.bytes(),
+                            totalBytes,
                             path: declaration.path,
-                            objectId: fromBatch.objectId,
-                            sourceSize: declaration.size,
-                            storedSize: fromBatch.size,
-                            mediaType: declaration.mediaType,
+                            percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                            bytesPerSecond: progress.rate(),
                         });
-                        continue;
-                    }
-                    const alreadyStored = alreadyHeld.get(declaration.sha256) ??
                         /*
-                          Only asked individually when the batch did not cover it — a digest
-                          that changed after the bulk question, because the file was rewritten
-                          while this upload was running.
+                          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.
                         */
-                        (await this.findStored(repositoryId, declaration));
-                    if (alreadyStored)
-                        progress.alreadyHeld();
-                    const result = alreadyStored ??
-                        (declaration.size <= DIRECT_LIMIT
-                            ? await (0, profile_js_1.timed)("send files one at a time", () => 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) => {
-                                /*
-                                  Recorded before the report reads it. Without this the bar does
-                                  not move at all during a multipart file: `bytes()` sums the
-                                  settled total and the open lanes, and this lane's offset is
-                                  only in the second of those once it has been set.
-                                */
+                        /*
+                          A large file goes up in pieces, cut where its own content says.
+                  
+                          This is what CBX is for and what it was never doing on the wire. The
+                          boundaries come from the same chunker the .cbx bundle uses, so an
+                          edit in the middle of a large file leaves the chunks either side of it
+                          untouched — and an untouched chunk is one the service already holds,
+                          which costs a question rather than a transfer. A small file is left
+                          whole: cutting it up would trade one request for several and save
+                          nothing.
+                        */
+                        const chunkProfile = (await this.microchunkAllowed())
+                            ? (0, chunking_js_1.microchunkProfileForFileSize)(declaration.size)
+                            : (0, chunking_js_1.profileForFileSize)(declaration.size);
+                        if (chunkProfile &&
+                            declaration.size >= CHUNK_THRESHOLD &&
+                            (await this.chunkingAllowed())) {
+                            const pieces = await this.putChunked(repositoryId, declaration, chunkProfile, (offset) => {
                                 progress.lane(index, offset);
                                 report({
                                     stage: "upload",
@@ -1463,16 +1416,100 @@ class Uploader {
                                         Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
                                     bytesPerSecond: progress.rate(),
                                 });
-                            }));
-                    progress.laneDone(index);
-                    uploaded.push({
-                        path: declaration.path,
-                        objectId: result.objectId,
-                        sourceSize: declaration.size,
-                        storedSize: result.size,
-                        mediaType: declaration.mediaType,
-                    });
-                    progress.finished(declaration.size, alreadyStored ? 0 : declaration.size);
+                            });
+                            progress.laneDone(index);
+                            /*
+                              A chunk is not a file. Counting every reused piece here made a
+                              one-file save report a negative number of sent files. The selected
+                              file counts as already stored only when every one of its pieces was
+                              reused and no payload crossed the wire.
+                            */
+                            if (pieces.sentBytes === 0)
+                                progress.alreadyHeld();
+                            uploaded.push({
+                                path: declaration.path,
+                                sha256: declaration.sha256,
+                                chunks: pieces.chunks,
+                                sourceSize: declaration.size,
+                                storedSize: pieces.chunks.reduce((sum, one) => sum + one.storedSize, 0),
+                                mediaType: declaration.mediaType,
+                            });
+                            progress.finished(declaration.size, pieces.sentBytes);
+                            continue;
+                        }
+                        const fromPack = packedInto.get(declaration.sha256);
+                        if (fromPack) {
+                            uploaded.push({
+                                path: declaration.path,
+                                sha256: declaration.sha256,
+                                pack: fromPack,
+                                sourceSize: declaration.size,
+                                /* Its share of the pack, so the version's totals stay honest. */
+                                storedSize: fromPack.storedSize,
+                                mediaType: declaration.mediaType,
+                            });
+                            continue;
+                        }
+                        const fromBatch = batched.get(declaration.sha256);
+                        if (fromBatch) {
+                            uploaded.push({
+                                path: declaration.path,
+                                objectId: fromBatch.objectId,
+                                sourceSize: declaration.size,
+                                storedSize: fromBatch.size,
+                                mediaType: declaration.mediaType,
+                            });
+                            continue;
+                        }
+                        const alreadyStored = alreadyHeld.get(declaration.sha256) ??
+                            /*
+                              Only asked individually when the batch did not cover it — a digest
+                              that changed after the bulk question, because the file was rewritten
+                              while this upload was running.
+                            */
+                            (await this.findStored(repositoryId, declaration));
+                        if (alreadyStored)
+                            progress.alreadyHeld();
+                        const result = alreadyStored ??
+                            (declaration.size <= DIRECT_LIMIT
+                                ? await (0, profile_js_1.timed)("send files one at a time", () => 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) => {
+                                    /*
+                                      Recorded before the report reads it. Without this the bar does
+                                      not move at all during a multipart file: `bytes()` sums the
+                                      settled total and the open lanes, and this lane's offset is
+                                      only in the second of those once it has been set.
+                                    */
+                                    progress.lane(index, offset);
+                                    report({
+                                        stage: "upload",
+                                        files: advance(index),
+                                        totalFiles: everyDeclaration.length,
+                                        bytes: progress.bytes(),
+                                        totalBytes,
+                                        path: declaration.path,
+                                        percent: 20 +
+                                            Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                                        bytesPerSecond: progress.rate(),
+                                    });
+                                }));
+                        progress.laneDone(index);
+                        uploaded.push({
+                            path: declaration.path,
+                            objectId: result.objectId,
+                            sourceSize: declaration.size,
+                            storedSize: result.size,
+                            mediaType: declaration.mediaType,
+                        });
+                        progress.finished(declaration.size, alreadyStored ? 0 : declaration.size);
+                    }
+                    finally {
+                        release();
+                    }
                 }
             };
             await Promise.all(Array.from({ length: Math.min(UPLOAD_LANES, declarations.length) }, () => runWorker()));

package/dist/cli/src/network.js

@@ -60,17 +60,37 @@ function describeError(error) {
         return "CodeRook did not answer in time. Check the connection, then try again.";
     }
     const cause = error.cause;
-    if (error.message === "fetch failed" && cause) {
-        const attempts = cause.errors?.length ? cause.errors : [cause];
+    if (error.message === "fetch failed") {
+        /*
+          Said in words first, with the code after for whoever needs it. The most
+          common one, ENOTFOUND, is simply being offline: the name could not be
+          looked up. And a failure that carries no code at all used to fall
+          through to the bare "fetch failed" it exists to replace.
+        */
+        const attempts = cause?.errors?.length ? cause.errors : cause ? [cause] : [];
+        const codes = [...new Set(attempts.map((one) => one.code).filter(Boolean))];
+        const said = codes.map((code) => PLAIN[code]).find(Boolean);
         const named = attempts
             .map((one) => [one.code, one.address].filter(Boolean).join(" "))
             .filter(Boolean);
-        if (named.length) {
-            return `Could not reach CodeRook (${[...new Set(named)].join(", ")}). Check the connection, then try again.`;
-        }
+        const detail = named.length ? [...new Set(named)].join(", ") : cause?.message ?? "";
+        return (`Could not reach CodeRook${said ? `: ${said}` : ""}` +
+            (detail ? ` (${detail})` : "") +
+            ". Check the connection, then try again.");
     }
     return error.message;
 }
+/** What each network failure means, for somebody who has not met the code. */
+const PLAIN = {
+    ENOTFOUND: "its address could not be looked up, which usually means this computer is offline",
+    EAI_AGAIN: "its address could not be looked up, which usually means this computer is offline",
+    ECONNREFUSED: "the connection was refused",
+    ECONNRESET: "the connection was dropped",
+    ETIMEDOUT: "the connection timed out",
+    ENETUNREACH: "there is no route to the internet from here",
+    EHOSTUNREACH: "there is no route to the internet from here",
+    UND_ERR_CONNECT_TIMEOUT: "the connection timed out",
+};
 /** Wait, for a retry. */
 function pause(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.34.3",
+  "version": "0.34.4",
   "description": "The command line for CodeRook (coderook.com): version control and project hosting for projects of any size. Every save is a compressed snapshot, private or public, never used to train AI.",
   "license": "Apache-2.0",
   "homepage": "https://coderook.com",