@coderook/cli 0.34.8 → 0.34.9

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

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

@@ -113,6 +113,24 @@ class UploadCancelled extends Error {
     }
 }
 exports.UploadCancelled = UploadCancelled;
+/*
+  Version listings already read by this process, by repository and version.
+
+  A save read the version it started from twice — once to plan, once to
+  send — and then read the version it had just made, each time the whole
+  list: three downloads of 6,628 rows to change one line of one file. A
+  version never changes once it exists, so a listing read once is the
+  listing for good.
+*/
+const versionListings = new Map();
+/*
+  Delta signatures, for the same reason: one describes a file of a version
+  that will never change, and the planning pass and the sending pass each
+  asked for it.
+*/
+const signatures = new Map();
+/** How many version listings a folder keeps in `.coderook/versions`. */
+const KEPT_LISTINGS = 3;
 class Uploader {
     credentials;
     aborted = false;
@@ -127,6 +145,7 @@ class Uploader {
     deltaProtocol = null;
     /** Batch delta is separate so V2 single-file support remains compatible. */
     deltaBatchSupported = null;
+    versionDeltaSupported = null;
     microchunkSupported = null;
     /** One shared preflight, so parallel upload lanes cannot race /health. */
     capabilityRequest = null;
@@ -524,7 +543,7 @@ class Uploader {
         if (!ticked.size)
             throw new Error("Nothing is selected to upload");
         const prior = request.repositoryId
-            ? await this.versionFiles(request.repositoryId, request.baseVersionId)
+            ? await this.versionFiles(request.repositoryId, request.baseVersionId, request.localPath)
             : new Map();
         // Ticked files are sent; everything else the project still has keeps the
         // copy already stored, and a file that is new but unticked is left out.
@@ -1013,7 +1032,56 @@ class Uploader {
             : null;
         const linesAdded = counted ? counted.added : request.linesAdded;
         const linesRemoved = counted ? counted.removed : request.linesRemoved;
-        const completed = await (0, profile_js_1.timed)("publish the version", () => this.call(`/v1/repositories/${repositoryId}/versions`, {
+        /*
+          The version's whole file list, as the service will hold it.
+        */
+        const wire = contents.map((item) => ({
+            path: item.path,
+            ...(item.pack
+                ? {
+                    pack: {
+                        objectId: item.pack.packObjectId,
+                        offset: item.pack.offset,
+                        length: item.pack.length,
+                    },
+                    sha256: item.sha256,
+                }
+                : item.chunks
+                    ? { chunks: item.chunks, sha256: item.sha256 }
+                    : { objectId: item.objectId }),
+            sourceSize: item.sourceSize,
+            storedSize: item.storedSize,
+            mediaType: item.mediaType,
+            executable: item.executable === true,
+        }));
+        /*
+          Or only what changed (version-delta-v1).
+    
+          The list above names every file in the project, so a save of one line
+          in a 6,628-file project sent 2.3 MB describing 6,627 files the service
+          already held exactly that way. When the service can take it, the save
+          names the version it started from, the paths that went, and only the
+          entries that differ from that version; the service fills in the rest
+          from its own record before it checks anything.
+        */
+        const startedFrom = typeof request.baseVersionId === "string" &&
+            prior.size &&
+            (await this.versionDeltaAllowed())
+            ? request.baseVersionId
+            : null;
+        const changesOnly = startedFrom
+            ? {
+                files: wire.filter((entry) => {
+                    const before = prior.get(entry.path);
+                    return !before || !sameEntry(entry, wireFromPrior(entry.path, before));
+                }),
+                filesFrom: {
+                    versionId: startedFrom,
+                    removed: [...prior.keys()].filter((held) => !named.has(held)),
+                },
+            }
+            : null;
+        const send = (asChanges) => (0, profile_js_1.timed)("publish the version", () => this.call(`/v1/repositories/${repositoryId}/versions`, {
             method: "POST",
             contentType: "application/json",
             body: JSON.stringify({
@@ -1057,27 +1125,21 @@ class Uploader {
                   One shape or the other, never both — the service refuses a file that
                   names an object and a chunk list, and so does its database.
                 */
-                files: contents.map((item) => ({
-                    path: item.path,
-                    ...(item.pack
-                        ? {
-                            pack: {
-                                objectId: item.pack.packObjectId,
-                                offset: item.pack.offset,
-                                length: item.pack.length,
-                            },
-                            sha256: item.sha256,
-                        }
-                        : item.chunks
-                            ? { chunks: item.chunks, sha256: item.sha256 }
-                            : { objectId: item.objectId }),
-                    sourceSize: item.sourceSize,
-                    storedSize: item.storedSize,
-                    mediaType: item.mediaType,
-                    executable: item.executable === true,
-                })),
+                ...(asChanges && changesOnly ? changesOnly : { files: wire }),
             }),
         }));
+        /*
+          A service that cannot build on the version named (it was taken down,
+          say) answers files_from_*; the whole list is then sent instead, which
+          every service accepts.
+        */
+        const completed = await send(true).catch((error) => {
+            const code = error.code;
+            if (changesOnly && typeof code === "string" && code.startsWith("files_from_")) {
+                return send(false);
+            }
+            throw error;
+        });
         /*
           A clean stale-base save may contain a server-side merge. The candidate
           manifest built above is then not the Version that landed: it lacks the
@@ -1086,8 +1148,21 @@ class Uploader {
           Version once rather than guessing.
         */
         let acceptedManifest = (0, publication_js_1.acceptedManifestDigests)(completed.manifest?.files);
-        if (!completed.mergeTrack && !Object.keys(acceptedManifest).length) {
-            acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id))].map(([file, descriptor]) => [file, descriptor.sha256]));
+        /*
+          A service that lists version-delta-v1 also says when it combined this
+          save with somebody else's (`combined`). Without that, and for a repeated
+          attempt, the version that landed may not be the list sent here, so it is
+          read back. Otherwise it is exactly that list, and reading 6,628 rows to
+          learn what was just sent is the third download this used to cost.
+        */
+        const landedAsSent = !completed.mergeTrack &&
+            !completed.repeated &&
+            !completed.combined &&
+            /* A key published on purpose is stored as its covered copy, not as sent. */
+            !request.allowSecrets &&
+            (await this.versionDeltaAllowed());
+        if (!completed.mergeTrack && !landedAsSent && !Object.keys(acceptedManifest).length) {
+            acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id, request.localPath))].map(([file, descriptor]) => [file, descriptor.sha256]));
         }
         const manifest = Object.keys(acceptedManifest).length
             ? acceptedManifest
@@ -1146,6 +1221,19 @@ class Uploader {
             if (held)
                 local[path] = held;
         }
+        /*
+          The next save starts from this version, so its listing is kept in the
+          folder now, from the list just sent — every entry with its digest — and
+          that save does not have to download it.
+        */
+        if (landedAsSent && request.localPath) {
+            const rows = wire.map((entry) => ({ ...entry, sha256: manifest[entry.path] }));
+            if (rows.every((row) => typeof row.sha256 === "string" && row.sha256.length === 64)) {
+                const key = `${repositoryId}/${completed.version.id}`;
+                versionListings.set(key, Promise.resolve(rows));
+                await writeListing(request.localPath, repositoryId, completed.version.id, rows);
+            }
+        }
         report({
             stage: "done",
             files: declarations.length,
@@ -2000,7 +2088,9 @@ class Uploader {
         });
     }
     /** What the newest version holds, so unchanged files can point at it. */
-    async versionFiles(repositoryId, versionId) {
+    async versionFiles(repositoryId, versionId, 
+    /** The project folder, whose `.coderook/versions` keeps listings between runs. */
+    localPath) {
         const held = new Map();
         try {
             // Explicit null is a genuinely empty base. Undefined belongs only to
@@ -2014,10 +2104,8 @@ class Uploader {
             }
             if (!wanted)
                 return held;
-            const body = await this.call(`/v1/repositories/${repositoryId}/versions/${wanted}/files`, {
-                method: "GET",
-            });
-            for (const row of body.files ?? []) {
+            const rows = await this.listing(repositoryId, wanted, localPath);
+            for (const row of rows) {
                 const pieces = Array.isArray(row.chunks)
                     ? row.chunks.map((chunk) => ({
                         objectId: String(chunk.objectId ?? ""),
@@ -2052,6 +2140,37 @@ class Uploader {
         }
         return held;
     }
+    /**
+     * A version's files, as the service lists them: from this process's memo,
+     * then the folder's own cache, and only then from the service.
+     *
+     * The folder cache is what makes the next save cheap: the version a save
+     * starts from is nearly always the one the previous save made, and that
+     * one is written here by the save that made it (rememberListing).
+     */
+    async listing(repositoryId, versionId, localPath) {
+        const key = `${repositoryId}/${versionId}`;
+        const known = versionListings.get(key);
+        if (known)
+            return known;
+        const reading = (async () => {
+            const cached = localPath
+                ? await readListing(localPath, repositoryId, versionId)
+                : null;
+            if (cached)
+                return cached;
+            const body = await this.call(`/v1/repositories/${repositoryId}/versions/${versionId}/files`, {
+                method: "GET",
+            });
+            const rows = body.files ?? [];
+            if (localPath)
+                await writeListing(localPath, repositoryId, versionId, rows);
+            return rows;
+        })();
+        versionListings.set(key, reading);
+        reading.catch(() => versionListings.delete(key));
+        return reading;
+    }
     /** The account's repository with this slug, if it has one. */
     async findBySlug(slug) {
         try {
@@ -2372,7 +2491,17 @@ class Uploader {
             return null;
         }
     }
-    async deltaSignature(repositoryId, baseVersionId, filePath, baseSha256, version) {
+    deltaSignature(repositoryId, baseVersionId, filePath, baseSha256, version) {
+        const key = [repositoryId, baseVersionId, filePath, baseSha256, version].join("\u0000");
+        const known = signatures.get(key);
+        if (known)
+            return known;
+        const asking = this.fetchDeltaSignature(repositoryId, baseVersionId, filePath, baseSha256, version);
+        signatures.set(key, asking);
+        asking.catch(() => signatures.delete(key));
+        return asking;
+    }
+    async fetchDeltaSignature(repositoryId, baseVersionId, filePath, baseSha256, version) {
         const token = await this.credentials.token();
         if (!token)
             throw new Error("Sign in again before uploading");
@@ -2841,6 +2970,20 @@ class Uploader {
                 : 0;
         return this.deltaProtocol;
     }
+    /**
+     * Whether a save may name only what changed (`filesFrom`).
+     *
+     * Asked, never assumed, and for a stronger reason than the others: a
+     * service that does not know the field would drop it and publish the
+     * changed files alone as the whole project. Only a service that lists
+     * `version-delta-v1` gets anything but the full list.
+     */
+    async versionDeltaAllowed() {
+        if (this.versionDeltaSupported !== null)
+            return this.versionDeltaSupported;
+        this.versionDeltaSupported = (await this.serviceFeatures()).includes("version-delta-v1");
+        return this.versionDeltaSupported;
+    }
     async deltaBatchAllowed() {
         if (this.deltaBatchSupported !== null)
             return this.deltaBatchSupported;
@@ -2975,3 +3118,84 @@ async function executableFor(request, relative, before) {
         return before;
     }
 }
+/*
+  The folder's cache of version listings: `.coderook/versions/<id>.json`.
+
+  `.coderook` is never uploaded and ignores itself, so this never reaches a
+  project. A version never changes, so an entry is either right or for a
+  different version; it is checked against both names it was written under,
+  and anything unreadable is simply not used.
+*/
+async function readListing(localPath, repositoryId, versionId) {
+    try {
+        const kept = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(localPath, ".coderook", "versions", `${versionId}.json`), "utf8"));
+        if (kept.repositoryId !== repositoryId ||
+            kept.versionId !== versionId ||
+            !Array.isArray(kept.files)) {
+            return null;
+        }
+        return kept.files;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeListing(localPath, repositoryId, versionId, files) {
+    const folder = node_path_1.default.join(localPath, ".coderook", "versions");
+    try {
+        await (0, promises_1.mkdir)(folder, { recursive: true });
+        await (0, promises_1.writeFile)(node_path_1.default.join(folder, `${versionId}.json`), JSON.stringify({ repositoryId, versionId, files }));
+        /* Only the newest few: the next save needs one, a retry another. */
+        const entries = await Promise.all((await (0, promises_1.readdir)(folder))
+            .filter((name) => name.endsWith(".json"))
+            .map(async (name) => ({
+            name,
+            at: (await (0, promises_1.stat)(node_path_1.default.join(folder, name))).mtimeMs,
+        })));
+        entries.sort((left, right) => right.at - left.at);
+        for (const old of entries.slice(KEPT_LISTINGS)) {
+            await (0, promises_1.rm)(node_path_1.default.join(folder, old.name), { force: true });
+        }
+    }
+    catch {
+        /* A cache that cannot be written costs one download next time, nothing more. */
+    }
+}
+/** A file the previous version holds, in the shape a save names it. */
+function wireFromPrior(filePath, held) {
+    return {
+        path: filePath,
+        ...(held.pack
+            ? {
+                pack: {
+                    objectId: held.pack.objectId,
+                    offset: held.pack.offset,
+                    length: held.pack.length,
+                },
+                sha256: held.sha256,
+            }
+            : held.chunks?.length
+                ? { chunks: held.chunks, sha256: held.sha256 }
+                : { objectId: held.objectId }),
+        sourceSize: held.sourceSize,
+        storedSize: held.storedSize,
+        mediaType: held.mediaType,
+        executable: held.executable === true,
+    };
+}
+/** Whether two entries name the same file stored the same way. */
+function sameEntry(left, right) {
+    return canonical(left) === canonical(right);
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.keys(value)
+            .filter((key) => value[key] !== undefined)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.34.8",
+  "version": "0.34.9",
   "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",