@coderook/cli 0.34.2 → 0.34.4

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

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

@@ -1081,6 +1081,16 @@ class Uploader {
                 shown = count;
             return shown;
         };
+        /*
+          Identical files are one upload.
+    
+          A folder holding two copies of the same file declares it twice, and both
+          copies used to go up in full: side by side in one batch, or in two lanes
+          at the same moment. The second copy now waits for the first to finish,
+          after which the service already holds the bytes and the copy costs a
+          question rather than a transfer.
+        */
+        const sending = new Map();
         const runSection = async (section) => {
             const declarations = section.files.map((file) => declarationByPath.get(file.path));
             /*
@@ -1151,6 +1161,17 @@ class Uploader {
             */
             const missing = declarations.filter((one) => !alreadyHeld.has(one.sha256));
             const smallOnes = missing.filter((one) => one.size <= BATCH_FILE_LIMIT);
+            /* The first file with each digest is sent; the rest are counted when it lands. */
+            const copiesOf = new Map();
+            const smallUnique = smallOnes.filter((one) => {
+                const copies = copiesOf.get(one.sha256);
+                if (copies) {
+                    copies.push(one);
+                    return false;
+                }
+                copiesOf.set(one.sha256, []);
+                return true;
+            });
             // 3. Send the objects.
             /*
               What was sent, in whichever shape it was sent. A small file is one
@@ -1177,7 +1198,7 @@ class Uploader {
                     (0, profile_js_1.counted)("files sent as deltas", 1);
                 }
             }
-            const smallForPacking = smallOnes.filter((one) => !batched.has(one.sha256));
+            const smallForPacking = smallUnique.filter((one) => !batched.has(one.sha256));
             if (smallForPacking.length > 1) {
                 let pack = [];
                 let packBytes = 0;
@@ -1281,6 +1302,8 @@ class Uploader {
                             if (!batched.has(digest) && !packedInto.has(digest))
                                 continue;
                             progress.finished(item.declaration.size, exactWireBytes === null ? item.encoded.body.byteLength : 0);
+                            for (const copy of copiesOf.get(digest) ?? [])
+                                progress.finished(copy.size, 0);
                         }
                         if (exactWireBytes !== null)
                             progress.finished(0, exactWireBytes);
@@ -1336,121 +1359,51 @@ class Uploader {
             const queue = declarations.entries();
             const runWorker = async () => {
                 for (const [index, declaration] of queue) {
-                    this.check();
-                    report({
-                        stage: "upload",
-                        files: advance(index),
-                        totalFiles: everyDeclaration.length,
-                        bytes: progress.bytes(),
-                        totalBytes,
-                        path: declaration.path,
-                        percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
-                        bytesPerSecond: progress.rate(),
-                    });
-                    /*
-                      Content the service already holds does not need sending. Asking costs
-                      one round trip and saves the whole file — which after an interrupted
-                      save is the difference between re-uploading a project and re-uploading
-                      nothing.
-                    */
-                    /*
-                      A large file goes up in pieces, cut where its own content says.
-              
-                      This is what CBX is for and what it was never doing on the wire. The
-                      boundaries come from the same chunker the .cbx bundle uses, so an
-                      edit in the middle of a large file leaves the chunks either side of it
-                      untouched — and an untouched chunk is one the service already holds,
-                      which costs a question rather than a transfer. A small file is left
-                      whole: cutting it up would trade one request for several and save
-                      nothing.
-                    */
-                    const chunkProfile = (await this.microchunkAllowed())
-                        ? (0, chunking_js_1.microchunkProfileForFileSize)(declaration.size)
-                        : (0, chunking_js_1.profileForFileSize)(declaration.size);
-                    if (chunkProfile &&
-                        declaration.size >= CHUNK_THRESHOLD &&
-                        (await this.chunkingAllowed())) {
-                        const pieces = await this.putChunked(repositoryId, declaration, chunkProfile, (offset) => {
-                            progress.lane(index, offset);
-                            report({
-                                stage: "upload",
-                                files: advance(index),
-                                totalFiles: everyDeclaration.length,
-                                bytes: progress.bytes(),
-                                totalBytes,
-                                path: declaration.path,
-                                percent: 20 +
-                                    Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
-                                bytesPerSecond: progress.rate(),
-                            });
-                        });
-                        progress.laneDone(index);
-                        /*
-                          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)
-                            progress.alreadyHeld();
-                        uploaded.push({
-                            path: declaration.path,
-                            sha256: declaration.sha256,
-                            chunks: pieces.chunks,
-                            sourceSize: declaration.size,
-                            storedSize: pieces.chunks.reduce((sum, one) => sum + one.storedSize, 0),
-                            mediaType: declaration.mediaType,
-                        });
-                        progress.finished(declaration.size, pieces.sentBytes);
-                        continue;
+                    const earlier = sending.get(declaration.sha256);
+                    if (earlier)
+                        await earlier;
+                    let release = () => { };
+                    if (!earlier) {
+                        sending.set(declaration.sha256, new Promise((done) => {
+                            release = done;
+                        }));
                     }
-                    const fromPack = packedInto.get(declaration.sha256);
-                    if (fromPack) {
-                        uploaded.push({
-                            path: declaration.path,
-                            sha256: declaration.sha256,
-                            pack: fromPack,
-                            sourceSize: declaration.size,
-                            /* Its share of the pack, so the version's totals stay honest. */
-                            storedSize: fromPack.storedSize,
-                            mediaType: declaration.mediaType,
-                        });
-                        continue;
-                    }
-                    const fromBatch = batched.get(declaration.sha256);
-                    if (fromBatch) {
-                        uploaded.push({
+                    try {
+                        this.check();
+                        report({
+                            stage: "upload",
+                            files: advance(index),
+                            totalFiles: everyDeclaration.length,
+                            bytes: progress.bytes(),
+                            totalBytes,
                             path: declaration.path,
-                            objectId: fromBatch.objectId,
-                            sourceSize: declaration.size,
-                            storedSize: fromBatch.size,
-                            mediaType: declaration.mediaType,
+                            percent: 20 + Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                            bytesPerSecond: progress.rate(),
                         });
-                        continue;
-                    }
-                    const alreadyStored = alreadyHeld.get(declaration.sha256) ??
                         /*
-                          Only asked individually when the batch did not cover it — a digest
-                          that changed after the bulk question, because the file was rewritten
-                          while this upload was running.
+                          Content the service already holds does not need sending. Asking costs
+                          one round trip and saves the whole file — which after an interrupted
+                          save is the difference between re-uploading a project and re-uploading
+                          nothing.
                         */
-                        (await this.findStored(repositoryId, declaration));
-                    if (alreadyStored)
-                        progress.alreadyHeld();
-                    const result = alreadyStored ??
-                        (declaration.size <= DIRECT_LIMIT
-                            ? await (0, profile_js_1.timed)("send files one at a time", () => this.putDirect(repositoryId, declaration)).catch((error) => {
-                                // Naming the file turns "it failed" into something actionable.
-                                const reason = error instanceof Error ? error.message : String(error);
-                                throw new Error(`${declaration.path}: ${reason}`);
-                            })
-                            : await this.putMultipart(repositoryId, declaration, (offset) => {
-                                /*
-                                  Recorded before the report reads it. Without this the bar does
-                                  not move at all during a multipart file: `bytes()` sums the
-                                  settled total and the open lanes, and this lane's offset is
-                                  only in the second of those once it has been set.
-                                */
+                        /*
+                          A large file goes up in pieces, cut where its own content says.
+                  
+                          This is what CBX is for and what it was never doing on the wire. The
+                          boundaries come from the same chunker the .cbx bundle uses, so an
+                          edit in the middle of a large file leaves the chunks either side of it
+                          untouched — and an untouched chunk is one the service already holds,
+                          which costs a question rather than a transfer. A small file is left
+                          whole: cutting it up would trade one request for several and save
+                          nothing.
+                        */
+                        const chunkProfile = (await this.microchunkAllowed())
+                            ? (0, chunking_js_1.microchunkProfileForFileSize)(declaration.size)
+                            : (0, chunking_js_1.profileForFileSize)(declaration.size);
+                        if (chunkProfile &&
+                            declaration.size >= CHUNK_THRESHOLD &&
+                            (await this.chunkingAllowed())) {
+                            const pieces = await this.putChunked(repositoryId, declaration, chunkProfile, (offset) => {
                                 progress.lane(index, offset);
                                 report({
                                     stage: "upload",
@@ -1463,16 +1416,100 @@ class Uploader {
                                         Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
                                     bytesPerSecond: progress.rate(),
                                 });
-                            }));
-                    progress.laneDone(index);
-                    uploaded.push({
-                        path: declaration.path,
-                        objectId: result.objectId,
-                        sourceSize: declaration.size,
-                        storedSize: result.size,
-                        mediaType: declaration.mediaType,
-                    });
-                    progress.finished(declaration.size, alreadyStored ? 0 : declaration.size);
+                            });
+                            progress.laneDone(index);
+                            /*
+                              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)
+                                progress.alreadyHeld();
+                            uploaded.push({
+                                path: declaration.path,
+                                sha256: declaration.sha256,
+                                chunks: pieces.chunks,
+                                sourceSize: declaration.size,
+                                storedSize: pieces.chunks.reduce((sum, one) => sum + one.storedSize, 0),
+                                mediaType: declaration.mediaType,
+                            });
+                            progress.finished(declaration.size, pieces.sentBytes);
+                            continue;
+                        }
+                        const fromPack = packedInto.get(declaration.sha256);
+                        if (fromPack) {
+                            uploaded.push({
+                                path: declaration.path,
+                                sha256: declaration.sha256,
+                                pack: fromPack,
+                                sourceSize: declaration.size,
+                                /* Its share of the pack, so the version's totals stay honest. */
+                                storedSize: fromPack.storedSize,
+                                mediaType: declaration.mediaType,
+                            });
+                            continue;
+                        }
+                        const fromBatch = batched.get(declaration.sha256);
+                        if (fromBatch) {
+                            uploaded.push({
+                                path: declaration.path,
+                                objectId: fromBatch.objectId,
+                                sourceSize: declaration.size,
+                                storedSize: fromBatch.size,
+                                mediaType: declaration.mediaType,
+                            });
+                            continue;
+                        }
+                        const alreadyStored = alreadyHeld.get(declaration.sha256) ??
+                            /*
+                              Only asked individually when the batch did not cover it — a digest
+                              that changed after the bulk question, because the file was rewritten
+                              while this upload was running.
+                            */
+                            (await this.findStored(repositoryId, declaration));
+                        if (alreadyStored)
+                            progress.alreadyHeld();
+                        const result = alreadyStored ??
+                            (declaration.size <= DIRECT_LIMIT
+                                ? await (0, profile_js_1.timed)("send files one at a time", () => this.putDirect(repositoryId, declaration)).catch((error) => {
+                                    // Naming the file turns "it failed" into something actionable.
+                                    const reason = error instanceof Error ? error.message : String(error);
+                                    throw new Error(`${declaration.path}: ${reason}`);
+                                })
+                                : await this.putMultipart(repositoryId, declaration, (offset) => {
+                                    /*
+                                      Recorded before the report reads it. Without this the bar does
+                                      not move at all during a multipart file: `bytes()` sums the
+                                      settled total and the open lanes, and this lane's offset is
+                                      only in the second of those once it has been set.
+                                    */
+                                    progress.lane(index, offset);
+                                    report({
+                                        stage: "upload",
+                                        files: advance(index),
+                                        totalFiles: everyDeclaration.length,
+                                        bytes: progress.bytes(),
+                                        totalBytes,
+                                        path: declaration.path,
+                                        percent: 20 +
+                                            Math.round((progress.bytes() / Math.max(totalBytes, 1)) * 72),
+                                        bytesPerSecond: progress.rate(),
+                                    });
+                                }));
+                        progress.laneDone(index);
+                        uploaded.push({
+                            path: declaration.path,
+                            objectId: result.objectId,
+                            sourceSize: declaration.size,
+                            storedSize: result.size,
+                            mediaType: declaration.mediaType,
+                        });
+                        progress.finished(declaration.size, alreadyStored ? 0 : declaration.size);
+                    }
+                    finally {
+                        release();
+                    }
                 }
             };
             await Promise.all(Array.from({ length: Math.min(UPLOAD_LANES, declarations.length) }, () => runWorker()));

