@coderook/cli 0.45.0 → 0.46.1

package/dist/cbx/src/shared/native_engine.js

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_SCAN_MIN_FILES = exports.ENGINE_MIN_BYTES = exports.ENGINE_MIN_FILES = void 0;
+exports.enginePath = enginePath;
+exports.engineProblem = engineProblem;
+exports.worthTheEngine = worthTheEngine;
+exports.engineStore = engineStore;
+exports.engineMeasure = engineMeasure;
+exports.engineScan = engineScan;
+exports.resetEngineForTests = resetEngineForTests;
+/**
+ * The native byte engine (cbx/engine, Rust), when there is one.
+ *
+ * The engine does the same byte work as the TypeScript here — hashing, cutting
+ * big files, framing and packing objects — with the same results: the same
+ * SHA-256 names, the same chunk cuts, the same "cbx-local 1" store. It is only
+ * faster, because it reads, hashes and compresses on every core at once. The
+ * cross-tests in cbx/engine/compat compare the two on real folders.
+ *
+ * It is optional. Every caller keeps its own TypeScript path and uses it
+ * whenever this returns null: no engine for this platform, CBX_ENGINE=off, a
+ * failed run, or an answer that does not look right. A run that fails once is
+ * not tried again in the same process, so a broken binary costs one attempt.
+ *
+ * Where it is looked for:
+ *   CBX_ENGINE=<path>   that binary ("off" turns the engine off)
+ *   engine-bin/<platform>-<arch>/cbx-engine[.exe] in this package or a folder above it
+ */
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/** The engine's command protocol this code speaks; `cbx-engine version` reports its own. */
+const PROTOCOL = 1;
+/** Below this much work, starting a process costs more than it saves. */
+exports.ENGINE_MIN_FILES = 24;
+exports.ENGINE_MIN_BYTES = 32 * 1024 * 1024;
+/** Below this many files a folder is walked faster here than by starting the engine. */
+exports.ENGINE_SCAN_MIN_FILES = 400;
+let located;
+let broken = null;
+function binaryName() {
+    return process.platform === "win32" ? "cbx-engine.exe" : "cbx-engine";
+}
+/*
+  Whether the binary may be run, making it so when it can be.
+
+  A package packed on Windows carries no execute bit, so on macOS and Linux the
+  engine arrives as a plain file. Setting the bit is all it needs; where the
+  install folder is not ours to change, the TypeScript path is used instead.
+*/
+function runnable(candidate) {
+    if (process.platform === "win32")
+        return true;
+    try {
+        (0, node_fs_1.accessSync)(candidate, node_fs_1.constants.X_OK);
+        return true;
+    }
+    catch {
+        try {
+            (0, node_fs_1.chmodSync)(candidate, 0o755);
+            (0, node_fs_1.accessSync)(candidate, node_fs_1.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/** Where the engine is, or null when there is none to use. */
+function enginePath() {
+    if (located !== undefined)
+        return located;
+    const chosen = process.env.CBX_ENGINE?.trim();
+    if (chosen === "off" || chosen === "0" || chosen === "false")
+        return (located = null);
+    if (chosen)
+        return (located = (0, node_fs_1.existsSync)(chosen) ? chosen : null);
+    /* CommonJS here; in an ES module build __dirname is not defined and only CBX_ENGINE applies. */
+    let directory = typeof __dirname === "string" ? __dirname : null;
+    const wanted = node_path_1.default.join("engine-bin", `${process.platform}-${process.arch}`, binaryName());
+    for (let depth = 0; directory && depth < 8; depth += 1) {
+        const candidate = node_path_1.default.join(directory, wanted);
+        if ((0, node_fs_1.existsSync)(candidate))
+            return (located = runnable(candidate) ? candidate : null);
+        const parent = node_path_1.default.dirname(directory);
+        directory = parent === directory ? null : parent;
+    }
+    return (located = null);
+}
+/** Why the engine is not being used, for diagnostics; null when it is available. */
+function engineProblem() {
+    if (broken)
+        return broken;
+    return enginePath() ? null : "no engine for this platform";
+}
+/*
+  Whether the engine should open and read files itself (store, measure), as
+  opposed to only walking folders (scan).
+
+  Not on Windows, for now. With real-time protection on, which is nearly
+  everyone, Windows Security scans each new file when the unsigned engine
+  opens it and barely slows Node, a signed and widely known program. On a
+  fresh copy of 8,525 files the engine took 13–16 s to store what Node read
+  and stored in 3 s; with protection off the engine took 0.5 s. Until the
+  engine is signed, Windows reads files here and the engine keeps the folder
+  walk, which only lists and stats and is not scanned. CBX_ENGINE_READS=on
+  turns engine reads back on.
+*/
+function engineMayRead() {
+    if (process.env.CBX_ENGINE_READS === "on")
+        return true;
+    if (process.env.CBX_ENGINE_READS === "off")
+        return false;
+    return process.platform !== "win32";
+}
+/** Whether a batch of this size is worth handing to the engine to read. */
+function worthTheEngine(files, bytes) {
+    if (enginePath() === null || broken || files === 0)
+        return false;
+    /* CBX_ENGINE_ALWAYS=1 sends every batch, however small, so tests can run everything through it. */
+    if (process.env.CBX_ENGINE_ALWAYS === "1")
+        return true;
+    if (!engineMayRead())
+        return false;
+    return files >= exports.ENGINE_MIN_FILES || bytes >= exports.ENGINE_MIN_BYTES;
+}
+function run(args, input, onLine, signal) {
+    const binary = enginePath();
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(binary, args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        }
+        catch (error) {
+            resolve({ stdout: "", stderr: String(error), code: -1 });
+            return;
+        }
+        /* Cancelling the operation stops the engine with it. */
+        const stop = () => child.kill();
+        if (signal?.aborted)
+            stop();
+        signal?.addEventListener("abort", stop, { once: true });
+        child.on("close", () => signal?.removeEventListener("abort", stop));
+        const out = [];
+        let err = "";
+        let partial = "";
+        child.stdout.on("data", (data) => out.push(data));
+        child.stderr.on("data", (data) => {
+            const text = partial + data.toString("utf8");
+            const lines = text.split("\n");
+            partial = lines.pop() ?? "";
+            for (const line of lines) {
+                if (onLine && line.startsWith("{"))
+                    onLine(line);
+                else
+                    err += `${line}\n`;
+            }
+        });
+        child.on("error", (error) => resolve({ stdout: "", stderr: String(error), code: -1 }));
+        child.on("close", (code) => resolve({ stdout: Buffer.concat(out).toString("utf8"), stderr: err + partial, code }));
+        child.stdin.on("error", () => {
+            /* The engine exited before reading; its exit code says why. */
+        });
+        child.stdin.end(input ?? "");
+    });
+}
+/*
+  Every answer carries the protocol it speaks, so an engine from another
+  release is caught on its first answer without a separate process to ask.
+*/
+function usable() {
+    return Boolean(enginePath()) && !broken;
+}
+async function ask(args, input, onLine, signal) {
+    if (!usable())
+        return null;
+    const answer = await run(args, JSON.stringify(input), onLine, signal);
+    /* Stopped on purpose is not a broken engine; the caller sees its own cancellation. */
+    if (signal?.aborted)
+        return null;
+    if (answer.code !== 0) {
+        broken = `cbx-engine ${args[0]} failed: ${answer.stderr.trim().slice(0, 300)}`;
+        return null;
+    }
+    let parsed = null;
+    try {
+        parsed = JSON.parse(answer.stdout);
+    }
+    catch {
+        broken = `cbx-engine ${args[0]} gave an answer that is not JSON`;
+        return null;
+    }
+    if (parsed?.protocol !== PROTOCOL) {
+        broken = `engine at ${enginePath()} does not speak protocol ${PROTOCOL}`;
+        return null;
+    }
+    return parsed;
+}
+const progressFrom = (report) => report
+    ? (line) => {
+        try {
+            const parsed = JSON.parse(line);
+            report(parsed.done, parsed.total, parsed.path);
+        }
+        catch {
+            /* A line that is not progress; ignored. */
+        }
+    }
+    : undefined;
+/**
+ * Store files into a "cbx-local 1" object store, as `storeFile` does for each.
+ *
+ * Null when the engine is not available or the run failed; a file the engine
+ * could not read comes back with `error`, for the caller's own path to retry
+ * and report. Objects are on disk (packs flushed) when this returns.
+ */
+async function engineStore(objectsDirectory, root, files, progress, signal) {
+    const answer = await ask(["store", objectsDirectory, root, ...(progress ? ["--progress"] : [])], files, progressFrom(progress), signal);
+    if (!answer || !Array.isArray(answer.files) || answer.files.length !== files.length) {
+        if (answer)
+            broken = "cbx-engine store answered for the wrong number of files";
+        return null;
+    }
+    const byPath = new Map();
+    for (const one of answer.files)
+        byPath.set(one.path, one);
+    return byPath;
+}
+/**
+ * Digests of many files at once; with `count`, also lines and whether the file is binary,
+ * worked out as `measure` in core/worktree.ts does.
+ */
+async function engineMeasure(root, files, progress, signal) {
+    const answer = await ask(["measure", root, ...(progress ? ["--progress"] : [])], files, progressFrom(progress), signal);
+    if (!answer || !Array.isArray(answer.files) || answer.files.length !== files.length) {
+        if (answer)
+            broken = "cbx-engine measure answered for the wrong number of files";
+        return null;
+    }
+    const byPath = new Map();
+    for (const one of answer.files)
+        byPath.set(one.path, one);
+    return byPath;
+}
+/**
+ * The files the ignore rules let into a save, found by the engine's own walk.
+ *
+ * Decided exactly as core/rules.ts and the walks in core/worktree.ts decide (the cross-test
+ * engine/compat/rules-cross.mjs compares them under many rule sets), returned in the order
+ * changedFiles meets them: breadth first, each folder in disk order. `rules` is what readRules
+ * gave; `tracked` what gitTracked gave. Each file's size, mtimeMs and mode come from one stat.
+ * Null when there is no engine or the walk failed, including on a rule JavaScript could not
+ * compile, so the TypeScript walk runs and fails in its own words.
+ */
+async function engineScan(root, rules, tracked, 
+/** How many files the folder held last time, when known; a small folder is walked faster without a process. */
+expectedFiles, 
+/**
+ * Stat every file (the default). False lets the engine use the size and time the folder
+ * listing already carries, which costs nothing per file on Windows; a file still open for
+ * writing can show its previous size and time there, so only read-only reports ask for it.
+ */
+exact = true) {
+    if (!enginePath() || broken)
+        return null;
+    if (expectedFiles !== undefined && expectedFiles < exports.ENGINE_SCAN_MIN_FILES && process.env.CBX_ENGINE_ALWAYS !== "1")
+        return null;
+    if (process.env.CBX_ENGINE_SCAN === "off")
+        return null;
+    const answer = await ask(["scan"], {
+        root,
+        shared: rules.shared,
+        local: rules.local,
+        trackedFiles: tracked ? [...tracked.files] : null,
+        trackedFolders: tracked ? [...tracked.folders] : null,
+        exact,
+    });
+    if (!answer || answer.invalidRule || !Array.isArray(answer.files))
+        return null;
+    return answer.files;
+}
+/** For tests: forget what was found, so a changed CBX_ENGINE is read again. */
+function resetEngineForTests() {
+    located = undefined;
+    broken = null;
+}

package/dist/cli/src/bin.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The cbx command.
+ *
+ * `cbx status` in a folder with a local history is the command people run
+ * most, and it needs only that history: no sign-in, no network, none of the
+ * upload, project or workspace code. Answered here it loads a handful of
+ * modules instead of all of the CLI's, which was most of its time. It prints
+ * through the same function the full command table uses (local_status.ts).
+ *
+ * Everything else goes to cli.ts unchanged, and so does status whenever
+ * anything about it is out of the ordinary: other arguments, a Node that is
+ * too old, no local history here, or the unread-messages reminder being due.
+ */
+const reminder_gate_js_1 = require("./reminder_gate.js");
+async function quickStatus() {
+    const argv = process.argv.slice(2);
+    if (argv.length !== 1 || argv[0] !== "status")
+        return null;
+    const { nodeTooOld } = await Promise.resolve().then(() => __importStar(require("./node_check.js")));
+    if (nodeTooOld())
+        return null;
+    if (await (0, reminder_gate_js_1.reminderDue)("status"))
+        return null;
+    const { Repository } = await Promise.resolve().then(() => __importStar(require("../../cbx/src/local/repository.js")));
+    const repository = await Repository.find(process.cwd());
+    if (!repository)
+        return null;
+    const { printLocalStatus, red } = await Promise.resolve().then(() => __importStar(require("./local_status.js")));
+    try {
+        return await printLocalStatus(repository);
+    }
+    catch (error) {
+        /* What localStatus's wrapper prints for anything status itself can raise. */
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+}
+quickStatus().then((code) => {
+    if (code === null) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require("./cli.js").start();
+    }
+    else {
+        process.exitCode = code;
+    }
+}, () => {
+    /* Anything unexpected here: the full command line answers instead. */
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require("./cli.js").start();
+});

package/dist/cli/src/cli.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGISTRY = void 0;
+exports.start = start;
 /**
  * cbx — the CBX engine from the command line, talking to CodeRook.
  *
@@ -502,7 +503,23 @@ async function commandStatus(parsed) {
       send, with the flag that would send them spelled out. The safe default
       does not change: a save adds and updates.
     */
-    const found = await (0, worktree_js_1.changedFiles)(folder, rules, baseline, "synchronize");
+    /*
+      The digests submit keeps, so an unchanged file is not read again just to
+      be reported unchanged. Without them status read and hashed every file in
+      the folder each time it ran. What it learns is kept for the next run.
+    */
+    const knownDigests = link?.repositoryId
+        ? await (0, config_js_1.readDigests)(link.repositoryId)
+        : new Map();
+    let learned = 0;
+    const remember = knownDigests.set.bind(knownDigests);
+    knownDigests.set = (key, value) => {
+        learned += 1;
+        return remember(key, value);
+    };
+    const found = await (0, worktree_js_1.changedFiles)(folder, rules, baseline, "synchronize", knownDigests, undefined, false);
+    if (learned && link?.repositoryId)
+        await (0, config_js_1.writeDigests)(link.repositoryId, knownDigests);
     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.
@@ -4217,7 +4234,8 @@ function leave(code) {
   command table — that every command is listed once, and fits — and must not
   find itself running a command with the test runner's own arguments.
 */
-if (require.main === module) {
+/** Run the command line with this process's arguments. bin.ts calls this for everything it does not answer itself. */
+function start() {
     (0, network_js_1.tuneNetwork)();
     main(node_process_1.default.argv.slice(2))
         .then(leave)
@@ -4226,3 +4244,5 @@ if (require.main === module) {
         leave(1);
     });
 }
+if (require.main === module)
+    start();