@coderook/cli 0.38.1 → 0.39.0

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

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

@@ -30,6 +30,7 @@ const solid_js_1 = require("./solid.js");
 const retry_js_1 = require("./retry.js");
 const staging_js_1 = require("./staging.js");
 const transfer_progress_js_1 = require("./transfer_progress.js");
+const upload_completion_js_1 = require("./upload_completion.js");
 const delta_js_1 = require("../shared/delta.js");
 const telemetry_js_1 = require("../shared/telemetry.js");
 /** Above this the API insists on a multipart session. */
@@ -230,6 +231,7 @@ class Uploader {
             // waiting rather than serve out its backoff first.
             this.check();
             try {
+                init.onAttempt?.(attempt);
                 return await this.attempt(route, init);
             }
             catch (error) {
@@ -243,6 +245,7 @@ class Uploader {
                 if (attempt >= retry_js_1.RETRY_ATTEMPTS || !(0, retry_js_1.worthRetrying)(error))
                     throw error;
                 this.telemetry.retry();
+                init.onRetry?.(attempt + 1, wait);
                 await this.pause(wait);
                 wait *= 2;
             }
@@ -928,27 +931,22 @@ class Uploader {
             (details ? ` Details: ${details}` : ""));
     }
     async publishVersion(at) {
+        const initial = {
+            stage: "publish", files: at.declarations.length, totalFiles: at.declarations.length,
+            bytes: at.progress.sentBytes, totalBytes: at.totalBytes, percent: 96,
+            bytesPerSecond: 0, path: "Preparing the file manifest",
+            completion: { phase: "preparing", elapsedSeconds: 0 },
+        };
+        return (0, upload_completion_js_1.withCompletionProgress)(initial, at.report, (report) => this.recordVersion({ ...at, report }));
+    }
+    async recordVersion(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.
         this.check();
-        report({
-            stage: "publish",
-            files: declarations.length,
-            totalFiles: declarations.length,
-            bytes: progress.sentBytes,
-            totalBytes,
-            /*
-              A save, not a version.
-      
-              Sending produces a commit; it becomes a version when somebody names
-              it, which happens later and on purpose. This line said "Recording the
-              version" while doing neither — it was the last wording left over from
-              before the two were separate, and it sat on the one screen a person
-              watches to the end.
-            */
-            path: "Writing down what was sent",
-            percent: 96,
-            bytesPerSecond: progress.rate(),
+        const completing = (phase, path) => report({
+            stage: "publish", files: declarations.length, totalFiles: declarations.length,
+            bytes: progress.sentBytes, totalBytes, percent: 96, bytesPerSecond: 0,
+            path, completion: { phase, elapsedSeconds: 0 },
         });
         // The version names everything the project holds: what was just sent,
         // plus every file that kept the object the last version pointed at.
@@ -1081,53 +1079,61 @@ class Uploader {
                 },
             }
             : 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({
-                message: request.message.trim() || "Saved from the CodeRook desktop app",
-                ...(request.baseVersionId === undefined
-                    ? {}
-                    : {
-                        ancestryMode: "required",
-                        baseVersionId: request.baseVersionId,
+        const send = (asChanges) => {
+            completing("confirming", "Files uploaded · waiting for CodeRook to confirm the save");
+            return (0, profile_js_1.timed)("publish the version", () => this.call(`/v1/repositories/${repositoryId}/versions`, {
+                method: "POST",
+                contentType: "application/json",
+                onAttempt: (attempt) => {
+                    if (attempt > 1)
+                        completing("confirming", `Retry ${attempt} · waiting for CodeRook to confirm the save`);
+                },
+                onRetry: (attempt, waitMs) => completing("retrying", `Confirmation interrupted · retry ${attempt} in ${Math.ceil(waitMs / 1000)} s · uploaded files are reused`),
+                body: JSON.stringify({
+                    message: request.message.trim() || "Saved from the CodeRook desktop app",
+                    ...(request.baseVersionId === undefined
+                        ? {}
+                        : {
+                            ancestryMode: "required",
+                            baseVersionId: request.baseVersionId,
+                        }),
+                    ...(request.expectedHeadVersionId === undefined
+                        ? {}
+                        : { expectedHeadVersionId: request.expectedHeadVersionId }),
+                    ...(request.track ? { track: request.track } : {}),
+                    ...(request.allowIgnored ? { allowIgnored: true } : {}),
+                    ...(this.trackedByGit.length ? { trackedByGit: this.trackedByGit } : {}),
+                    ...(request.allowSecrets ? { allowSecrets: true } : {}),
+                    ...(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.
+                    */
+                    idempotencyKey: (0, publish_name_js_1.publishAttemptName)({
+                        repositoryId,
+                        expectedHeadVersionId: request.expectedHeadVersionId,
+                        message: request.message,
+                        /*
+                          Named by what each file is. A whole file is its object; a chunked
+                          one is the digest of its contents — so retrying the same publish
+                          produces the same key either way, which is the point of it.
+                        */
+                        files: contents.map((item) => ({
+                            path: item.path,
+                            objectId: item.objectId ?? item.sha256 ?? "",
+                        })),
                     }),
-                ...(request.expectedHeadVersionId === undefined
-                    ? {}
-                    : { expectedHeadVersionId: request.expectedHeadVersionId }),
-                ...(request.track ? { track: request.track } : {}),
-                ...(request.allowIgnored ? { allowIgnored: true } : {}),
-                ...(this.trackedByGit.length ? { trackedByGit: this.trackedByGit } : {}),
-                ...(request.allowSecrets ? { allowSecrets: true } : {}),
-                ...(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.
-                */
-                idempotencyKey: (0, publish_name_js_1.publishAttemptName)({
-                    repositoryId,
-                    expectedHeadVersionId: request.expectedHeadVersionId,
-                    message: request.message,
+                    sourceSize: sourceBytes,
+                    storedSize: storedBytes,
                     /*
-                      Named by what each file is. A whole file is its object; a chunked
-                      one is the digest of its contents — so retrying the same publish
-                      produces the same key either way, which is the point of it.
+                      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,
-                        objectId: item.objectId ?? item.sha256 ?? "",
-                    })),
+                    ...(asChanges && changesOnly ? changesOnly : { files: wire }),
                 }),
-                sourceSize: sourceBytes,
-                storedSize: storedBytes,
-                /*
-                  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.
-                */
-                ...(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
@@ -1147,6 +1153,7 @@ class Uploader {
           instead. A repeated attempt predates manifest echoing, so read that
           Version once rather than guessing.
         */
+        completing("local", "CodeRook confirmed the save · updating local records");
         let acceptedManifest = (0, publication_js_1.acceptedManifestDigests)(completed.manifest?.files);
         /*
           A service that lists version-delta-v1 also says when it combined this
@@ -1162,6 +1169,7 @@ class Uploader {
             !request.allowSecrets &&
             (await this.versionDeltaAllowed());
         if (!completed.mergeTrack && !landedAsSent && !Object.keys(acceptedManifest).length) {
+            completing("local", "CodeRook confirmed the save · reading the accepted file manifest");
             acceptedManifest = Object.fromEntries([...(await this.versionFiles(repositoryId, completed.version.id, request.localPath))].map(([file, descriptor]) => [file, descriptor.sha256]));
         }
         const manifest = Object.keys(acceptedManifest).length
@@ -1181,6 +1189,7 @@ class Uploader {
           file, which on a 47,000-file project was over a billion comparisons at
           the very end of a save.
         */
+        completing("local", "CodeRook confirmed the save · updating local file records");
         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
@@ -1231,6 +1240,7 @@ class Uploader {
             if (rows.every((row) => typeof row.sha256 === "string" && row.sha256.length === 64)) {
                 const key = `${repositoryId}/${completed.version.id}`;
                 versionListings.set(key, Promise.resolve(rows));
+                completing("local", "CodeRook confirmed the save · caching the file listing for next time");
                 await writeListing(request.localPath, repositoryId, completed.version.id, rows);
             }
         }

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCompletionProgress = withCompletionProgress;
+/** Keep a pending completion visible without inventing server-side progress.
+ * Every phase change comes from the uploader; ticks only measure elapsed time.
+ */
+async function withCompletionProgress(initial, report, work) {
+    const started = performance.now();
+    let latest = initial;
+    let active = true;
+    const emit = (progress) => {
+        latest = progress;
+        if (progress.stage !== "publish")
+            active = false;
+        report(progress.stage === "publish" ? {
+            ...progress,
+            completion: {
+                phase: progress.completion?.phase ?? "preparing",
+                elapsedSeconds: Math.max(0, (performance.now() - started) / 1000),
+            },
+        } : progress);
+    };
+    emit(initial);
+    const timer = setInterval(() => { if (active)
+        emit(latest); }, 1000);
+    timer.unref?.();
+    try {
+        return await work(emit);
+    }
+    finally {
+        active = false;
+        clearInterval(timer);
+    }
+}

package/dist/cli/src/cli.js

@@ -27,6 +27,7 @@ const api_js_1 = require("./api.js");
 const registry_js_1 = require("./registry.js");
 const help_js_1 = require("./help.js");
 const progress_js_1 = require("./progress.js");
+const upload_progress_js_1 = require("./upload_progress.js");
 const publish_js_1 = require("./publish.js");
 const attach_command_js_1 = require("./attach_command.js");
 const build_command_js_1 = require("./build_command.js");
@@ -51,6 +52,8 @@ const worktree_js_1 = require("../../cbx/src/core/worktree.js");
 const rules_js_1 = require("../../cbx/src/core/rules.js");
 const upload_js_1 = require("../../cbx/src/core/upload.js");
 const download_js_1 = require("../../cbx/src/core/download.js");
+const machine_js_1 = require("./machine.js");
+const workspace_machine_js_1 = require("./workspace_machine.js");
 const safe_path_js_1 = require("../../cbx/src/shared/safe_path.js");
 const faults_js_1 = require("../../cbx/src/core/faults.js");
 const version_commands_js_1 = require("./version_commands.js");
@@ -429,6 +432,30 @@ async function commandLink(parsed) {
     console.log(dim(`  ${accent("cbx status")} shows how this folder differs from it; nothing was sent or fetched.`));
     return 0;
 }
+/**
+ * Run a folder command, then tell the project which version this machine's
+ * folder now holds (machine.ts): after a save nothing is left unsent, after a
+ * fetch the count is not known without scanning again.
+ */
+function announcing(run, saved) {
+    return async (parsed) => {
+        const code = await run(parsed);
+        if (code === 0) {
+            const folder = folderFor(parsed);
+            const link = await (0, config_js_1.readLink)(folder).catch(() => null);
+            if (link) {
+                await (0, machine_js_1.checkIn)(link.repositoryId, {
+                    kind: "folder",
+                    folder,
+                    track: link.track ?? null,
+                    baseVersionId: link.baseVersionId ?? link.versionId ?? null,
+                    changedFiles: saved ? 0 : null,
+                });
+            }
+        }
+        return code;
+    };
+}
 async function commandStatus(parsed) {
     const folder = folderFor(parsed);
     let link;
@@ -460,6 +487,14 @@ async function commandStatus(parsed) {
     const found = await (0, worktree_js_1.changedFiles)(folder, rules, baseline, "synchronize");
     const gone = found.filter((file) => file.deleted);
     const files = found.filter((file) => !file.deleted);
+    // Tells the project's Actions page what this machine's folder holds; never delays or fails status.
+    void (0, machine_js_1.checkIn)(link?.repositoryId, {
+        kind: "folder",
+        folder,
+        track: link?.track ?? null,
+        baseVersionId: link?.baseVersionId ?? link?.versionId ?? null,
+        changedFiles: found.length,
+    });
     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} ${Object.keys(link.manifest).length === 1 ? "file" : "files"} ${dim(`(${link.slug})`)}`
@@ -1071,6 +1106,7 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
         console.log("");
     }
     const line = progressLine();
+    const uploadDisplay = new upload_progress_js_1.UploadDisplay();
     let uploader = new upload_js_1.Uploader(config_js_1.credentials);
     /*
       Built by the shared description, so this and the git remote helper cannot
@@ -1226,14 +1262,12 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
                 console.log("Nothing was uploaded and no Version was created.");
                 return 0;
             }
-            result = await uploader.execute(uploadRequest, plan, (progress) => {
-                line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
-                    `${progress.stage.padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
-                    dim(progress.path.slice(-40)));
-            });
+            result = await uploader.execute(uploadRequest, plan, (progress) => uploadDisplay.report(progress));
+            uploadDisplay.done();
             break;
         }
         catch (error) {
+            uploadDisplay.done();
             done(line);
             /*
               Classified by the shared description rather than by a private regular
@@ -2347,7 +2381,7 @@ const SPECS = [
             'cbx submit --into voxai-coder -m "First save from the Linux machine"',
             'cbx submit --track spike -m "Try the other encoder"',
         ],
-        run: commandSubmit,
+        run: announcing(commandSubmit, true),
     },
     {
         name: "diff",
@@ -2605,7 +2639,7 @@ const SPECS = [
         options: [
             { flags: "--replace", description: "make it an exact copy, discarding local changes" },
         ],
-        run: commandGet,
+        run: announcing(commandGet, false),
     },
     {
         name: "clone",
@@ -2718,7 +2752,7 @@ const SPECS = [
         name: "workspace",
         group: "Your projects",
         summary: "edit, save and run a private project remotely without a checkout",
-        usage: "workspace <open|list|show|read|files|search|diff|patch|save|run|logs|cancel|deploy|preview|handoff|close|recipe> <project> [workspace] [job]",
+        usage: "workspace <open|list|show|read|files|search|diff|patch|save|run|logs|cancel|deploy|preview|handoff|close|recipe|assign|assignments|unassign|checkout> <project> [workspace] [job] | workspace push [folder]",
         detail: "Works on CodeRook's durable remote draft, never the current local folder. Use --data-file for structured edits or recipe configuration. Mutations need the reviewed --revision and a unique --key; reuse the same key and request when retrying. Recipes reference existing project workflows. Saving and deploying are separate operations.",
         options: [
             { flags: "--data-file <path>", description: "read an operation's JSON from this local file" },
@@ -2737,10 +2771,24 @@ const SPECS = [
             { flags: "--version <id>", description: "saved workspace version to deploy" },
             { flags: "-m, --message <text>", description: "describe the version being saved" },
             { flags: "--note <text>", description: "task context for another computer/assistant" },
+            { flags: "--days <number>", description: "assign: how long the handed-over token lasts (1-90, default 14)" },
+            { flags: "--save", description: "push: save the draft after sending the changes" },
+            { flags: "--dry-run", description: "push: list what would be sent, send nothing" },
         ],
-        examples: ["cbx workspace open my-project --name \"Laptop work\" --key laptop-open-001", "cbx workspace list my-project"],
+        examples: ["cbx workspace open my-project --name \"Laptop work\" --key laptop-open-001", "cbx workspace list my-project", "cbx workspace assign my-project <draft> --name Laptop", "cbx workspace checkout my-project <draft>", "cbx workspace push --save -m \"Fix the export dialog\""],
         run: workspace_command_js_1.commandWorkspace,
     },
+    {
+        name: "machines",
+        group: "Your projects",
+        summary: "the PCs working on a project, how far behind each is, and its runners",
+        usage: "machines [project]",
+        detail: "Every PC with a folder linked to the project, or working on a draft handed to it, says which version it holds when cbx runs there. " +
+            "This lists them with how many versions behind the project's line each is and how many files it has not saved, then the project's runners. " +
+            "Machines not seen for 30 days are left out. Set CODEROOK_NO_PRESENCE to keep a machine off the list.",
+        examples: ["cbx machines", "cbx machines my-project"],
+        run: async (parsed) => (0, workspace_machine_js_1.commandMachines)(parsed, (await (0, config_js_1.readLink)(folderFor(parsed)).catch(() => null))?.repositoryId ?? null),
+    },
     {
         name: "ai",
         group: "Your projects",

package/dist/cli/src/local_commands.js

@@ -26,6 +26,7 @@ exports.localMerge = localMerge;
  */
 const node_path_1 = __importDefault(require("node:path"));
 const node_process_1 = __importDefault(require("node:process"));
+const upload_progress_js_1 = require("./upload_progress.js");
 const history_js_1 = require("../../cbx/src/local/history.js");
 const merge_js_1 = require("../../cbx/src/local/merge.js");
 const repository_js_1 = require("../../cbx/src/local/repository.js");
@@ -384,6 +385,7 @@ async function localPush(parsed, repository) {
                 return 1;
         }
         const interactive = node_process_1.default.stdout.isTTY;
+        const uploadDisplay = new upload_progress_js_1.UploadDisplay();
         const result = await (0, remote_js_1.push)(repository, {
             credentials: config_js_1.credentials,
             projectName: link?.slug ?? (chosen ? ("id" in chosen ? chosen.slug : chosen.name) : node_path_1.default.basename(repository.root)),
@@ -392,10 +394,13 @@ async function localPush(parsed, repository) {
             allowSecrets: has(parsed, "allow-secrets"),
             acknowledged: has(parsed, "yes", "y"),
             report: (event) => {
+                if (event.kind === "upload")
+                    uploadDisplay.report(event.progress);
                 if (event.kind === "save" && interactive) {
                     node_process_1.default.stdout.write(`\r${dim(`Sending ${event.index + 1} of ${event.total}: ${event.save.message.split("\n")[0].slice(0, 50)}`)}   `);
                 }
                 if (event.kind === "pushed" || event.kind === "unchanged") {
+                    uploadDisplay.done();
                     if (interactive)
                         node_process_1.default.stdout.write(`\r${" ".repeat(80)}\r`);
                     console.log(`  ${accent(short(event.save.id))}  ` +
@@ -403,7 +408,7 @@ async function localPush(parsed, repository) {
                         `  ${event.save.message.split("\n")[0]}`);
                 }
             },
-        });
+        }).finally(() => uploadDisplay.done());
         if (!result.pushed.length) {
             console.log(`Everything on ${accent(result.line)} is already on CodeRook.`);
             return 0;

package/dist/cli/src/machine.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.machineIdentity = machineIdentity;
+exports.checkIn = checkIn;
+/**
+ * This machine, as a project's Actions page shows it (backend machines.ts).
+ *
+ * Each machine gets a random id the first time cbx runs there, kept in its
+ * settings folder, and is named after the computer. When cbx works in a
+ * folder linked to a project, or on a draft handed to this machine, it says
+ * so: which version it holds, which line it saves to, how many files it has
+ * not saved. Only the folder's name goes, never its path.
+ *
+ * Saying so is best effort. It never delays a command by more than a moment,
+ * never fails one, and is skipped when CODEROOK_NO_PRESENCE is set.
+ */
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const identify_js_1 = require("../../cbx/src/core/identify.js");
+const config_js_1 = require("./config.js");
+let cached = null;
+/** This machine's id and name, made once and kept. */
+async function machineIdentity() {
+    if (cached)
+        return cached;
+    const file = node_path_1.default.join((0, config_js_1.configDirectory)(), "machine.json");
+    let id = "";
+    try {
+        const saved = JSON.parse(await (0, promises_1.readFile)(file, "utf8"));
+        if (typeof saved.id === "string" && /^[A-Za-z0-9_-]{8,64}$/.test(saved.id))
+            id = saved.id;
+    }
+    catch {
+        /* First run on this machine, or the file was removed. */
+    }
+    if (!id) {
+        id = (0, node_crypto_1.randomBytes)(12).toString("base64url");
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(file), { recursive: true }).catch(() => undefined);
+        await (0, promises_1.writeFile)(file, JSON.stringify({ id }, null, 2) + "\n").catch(() => undefined);
+    }
+    cached = { id, name: (process.env.CODEROOK_MACHINE_NAME || (0, node_os_1.hostname)() || "This machine").slice(0, 120) };
+    return cached;
+}
+/** Tell the project this machine is here. Never throws, and gives up after a moment. */
+async function checkIn(repositoryId, state) {
+    if (!repositoryId || process.env.CODEROOK_NO_PRESENCE)
+        return;
+    try {
+        const token = await (0, config_js_1.loadToken)();
+        if (!token)
+            return;
+        const me = await machineIdentity();
+        const client = (0, identify_js_1.clientHeaders)()["x-coderook-client"] ?? "";
+        await fetch(`${(0, config_js_1.apiOrigin)()}/v1/repositories/${encodeURIComponent(repositoryId)}/machines`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${token}`, "content-type": "application/json", ...(0, identify_js_1.clientHeaders)() },
+            body: JSON.stringify({
+                machineId: me.id,
+                name: me.name,
+                kind: state.kind,
+                platform: `${(0, node_os_1.platform)()} ${(0, node_os_1.release)()}`.slice(0, 80),
+                clientVersion: client.startsWith("cli/") ? client.slice(4) : null,
+                folderName: state.folder ? node_path_1.default.basename(node_path_1.default.resolve(state.folder)) : null,
+                track: state.track ?? null,
+                baseVersionId: state.baseVersionId ?? null,
+                changedFiles: state.changedFiles ?? null,
+                workspaceId: state.workspaceId ?? null,
+            }),
+            signal: AbortSignal.timeout(2500),
+        });
+    }
+    catch {
+        /* Offline, signed out or slow: the command's own work is what matters. */
+    }
+}

package/dist/cli/src/upload_progress.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadDisplay = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+const progress_1 = require("./progress");
+/** The timer in the shared uploader keeps finalization visible in every client. */
+class UploadDisplay {
+    interactive;
+    write;
+    phase = "";
+    frame = 0;
+    constructor(interactive = Boolean(node_process_1.default.stdout.isTTY), write = (text) => { node_process_1.default.stdout.write(text); }) {
+        this.interactive = interactive;
+        this.write = write;
+    }
+    report(progress) {
+        const finishing = progress.stage === "publish";
+        const phase = finishing ? progress.path : progress.stage;
+        if (!this.interactive) {
+            if (finishing && phase !== this.phase)
+                this.write(`  ${phase}\n`);
+            this.phase = phase;
+            return;
+        }
+        this.phase = phase;
+        const seconds = Math.floor(progress.completion?.elapsedSeconds ?? 0);
+        const clock = `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+        const detail = finishing
+            ? `${["|", "/", "-", "\\"][this.frame++ % 4]} Finalizing save · ${clock} elapsed · ${progress.path}`
+            : `${(0, progress_1.bar)(progress.percent / 100, 18, (text) => text)} ${progress.percent}% ${progress.stage} ${progress.files}/${progress.totalFiles} ${progress.path}`;
+        // Keep status on one terminal row, including narrow windows.
+        const width = Math.max(1, (node_process_1.default.stdout.columns ?? 120) - 3);
+        this.write(`\r\x1b[2K  ${detail.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, width)}`);
+    }
+    done() { if (this.interactive)
+        this.write("\r\x1b[2K"); }
+}
+exports.UploadDisplay = UploadDisplay;

package/dist/cli/src/workspace_command.js

@@ -6,8 +6,11 @@ const promises_1 = require("node:fs/promises");
 const node_readline_1 = require("node:readline");
 const api_js_1 = require("./api.js");
 const config_js_1 = require("./config.js");
+const workspace_machine_js_1 = require("./workspace_machine.js");
 async function commandWorkspace(parsed) {
     const [operation, projectRef, workspace, runId] = parsed.positional;
+    if (operation && workspace_machine_js_1.MACHINE_OPERATIONS.has(operation))
+        return (0, workspace_machine_js_1.commandWorkspaceMachine)(parsed);
     if (!operation || !projectRef)
         throw new Error("Use cbx workspace <operation> <project> [workspace]. See cbx help workspace.");
     const project = await (0, api_js_1.findProject)(projectRef);

package/dist/cli/src/workspace_machine.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MACHINE_OPERATIONS = void 0;
+exports.commandWorkspaceMachine = commandWorkspaceMachine;
+exports.commandMachines = commandMachines;
+/**
+ * Working on a remote draft from a machine's own folder, and handing a draft
+ * to another machine (backend workspace_assignments.ts).
+ *
+ *   cbx workspace assign <project> <draft> [--name "Laptop"] [--days 14]
+ *       make a token that reaches that one draft; shown once
+ *   cbx workspace assignments <project> <draft>     the live ones
+ *   cbx workspace unassign <project> <draft> <id>   end one
+ *   cbx workspace checkout <project> <draft> [folder]
+ *       the draft as files: its base version, with the draft's edits on top
+ *   cbx workspace push [folder] [--save -m "…"] [--dry-run]
+ *       send this folder's text changes into the draft, and save it if asked
+ *
+ * A checked-out folder is not a linked folder: `cbx submit` does not apply to
+ * it, and its record lives in .coderook/workspace.json. Edits go in as the
+ * draft's own changes, each checked against the copy this folder last had,
+ * so somebody else's edit to the same file in the meantime is refused rather
+ * than overwritten. Text only, 256 KiB a file, as the draft itself allows.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const download_js_1 = require("../../cbx/src/core/download.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+const machine_js_1 = require("./machine.js");
+const colour_js_1 = require("./colour.js");
+const RECORD = node_path_1.default.join(".coderook", "workspace.json");
+const MAX_FILE = 256 * 1024;
+const MAX_BATCH = 900 * 1024;
+function flag(parsed, ...names) {
+    for (const name of names) {
+        const value = parsed.flags.get(name);
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+const sha = (bytes) => (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+const key = (what) => `${what}-${(0, node_crypto_1.randomBytes)(9).toString("base64url")}`;
+async function readRecord(folder) {
+    try {
+        return JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(folder, RECORD), "utf8"));
+    }
+    catch {
+        throw new Error(`${folder} is not a checked-out draft. Get one with: cbx workspace checkout <project> <draft> [folder]`);
+    }
+}
+async function writeRecord(folder, record) {
+    await (0, promises_1.mkdir)(node_path_1.default.join(folder, ".coderook"), { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(folder, RECORD), JSON.stringify(record, null, 2) + "\n");
+}
+async function project(reference) {
+    if (!reference)
+        throw new Error("Which project? Name it after the operation.");
+    const found = await (0, api_js_1.findProject)(reference);
+    if (!found)
+        throw new Error(`No accessible project ${reference}`);
+    return found;
+}
+/** The operations this file handles; anything else is the generic workspace command's. */
+exports.MACHINE_OPERATIONS = new Set(["assign", "assignments", "unassign", "checkout", "push"]);
+async function commandWorkspaceMachine(parsed) {
+    const [operation, first, second, third] = parsed.positional;
+    if (operation === "push")
+        return push(parsed, first ?? ".");
+    const found = await project(first);
+    const root = `/v1/repositories/${encodeURIComponent(found.id)}/workspaces`;
+    if (!second)
+        throw new Error("Name the draft (its ID) after the project. List them with: cbx workspace list <project>");
+    const draft = `${root}/${encodeURIComponent(second)}`;
+    if (operation === "assign") {
+        const days = flag(parsed, "days");
+        const made = await (0, api_js_1.callApi)(`${draft}/assignments`, {
+            method: "POST",
+            body: { name: flag(parsed, "name"), ...(days ? { days: Number(days) } : {}) },
+        });
+        console.log(`${(0, colour_js_1.green)("Handed over.")} This token reaches draft ${second} only, until ${made.assignment.expiresAt ? new Date(made.assignment.expiresAt).toLocaleDateString() : "it is revoked"}.`);
+        console.log((0, colour_js_1.dim)("It is shown once. Give it to the other machine privately."));
+        console.log(`\n  ${(0, colour_js_1.bold)(made.token)}\n`);
+        console.log("On that machine:");
+        console.log(`  ${(0, colour_js_1.accent)("npm install -g @coderook/cli")}`);
+        console.log(`  ${(0, colour_js_1.accent)("cbx sign-in")}                         ${(0, colour_js_1.dim)("paste the token when asked")}`);
+        console.log(`  ${(0, colour_js_1.accent)(`cbx workspace checkout ${found.slug} ${second}`)}`);
+        console.log(`  ${(0, colour_js_1.dim)("…work, then")} ${(0, colour_js_1.accent)('cbx workspace push --save -m "What changed"')}`);
+        console.log((0, colour_js_1.dim)(`\nEnd it early: cbx workspace unassign ${found.slug} ${second} ${made.assignment.id}`));
+        return 0;
+    }
+    if (operation === "assignments") {
+        const listed = await (0, api_js_1.callApi)(`${draft}/assignments`);
+        if (!listed.assignments.length)
+            console.log((0, colour_js_1.dim)("This draft is not handed to any machine."));
+        for (const one of listed.assignments) {
+            console.log(`${(0, colour_js_1.bold)(one.name)}  ${(0, colour_js_1.dim)(one.prefix + "…")}  ${(0, colour_js_1.dim)(`until ${one.expiresAt ? new Date(one.expiresAt).toLocaleDateString() : "revoked"}`)}  ` +
+                (0, colour_js_1.dim)(one.lastUsedAt ? `last used ${new Date(one.lastUsedAt).toLocaleString()}` : "not used yet") +
+                (0, colour_js_1.dim)(`  ${one.id}`));
+        }
+        return 0;
+    }
+    if (operation === "unassign") {
+        if (!third)
+            throw new Error("Name the assignment's ID after the draft. See them with: cbx workspace assignments <project> <draft>");
+        await (0, api_js_1.callApi)(`${draft}/assignments/${encodeURIComponent(third)}`, { method: "DELETE" });
+        console.log(`${(0, colour_js_1.green)("Ended.")} That machine can no longer reach the draft.`);
+        return 0;
+    }
+    return checkout(found, draft, second, third);
+}
+async function checkout(found, draft, workspaceId, into) {
+    const folder = node_path_1.default.resolve(into ?? `${found.slug}-draft`);
+    if ((0, node_fs_1.existsSync)(node_path_1.default.join(folder, RECORD))) {
+        console.error((0, colour_js_1.red)(`${folder} already holds a checked-out draft. Use cbx workspace push there, or choose another folder.`));
+        return 1;
+    }
+    const info = await (0, api_js_1.callApi)(draft);
+    const downloader = new download_js_1.Downloader(config_js_1.credentials);
+    let manifest;
+    try {
+        const result = await downloader.run(found.id, info.workspace.baseVersionId, folder, () => undefined, null, "replace");
+        manifest = { ...result.manifest };
+    }
+    catch (error) {
+        if (error instanceof download_js_1.DownloadFailed) {
+            console.error((0, colour_js_1.red)(error.message));
+            return 1;
+        }
+        throw error;
+    }
+    // The draft's own edits on top, each checked against the hash the draft gives for it.
+    let revision = info.workspace.revision;
+    let edited = 0;
+    for (let offset = 0; offset !== null;) {
+        const page = await (0, api_js_1.callApi)(`${draft}/diff?offset=${offset}`);
+        revision = page.revision;
+        for (const change of page.changes) {
+            const target = node_path_1.default.join(folder, ...change.path.split("/"));
+            if (change.removed || !change.after) {
+                await (0, promises_1.rm)(target, { force: true });
+                delete manifest[change.path];
+            }
+            else {
+                if (change.after.content === null) {
+                    throw new Error(`The draft's copy of ${change.path} could not be read as text (${change.after.reason ?? "unreadable"}).`);
+                }
+                if (sha(change.after.content) !== change.after.sha256) {
+                    throw new Error(`The draft's copy of ${change.path} did not arrive exactly; nothing was overwritten past it. Try again.`);
+                }
+                await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+                await (0, promises_1.writeFile)(target, change.after.content);
+                manifest[change.path] = change.after.sha256;
+            }
+            edited += 1;
+        }
+        offset = page.nextOffset;
+    }
+    await writeRecord(folder, {
+        projectId: found.id,
+        projectSlug: found.slug,
+        workspaceId,
+        name: info.workspace.name,
+        revision,
+        baseVersionId: info.workspace.baseVersionId,
+        track: info.workspace.track,
+        files: manifest,
+    });
+    await (0, machine_js_1.checkIn)(found.id, { kind: "workspace", folder, workspaceId, track: info.workspace.track, baseVersionId: info.workspace.baseVersionId, changedFiles: 0 });
+    console.log(`${(0, colour_js_1.green)("Checked out")} ${(0, colour_js_1.bold)(info.workspace.name)} into ${folder}`);
+    console.log((0, colour_js_1.dim)(`  ${Object.keys(manifest).length} files · revision ${revision}${edited ? ` · ${edited} edited in the draft` : ""}`));
+    console.log((0, colour_js_1.dim)("  Send changes back with ") + (0, colour_js_1.accent)("cbx workspace push") + (0, colour_js_1.dim)(", and save with ") + (0, colour_js_1.accent)('cbx workspace push --save -m "…"'));
+    return 0;
+}
+async function push(parsed, where) {
+    const folder = node_path_1.default.resolve(where);
+    const record = await readRecord(folder);
+    const draft = `/v1/repositories/${encodeURIComponent(record.projectId)}/workspaces/${encodeURIComponent(record.workspaceId)}`;
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const found = await (0, worktree_js_1.changedFiles)(folder, rules, new Map(Object.entries(record.files)), "synchronize");
+    const changes = [];
+    const refused = [];
+    for (const file of found) {
+        if (file.path === RECORD.replaceAll("\\", "/") || file.path.startsWith(".coderook/"))
+            continue;
+        if (file.deleted) {
+            changes.push({ path: file.path, remove: true, expectedSha256: record.files[file.path] ?? null });
+            continue;
+        }
+        const bytes = await (0, promises_1.readFile)(node_path_1.default.join(folder, ...file.path.split("/")));
+        if (bytes.length > MAX_FILE || bytes.includes(0)) {
+            refused.push(file.path);
+            continue;
+        }
+        changes.push({ path: file.path, content: bytes.toString("utf8"), expectedSha256: record.files[file.path] ?? null });
+    }
+    if (refused.length) {
+        console.error((0, colour_js_1.red)(`${refused.length} file${refused.length === 1 ? " is" : "s are"} binary or over 256 KiB, which a draft cannot take:`));
+        for (const one of refused.slice(0, 20))
+            console.error(`  ${one}`);
+        console.error((0, colour_js_1.dim)("Nothing was sent. Leave them out, or save them with a normal upload from a linked folder."));
+        return 1;
+    }
+    if (!changes.length && !parsed.flags.has("save")) {
+        console.log("Nothing changed since this folder's last push.");
+        return 0;
+    }
+    if (parsed.flags.has("dry-run")) {
+        for (const one of changes)
+            console.log(`  ${one.remove ? (0, colour_js_1.red)("removed") : record.files[one.path] ? "changed" : (0, colour_js_1.green)("new")}  ${one.path}`);
+        console.log((0, colour_js_1.dim)(`${changes.length} change${changes.length === 1 ? "" : "s"} would go to draft ${record.name}.`));
+        return 0;
+    }
+    // In batches the draft accepts, each against the revision the last one made.
+    let revision = record.revision;
+    for (let start = 0; start < changes.length;) {
+        const batch = [];
+        let bytes = 0;
+        while (start < changes.length) {
+            const next = changes[start];
+            const size = next.content ? Buffer.byteLength(next.content) : 0;
+            if (batch.length && bytes + size > MAX_BATCH)
+                break;
+            batch.push(next);
+            bytes += size;
+            start += 1;
+        }
+        const result = await (0, api_js_1.callApi)(`${draft}/changes`, {
+            method: "POST",
+            body: { expectedRevision: revision, operationKey: key("push"), changes: batch },
+        });
+        revision = result.workspace.revision;
+        for (const one of batch) {
+            if (one.remove)
+                delete record.files[one.path];
+            else
+                record.files[one.path] = sha(one.content);
+        }
+        record.revision = revision;
+        await writeRecord(folder, record);
+    }
+    if (changes.length)
+        console.log(`${(0, colour_js_1.green)("Sent")} ${changes.length} change${changes.length === 1 ? "" : "s"} to ${(0, colour_js_1.bold)(record.name)} · revision ${revision}`);
+    if (parsed.flags.has("save")) {
+        const message = flag(parsed, "m", "message");
+        if (!message) {
+            console.error((0, colour_js_1.red)('Say what changed: cbx workspace push --save -m "…"'));
+            return 1;
+        }
+        const saved = await (0, api_js_1.callApi)(`${draft}/save`, {
+            method: "POST",
+            body: { expectedRevision: revision, operationKey: key("save"), message },
+        });
+        if (saved.mergeTrack) {
+            console.log(`${(0, colour_js_1.accent)("Saved onto a merge track")} ${saved.mergeTrack.reference ?? ""}: somebody else changed the same lines, so it waits to be settled.`);
+        }
+        else if (saved.review) {
+            // A machine the draft was handed to saves to the draft's own line, for the owner to merge.
+            console.log(`${(0, colour_js_1.green)("Saved")} as v${saved.version?.sequence ?? "?"} on ${(0, colour_js_1.accent)(saved.review.line)}.`);
+            console.log(saved.review.pull
+                ? (0, colour_js_1.dim)(`  Pull request ${saved.review.pull.reference} carries it to ${saved.review.into}; it lands when the owner or a reviewer merges it.`)
+                : (0, colour_js_1.dim)(`  The owner merges it into ${saved.review.into} from that line.`));
+        }
+        else {
+            console.log(`${(0, colour_js_1.green)("Saved")} as v${saved.version?.sequence ?? "?"} on ${record.track}.`);
+        }
+    }
+    await (0, machine_js_1.checkIn)(record.projectId, { kind: "workspace", folder, workspaceId: record.workspaceId, track: record.track, baseVersionId: record.baseVersionId, changedFiles: 0 });
+    return 0;
+}
+function ago(when) {
+    const minutes = Math.round((Date.now() - Date.parse(when)) / 60000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.round(minutes / 60);
+    return hours < 48 ? `${hours} h ago` : `${Math.round(hours / 24)} days ago`;
+}
+/** cbx machines [project]: the PCs working on a project, and its runners. */
+async function commandMachines(parsed, linkedProject) {
+    const reference = parsed.positional[0] ?? linkedProject;
+    if (!reference)
+        throw new Error("Which project? Try: cbx machines <project>, or run it in a linked folder.");
+    const found = await project(reference);
+    const root = `/v1/repositories/${encodeURIComponent(found.id)}`;
+    const [machines, runners] = await Promise.all([
+        (0, api_js_1.callApi)(`${root}/machines`),
+        (0, api_js_1.callApi)(`${root}/runners`).catch(() => ({ runners: [] })),
+    ]);
+    console.log((0, colour_js_1.bold)(found.slug));
+    console.log((0, colour_js_1.dim)("Linked folders and handed-over drafts"));
+    if (!machines.machines.length)
+        console.log((0, colour_js_1.dim)("  None in the last 30 days."));
+    for (const one of machines.machines) {
+        const behind = one.baseSequence !== null && one.lineSequence !== null
+            ? one.lineSequence > one.baseSequence
+                ? (0, colour_js_1.red)(`${one.lineSequence - one.baseSequence} behind`)
+                : (0, colour_js_1.green)("up to date")
+            : (0, colour_js_1.dim)("version unknown");
+        const what = one.kind === "workspace" ? `draft ${one.workspace?.name ?? "(private)"}` : `folder ${one.folderName ?? "?"}`;
+        console.log(`  ${(0, colour_js_1.bold)(one.name)}${one.mine ? (0, colour_js_1.dim)(" (you)") : ""}  ${(0, colour_js_1.dim)(one.person.displayName)}  ${what}` +
+            `  ${one.baseSequence !== null ? `v${one.baseSequence}` : ""} ${behind}` +
+            `  ${one.changedFiles === null ? "" : one.changedFiles ? `${one.changedFiles} unsaved` : (0, colour_js_1.dim)("nothing unsaved")}` +
+            `  ${(0, colour_js_1.dim)(ago(one.lastSeenAt))}`);
+    }
+    console.log((0, colour_js_1.dim)("Runners"));
+    if (!runners.runners.length)
+        console.log((0, colour_js_1.dim)("  None connected."));
+    for (const one of runners.runners) {
+        const online = Date.now() - Date.parse(one.lastSeenAt) < 120000;
+        console.log(`  ${(0, colour_js_1.bold)(one.name)}  ${(0, colour_js_1.dim)(one.platform ?? "")}  ${online ? (0, colour_js_1.green)("online") : (0, colour_js_1.dim)("offline")}  ${(0, colour_js_1.dim)(`${one.runsClaimed} runs · ${ago(one.lastSeenAt)}`)}`);
+    }
+    return 0;
+}

package/package.json

@@ -1,66 +1,67 @@
-{
-  "name": "@coderook/cli",
-  "version": "0.38.1",
-  "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",
-  "bugs": {
-    "url": "https://github.com/AlexC1991/cbx/issues"
-  },
-  "keywords": [
-    "coderook",
-    "cbx",
-    "version-control",
-    "vcs",
-    "versioning",
-    "project-hosting",
-    "backup",
-    "snapshots",
-    "large-files",
-    "gamedev"
-  ],
-  "engines": {
-    "node": ">=22.15.0"
-  },
-  "bin": {
-    "cbx": "dist/cli/src/cli.js",
-    "coderook": "dist/cli/src/cli.js",
-    "git-remote-coderook": "dist/cli/src/git_remote_bin.js"
-  },
-  "files": [
-    ".claude-plugin",
-    "dist",
-    "skills",
-    "NOTICE"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-cbx-licence.mjs",
-    "check": "tsc -p tsconfig.json --noEmit",
-    "test": "tsc -p tsconfig.json && node --test --experimental-strip-types test/*.test.ts",
-    "start": "node dist/cli/src/cli.js",
-    "prepublishOnly": "npm run sync:plugin && npm run build",
-    "test:e2e": "node test/e2e.mjs",
-    "test:matrix": "node test/state-matrix.mjs",
-    "test:attempt": "node test/attempt-identity.mjs",
-    "test:get": "node test/get-safety.mjs",
-    "test:live": "node test/e2e.mjs --allow-production && node test/state-matrix.mjs --allow-production && node test/get-safety.mjs --allow-production && node test/get-track.mjs --allow-production && node test/get-protects-edits.mjs --allow-production && node test/upgrade-migration.mjs --allow-production && node test/fault-get.mjs --allow-production && node test/version-floor.mjs --allow-production && node test/fault-submit.mjs --allow-production && node test/race-attempts.mjs --allow-production && node test/attempt-identity.mjs --allow-production",
-    "test:getedits": "node test/get-protects-edits.mjs",
-    "test:upgrade": "node test/upgrade-migration.mjs",
-    "test:faultget": "node test/fault-get.mjs",
-    "test:floor": "node test/version-floor.mjs",
-    "test:faultsubmit": "node test/fault-submit.mjs",
-    "test:race": "node test/race-attempts.mjs",
-    "test:runner": "node test/runner-live.mjs",
-    "sync:plugin": "node scripts/sync-plugin-version.mjs",
-    "test:track": "node test/get-track.mjs"
-  },
-  "devDependencies": {
-    "@types/node": "24.10.1",
-    "typescript": "5.9.3"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/AlexC1991/cbx.git",
-    "directory": "cli"
-  }
-}
+{
+  "name": "@coderook/cli",
+  "version": "0.39.0",
+  "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",
+  "bugs": {
+    "url": "https://github.com/AlexC1991/cbx/issues"
+  },
+  "keywords": [
+    "coderook",
+    "cbx",
+    "version-control",
+    "vcs",
+    "versioning",
+    "project-hosting",
+    "backup",
+    "snapshots",
+    "large-files",
+    "gamedev"
+  ],
+  "engines": {
+    "node": ">=22.15.0"
+  },
+  "bin": {
+    "cbx": "dist/cli/src/cli.js",
+    "coderook": "dist/cli/src/cli.js",
+    "git-remote-coderook": "dist/cli/src/git_remote_bin.js"
+  },
+  "files": [
+    ".claude-plugin",
+    "dist",
+    "skills",
+    "NOTICE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-cbx-licence.mjs",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node --test --experimental-strip-types test/*.test.ts",
+    "start": "node dist/cli/src/cli.js",
+    "prepublishOnly": "npm run sync:plugin && npm run build",
+    "test:e2e": "node test/e2e.mjs",
+    "test:matrix": "node test/state-matrix.mjs",
+    "test:attempt": "node test/attempt-identity.mjs",
+    "test:get": "node test/get-safety.mjs",
+    "test:live": "node test/e2e.mjs --allow-production && node test/state-matrix.mjs --allow-production && node test/get-safety.mjs --allow-production && node test/get-track.mjs --allow-production && node test/get-protects-edits.mjs --allow-production && node test/upgrade-migration.mjs --allow-production && node test/fault-get.mjs --allow-production && node test/version-floor.mjs --allow-production && node test/fault-submit.mjs --allow-production && node test/race-attempts.mjs --allow-production && node test/attempt-identity.mjs --allow-production",
+    "test:getedits": "node test/get-protects-edits.mjs",
+    "test:upgrade": "node test/upgrade-migration.mjs",
+    "test:faultget": "node test/fault-get.mjs",
+    "test:floor": "node test/version-floor.mjs",
+    "test:faultsubmit": "node test/fault-submit.mjs",
+    "test:race": "node test/race-attempts.mjs",
+    "test:runner": "node test/runner-live.mjs",
+    "sync:plugin": "node scripts/sync-plugin-version.mjs",
+    "test:track": "node test/get-track.mjs",
+    "package:remote": "node ../scripts/package-cli-release.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlexC1991/cbx.git",
+    "directory": "cli"
+  }
+}

package/skills/coderook/SKILL.md

@@ -25,6 +25,10 @@ Use `cbx workspace` when the person wants to continue a CodeRook project from a
 
 `cbx workspace show <project> <id>` includes the administrator-configured recipe commands and target information. Run a named recipe, inspect its job with `logs`, and use `cancel` if needed. Only deploy an explicitly requested target and a saved version with applicable checks. A missing recipe requires configuration; running a local terminal command does not change remote files.
 
+To hand a draft to a machine that is not signed in as the owner, run `cbx workspace assign <project> <draft> --name "Laptop"`. It prints a token that reaches that one draft (read the project, edit, save and run its checks; no deploys, settings, other drafts or more tokens). Tell the person to give it to the other machine privately; never repeat the token yourself. On that machine: `cbx sign-in` (paste the token), `cbx workspace checkout <project> <draft> [folder]`, edit the files, then `cbx workspace push` (add `--save -m "…"` to save, `--dry-run` to preview). A checked-out folder is not a linked folder, so `cbx submit` does not apply there. A handed-over machine's saves never land on the draft's line directly: they go to the draft's own line `drafts/<name>-<id>` and open a pull request into it, which the owner or a reviewer approves and merges (see it with `cbx pr list`). Saves made signed in as the owner go straight to the line. `cbx workspace assignments` lists live tokens and `cbx workspace unassign` ends one; archiving the draft ends them all.
+
+`cbx machines [project]` shows the PCs working on a project: linked folders and handed-over drafts, the version each holds, how far behind the line it is and its unsaved file count, then the runners. A machine appears when cbx status, get, submit or a workspace command runs there; `CODEROOK_NO_PRESENCE=1` keeps one off the list. Check it before assuming nobody else is mid-change.
+
 `cbx mcp --workspaces` opts into the remote workspace tools using this account's stored token. The original `cbx mcp` stays read-only. A token needs explicit workspace edit/run/deploy grants for those actions; never print its value. The remote plugin can connect directly without this CLI.
 
 Native jobs require CLI 0.38.0 or later on the selected Windows laptop and a matching `cbx runner --name` and label. The named recipe can select `includePaths` so only needed inputs download to a temporary job folder. Hosted jobs continue with the desktop PC off. Native execution, local GPU features, toolchains and signed-in services need their own suitable machine/setup. Remote task notes share project handover state, not proprietary chat history.