package/dist/cli/src/api.js

@@ -36,6 +36,7 @@ exports.createIssue = createIssue;
 exports.releases = releases;
 exports.collaborators = collaborators;
 exports.invite = invite;
+exports.acceptInvite = acceptInvite;
 exports.watch = watch;
 exports.setWatch = setWatch;
 exports.workflows = workflows;
@@ -688,9 +689,14 @@ async function collaborators(repositoryId) {
     };
 }
 async function invite(repositoryId, input) {
-    await call(`/v1/repositories/${encodeURIComponent(repositoryId)}/invites`, {
+    const row = await call(`/v1/repositories/${encodeURIComponent(repositoryId)}/invites`, { method: "POST", body: input });
+    return typeof row?.inviteUrl === "string" ? { inviteUrl: row.inviteUrl } : {};
+}
+/** Join a project from an invite link (or the token inside it). */
+async function acceptInvite(token) {
+    return call("/v1/invites/accept", {
         method: "POST",
-        body: input,
+        body: { token },
     });
 }
 async function watch(repositoryId) {

package/dist/cli/src/attach_command.js

@@ -28,11 +28,7 @@ const api_js_1 = require("./api.js");
 const project_commands_js_1 = require("./project_commands.js");
 const version_commands_js_1 = require("./version_commands.js");
 const api_js_2 = require("./api.js");
-const dim = (value) => `${value}`;
-const bold = (value) => `${value}`;
-const red = (value) => `${value}`;
-const green = (value) => `${value}`;
-const accent = (value) => `${value}`;
+const colour_js_1 = require("./colour.js");
 /** What the service will take in one request. */
 const DIRECT_LIMIT = 95 * 1024 * 1024;
 /** Comfortably under the cap, so one slow part does not hold the rest up. */
@@ -114,7 +110,7 @@ async function sendFile(repositoryId, file, size, sha256, mediaType, say) {
         repositoryRole: "chunk",
     });
     const parts = Math.ceil(size / PART_SIZE);
-    say(dim(`  ${readable(size)} in ${parts} parts`));
+    say((0, colour_js_1.dim)(`  ${readable(size)} in ${parts} parts`));
     const handle = await (0, promises_1.open)(file, "r");
     try {
         for (let index = 0; index < parts; index += 1) {
@@ -123,7 +119,7 @@ async function sendFile(repositoryId, file, size, sha256, mediaType, say) {
             const buffer = Buffer.alloc(length);
             await handle.read(buffer, 0, length, start);
             await (0, api_js_1.uploadPart)(session.uploadSessionId, index + 1, buffer);
-            say(dim(`  part ${index + 1}/${parts}`));
+            say((0, colour_js_1.dim)(`  part ${index + 1}/${parts}`));
         }
     }
     finally {
@@ -134,24 +130,24 @@ async function sendFile(repositoryId, file, size, sha256, mediaType, say) {
 async function commandAttach(parsed) {
     const file = parsed.positional[0];
     if (!file) {
-        console.error(red("Which file?") + dim("  cbx attach ./release/Installer.exe"));
+        console.error((0, colour_js_1.red)("Which file?") + (0, colour_js_1.dim)("  cbx attach ./release/Installer.exe"));
         return 1;
     }
     let size;
     try {
         const info = await (0, promises_1.stat)(file);
         if (!info.isFile()) {
-            console.error(red(`${file} is not a file.`));
+            console.error((0, colour_js_1.red)(`${file} is not a file.`));
             return 1;
         }
         size = info.size;
     }
     catch {
-        console.error(red(`There is no file at ${file}.`));
+        console.error((0, colour_js_1.red)(`There is no file at ${file}.`));
         return 1;
     }
     if (size === 0) {
-        console.error(red("That file is empty."));
+        console.error((0, colour_js_1.red)("That file is empty."));
         return 1;
     }
     /*
@@ -168,26 +164,26 @@ async function commandAttach(parsed) {
         return 1;
     const all = await (0, api_js_2.versions)(project.id);
     if (!all.length) {
-        console.error(red("This project has no versions yet."));
+        console.error((0, colour_js_1.red)("This project has no versions yet."));
         return 1;
     }
     const target = which.n
         ? all.find((one) => String(one.sequence) === which.n.replace(/^v/i, ""))
         : all.reduce((newest, one) => (one.sequence > newest.sequence ? one : newest));
     if (!target) {
-        console.error(red(`This project has no version ${which.n}.`));
+        console.error((0, colour_js_1.red)(`This project has no version ${which.n}.`));
         return 1;
     }
     const named = parsed.flags.get("name");
     const name = typeof named === "string" && named.trim() ? named.trim() : node_path_1.default.basename(file);
-    console.log(`${bold(name)} ${dim(`(${readable(size)})`)} → ${accent(`v${target.sequence}`)} of ${project.name}`);
+    console.log(`${(0, colour_js_1.bold)(name)} ${(0, colour_js_1.dim)(`(${readable(size)})`)} → ${(0, colour_js_1.accent)(`v${target.sequence}`)} of ${project.name}`);
     let objectId;
     try {
         const sha256 = await digestOf(file);
         objectId = await sendFile(project.id, file, size, sha256, mediaTypeOf(name), (text) => console.log(text));
     }
     catch (error) {
-        console.error(red(error instanceof Error ? error.message : String(error)));
+        console.error((0, colour_js_1.red)(error instanceof Error ? error.message : String(error)));
         return 1;
     }
     try {
@@ -195,23 +191,23 @@ async function commandAttach(parsed) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.error(red(message));
+        console.error((0, colour_js_1.red)(message));
         if (/already has something called/i.test(message)) {
-            console.error(dim("  Use --name to give this one a different name on the version."));
+            console.error((0, colour_js_1.dim)("  Use --name to give this one a different name on the version."));
         }
         return 1;
     }
-    console.log(green(`Attached. It is a download on v${target.sequence}.`));
+    console.log((0, colour_js_1.green)(`Attached. It is a download on v${target.sequence}.`));
     if (!target.name) {
         /*
           Said because it is the difference between attaching and publishing. A
           commit is not offered to anybody, so the download exists and nobody
           outside the project can reach it yet.
         */
-        console.log(dim("  v") +
-            dim(String(target.sequence)) +
-            dim(" is a commit, so nobody outside the project can take it yet."));
-        console.log(dim(`  Make it a version: cbx mark ${target.sequence} --name v1.0`));
+        console.log((0, colour_js_1.dim)("  v") +
+            (0, colour_js_1.dim)(String(target.sequence)) +
+            (0, colour_js_1.dim)(" is a commit, so nobody outside the project can take it yet."));
+        console.log((0, colour_js_1.dim)(`  Make it a version: cbx mark ${target.sequence} --name v1.0`));
     }
     return 0;
 }

package/dist/cli/src/cli.js

@@ -73,6 +73,10 @@ const bold = (text) => (colour ? `${text}` : text);
 const accent = (text) => (colour ? `${text}` : text);
 const red = (text) => (colour ? `${text}` : text);
 const green = (text) => (colour ? `${text}` : text);
+/** "1 file", "3 files". */
+function fileCount(count) {
+    return `${count} ${count === 1 ? "file" : "files"}`;
+}
 function bytes(value) {
     if (value >= 1024 ** 3)
         return `${(value / 1024 ** 3).toFixed(2)} GB`;
@@ -288,7 +292,7 @@ async function reconcile(folder, options = {}) {
             await (0, config_js_1.writeLink)(folder, known);
         }
         if (behind && !options.quiet) {
-            console.log(dim(`The account is on v${behind.sequence}; this folder is based on v${known.sequence}.`));
+            console.log(dim(`The project is on v${behind.sequence}; this folder is based on v${known.sequence}.`));
         }
         return {
             link: known,
@@ -732,6 +736,23 @@ function noteKeptDeletions(folder, baseline, syncing) {
         ` (${gone.slice(0, 3).join(", ")}${gone.length > 3 ? ", …" : ""}). A save adds and updates;` +
         ` run cbx submit --sync to remove ${gone.length === 1 ? "it" : "them"}.`));
 }
+/*
+  The service names each clash by its kind ("text_region", "add_add", …).
+  Those are its words, not the reader's: say what actually happened.
+*/
+const CONFLICT_WORDS = {
+    text_region: "you both changed the same lines",
+    modify_delete: "changed on one side, removed on the other",
+    add_add: "added on both sides, differently",
+    rename: "renamed differently on each side",
+    path_collision: "two files now want the same name",
+    binary: "not text, so it can't be combined line by line",
+    symlink: "a link both sides changed",
+    structured: "both changed the same entry",
+};
+function conflictWords(kind) {
+    return CONFLICT_WORDS[kind] ?? kind.replace(/_/g, " ");
+}
 async function commandSubmit(parsed) {
     const folder = folderFor(parsed);
     const message = flagText(parsed, "m", "message") ?? "";
@@ -1114,7 +1135,14 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
                 if (ahead.collidingPaths.length > 5) {
                     console.log(dim(`  and ${ahead.collidingPaths.length - 5} more`));
                 }
-                console.log(dim("  Your upload will be kept whole and put on a merge for you to settle."));
+                /*
+                  This check compares whole files, so it cannot know yet whether the
+                  two of you touched the same lines. The service combines text line
+                  by line when it can; saying "it will be put on a merge" here was a
+                  promise the next line ("Saved v3") then broke.
+                */
+                console.log(dim("  If you changed different lines of a text file, the two combine on their own."));
+                console.log(dim("  Otherwise your upload is kept whole on a merge for you to settle."));
                 console.log(dim("  Run cbx get first if you would rather build on theirs."));
                 console.log("");
             }
@@ -1238,7 +1266,7 @@ The connection failed: ${text}`));
             : `${result.mergeTrack.conflicts.length} 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(conflict.kind)}`);
+            console.log(`  ${red(conflict.path)}  ${dim(conflictWords(conflict.kind))}`);
         }
         console.log(`\nRun ${accent(`cbx merge ${result.mergeTrack.reference}`)} to decide,` +
             ` or ${accent("cbx merges")} to see everything waiting.`);
@@ -1655,7 +1683,7 @@ trackName) {
     });
     // The record is written; the run has not reported success yet.
     (0, faults_js_1.maybeFail)("get:after-record");
-    console.log(`${accent(`v${latest.sequence}`)} · ${result.files} files · ${bytes(result.bytes)} into ${destination}`);
+    console.log(`${accent(`v${latest.sequence}`)} · ${fileCount(result.files)} · ${bytes(result.bytes)} into ${destination}`);
     return 0;
 }
 /**
@@ -1789,7 +1817,7 @@ async function commandUnbundle(parsed) {
             dim(progress.path.slice(-40)));
     });
     done(line);
-    console.log(`${result.files} files · ${bytes(result.bytes)} into ${destination}`);
+    console.log(`${fileCount(result.files)} · ${bytes(result.bytes)} into ${destination}`);
     return 0;
 }
 async function commandInspect(parsed) {
@@ -1801,7 +1829,7 @@ async function commandInspect(parsed) {
     const manifest = await (0, cbx_js_1.readManifest)(node_path_1.default.resolve(source));
     const total = manifest.files.reduce((sum, file) => sum + file.size, 0);
     console.log(`${bold(manifest.source_name)} · format ${manifest.format} v${manifest.format_version}`);
-    console.log(`${manifest.files.length} files · ${bytes(total)} · ` +
+    console.log(`${fileCount(manifest.files.length)} · ${bytes(total)} · ` +
         `${Object.keys(manifest.chunks).length} chunks`);
     if (hasFlag(parsed, "files")) {
         for (const file of manifest.files) {
@@ -2022,13 +2050,17 @@ async function commandMerge(parsed) {
         }
     }
     console.log(`
-${accent(now.mergeTrack.reference)} · ${now.provisional.fileCount} files · ` +
+${accent(now.mergeTrack.reference)} · ` +
+        /*
+          The combined version is only counted once it can be built; until then
+          its file count is 0, which read as "your upload was empty".
+        */
         (now.provisional.ready
-            ? "ready to apply"
+            ? `${fileCount(now.provisional.fileCount)} · ready to apply`
             : `${now.provisional.unresolvedPaths.length} still to decide`));
     for (const conflict of now.conflicts) {
         console.log(`  ${conflict.resolvedAt ? accent("decided") : red("waiting")}  ${conflict.path}` +
-            `  ${dim(conflict.kind)}${conflict.resolution ? dim(` (${conflict.resolution})`) : ""}`);
+            `  ${dim(conflictWords(conflict.kind))}${conflict.resolution ? dim(` (${conflict.resolution})`) : ""}`);
     }
     if (hasFlag(parsed, "apply")) {
         if (!now.provisional.ready) {
@@ -2048,7 +2080,7 @@ Applied as ${accent(`v${applied.version.sequence}`)}.`);
     if (!decision && stillOpen) {
         console.log(dim(`
 --mine keeps yours, --theirs keeps what was already saved,` +
-            ` --drop removes the file.
+            ` --both keeps theirs and saves yours beside it, --drop removes the file.
 Add --path <file> for one file, then --apply when ready.`));
     }
     else if (now.provisional.ready) {
@@ -3098,9 +3130,13 @@ const SPECS = [
         usage: "people [project]",
         options: [
             { flags: "--invite <email>", description: "ask somebody to join" },
-            { flags: "--role <role>", description: "what they may do (default member)" },
+            { flags: "--role <role>", description: "write, read or admin (default write)" },
+            { flags: "--accept <link>", description: "join a project you were invited to" },
+        ],
+        examples: [
+            "cbx people my-project --invite sam@example.com",
+            "cbx people --accept https://coderook.com/?invite=…",
         ],
-        examples: ["cbx people my-project --invite sam@example.com"],
         run: service_commands_js_1.commandCollaborators,
     },
     {

package/dist/cli/src/colour.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accent = exports.green = exports.red = exports.bold = exports.dim = void 0;
+/*
+  Colour for the command modules, on the same terms as cli.ts: only at a
+  terminal, and never when NO_COLOR is set. Each module used to carry its own
+  always-on copy, so output piped to a file, or a script asking for plain
+  text, still came back full of escape codes.
+*/
+const colour = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const paint = (code) => (text) => colour ? `[${code}m${text}` : text;
+exports.dim = paint("2");
+exports.bold = paint("1");
+exports.red = paint("31");
+exports.green = paint("32");
+exports.accent = paint("33");