@coderook/cli 0.42.3 → 0.42.5

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

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/dist/cli/src/workspace_machine.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MACHINE_OPERATIONS = void 0;
+exports.readWhole = readWhole;
 exports.commandWorkspaceMachine = commandWorkspaceMachine;
 exports.commandMachines = commandMachines;
 /**
@@ -23,7 +24,7 @@ exports.commandMachines = commandMachines;
  * 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.
+ * than overwritten. Text only, 1 MiB a file, as the draft itself allows.
  */
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -36,8 +37,29 @@ 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;
+/* The draft's own limit per text file (backend remote_workspaces.ts MAX_EDIT_BYTES). */
+const MAX_FILE = 1024 * 1024;
+/*
+  One request to the draft may be 2 MiB. Batches are measured as the JSON that
+  is sent, since escaping makes content larger than its bytes on disk, and kept
+  well under the cap.
+*/
+const MAX_REQUEST = 2 * 1024 * 1024;
+const MAX_BATCH = 1536 * 1024;
+const encodedSize = (change) => Buffer.byteLength(JSON.stringify(change));
+/** One draft text file in full, from the line-paged read (2,000 lines a request). */
+async function readWhole(draft, filePath, read = (route) => (0, api_js_1.callApi)(route)) {
+    const lines = [];
+    for (let start = 1;;) {
+        const page = await read(`${draft}/files?path=${encodeURIComponent(filePath)}&startLine=${start}&lines=2000`);
+        const got = page.content.split("\n");
+        lines.push(...got);
+        if (!page.truncated)
+            break;
+        start += got.length;
+    }
+    return lines.join("\n");
+}
 function flag(parsed, ...names) {
     for (const name of names) {
         const value = parsed.flags.get(name);
@@ -149,6 +171,14 @@ async function checkout(found, draft, workspaceId, into) {
                 delete manifest[change.path];
             }
             else {
+                /*
+                  A diff page carries at most 4 MiB of content; a text file past that
+                  budget comes with only its digest, and is read on its own, a page of
+                  lines at a time.
+                */
+                if (change.after.content === null && change.after.reason?.startsWith("page byte limit")) {
+                    change.after.content = await readWhole(draft, change.path);
+                }
                 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"}).`);
                 }
@@ -199,10 +229,16 @@ async function push(parsed, where) {
             refused.push(file.path);
             continue;
         }
-        changes.push({ path: file.path, content: bytes.toString("utf8"), expectedSha256: record.files[file.path] ?? null });
+        const change = { path: file.path, content: bytes.toString("utf8"), expectedSha256: record.files[file.path] ?? null };
+        /* Under 1 MiB but so full of escapes that it cannot travel in one request. */
+        if (encodedSize(change) > MAX_REQUEST - 64 * 1024) {
+            refused.push(file.path);
+            continue;
+        }
+        changes.push(change);
     }
     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:`));
+        console.error((0, colour_js_1.red)(`${refused.length} file${refused.length === 1 ? " is" : "s are"} binary or over 1 MiB, 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."));
@@ -225,7 +261,7 @@ async function push(parsed, where) {
         let bytes = 0;
         while (start < changes.length) {
             const next = changes[start];
-            const size = next.content ? Buffer.byteLength(next.content) : 0;
+            const size = encodedSize(next);
             if (batch.length && bytes + size > MAX_BATCH)
                 break;
             batch.push(next);

package/package.json

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