@coderook/cli 0.42.4 → 0.42.6

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

package/dist/cli/src/cli.js

@@ -1541,12 +1541,26 @@ async function commandGet(parsed) {
               would bury the only copy.
             */
             if (resuming) {
+                /*
+                  Only a file this fetch rewrites can be buried by finishing it: one
+                  whose incoming copy differs from what was placed here. An edit to a
+                  file the version left alone is kept, exactly as an ordinary fetch
+                  keeps it, so it is no reason to stop. It used to be: completing in
+                  "replace" mode rewrote every file, so any edit at all, anywhere,
+                  refused the resume (2026-11-06, two page edits blocked a catch-up).
+                */
                 const notYetArrived = await (0, worktree_js_1.changedFiles)(folder, rules, incoming);
                 const changedInTheGap = notYetArrived.filter((file) => !file.deleted &&
                     incoming.has(file.path) &&
+                    incoming.get(file.path) !== link.local[file.path] &&
                     edited.some((one) => one.path === file.path));
                 if (!changedInTheGap.length) {
-                    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null, "replace", await (0, track_commands_js_1.trackFor)(folder));
+                    /*
+                      Reconciling finishes the job: every file the version changed is
+                      placed (the half the interrupted run already placed are placed
+                      again, harmlessly), and what it left alone stays as it is.
+                    */
+                    return fetchInto(link.repositoryId, folder, link.slug, link.local ?? null, "reconcile", await (0, track_commands_js_1.trackFor)(folder));
                 }
                 console.error(red(`${changedInTheGap.length} file${changedInTheGap.length === 1 ? "" : "s"} ` +
                     `changed while the interrupted fetch was stopped:`));

package/dist/cli/src/workspace_command.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandWorkspace = commandWorkspace;
+exports.deployLanded = deployLanded;
 exports.commandWorkspaceMcp = commandWorkspaceMcp;
 const promises_1 = require("node:fs/promises");
 const node_readline_1 = require("node:readline");
@@ -154,13 +155,80 @@ async function commandWorkspace(parsed) {
         else if (operation !== "show")
             throw new Error(`Unknown workspace operation ${operation}`);
     }
-    const result = await (0, api_js_1.callApi)(path, {
-        method,
-        ...(body === undefined ? {} : { body }),
-    });
+    let result;
+    try {
+        result = await (0, api_js_1.callApi)(path, {
+            method,
+            ...(body === undefined ? {} : { body }),
+        });
+    }
+    catch (error) {
+        /*
+          Saves land one at a time, each on top of whatever landed before, so the
+          version a save made can differ from the draft that was checked: other
+          people's work landed in between. That version is the one to check and
+          ship, so check it where it is and deploy it, rather than refusing.
+        */
+        if (operation === "deploy" && error instanceof api_js_1.ServiceError && error.code === "workspace_saved_content_changed") {
+            result = await deployLanded(root, body);
+        }
+        else
+            throw error;
+    }
     console.log(JSON.stringify(result, null, 2));
     return 0;
 }
+const say = (line) => process.stderr.write(line + "\n");
+const FINISHED = new Set(["passed", "failed", "cancelled", "canceled", "timed_out", "error", "skipped"]);
+/** Check a saved version where it landed, in an unedited draft on it, then deploy it. */
+async function deployLanded(root, body, options = {}) {
+    const api = options.api ?? api_js_1.callApi;
+    const wait = options.wait ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const saved = String(body.savedVersionId ?? "");
+    const recipe = String(body.recipe ?? "");
+    say(`That version merged onto the line after this draft was checked. Checking the version itself, then deploying it.`);
+    const opened = await api(`${root}/workspaces`, {
+        method: "POST",
+        body: { name: `Deploy ${saved.slice(0, 8)} (${recipe})`, operationKey: `deploy-landed-${saved}-${recipe}`, baseVersionId: saved },
+    });
+    const ws = `${root}/workspaces/${opened.workspace.id}`;
+    if (opened.workspace.revision !== 0)
+        throw new Error(`Draft ${opened.workspace.id} was edited; open a fresh one on the saved version.`);
+    const shown = await api(ws);
+    const required = shown.recipes?.find((r) => r.name === recipe)?.required_recipes ?? [];
+    const deadline = Date.now() + (options.deadlineMs ?? 45 * 60_000);
+    for (const name of required) {
+        const started = await api(`${ws}/runs`, {
+            method: "POST",
+            body: { expectedRevision: 0, operationKey: `check-${saved}-${name}`, recipe: name },
+        });
+        say(`  ${name}: run #${started.number ?? started.runId} on the saved version…`);
+        for (;;) {
+            /* The job endpoint answers { run: { status, number, … }, logs, artifacts }. */
+            const answer = await api(`${ws}/runs/${started.runId}`);
+            const run = answer.run ?? { status: "unknown" };
+            if (run.status === "passed") {
+                say(`  ${name}: passed`);
+                break;
+            }
+            if (FINISHED.has(run.status) || run.status === "unknown")
+                throw new Error(`${name} ${run.status} on the saved version (run #${run.number ?? started.runId}); not deploying.`);
+            if (Date.now() > deadline)
+                throw new Error(`${name} has not finished; deploy again later with the same command.`);
+            await wait(15_000);
+        }
+    }
+    return api(`${ws}/runs`, {
+        method: "POST",
+        body: {
+            expectedRevision: 0,
+            operationKey: `${String(body.operationKey ?? "deploy")}-landed`,
+            recipe,
+            target: body.target,
+            savedVersionId: saved,
+        },
+    });
+}
 /** Explicit remote/write-capable alternative; the original cbx mcp stays read-only. */
 async function commandWorkspaceMcp() {
     const lines = (0, node_readline_1.createInterface)({ input: process.stdin, crlfDelay: Infinity });

package/package.json

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