@coderook/cli 0.29.0 → 0.29.1

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.29.0",
+  "version": "0.29.1",
   "author": {
     "name": "ACCA Gaming Productions",
     "url": "https://coderook.com"

package/dist/cli/src/cli.js

@@ -661,6 +661,16 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
         localPath: folder,
         changed: files.filter((file) => !file.deleted).map((file) => file.path),
         deleted: files.filter((file) => file.deleted).map((file) => file.path),
+        /*
+          Nothing is left out, and `changed` above is not the whole of it.
+    
+          `submit` sends whatever the rules allow — there is no per-file choosing
+          here — but it was passing the listed rows as the selection, and that list
+          stops at twenty thousand. A folder of twenty-one thousand files saved
+          twenty thousand of them and said "Saved v1" without mentioning the rest.
+          An empty exclusion list is how "all of it" is said.
+        */
+        excluded: [],
         message,
         /*
           A folder's name is the right default and the wrong answer for import,

package/dist/cli/src/publish.js

@@ -8,6 +8,7 @@ function uploadRequestFor(input) {
         localPath: input.localPath,
         // Both lists. See the note at the top of this file.
         include: [...input.changed, ...input.deleted],
+        ...(input.excluded === undefined ? {} : { excluded: input.excluded }),
         deletions: input.deleted,
         message: input.message,
         projectName: input.projectName,

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

@@ -424,60 +424,98 @@ class Uploader {
         // 1. Measure and hash. This is what makes an unchanged file free.
         const declarations = [];
         let totalBytes = 0;
-        for (const [index, file] of sending.entries()) {
-            this.check();
-            const full = node_path_1.default.join(request.localPath, file.path);
-            let size;
-            try {
-                size = (await (0, promises_1.stat)(full)).size;
-            }
-            catch (error) {
-                // Unreadable now, though it was listed a moment ago. Skipping it
-                // would publish a version quietly missing a file the person chose.
-                vanished.push(file.path);
-                readFailures.set(file.path, error instanceof Error ? error.message : String(error));
-                continue;
-            }
-            report({
-                stage: "hash",
-                files: index,
-                totalFiles: sending.length,
-                bytes: totalBytes,
-                totalBytes: 0,
-                path: file.path,
-                percent: Math.round((index / sending.length) * 20),
-                bytesPerSecond: 0,
-            });
-            /*
-              Hashing is the first thing that opens the file, and opening is what
-              fails on a file another program holds — a database in use, a browser
-              profile's LOCK, an antivirus mid-scan. On Windows those still answer
-              stat() perfectly well, so the check three lines above lets them
-              through and the read below was the one that actually broke.
-      
-              It was unguarded, so the person got a raw "EBUSY: resource busy or
-              locked" naming a path they never chose to think about, instead of the
-              sentence this code already writes for exactly this situation. The
-              outcome was always going to be a refusal; what was missing was it
-              being legible.
-            */
-            let digest;
-            try {
-                digest = await (0, profile_js_1.timed)("hash files", () => digestOf(full));
+        /*
+          Hashed several at a time, and reported by how many are done.
+    
+          Each file here is an open, a read and a close, and on Windows every open
+          is also an antivirus scan — so this stage is waiting, not computing.
+          Taken strictly one after another, a folder of twenty thousand small
+          files spent a quarter of an hour in a step that moves no data at all,
+          and the bar sat on 0% for the first thousand of them because it only
+          ever spanned a fifth of itself across the whole stage.
+    
+          Overlapping the waits collapses them into one wait. The results are
+          written into their own slots rather than pushed, because which disk read
+          finishes first must not decide the order of a version's file list.
+        */
+        const HASH_LANES = 8;
+        const measured = new Array(sending.length).fill(null);
+        let hashed = 0;
+        let cursor = 0;
+        /** Throttled: twenty thousand sends is its own cost, and nobody reads them. */
+        let told = 0;
+        const lane = async () => {
+            for (;;) {
+                const index = cursor;
+                cursor += 1;
+                if (index >= sending.length)
+                    return;
+                const file = sending[index];
+                this.check();
+                const full = node_path_1.default.join(request.localPath, file.path);
+                let size;
+                try {
+                    size = (await (0, promises_1.stat)(full)).size;
+                }
+                catch (error) {
+                    // Unreadable now, though it was listed a moment ago. Skipping it
+                    // would publish a version quietly missing a file the person chose.
+                    vanished.push(file.path);
+                    readFailures.set(file.path, error instanceof Error ? error.message : String(error));
+                    hashed += 1;
+                    continue;
+                }
+                /*
+                  Hashing is the first thing that opens the file, and opening is what
+                  fails on a file another program holds — a database in use, a browser
+                  profile's LOCK, an antivirus mid-scan. On Windows those still answer
+                  stat() perfectly well, so the check above lets them through and the
+                  read below is the one that actually breaks.
+        
+                  It was unguarded, so the person got a raw "EBUSY: resource busy or
+                  locked" naming a path they never chose to think about, instead of
+                  the sentence this code already writes for exactly this situation.
+                */
+                let digest;
+                try {
+                    digest = await (0, profile_js_1.timed)("hash files", () => digestOf(full));
+                }
+                catch (error) {
+                    vanished.push(file.path);
+                    readFailures.set(file.path, error instanceof Error ? error.message : String(error));
+                    hashed += 1;
+                    continue;
+                }
+                measured[index] = {
+                    path: file.path,
+                    full,
+                    size,
+                    sha256: digest,
+                    mediaType: mediaTypeOf(file.path),
+                };
+                hashed += 1;
+                const now = Date.now();
+                if (now - told > 80 || hashed === sending.length) {
+                    told = now;
+                    report({
+                        stage: "hash",
+                        files: hashed,
+                        totalFiles: sending.length,
+                        bytes: 0,
+                        totalBytes: 0,
+                        path: file.path,
+                        percent: Math.round((hashed / sending.length) * 20),
+                        bytesPerSecond: 0,
+                    });
+                }
             }
-            catch (error) {
-                vanished.push(file.path);
-                readFailures.set(file.path, error instanceof Error ? error.message : String(error));
+        };
+        await Promise.all(Array.from({ length: Math.min(HASH_LANES, sending.length) }, () => lane()));
+        for (const one of measured) {
+            if (!one)
                 continue;
-            }
-            declarations.push({
-                path: file.path,
-                full,
-                size,
-                sha256: digest,
-                mediaType: mediaTypeOf(file.path),
-            });
-            totalBytes += size;
+            declarations.push(one);
+            totalBytes += one.size;
         }
         /*
           A deletion-only save has no file to hash or upload, but it is still a
@@ -1060,7 +1098,16 @@ class Uploader {
             totalFiles: declarations.length,
             bytes: sentBytes,
             totalBytes,
-            path: "Recording the version",
+            /*
+              A save, not a version.
+      
+              Sending produces a commit; it becomes a version when somebody names
+              it, which happens later and on purpose. This line said "Recording the
+              version" while doing neither — it was the last wording left over from
+              before the two were separate, and it sat on the one screen a person
+              watches to the end.
+            */
+            path: "Writing down what was sent",
             percent: 96,
             bytesPerSecond: rate(),
         });

package/package.json

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