@coderook/cli 0.21.0 → 0.22.0

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, from Claude Code.",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

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

@@ -718,7 +718,14 @@ class Uploader {
                             });
                         });
                         inFlight.delete(index);
-                        alreadyOnAccount += pieces.reused;
+                        /*
+                          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)
+                            alreadyOnAccount += 1;
                         uploaded.push({
                             path: declaration.path,
                             sha256: declaration.sha256,
@@ -988,7 +995,7 @@ class Uploader {
             ...(completed.repeated ? { repeated: true } : {}),
             sourceBytes: completed.version.sourceSize ?? sourceBytes,
             storedBytes: completed.version.storedSize ?? storedBytes,
-            sentBytes,
+            sentBytes: transferred,
             sentFiles: uploaded.length - alreadyOnAccount,
             reusedFiles: reused.length,
             /** Selected, but the service already held the content. */
@@ -1301,8 +1308,8 @@ class Uploader {
         */
         const CHUNK_LANES = 4;
         const active = new Set();
-        const dispatch = async (piece, at) => {
-            const task = this.sendChunk(repositoryId, declaration, piece, chunks, at, note).finally(() => {
+        const dispatch = async (piece, at, digest) => {
+            const task = this.sendChunk(repositoryId, declaration, piece, digest, chunks, at, note).finally(() => {
                 active.delete(task);
                 done += piece.length;
                 onOffset(done);
@@ -1311,6 +1318,51 @@ class Uploader {
             if (active.size >= CHUNK_LANES)
                 await Promise.race(active);
         };
+        /*
+          Ask about a bounded group of chunks before sending any of them.
+    
+          The old path asked once per chunk, with four GETs in flight. Besides
+          spending one network round trip per piece, an unavailable lookup was
+          deliberately treated as a miss, so a transient failure retransmitted
+          every otherwise reusable chunk. The website already uses the bulk
+          endpoint. Reusing it here gives Desktop and CLI the same wire behaviour
+          while retaining the safe "send it if unsure" fallback.
+    
+          A batch is no larger than the existing chunk lane count, so this does
+          not increase the memory ceiling: at most four bounded pieces are held.
+        */
+        const batch = [];
+        const flush = async () => {
+            if (!batch.length)
+                return;
+            const ready = batch.splice(0, batch.length);
+            const held = await this.storedInBulk(repositoryId, ready.map((item) => item.digest));
+            for (const item of ready) {
+                const stored = held.get(item.digest);
+                if (stored) {
+                    note("reused", 0);
+                    chunks[item.at] = {
+                        objectId: stored.objectId,
+                        sourceSize: item.piece.length,
+                        storedSize: stored.size,
+                    };
+                    done += item.piece.length;
+                    onOffset(done);
+                    continue;
+                }
+                await dispatch(item.piece, item.at, item.digest);
+            }
+            await Promise.all(active);
+        };
+        const queue = async (piece) => {
+            batch.push({
+                piece,
+                at: ordinal++,
+                digest: (0, node_crypto_1.createHash)("sha256").update(piece).digest("hex"),
+            });
+            if (batch.length >= CHUNK_LANES)
+                await flush();
+        };
         let ordinal = 0;
         let pending = Buffer.alloc(0);
         for await (const block of (0, node_fs_1.createReadStream)(declaration.full, {
@@ -1321,7 +1373,7 @@ class Uploader {
             pending = pending.length ? Buffer.concat([pending, incoming]) : incoming;
             let from = 0;
             for (const cut of (0, chunking_js_1.cutPoints)(pending, profile)) {
-                await dispatch(Buffer.from(pending.subarray(from, cut)), ordinal++);
+                await queue(Buffer.from(pending.subarray(from, cut)));
                 from = cut;
             }
             pending = Buffer.from(pending.subarray(from));
@@ -1333,8 +1385,8 @@ class Uploader {
           Dropping it truncates every chunked file by exactly its last piece.
         */
         if (pending.length)
-            await dispatch(pending, ordinal++);
-        await Promise.all(active);
+            await queue(pending);
+        await flush();
         /*
           Order is the file. Every position must be filled: a hole would mean a
           chunk that never landed, and publishing around it would produce a version
@@ -1351,7 +1403,7 @@ class Uploader {
         };
     }
     /** Send one chunk, reusing it if the account already holds those bytes. */
-    async sendChunk(repositoryId, declaration, piece, 
+    async sendChunk(repositoryId, declaration, piece, digest, 
     /*
       Written at a known position rather than appended. The chunks are sent
       several at a time and finish in whatever order the network decides, but
@@ -1362,48 +1414,27 @@ class Uploader {
     chunks, at, note) {
         {
             this.check();
-            const digest = (0, node_crypto_1.createHash)("sha256").update(piece).digest("hex");
-            /*
-              Asked per chunk rather than per file. This is the whole saving: the
-              parts of a large file that did not change answer "already held" and
-              never travel.
-            */
-            const held = await this.findStored(repositoryId, {
-                ...declaration,
-                sha256: digest,
-                size: piece.length,
+            const encoded = await (0, compress_js_1.encodeForUpload)(new Uint8Array(piece), declaration.path, await this.gzipAllowed());
+            const query = encoded.encoding === "gzip"
+                ? `?kind=chunk&role=chunk&encoding=gzip` +
+                    `&logicalSize=${piece.length}` +
+                    `&storedSha256=${encoded.storedSha256}`
+                : `?kind=chunk&role=chunk`;
+            const stored = await this.call(`/v1/repositories/${repositoryId}/objects/${digest}${query}`, {
+                method: "PUT",
+                contentType: "application/octet-stream",
+                body: encoded.body,
+            }).catch((error) => {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new Error(`${declaration.path}: ${reason}`);
             });
-            if (held) {
-                note("reused", 0);
-                chunks[at] = {
-                    objectId: held.objectId,
-                    sourceSize: piece.length,
-                    storedSize: held.size,
-                };
-            }
-            else {
-                const encoded = await (0, compress_js_1.encodeForUpload)(new Uint8Array(piece), declaration.path, await this.gzipAllowed());
-                const query = encoded.encoding === "gzip"
-                    ? `?kind=chunk&role=chunk&encoding=gzip` +
-                        `&logicalSize=${piece.length}` +
-                        `&storedSha256=${encoded.storedSha256}`
-                    : `?kind=chunk&role=chunk`;
-                const stored = await this.call(`/v1/repositories/${repositoryId}/objects/${digest}${query}`, {
-                    method: "PUT",
-                    contentType: "application/octet-stream",
-                    body: encoded.body,
-                }).catch((error) => {
-                    const reason = error instanceof Error ? error.message : String(error);
-                    throw new Error(`${declaration.path}: ${reason}`);
-                });
-                note("sent", encoded.body.byteLength);
-                chunks[at] = {
-                    objectId: stored.objectId,
-                    sourceSize: piece.length,
-                    /* What the service keeps, which is smaller when the piece gzipped. */
-                    storedSize: stored.storedSize ?? stored.size,
-                };
-            }
+            note("sent", encoded.body.byteLength);
+            chunks[at] = {
+                objectId: stored.objectId,
+                sourceSize: piece.length,
+                /* What the service keeps, which is smaller when the piece gzipped. */
+                storedSize: stored.storedSize ?? stored.size,
+            };
         }
     }
     async putDirect(repositoryId, declaration) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",