@coderook/cli 0.29.2 → 0.29.3

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

package/dist/cli/src/cli.js

@@ -194,6 +194,23 @@ async function reconcile(folder, options = {}) {
     const project = link
         ? (await (0, api_js_2.projects)()).find((candidate) => candidate.id === link.repositoryId)
         : await (0, api_js_2.findProject)(reference);
+    /*
+      A link that has outlived the project it points at.
+  
+      The list above is everything this account can reach — owned, shared with
+      them, and through their organisation — so a linked project missing from it
+      is gone or no longer theirs. Left alone, the next call that used the
+      remembered id failed with "Repository not found", which names neither the
+      folder nor anything to do about it; the soak suite hit exactly this and it
+      took a debugger to work out which folder was complaining.
+    */
+    if (link && !project) {
+        throw new Error(`This folder is linked to a project that is no longer on your account.\n` +
+            `  ${folder}\n` +
+            `It may have been deleted, or your access to it withdrawn.\n` +
+            `Detach the folder with ${accent("cbx unlink")} — the files here are ` +
+            `untouched, and submitting afterwards starts a new project from them.`);
+    }
     if (!project?.versionCount) {
         // Nothing saved on the account, so everything here is outstanding.
         return { link: link ?? null, baseline: null, behind: null };
@@ -303,6 +320,19 @@ async function commandProjects() {
     }
     return 0;
 }
+async function commandUnlink(parsed) {
+    const folder = folderFor(parsed);
+    const link = await (0, config_js_1.readLink)(folder);
+    if (!(await (0, config_js_1.forgetLink)(folder))) {
+        console.log("This folder was not linked to a project.");
+        return 0;
+    }
+    console.log(`Detached ${bold(node_path_1.default.basename(folder))}` +
+        (link?.slug ? dim(` from ${link.slug}`) : "") +
+        ".");
+    console.log(dim("Nothing was deleted. Submitting from here now starts a new project."));
+    return 0;
+}
 async function commandStatus(parsed) {
     const folder = folderFor(parsed);
     let link;
@@ -1678,6 +1708,20 @@ const SPECS = [
         ],
         run: commandSubmit,
     },
+    {
+        name: "unlink",
+        group: "Working with a folder",
+        summary: "detach this folder from its project",
+        usage: "unlink [folder]",
+        detail: "Forgets which project this folder belongs to. Nothing is deleted:\n" +
+            "the files here are untouched and the project stays on your account.\n\n" +
+            "Mostly useful when a folder points at a project that is gone — one\n" +
+            "that was deleted, or shared with you and since withdrawn — because\n" +
+            "until the folder forgets it, every command asks about a project that\n" +
+            "is no longer there.",
+        examples: ["cbx unlink", "cbx unlink ./old-copy"],
+        run: commandUnlink,
+    },
     {
         name: "import",
         group: "Getting started",

package/dist/cli/src/config.js

@@ -11,6 +11,7 @@ exports.loadToken = loadToken;
 exports.clearToken = clearToken;
 exports.keyFor = keyFor;
 exports.readLink = readLink;
+exports.forgetLink = forgetLink;
 exports.writeLink = writeLink;
 /**
  * Where the command-line tool keeps its credential and its project links.
@@ -151,6 +152,24 @@ async function readLink(localPath) {
         baseVersionId: link.baseVersionId ?? link.versionId,
     };
 }
+/**
+ * Forget which project a folder belongs to.
+ *
+ * Both keys, because a folder linked by an older build is recorded under the
+ * old one and leaving that behind would mean the folder was still linked
+ * afterwards — which is the one thing this is for.
+ */
+async function forgetLink(localPath) {
+    const links = await readLinks();
+    const had = links[keyFor(localPath)] !== undefined ||
+        links[legacyKeyFor(localPath)] !== undefined;
+    if (!had)
+        return false;
+    delete links[keyFor(localPath)];
+    delete links[legacyKeyFor(localPath)];
+    await writePrivate(linksFile(), JSON.stringify(links, null, 2));
+    return true;
+}
 async function writeLink(localPath, link) {
     const links = await readLinks();
     // A folder recorded under the old key moves to the new one rather than

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

@@ -585,43 +585,75 @@ class Downloader {
                 sayProgress(file.path);
             };
             /*
-              Wide for the small, narrow for the large.
+              Bounded by bytes in flight, not by how many files are open.
       
               Six lanes turned an hour-long restore of many small files into a
-              minute, and made a restore of a few very large ones eight times
-              slower: each large file is already fetched in pieces, so six at once
-              is six times the outstanding requests against the same line, and they
-              all finish later than they would have one after another.
+              minute, and made a restore of three very large ones eight times
+              slower — 93 seconds became 802. Splitting the queue by file size
+              fixed that shape and cost another: a project of forty-megabyte video
+              files had its six big ones running two at a time while the small ones
+              finished and left the line idle, and its fetch went from 54 seconds
+              to 151.
       
-              Split by what the job is: a pack or a small file is one request and
-              belongs in the wide lane; a large file is a stream of its own and
-              belongs in the narrow one. Both run at once, so a project holding
-              both kinds keeps the line busy without either starving the other.
-              The sending side splits its work the same way — see the note beside
-              BATCH_LANES in upload.ts.
+              Neither is really about file count. A file is fetched a piece at a
+              time, so each job holds exactly one request open whatever its size —
+              what six large files at once actually costs is six streams' worth of
+              bytes being buffered, hashed and written against one line. So that is
+              what is bounded: lanes take work while the bytes already in flight
+              leave room for it. Forty-megabyte files then run five or six at a
+              time and hundred-megabyte ones run two, without a threshold having to
+              guess which project this is.
             */
-            const HEAVY_BYTES = 8 * 1024 * 1024;
-            const light = jobs.filter((job) => job.kind === "pack" || job.file.sourceSize < HEAVY_BYTES);
-            const heavy = jobs.filter((job) => job.kind === "file" && job.file.sourceSize >= HEAVY_BYTES);
-            const drain = async (queue, lanes) => {
-                let next = 0;
-                const lane = async () => {
-                    for (;;) {
-                        const at = next;
-                        next += 1;
-                        if (at >= queue.length)
-                            return;
-                        this.check();
-                        const job = queue[at];
+            const LANES = 6;
+            const BYTES_IN_FLIGHT = 200 * 1024 * 1024;
+            const sizeOf = (job) => job.kind === "pack" ? 0 : job.file.sourceSize;
+            let next = 0;
+            let flying = 0;
+            /*
+              Every waiting lane, not the most recent one. A single slot would let a
+              second waiter overwrite the first, and the first would then never be
+              woken — a restore that stops with lanes idle and work left.
+            */
+            const waiting = [];
+            const wakeAll = () => {
+                while (waiting.length)
+                    waiting.pop()();
+            };
+            const roomFor = async (size) => {
+                /*
+                  One job always proceeds, however large. A file bigger than the whole
+                  budget would otherwise wait for room that can never appear.
+                */
+                while (flying > 0 && flying + size > BYTES_IN_FLIGHT) {
+                    await new Promise((resolve) => {
+                        waiting.push(resolve);
+                    });
+                }
+            };
+            const lane = async () => {
+                for (;;) {
+                    const at = next;
+                    next += 1;
+                    if (at >= jobs.length)
+                        return;
+                    this.check();
+                    const job = jobs[at];
+                    const size = sizeOf(job);
+                    await roomFor(size);
+                    flying += size;
+                    try {
                         if (job.kind === "pack")
                             await restorePack(job.id);
                         else
                             await restoreFile(job.file);
                     }
-                };
-                await Promise.all(Array.from({ length: Math.min(lanes, queue.length) }, () => lane()));
+                    finally {
+                        flying -= size;
+                        wakeAll();
+                    }
+                }
             };
-            await Promise.all([drain(light, 6), drain(heavy, 2)]);
+            await Promise.all(Array.from({ length: Math.min(LANES, jobs.length) }, () => lane()));
             /*
               Everything has arrived and verified, so it can go into place. Each
               file is renamed over its destination individually: a rename within

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

@@ -132,6 +132,8 @@ class Uploader {
       while somebody reads the plan is hashed again rather than published under
       the digest it used to have.
     */
+    /** Whether this save has already said that packing was refused. */
+    packRefusalSaid = false;
     plannedDigests = new Map();
     planningCreatedRepositoryId = null;
     /** Attached to every object write after the server admits the exact plan. */
@@ -272,6 +274,7 @@ class Uploader {
      */
     async plan(request, report) {
         this.planning = true;
+        this.packRefusalSaid = false;
         this.activeQuoteId = null;
         this.plannedQuote = null;
         this.planningCreatedRepositoryId = null;
@@ -968,12 +971,23 @@ class Uploader {
                                     batched.set(digest, one);
                             }
                         }
-                        catch {
+                        catch (reason) {
                             /*
                               A refusal here is never fatal: everything in the pack is simply
                               left for the ordinary path below, which sends it one at a time.
                               An older deployment without this route lands here every time.
+                  
+                              Said once per save, not once per pack. It used to be swallowed
+                              outright, and when the service began refusing packs for a reason
+                              that also broke the fallback, the only thing anybody saw was the
+                              fallback's complaint about an arbitrary file — which described
+                              neither what went wrong nor where. One line naming the first
+                              refusal is what makes the next one an hour shorter to find.
                             */
+                            if (!this.packRefusalSaid) {
+                                this.packRefusalSaid = true;
+                                console.warn(`Packing was refused; sending these files individually. ${String(reason).slice(0, 300)}`);
+                            }
                         }
                         /*
                           Only what actually landed. Counting the whole pack meant a batch the

package/package.json

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