@coderook/cli 0.42.1 → 0.42.3

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

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

@@ -11,7 +11,7 @@ exports.readManifest = readManifest;
 exports.unpackBundle = unpackBundle;
 exports.collectEntries = collectEntries;
 /**
- * The CodeBox `.cbx` bundle, as `prototype/cbx_benchmark.py` writes it.
+ * The CBX `.cbx` bundle, as `prototype/cbx_benchmark.py` writes it.
  *
  * This is a port of that format, not a second one. The byte layout, the
  * manifest keys, the codec rule and the chunk index are taken from the
@@ -294,12 +294,12 @@ async function readManifest(source) {
     try {
         const size = (await handle.stat()).size;
         if (size < HEADER_BYTES + FOOTER_BYTES) {
-            throw new Error("That file is too small to be a CodeBox bundle");
+            throw new Error("That file is too small to be a CBX bundle");
         }
         const header = Buffer.alloc(HEADER_BYTES);
         await handle.read(header, 0, HEADER_BYTES, 0);
         if (header.subarray(0, 4).toString("latin1") !== exports.HEADER_MAGIC) {
-            throw new Error("That file is not a CodeBox bundle");
+            throw new Error("That file is not a CBX bundle");
         }
         const version = header.readUInt16LE(4);
         if (!SUPPORTED_FORMAT_VERSIONS.has(version)) {

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

@@ -110,7 +110,7 @@ const RULES = [
     { extension: ".ckpt", reason: "Model weights — large, and usually downloadable", recommended: false },
     { extension: ".pt", reason: "Model weights — large, and usually downloadable", recommended: false },
     { extension: ".pth", reason: "Model weights — large, and usually downloadable", recommended: false },
-    { extension: ".cbx", reason: "A CodeBox bundle of this project, inside the project", recommended: true },
+    { extension: ".cbx", reason: "A CBX bundle of this project, inside the project", recommended: true },
     { extension: ".pyc", reason: "Python bytecode", recommended: true },
     { extension: ".log", reason: "Log files", recommended: false },
     { file: "Local State", reason: "Browser profile data", recommended: true },

package/dist/cli/src/cli.js

@@ -6,7 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGISTRY = void 0;
 /**
- * cbx — the CodeBox engine from the command line, talking to CodeRook.
+ * cbx — the CBX engine from the command line, talking to CodeRook.
  *
  * The same engines the desktop application uses — the same scanner, the same
  * ignore rules, the same upload and download — with a terminal in front of
@@ -65,6 +65,7 @@ const diff_command_js_1 = require("./diff_command.js");
 const network_js_1 = require("./network.js");
 const local_commands_js_1 = require("./local_commands.js");
 const profile_js_1 = require("../../cbx/src/core/profile.js");
+const remote_restore_js_1 = require("./remote_restore.js");
 const detect_js_1 = require("../../cbx/src/core/detect.js");
 const cbx_js_1 = require("../../cbx/src/core/cbx.js");
 const api_js_2 = require("./api.js");
@@ -103,9 +104,22 @@ function bytes(value) {
 /** One line that rewrites itself, so progress does not scroll the terminal. */
 function progressLine() {
     let last = 0;
+    let lastPlain = 0;
     return (text) => {
-        if (!node_process_1.default.stdout.isTTY)
+        /*
+          Without a terminal (a script, a bot, a CI log) the redrawn bar cannot
+          work, and this used to print nothing at all: a 1.79 GB clone ran for
+          minutes in silence and was taken for a hang (2026-11-05). So a plain
+          line instead, at most every ten seconds.
+        */
+        if (!node_process_1.default.stdout.isTTY) {
+            const now = Date.now();
+            if (now - lastPlain < 10_000)
+                return;
+            lastPlain = now;
+            node_process_1.default.stdout.write(`${text.replace(/\[[0-9;]*m/g, "").replace(/[█░▏▎▍▌▋▊▉]+/g, "").replace(/\s+/g, " ").trim()}\n`);
             return;
+        }
         /*
           Measured without the colour codes. Padding to the raw length of a string
           carrying escape sequences overshoots by however many invisible
@@ -2470,15 +2484,17 @@ const SPECS = [
         detail: "With no paths, makes the whole folder match the save; with paths,\n" +
             "only those files and folders. The default is the last save, which\n" +
             "throws away what you changed since.\n\n" +
+            "In a folder linked to a CodeRook project, the save is a Version on\n" +
+            "CodeRook: the one the folder is on, or --from vN.\n\n" +
             "Unsaved changes to a file it would overwrite stop it, and it lists\n" +
             "them. Add --force to discard them. Files the history has never held\n" +
             "are left alone either way, and your line does not move.",
         options: [
-            { flags: "--from <save>", description: "a line, line~N, or the start of a save id" },
+            { flags: "--from <save>", description: "a line, line~N, or the start of a save id; vN in a linked folder" },
             { flags: "-f, --force", description: "overwrite unsaved changes" },
         ],
-        examples: ["cbx restore src/player.ts --force", "cbx restore --from main~3"],
-        run: local_commands_js_1.commandRestore,
+        examples: ["cbx restore src/player.ts --force", "cbx restore --from main~3", "cbx restore website/app --from v272"],
+        run: (0, local_commands_js_1.localFirst)((parsed) => (0, local_commands_js_1.commandRestore)(parsed), remote_restore_js_1.commandRemoteRestore),
     },
     {
         name: "switch",

package/dist/cli/src/help.js

@@ -39,7 +39,7 @@ function renderHelp(registry, version) {
     const listed = registry.specs.filter((spec) => !spec.deprecatedBy);
     const column = Math.min(nameColumn(listed), exports.USAGE_COLUMN);
     const lines = [
-        `${(0, colour_js_1.bold)("cbx")} ${(0, colour_js_1.dim)(version)} — the CodeBox engine, for CodeRook`,
+        `${(0, colour_js_1.bold)("cbx")} ${(0, colour_js_1.dim)(version)} — the CBX engine, for CodeRook`,
         "",
     ];
     for (const group of registry_js_1.GROUP_ORDER) {

package/dist/cli/src/remote_restore.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkedRoot = linkedRoot;
+exports.selectFiles = selectFiles;
+exports.projectPath = projectPath;
+exports.commandRemoteRestore = commandRemoteRestore;
+/**
+ * `cbx restore` in a folder linked to a CodeRook project.
+ *
+ * `restore` used to know only the local history (`cbx init` and `cbx save`),
+ * so in a folder made by `cbx clone` or `cbx link`, the kind nearly everyone
+ * has, it answered "No history here" while `cbx log` beside it worked.
+ * The folder does have a history; it lives on CodeRook. This puts files back
+ * the way a saved Version had them, by default the Version the folder is on.
+ *
+ * Same rules as the local restore:
+ * - an unsaved edit to a file it would overwrite stops it, listed, unless
+ *   --force is given;
+ * - files the Version does not hold are left alone;
+ * - the folder's link does not move, so `cbx submit` afterwards saves the
+ *   folder as it now is, and `cbx get` still sees restored-from-older files
+ *   as edits rather than silently overwriting them.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const download_js_1 = require("../../cbx/src/core/download.js");
+const safe_path_js_1 = require("../../cbx/src/shared/safe_path.js");
+const config_js_1 = require("./config.js");
+const ESC = String.fromCharCode(27);
+const paint = (code) => (value) => `${ESC}[${code}m${value}${ESC}[0m`;
+const dim = paint("2");
+const red = paint("31");
+const green = paint("32");
+const accent = paint("33");
+const plural = (count, one, many = `${one}s`) => `${count} ${count === 1 ? one : many}`;
+async function digestOfFile(full) {
+    try {
+        const hash = (0, node_crypto_1.createHash)("sha256");
+        for await (const block of (0, node_fs_1.createReadStream)(full))
+            hash.update(block);
+        return hash.digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+/** The linked folder this directory is in, walking up as `git` does. */
+async function linkedRoot(from) {
+    let at = node_path_1.default.resolve(from);
+    for (;;) {
+        const link = await (0, config_js_1.readLink)(at);
+        if (link)
+            return { root: at, link };
+        const parent = node_path_1.default.dirname(at);
+        if (parent === at)
+            return null;
+        at = parent;
+    }
+}
+/** Project paths a restore covers: the named files and everything under named folders. */
+function selectFiles(files, wanted) {
+    if (!wanted.length)
+        return files;
+    return files.filter((file) => wanted.some((one) => one === "" || file.path === one || file.path.startsWith(`${one}/`)));
+}
+/** A path typed on the command line, as a path inside the project ("" for the root). */
+function projectPath(root, cwd, typed) {
+    const relative = node_path_1.default.relative(root, node_path_1.default.resolve(cwd, typed));
+    if (relative.startsWith("..") || node_path_1.default.isAbsolute(relative))
+        return null;
+    return relative.split(node_path_1.default.sep).join("/").replace(/\/+$/, "");
+}
+async function commandRemoteRestore(parsed) {
+    const found = await linkedRoot(node_process_1.default.cwd());
+    if (!found) {
+        console.error(red("No history here."));
+        console.error(dim("  This folder is not linked to a CodeRook project and has no local history. ") +
+            accent("cbx link <project>") + dim(" connects it; ") + accent("cbx init") +
+            dim(" starts a history on this machine."));
+        return 1;
+    }
+    const { root, link } = found;
+    const force = parsed.flags.has("force") || parsed.flags.has("f");
+    const wanted = [];
+    for (const typed of parsed.positional) {
+        const one = projectPath(root, node_process_1.default.cwd(), typed);
+        if (one === null) {
+            console.error(red(`${typed} is outside the project folder (${root}).`));
+            return 1;
+        }
+        wanted.push(one);
+    }
+    const downloader = new download_js_1.Downloader(config_js_1.credentials);
+    const versions = await downloader.versions(link.repositoryId);
+    const from = parsed.flags.get("from");
+    let version;
+    if (typeof from === "string") {
+        const sequence = /^v?(\d+)$/i.exec(from.trim());
+        version = sequence
+            ? versions.find((one) => one.sequence === Number(sequence[1]))
+            : versions.find((one) => one.id.startsWith(from.trim()));
+        if (!version) {
+            console.error(red(`No version ${from} in ${link.slug}.`) + dim(" cbx versions lists them."));
+            return 1;
+        }
+    }
+    else {
+        const base = link.baseVersionId ?? link.versionId;
+        version =
+            versions.find((one) => one.id === base) ??
+                versions.find((one) => one.sequence === link.sequence);
+        if (!version) {
+            console.error(red("This folder's saved version could not be found.") +
+                dim(" Name one with --from vN."));
+            return 1;
+        }
+    }
+    const files = selectFiles(await downloader.files(link.repositoryId, version.id), wanted);
+    if (!files.length) {
+        console.error(red(`v${version.sequence} holds nothing at ${wanted.join(", ") || "the project root"}.`));
+        return 1;
+    }
+    const toWrite = [];
+    const edited = [];
+    for (const file of files) {
+        const unsafe = (0, safe_path_js_1.whyUnsafe)(file.path);
+        if (unsafe) {
+            console.error(red(`Skipped ${JSON.stringify(file.path)}: ${unsafe}.`));
+            continue;
+        }
+        const here = await digestOfFile(node_path_1.default.join(root, ...file.path.split("/")));
+        if (here === file.sha256)
+            continue;
+        /*
+          Different from the version. If it still matches what CodeRook last placed
+          here, it is only an older or newer copy and may be replaced. Otherwise it
+          is somebody's unsaved work, and that needs --force.
+        */
+        const placed = link.local?.[file.path];
+        if (here !== null && here !== placed && !force)
+            edited.push(file.path);
+        toWrite.push(file);
+    }
+    if (edited.length) {
+        console.error(red(`${plural(edited.length, "file")} here ${edited.length === 1 ? "has" : "have"} ` +
+            `unsaved changes that restoring would overwrite:`));
+        for (const one of edited.slice(0, 20))
+            console.error(`  ${one}`);
+        if (edited.length > 20)
+            console.error(dim(`  …and ${edited.length - 20} more`));
+        console.error(`\nAdd ${accent("--force")} to discard them, or save them first with ${accent("cbx submit")}.`);
+        return 1;
+    }
+    if (!toWrite.length) {
+        console.log(`Already matches ${accent(`v${version.sequence}`)}; nothing to put back.`);
+        return 0;
+    }
+    for (const file of toWrite) {
+        await downloader.fileTo(link.repositoryId, version.id, file, node_path_1.default.join(root, ...file.path.split("/")));
+    }
+    console.log(`Put back ${plural(toWrite.length, "file")} from ${accent(`v${version.sequence}`)}: ` +
+        `${version.message.split("\n")[0]}`);
+    for (const file of toWrite.slice(0, 20))
+        console.log(`  ${green("restored")} ${file.path}`);
+    if (toWrite.length > 20)
+        console.log(dim(`  …and ${toWrite.length - 20} more`));
+    console.log(dim("The folder's link has not moved. cbx submit saves the folder as it is now."));
+    return 0;
+}

package/package.json

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