@coderook/cli 0.34.5 → 0.34.7

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

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

@@ -21,6 +21,7 @@ exports.LICENCE_FILE = exports.DEFAULT_LICENCE = exports.LICENCES = void 0;
 exports.licenceById = licenceById;
 exports.licenceText = licenceText;
 exports.detectLicence = detectLicence;
+exports.existingLicence = existingLicence;
 exports.licenceNewProject = licenceNewProject;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
@@ -281,6 +282,23 @@ function detectLicence(text) {
  *
  * Returns the licence written, or null when nothing was.
  */
+/*
+  The names a licence goes by, as a file or as a folder of them.
+
+  Only the exact name LICENSE was looked for, which missed nearly every way a
+  project actually carries its licence — LICENSE.md, LICENCE.txt, COPYING,
+  the LICENSE-MIT and LICENSE-APACHE pair, a licenses folder. Found by saving
+  a copy of Blender: its licences live in a folder called `license`, which on
+  Windows answers to "LICENSE" as well, so the check opened a directory and
+  the save failed. Had the folder been named anything else, the save would
+  have put an MIT licence beside Blender's GPL one.
+*/
+const LICENCE_NAME = /^(licen[cs]es?|copying|copyright|unlicen[cs]e)([-._ ].*)?$/i;
+/** The licence file or folder this folder already has, if any. */
+async function existingLicence(folder) {
+    const names = await (0, promises_1.readdir)(folder).catch(() => []);
+    return names.find((name) => LICENCE_NAME.test(name)) ?? null;
+}
 async function licenceNewProject(folder, holder, skip = false) {
     /*
       No name, no licence. A copyright line naming nobody is worse than the
@@ -289,10 +307,19 @@ async function licenceNewProject(folder, holder, skip = false) {
     */
     if (skip || !holder.trim())
         return null;
+    /* Any licence at all is somebody's decision, whatever it is called. */
+    if (await existingLicence(folder))
+        return null;
     const target = node_path_1.default.join(folder, exports.LICENCE_FILE);
-    const already = await (0, promises_1.readFile)(target, "utf8").catch(() => null);
-    if (already !== null)
+    /*
+      A nudge, never a reason to fail. A folder that cannot be written to is
+      saved without one, exactly as it would have been before this existed.
+    */
+    try {
+        await (0, promises_1.writeFile)(target, licenceText(exports.DEFAULT_LICENCE, holder.trim()), { encoding: "utf8", flag: "wx" });
+    }
+    catch {
         return null;
-    await (0, promises_1.writeFile)(target, licenceText(exports.DEFAULT_LICENCE, holder.trim()), "utf8");
+    }
     return exports.DEFAULT_LICENCE;
 }

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

@@ -180,6 +180,8 @@ class Uploader {
         return new Map(this.plannedDigests);
     }
     planningCreatedRepositoryId = null;
+    /** Set once the send has begun to move objects; see execute. */
+    sendingBegan = false;
     /** Attached to every object write after the server admits the exact plan. */
     activeQuoteId = null;
     constructor(credentials) {
@@ -409,9 +411,22 @@ class Uploader {
     /** Execute a still-active quote produced by {@link plan}. */
     async execute(request, plan, report) {
         this.activeQuoteId = plan.quoteId;
+        this.sendingBegan = false;
         try {
             return await this.runPass({ ...request, repositoryId: plan.repositoryId }, report);
         }
+        catch (error) {
+            /*
+              A first save that stops before a single object has moved leaves no
+              project behind. The plan created it, and it used to stay — empty, at
+              v0 — after a refusal that had just said nothing was changed. Once
+              objects have gone up it stays, because a retry reuses them.
+            */
+            if (plan.repositoryCreated && !this.sendingBegan) {
+                await this.cancelPlan(plan, true).catch(() => undefined);
+            }
+            throw error;
+        }
         finally {
             this.activeQuoteId = null;
         }
@@ -609,6 +624,17 @@ class Uploader {
         const HASH_LANES = 8;
         const measured = new Array(sending.length).fill(null);
         let hashed = 0;
+        /*
+          Files whose bytes are no longer the bytes the plan priced.
+    
+          The service holds a save to what its plan named, so a file written to
+          between the plan and the send went up as an object nobody had asked
+          for and was refused as "a file that was not part of what it asked to
+          send", with advice to update the app. Found by saving a folder while a
+          program appended to a text file in it. Caught here instead, before
+          anything is sent, and named for what it is.
+        */
+        const changedSincePlan = [];
         let cursor = 0;
         /** Throttled: twenty thousand sends is its own cost, and nobody reads them. */
         let told = 0;
@@ -691,6 +717,7 @@ class Uploader {
                   and a match there means the digest already taken still describes the
                   bytes. Reading is what costs; deciding not to read is free.
                 */
+                const fromPlan = this.planning ? undefined : this.plannedDigests.get(file.path);
                 const remembered = this.plannedDigests.get(file.path) ??
                     request.knownDigests?.get(file.path);
                 if (remembered &&
@@ -722,6 +749,8 @@ class Uploader {
                     hashed += 1;
                     continue;
                 }
+                if (fromPlan && fromPlan.sha256 !== digest)
+                    changedSincePlan.push(file.path);
                 this.plannedDigests.set(file.path, { size, mtimeMs, sha256: digest });
                 measured[index] = {
                     path: file.path,
@@ -752,6 +781,16 @@ class Uploader {
         if (!declarations.length && !deletions.size) {
             throw new Error("Nothing is selected to upload");
         }
+        if (changedSincePlan.length) {
+            const one = changedSincePlan.length === 1;
+            const shown = changedSincePlan.slice(0, 5).join(", ");
+            const rest = changedSincePlan.length > 5 ? ` and ${changedSincePlan.length - 5} more` : "";
+            throw new Error(`${changedSincePlan.length} file${one ? "" : "s"} changed while the save was running, ` +
+                `so nothing was sent: ${shown}${rest}. Something is still writing to ${one ? "it" : "them"}. ` +
+                `Save again once ${one ? "it has" : "they have"} stopped changing, or leave ${one ? "it" : "them"} ` +
+                `out — untick ${one ? "it" : "them"} in the app, or add ${one ? "it" : "them"} to .gitignore. ` +
+                `Nothing was changed on your account.`);
+        }
         return { declarations, totalBytes };
     }
     /**
@@ -809,6 +848,66 @@ class Uploader {
      * that did not arrive, while past here there is a version. Keeping the
      * boundary a function call rather than a comment makes that legible.
      */
+    /**
+     * Refuse a save that would leave out files somebody chose, naming why.
+     *
+     * Called as soon as the reading is done as well as before the version is
+     * named. Only the second existed, after the plan had already created the
+     * project, so a first save refused for one locked file left an empty
+     * project behind while saying "Nothing was changed on your account".
+     */
+    refuseUnreadable(dropped, readFailures) {
+        const shown = dropped.slice(0, 5).join(", ");
+        const rest = dropped.length > 5 ? ` and ${dropped.length - 5} more` : "";
+        const details = dropped
+            .map((name) => readFailures.get(name) ? `${name}: ${readFailures.get(name)}` : "")
+            .filter(Boolean)
+            .slice(0, 3)
+            .join("; ");
+        /*
+          Say what to do about it. Refusing is right — a version quietly missing
+          a file somebody chose is the one failure a backup tool must never have
+          — but the message stopped at the refusal, and the person is left with
+          a list of paths and no idea that the fix is either closing whatever
+          holds them or unticking them. Almost every case is a file another
+          program has open, so that is what it says.
+        */
+        /*
+          Each cause named for what it is. Every failure used to be put down to
+          "another program may have a file open", which was wrong for a file
+          this account may not read and for one deleted mid-save, and "untick"
+          means nothing on the command line, where there is nothing to tick.
+          Found by saving a folder with one file held open and one with
+          reading denied.
+        */
+        const reasonOf = (name) => readFailures.get(name) ?? "";
+        const causes = new Set(dropped.map((name) => {
+            const reason = reasonOf(name);
+            if (reason.includes("ignore rules"))
+                return "ignored";
+            if (/EACCES|EPERM|permission|access is denied/i.test(reason))
+                return "permission";
+            if (/ENOENT|no such file/i.test(reason))
+                return "gone";
+            return "busy";
+        }));
+        const said = [];
+        if (causes.has("busy"))
+            said.push("Another program has a file open: close it.");
+        if (causes.has("permission"))
+            said.push("This account is not allowed to read a file: change its permissions.");
+        if (causes.has("gone"))
+            said.push("A file was deleted or moved while the save was running.");
+        if (causes.has("ignored"))
+            said.push("A file is excluded by the project's ignore rules: change the rules.");
+        throw new Error(`${dropped.length} selected file${dropped.length === 1 ? "" : "s"} could not be included, ` +
+            `so nothing was saved: ${shown}${rest}. ` +
+            `${said.join(" ")} Or leave ${dropped.length === 1 ? "it" : "them"} out — untick ` +
+            `${dropped.length === 1 ? "it" : "them"} in the app, or add ${dropped.length === 1 ? "it" : "them"} ` +
+            `to .gitignore — and save again. ` +
+            `Nothing was changed on your account.` +
+            (details ? ` Details: ${details}` : ""));
+    }
     async publishVersion(at) {
         const { request, repositoryId, declarations, uploaded, reused, prior, everything, ticked, deletions, readFailures, vanished, totalBytes, progress, report, } = at;
         // 4. Name the version, which is what makes the upload visible.
@@ -837,7 +936,7 @@ class Uploader {
         const contents = [
             ...uploaded,
             ...reused.map((file) => {
-                const held = prior.get(file.path);
+                const held = file.storedAs ?? prior.get(file.path);
                 /*
                   Republished in the shape it was already stored in. A file kept in
                   pieces names the same pieces; flattening it to one object here would
@@ -872,7 +971,7 @@ class Uploader {
                             : { objectId: held.objectId }),
                     sourceSize: held.sourceSize,
                     storedSize: held.storedSize,
-                    mediaType: held.mediaType,
+                    mediaType: file.mediaType,
                     executable: request.executable?.get(file.path) ?? held.executable,
                 };
             }),
@@ -899,31 +998,8 @@ class Uploader {
                 ...[...ticked].filter((chosen) => !named.has(chosen) && !deletions.has(chosen)),
             ]),
         ];
-        if (dropped.length) {
-            const shown = dropped.slice(0, 5).join(", ");
-            const rest = dropped.length > 5 ? ` and ${dropped.length - 5} more` : "";
-            const details = dropped
-                .map((name) => readFailures.get(name) ? `${name}: ${readFailures.get(name)}` : "")
-                .filter(Boolean)
-                .slice(0, 3)
-                .join("; ");
-            /*
-              Say what to do about it. Refusing is right — a version quietly missing
-              a file somebody chose is the one failure a backup tool must never have
-              — but the message stopped at the refusal, and the person is left with
-              a list of paths and no idea that the fix is either closing whatever
-              holds them or unticking them. Almost every case is a file another
-              program has open, so that is what it says.
-            */
-            const excluded = dropped.some((name) => readFailures.get(name)?.includes("ignore rules"));
-            throw new Error(`${dropped.length} selected file${dropped.length === 1 ? "" : "s"} could not be included, ` +
-                `so nothing was saved: ${shown}${rest}. ` +
-                (excluded
-                    ? `At least one is excluded by the project's ignore rules. Change the rules or untick it and try again. `
-                    : `Another program may have a file open. Close it or untick the file and try again. `) +
-                `Nothing was changed on your account.` +
-                (details ? ` Details: ${details}` : ""));
-        }
+        if (dropped.length)
+            this.refuseUnreadable(dropped, readFailures);
         const sourceBytes = contents.reduce((total, item) => total + item.sourceSize, 0);
         const storedBytes = contents.reduce((total, item) => total + item.storedSize, 0);
         /*
@@ -932,6 +1008,11 @@ class Uploader {
           objects are immutable and content-addressed, so a retry reuses them.
         */
         (0, faults_js_1.maybeFail)("submit:after-objects");
+        const counted = request.countLines
+            ? await (0, profile_js_1.timed)("count the changed lines", () => request.countLines()).catch(() => null)
+            : 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`, {
             method: "POST",
             contentType: "application/json",
@@ -950,10 +1031,8 @@ class Uploader {
                 ...(request.allowIgnored ? { allowIgnored: true } : {}),
                 ...(this.trackedByGit.length ? { trackedByGit: this.trackedByGit } : {}),
                 ...(request.allowSecrets ? { allowSecrets: true } : {}),
-                ...(request.linesAdded === undefined ? {} : { linesAdded: request.linesAdded }),
-                ...(request.linesRemoved === undefined
-                    ? {}
-                    : { linesRemoved: request.linesRemoved }),
+                ...(linesAdded === undefined ? {} : { linesAdded }),
+                ...(linesRemoved === undefined ? {} : { linesRemoved }),
                 /*
                   Names this attempt so a retry after a lost connection is answered
                   with the version already made, rather than making a second one.
@@ -1013,7 +1092,7 @@ class Uploader {
         const manifest = Object.keys(acceptedManifest).length
             ? acceptedManifest
             : {
-                ...Object.fromEntries(reused.map((file) => [file.path, prior.get(file.path).sha256])),
+                ...Object.fromEntries(reused.map((file) => [file.path, (file.storedAs ?? prior.get(file.path)).sha256])),
                 ...Object.fromEntries(declarations.map((declaration) => [declaration.path, declaration.sha256])),
             };
         /*
@@ -1028,6 +1107,16 @@ class Uploader {
           the very end of a save.
         */
         const sentDigest = new Map(declarations.map((declaration) => [declaration.path, declaration.sha256]));
+        /*
+          A file named from bytes already stored, at a path the last version did
+          not have, holds those bytes here too. Without this a renamed folder was
+          saved correctly and then reported as "behind" file by file, because this
+          record looked its old digest up by its new path and found nothing.
+        */
+        for (const file of reused) {
+            if (file.storedAs)
+                sentDigest.set(file.path, file.storedAs.sha256);
+        }
         const onDisk = new Set(everything.map((file) => file.path));
         const local = Object.fromEntries(everything.flatMap((file) => {
             const sent = sentDigest.get(file.path);
@@ -1101,6 +1190,8 @@ class Uploader {
      * rather than before.
      */
     async sendObjects(at) {
+        if (!this.planning)
+            this.sendingBegan = true;
         const { request, repositoryId, prior, 
         /*
           Bound under a distinct name on purpose. `runSection` declares its own
@@ -1155,6 +1246,22 @@ class Uploader {
           question rather than a transfer.
         */
         const inFlightByDigest = new Map();
+        /*
+          What the account already holds, asked once for the whole save.
+    
+          Asked per section, the answer changed under the save's feet. The plan
+          stores nothing, so every section of the plan heard the same answer; the
+          send stores as it goes and runs sections side by side, so a later
+          section holding a copy of a file an earlier one had just sent heard
+          "already held" and left it out of its pack. The pack's bytes, and so its
+          digest, were then not the pack the plan had priced, and the service
+          refused it as "a file that was not part of what it asked to send". A
+          copy of Blender 4.5 — 326 contents present more than once — failed this
+          way every time. One answer, taken before anything is sent, is the answer
+          the plan was given.
+        */
+        let heldOnce = null;
+        const heldAtStart = () => (heldOnce ??= (0, profile_js_1.timed)("ask what is already held", () => this.storedInBulk(repositoryId, everyDeclaration.map((one) => one.sha256))));
         const runSection = async (section) => {
             const declarations = section.files.map((file) => declarationByPath.get(file.path));
             /*
@@ -1214,7 +1321,7 @@ class Uploader {
             asking took longer than the transfer. The answer per digest is a boolean
             and an identifier, so the whole question fits in one request.
           */
-            const alreadyHeld = await (0, profile_js_1.timed)("ask what is already held", () => this.storedInBulk(repositoryId, declarations.map((one) => one.sha256)));
+            const alreadyHeld = await heldAtStart();
             /*
               The small files go first, packed together.
         
@@ -1689,6 +1796,12 @@ class Uploader {
           than from the disk.
         */
         const hashed = await this.hashSelection(request, sending, deletions, readFailures, vanished, report);
+        /*
+          Before the project is created or anything priced: see refuseUnreadable.
+          `vanished` holds every chosen file that is gone or could not be read.
+        */
+        if (vanished.length)
+            this.refuseUnreadable([...new Set(vanished)], readFailures);
         /*
           A file that is exactly what the last version held is kept, not sent.
     
@@ -1704,31 +1817,48 @@ class Uploader {
           same bytes, and the previous version's object for them — a pack slice,
           its chunks, or a plain object — is named again instead.
         */
-        const keptAsItWas = (declaration) => {
+        const stored = (was) => !!was && !!(was.pack?.objectId || was.chunks?.length || was.objectId);
+        /*
+          Matched by what a file is, not only by where it sits.
+    
+          Same path and same bytes was the only reuse, so renaming a folder sent
+          every file in it again: the service recognises a stored object by its
+          digest but not a slice of a pack, and small files live in packs. Moving
+          a 2,192-file folder in a copy of the Cheat Engine sources re-sent all of
+          it, 5.5 MB, to record bytes the project already held. Any file in the
+          previous version with the same digest is the same bytes, wherever it was.
+        */
+        const priorByDigest = new Map();
+        for (const was of prior.values()) {
+            if (stored(was) && !priorByDigest.has(was.sha256))
+                priorByDigest.set(was.sha256, was);
+        }
+        const storedAs = (declaration) => {
             const was = prior.get(declaration.path);
-            return (!!was &&
-                was.sha256 === declaration.sha256 &&
-                !deletions.has(declaration.path) &&
-                !!(was.pack?.objectId || was.chunks?.length || was.objectId));
+            if (stored(was) && was.sha256 === declaration.sha256)
+                return was;
+            return priorByDigest.get(declaration.sha256) ?? null;
         };
+        const keptAsItWas = (declaration) => storedAs(declaration) !== null;
         const declarations = hashed.declarations.filter((one) => !keptAsItWas(one));
         let totalBytes = hashed.totalBytes;
         for (const one of hashed.declarations) {
-            if (!keptAsItWas(one))
+            const held = storedAs(one);
+            if (!held)
                 continue;
             totalBytes -= one.size;
-            const held = prior.get(one.path);
             reused.push({
                 path: one.path,
                 sourceSize: held.sourceSize,
                 storedSize: held.storedSize,
-                mediaType: held.mediaType,
+                mediaType: one.mediaType,
                 added: 0,
                 removed: 0,
                 included: true,
                 deleted: false,
                 binary: false,
                 lines: 0,
+                ...(held === prior.get(one.path) ? {} : { storedAs: held }),
             });
         }
         (0, profile_js_1.counted)("files kept as they were", hashed.declarations.length - declarations.length);

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

@@ -33,6 +33,7 @@ exports.detectPrivateDirectories = detectPrivateDirectories;
 exports.detectPastedCredentials = detectPastedCredentials;
 exports.uploadConcerns = uploadConcerns;
 exports.isCredentialByName = isCredentialByName;
+exports.holdsOnlyCertificates = holdsOnlyCertificates;
 exports.detectSecrets = detectSecrets;
 /** Reading a project folder: changed files, diffs, and rule measurement. */
 const node_child_process_1 = require("node:child_process");
@@ -1737,6 +1738,13 @@ onScanned) {
     const wanted = include.filter((relative) => (0, secret_patterns_js_1.worthReading)(relative.slice(relative.lastIndexOf("/") + 1)));
     let cursor = 0;
     let stop = false;
+    /*
+      Every file looked at, read or passed over for its size. Reporting only
+      those read left the count short of its own total: a refused save of
+      Blender stopped on "3700 of 3747 files", which reads as a scan that gave
+      up rather than one that finished.
+    */
+    let looked = 0;
     const lane = async () => {
         for (;;) {
             if (stop)
@@ -1745,6 +1753,9 @@ onScanned) {
             cursor += 1;
             if (at >= wanted.length)
                 return;
+            looked += 1;
+            if (onScanned && looked % 50 === 0)
+                onScanned(looked, wanted.length);
             if (found.length >= MOST_FINDINGS) {
                 stop = true;
                 return;
@@ -1768,8 +1779,6 @@ onScanned) {
             }
             read += 1;
             bytes += contents.byteLength;
-            if (onScanned && read % 50 === 0)
-                onScanned(read, wanted.length);
             if (!(0, secret_patterns_js_1.looksLikeText)(contents))
                 continue;
             const credentials = (0, secret_patterns_js_1.findCredentials)(contents.toString("utf8"));
@@ -1778,6 +1787,8 @@ onScanned) {
         }
     };
     await Promise.all(Array.from({ length: Math.min(LANES, wanted.length) }, () => lane()));
+    if (onScanned && wanted.length)
+        onScanned(looked, wanted.length);
     /*
       `stop` is also set by the findings ceiling, which is a different statement
       from running out of budget — forty findings is plenty to act on, and the
@@ -1847,6 +1858,38 @@ function isCredentialByName(relativePath) {
         SECRET_SUFFIXES.some((suffix) => name.endsWith(suffix)) ||
         parts.slice(0, -1).includes("secrets"));
 }
+/*
+  A `.pem` is a container, not a kind of file.
+
+  It holds a private key as readily as a certificate, and the name cannot
+  tell the two apart — so every one was refused. That refused Blender: its
+  bundled Python carries `certifi/cacert.pem` twice, Mozilla's list of the
+  certificate authorities a program should trust, which ships inside every
+  pip there is and is public by design. A certificate is the half of a key
+  pair that exists to be handed out.
+
+  So a `.pem` is opened and judged by its blocks. Only certificates (and
+  revocation lists) clear it; a private key anywhere in it, a block of any
+  other kind, no blocks at all, or a file too large or unreadable to look
+  at all leave it a credential, as before.
+*/
+const CERTIFICATE_BUNDLE_LIMIT = 4 * 1024 * 1024;
+async function holdsOnlyCertificates(full) {
+    try {
+        const info = await (0, promises_1.stat)(full);
+        if (info.size > CERTIFICATE_BUNDLE_LIMIT)
+            return false;
+        const text = await (0, promises_1.readFile)(full, "latin1");
+        if (/PRIVATE KEY/i.test(text))
+            return false;
+        const blocks = text.match(/-----BEGIN [A-Z0-9 ]+-----/g) ?? [];
+        return (blocks.length > 0 &&
+            blocks.every((block) => /^-----BEGIN (TRUSTED |X509 )?(CERTIFICATE|CRL)-----$/.test(block)));
+    }
+    catch {
+        return false;
+    }
+}
 async function detectSecrets(root) {
     const found = [];
     let seen = 0;
@@ -1896,8 +1939,12 @@ async function detectSecrets(root) {
                       that templates are not credentials.
                     */
                     const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
-                    if (isCredentialByName(relative))
-                        found.push(relative);
+                    if (!isCredentialByName(relative))
+                        continue;
+                    if (entry.name.toLowerCase().endsWith(".pem") && (await holdsOnlyCertificates(full))) {
+                        continue;
+                    }
+                    found.push(relative);
                 }
             }
         };

package/dist/cli/src/cli.js

@@ -376,7 +376,7 @@ async function commandProjects() {
     const width = Math.max(...all.map((project) => project.slug.length));
     for (const project of all) {
         console.log(`${accent(project.slug.padEnd(width))}  v${String(project.versionCount).padEnd(4)}` +
-            `${String(project.fileCount).padStart(6)} files  ${bytes(project.storedBytes).padStart(9)}` +
+            `${String(project.fileCount).padStart(6)} ${project.fileCount === 1 ? "file " : "files"}  ${bytes(project.storedBytes).padStart(9)}` +
             `  ${dim(project.visibility)}`);
     }
     return 0;
@@ -454,7 +454,7 @@ async function commandStatus(parsed) {
     const files = found.filter((file) => !file.deleted);
     console.log(bold(node_path_1.default.basename(folder)) + dim(`  ${folder}`));
     console.log(link
-        ? `Account holds ${accent(`v${link.sequence}`)} · ${Object.keys(link.manifest).length} files ${dim(`(${link.slug})`)}`
+        ? `Account holds ${accent(`v${link.sequence}`)} · ${Object.keys(link.manifest).length} ${Object.keys(link.manifest).length === 1 ? "file" : "files"} ${dim(`(${link.slug})`)}`
         : dim("This folder is not linked to a project."));
     if (!link) {
         const likes = (0, folder_match_js_1.similarProjects)(await (0, api_js_2.projects)().catch(() => []), node_path_1.default.basename(folder));
@@ -574,8 +574,10 @@ async function commandStatus(parsed) {
         return 0;
     }
     console.log(`\n${files.length} file${files.length === 1 ? "" : "s"} to submit:`);
+    /* New is not changed: a file the saved version never had was listed as "changed". */
     for (const file of files.slice(0, 50)) {
-        console.log(`  ${accent("changed")}  ${file.path}`);
+        const fresh = !baseline?.has(file.path);
+        console.log(`  ${fresh ? green("new    ") : accent("changed")}  ${file.path}`);
     }
     if (files.length > 50)
         console.log(dim(`  …and ${files.length - 50} more`));
@@ -728,13 +730,14 @@ async function digestOfFile(full) {
  */
 function noteKeptDeletions(folder, baseline, syncing) {
     if (syncing || !baseline?.size)
-        return;
+        return 0;
     const gone = [...baseline.keys()].filter((file) => !(0, node_fs_1.existsSync)(node_path_1.default.join(folder, ...file.split("/"))));
     if (!gone.length)
-        return;
+        return 0;
     console.log(dim(`${gone.length} file${gone.length === 1 ? "" : "s"} deleted here ${gone.length === 1 ? "is" : "are"} still in the saved version` +
         ` (${gone.slice(0, 3).join(", ")}${gone.length > 3 ? ", …" : ""}). A save adds and updates;` +
         ` run cbx submit --sync to remove ${gone.length === 1 ? "it" : "them"}.`));
+    return gone.length;
 }
 /*
   The service names each clash by its kind ("text_region", "add_add", …).
@@ -914,6 +917,20 @@ async function commandSubmit(parsed) {
         }
     }
     if (!files.length) {
+        /*
+          Deleted files are not "nothing". A plain save never removes, so a
+          folder with 1,723 files deleted from it was told it "matches the saved
+          version" straight after status had listed every one of them — found by
+          deleting a folder from a copy of the Cheat Engine sources.
+        */
+        if (!hasFlag(parsed, "sync")) {
+            const kept = [...(baseline?.keys() ?? [])].some((file) => !(0, node_fs_1.existsSync)(node_path_1.default.join(folder, ...file.split("/"))));
+            if (kept) {
+                console.log("Nothing new to submit.");
+                noteKeptDeletions(folder, baseline, false);
+                return 0;
+            }
+        }
         // Having nothing to send is not the same as holding the whole version:
         // a merge can leave this folder with an older copy of somebody else's
         // file. Saying so is what stops "nothing to do" from reading as "level".
@@ -1263,7 +1280,7 @@ The connection failed: ${text}`));
         */
         console.log(`\nSomebody else saved first, and ${result.mergeTrack.conflicts.length === 1
             ? "one file overlaps"
-            : `${result.mergeTrack.conflicts.length} files overlap`}.`);
+            : `${result.mergeTrack.conflicts.length} ${result.mergeTrack.conflicts.length === 1 ? "file overlaps" : "files overlap"}`}.`);
         console.log(`Your work is complete and kept as ${accent(result.mergeTrack.reference)}:`);
         for (const conflict of result.mergeTrack.conflicts.slice(0, 20)) {
             console.log(`  ${red(conflict.path)}  ${dim(conflictWords(conflict.kind))}`);

package/dist/cli/src/mcp.js

@@ -136,7 +136,7 @@ const TOOLS = [
             if (!saved.length)
                 return "No versions saved yet.";
             return saved
-                .map((one) => `v${one.sequence}  ${one.createdAt.slice(0, 10)}  ${one.fileCount} files  ` +
+                .map((one) => `v${one.sequence}  ${one.createdAt.slice(0, 10)}  ${one.fileCount} ${one.fileCount === 1 ? "file" : "files"}  ` +
                 `${bytes(one.storedSize)}  ${one.message || "(no message)"}`)
                 .join("\n");
         },
@@ -167,7 +167,7 @@ const TOOLS = [
             if (files.length > shown.length) {
                 lines.push(`… and ${files.length - shown.length} more`);
             }
-            return `v${version.sequence} · ${files.length} files\n${lines.join("\n")}`;
+            return `v${version.sequence} · ${files.length} ${files.length === 1 ? "file" : "files"}\n${lines.join("\n")}`;
         },
     },
     {

package/dist/cli/src/project_commands.js

@@ -385,7 +385,7 @@ async function commandVersions(parsed) {
             ...version.labels.map((label) => (0, colour_js_1.accent)(label.name)),
         ].filter(Boolean);
         console.log(`  ${(0, colour_js_1.accent)(`v${version.sequence}`).padEnd(16)} ${when.padEnd(22)}` +
-            `${String(version.fileCount).padStart(5)} files  ${bytes(version.storedSize)}` +
+            `${String(version.fileCount).padStart(5)} ${version.fileCount === 1 ? "file " : "files"}  ${bytes(version.storedSize)}` +
             (marks.length ? `  ${marks.join(" ")}` : ""));
         if (version.message)
             console.log(`    ${(0, colour_js_1.dim)(version.message)}`);

package/dist/cli/src/service_commands.js

@@ -569,7 +569,8 @@ async function commandDelete(parsed) {
     if (!project)
         return 1;
     if (parsed.flags.get("yes") !== true) {
-        console.log(`This deletes ${(0, colour_js_1.bold)(project.name)} — ${project.versionCount} versions, ` +
+        console.log(`This deletes ${(0, colour_js_1.bold)(project.name)} — ${project.versionCount} ` +
+            `${project.versionCount === 1 ? "version" : "versions"}, ` +
             `${bytes(project.storedBytes)}.`);
         console.log((0, colour_js_1.dim)("It is kept for 30 days before the storage is reclaimed."));
         const prompt = (0, promises_1.createInterface)({

package/package.json

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