@coderook/cli 0.1.0

package/dist/cli/src/config.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentials = exports.DEFAULT_API = void 0;
+exports.apiOrigin = apiOrigin;
+exports.configDirectory = configDirectory;
+exports.storeToken = storeToken;
+exports.loadToken = loadToken;
+exports.clearToken = clearToken;
+exports.readLink = readLink;
+exports.writeLink = writeLink;
+/**
+ * Where the command-line tool keeps its credential and its project links.
+ *
+ * The desktop uses the operating-system vault; a terminal has no such thing
+ * everywhere, so the token lives in a file that only its owner can read. The
+ * location follows each platform's convention rather than scattering dot
+ * directories about.
+ */
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+exports.DEFAULT_API = "https://api.coderook.com";
+function apiOrigin() {
+    return (process.env.CODEROOK_API_URL || exports.DEFAULT_API).replace(/\/+$/, "");
+}
+/** The per-user configuration directory, per platform convention. */
+function configDirectory() {
+    if (process.env.CODEROOK_CONFIG_DIR)
+        return process.env.CODEROOK_CONFIG_DIR;
+    if (process.platform === "win32") {
+        return node_path_1.default.join(process.env.APPDATA ?? node_path_1.default.join((0, node_os_1.homedir)(), "AppData", "Roaming"), "CodeRook");
+    }
+    if (process.platform === "darwin") {
+        return node_path_1.default.join((0, node_os_1.homedir)(), "Library", "Application Support", "CodeRook");
+    }
+    return node_path_1.default.join(process.env.XDG_CONFIG_HOME ?? node_path_1.default.join((0, node_os_1.homedir)(), ".config"), "coderook");
+}
+const tokenFile = () => node_path_1.default.join(configDirectory(), "token");
+const linksFile = () => node_path_1.default.join(configDirectory(), "links.json");
+/** Write a file only its owner can read, and atomically. */
+async function writePrivate(target, body) {
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+    const temporary = `${target}.tmp`;
+    await (0, promises_1.writeFile)(temporary, body, "utf8");
+    // Windows ignores the mode; on everything else this is what keeps the
+    // token out of other accounts' reach.
+    await (0, promises_1.chmod)(temporary, 0o600).catch(() => undefined);
+    await (0, promises_1.rename)(temporary, target);
+}
+async function storeToken(token) {
+    await writePrivate(tokenFile(), `${token.trim()}\n`);
+}
+/**
+ * The token, from the environment first so continuous integration can supply
+ * one without writing anything to disk.
+ */
+async function loadToken() {
+    const fromEnvironment = process.env.CODEROOK_TOKEN?.trim();
+    if (fromEnvironment)
+        return fromEnvironment;
+    try {
+        return (await (0, promises_1.readFile)(tokenFile(), "utf8")).trim();
+    }
+    catch {
+        return "";
+    }
+}
+async function clearToken() {
+    await (0, promises_1.rm)(tokenFile(), { force: true });
+}
+exports.credentials = {
+    origin: apiOrigin,
+    token: loadToken,
+};
+function keyFor(localPath) {
+    return node_path_1.default.resolve(localPath).toLowerCase();
+}
+async function readLinks() {
+    try {
+        return JSON.parse(await (0, promises_1.readFile)(linksFile(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+async function readLink(localPath) {
+    return (await readLinks())[keyFor(localPath)] ?? null;
+}
+async function writeLink(localPath, link) {
+    const links = await readLinks();
+    links[keyFor(localPath)] = link;
+    await writePrivate(linksFile(), JSON.stringify(links, null, 2));
+}

package/dist/desktop-app/src/main/cbx.js

@@ -0,0 +1,455 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOOTER_MAGIC = exports.MANIFEST_MAGIC = exports.CHUNK_MAGIC = exports.HEADER_MAGIC = void 0;
+exports.cutPoints = cutPoints;
+exports.packBundle = packBundle;
+exports.readManifest = readManifest;
+exports.unpackBundle = unpackBundle;
+exports.collectEntries = collectEntries;
+/**
+ * The CodeBox `.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
+ * prototype so that an archive written here can be opened by
+ * `codebox-compression.cmd unpack`, and an archive written by that tool can
+ * be opened here — including format version 2 solid packs.
+ *
+ *   header       <4sHH16s>      CBX1, format version, flags, bundle id
+ *   chunk frame  <4sB3xQQ32s32s> CHNK, codec, raw size, stored size, digests
+ *   manifest     <4sQQ32s>      MANF, raw length, stored length, raw digest
+ *   footer       <4sQQ32s>      CBXF, manifest offset, record length, digest
+ *
+ * Chunks are Zstandard level 3, stored raw unless compression saves at least
+ * two percent, and identified by the SHA-256 of their original bytes.
+ */
+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 node_zlib_1 = require("node:zlib");
+exports.HEADER_MAGIC = "CBX1";
+exports.CHUNK_MAGIC = "CHNK";
+exports.MANIFEST_MAGIC = "MANF";
+exports.FOOTER_MAGIC = "CBXF";
+const HEADER_BYTES = 24;
+const CHUNK_HEADER_BYTES = 88;
+const MANIFEST_HEADER_BYTES = 52;
+const FOOTER_BYTES = 52;
+/** The prototype writes 2 and accepts 1; without solid packs this is a 1. */
+const WRITTEN_FORMAT_VERSION = 1;
+const SUPPORTED_FORMAT_VERSIONS = new Set([1, 2]);
+const CODEC_NONE = 0;
+const CODEC_ZSTD = 1;
+const ZSTD_LEVEL = 3;
+const MIN_COMPRESSION_SAVING = 0.02;
+const READ_SIZE = 8 * 1024 * 1024;
+const MIN_CHUNK_SIZE = 2 * 1024 * 1024;
+const AVG_CHUNK_SIZE = 8 * 1024 * 1024;
+const MAX_CHUNK_SIZE = 32 * 1024 * 1024;
+const zstd = (raw) => (0, node_zlib_1.zstdCompressSync)(raw, {
+    params: { [node_zlib_1.constants.ZSTD_c_compressionLevel]: ZSTD_LEVEL },
+});
+function sha256(data) {
+    return (0, node_crypto_1.createHash)("sha256").update(data).digest("hex");
+}
+/**
+ * Streaming content-defined chunking, as FastCDC does it: a rolling gear
+ * hash cuts where the content says to, so inserting bytes early in a large
+ * file re-cuts one chunk instead of every chunk after it. The prototype uses
+ * the `fastcdc` package; cut positions do not have to agree between writers
+ * for an archive to be readable, because the manifest records the chunk list.
+ */
+const GEAR = (() => {
+    const table = new Uint32Array(256);
+    let seed = 0x9e3779b9;
+    for (let index = 0; index < 256; index += 1) {
+        seed = (Math.imul(seed, 1103515245) + 12345) >>> 0;
+        table[index] = seed;
+    }
+    return table;
+})();
+const NORMAL_MASK = 0x0003_5000;
+const SMALL_MASK = 0x0003_5403;
+/** Cut positions inside `buffer`; the tail is left for the next read. */
+function cutPoints(buffer) {
+    const cuts = [];
+    let from = 0;
+    let hash = 0;
+    for (let at = 0; at < buffer.length; at += 1) {
+        hash = ((hash << 1) + GEAR[buffer[at]]) >>> 0;
+        const length = at - from + 1;
+        if (length < MIN_CHUNK_SIZE)
+            continue;
+        const mask = length < AVG_CHUNK_SIZE ? SMALL_MASK : NORMAL_MASK;
+        if (length >= MAX_CHUNK_SIZE || (hash & mask) === 0) {
+            cuts.push(at + 1);
+            from = at + 1;
+            hash = 0;
+        }
+    }
+    return cuts;
+}
+function chunkFrame(raw) {
+    const rawDigest = (0, node_crypto_1.createHash)("sha256").update(raw).digest();
+    let codec = CODEC_NONE;
+    let stored = raw;
+    if (raw.length) {
+        const squeezed = zstd(raw);
+        // Raw storage unless compression is worth at least the stated margin.
+        if (squeezed.length <= raw.length * (1 - MIN_COMPRESSION_SAVING)) {
+            codec = CODEC_ZSTD;
+            stored = squeezed;
+        }
+    }
+    const storedDigest = (0, node_crypto_1.createHash)("sha256").update(stored).digest();
+    const head = Buffer.alloc(CHUNK_HEADER_BYTES);
+    head.write(exports.CHUNK_MAGIC, 0, "latin1");
+    head.writeUInt8(codec, 4);
+    // Three padding bytes, as the "3x" in the struct format.
+    head.writeBigUInt64LE(BigInt(raw.length), 8);
+    head.writeBigUInt64LE(BigInt(stored.length), 16);
+    rawDigest.copy(head, 24);
+    storedDigest.copy(head, 56);
+    return {
+        frame: Buffer.concat([head, stored]),
+        record: {
+            raw_size: raw.length,
+            stored_size: stored.length,
+            codec,
+            stored_sha256: storedDigest.toString("hex"),
+        },
+    };
+}
+/**
+ * Write a bundle. Frames stream out as files are read, and the completed
+ * file is renamed into place only at the end, so an interrupted pack leaves
+ * a `.partial` that is never mistaken for a finished archive.
+ */
+async function packBundle(request, report) {
+    const partial = `${request.target}.partial`;
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(node_path_1.default.resolve(request.target)), { recursive: true });
+    const handle = await (0, promises_1.open)(partial, "w");
+    const chunks = {};
+    const files = [];
+    const directories = new Set();
+    let offset = 0;
+    let duplicateBytes = 0;
+    let compressedChunks = 0;
+    let sourceBytes = 0;
+    const append = async (data) => {
+        const at = offset;
+        await handle.write(data, 0, data.length, at);
+        offset += data.length;
+        return at;
+    };
+    try {
+        const header = Buffer.alloc(HEADER_BYTES);
+        header.write(exports.HEADER_MAGIC, 0, "latin1");
+        header.writeUInt16LE(WRITTEN_FORMAT_VERSION, 4);
+        header.writeUInt16LE(0, 6);
+        (0, node_crypto_1.randomBytes)(16).copy(header, 8);
+        await append(header);
+        let totalBytes = 0;
+        const sizes = new Map();
+        for (const relative of request.entries) {
+            const info = await (0, promises_1.stat)(node_path_1.default.join(request.root, relative));
+            sizes.set(relative, {
+                size: info.size,
+                mtimeNs: Number(info.mtimeMs) * 1e6,
+                mode: info.mode,
+            });
+            totalBytes += info.size;
+            const parent = node_path_1.default.posix.dirname(relative);
+            if (parent && parent !== ".")
+                directories.add(parent);
+        }
+        for (const [position, relative] of request.entries.entries()) {
+            const details = sizes.get(relative);
+            report?.({
+                files: position,
+                totalFiles: request.entries.length,
+                bytes: sourceBytes,
+                totalBytes,
+                path: relative,
+                percent: Math.round((sourceBytes / Math.max(totalBytes, 1)) * 100),
+            });
+            const whole = (0, node_crypto_1.createHash)("sha256");
+            const references = [];
+            const emit = async (raw) => {
+                const digest = sha256(raw);
+                references.push(digest);
+                if (chunks[digest]) {
+                    duplicateBytes += raw.length;
+                    return;
+                }
+                const { frame, record } = chunkFrame(raw);
+                const at = await append(frame);
+                chunks[digest] = { payload_offset: at + CHUNK_HEADER_BYTES, ...record };
+                if (record.codec === CODEC_ZSTD)
+                    compressedChunks += 1;
+            };
+            let pending = Buffer.alloc(0);
+            for await (const piece of (0, node_fs_1.createReadStream)(node_path_1.default.join(request.root, relative), { highWaterMark: READ_SIZE })) {
+                const block = Buffer.from(piece);
+                whole.update(block);
+                pending = pending.length ? Buffer.concat([pending, block]) : block;
+                let from = 0;
+                for (const cut of cutPoints(pending)) {
+                    await emit(pending.subarray(from, cut));
+                    from = cut;
+                }
+                pending = pending.subarray(from);
+            }
+            if (pending.length)
+                await emit(pending);
+            files.push({
+                path: relative,
+                size: details.size,
+                mtime_ns: Math.round(details.mtimeNs),
+                mode: details.mode,
+                sha256: whole.digest("hex"),
+                chunks: references,
+                logical_stored_bytes: references.reduce((total, digest) => total + (chunks[digest]?.stored_size ?? 0), 0),
+            });
+            sourceBytes += details.size;
+        }
+        const manifest = {
+            format: "cbx-prototype",
+            format_version: WRITTEN_FORMAT_VERSION,
+            source_name: request.sourceName,
+            source_kind: request.sourceKind ?? "directory",
+            created_unix_ns: Date.now() * 1e6,
+            chunking: {
+                algorithm: "gear-streaming",
+                min_size: MIN_CHUNK_SIZE,
+                avg_size: AVG_CHUNK_SIZE,
+                max_size: MAX_CHUNK_SIZE,
+                read_size: READ_SIZE,
+                small_file_packing: { enabled: false },
+            },
+            compression: {
+                codec: "zstd",
+                level: ZSTD_LEVEL,
+                minimum_saving: MIN_COMPRESSION_SAVING,
+            },
+            directories: [...directories].sort(),
+            skipped_links: [],
+            files,
+            chunks,
+        };
+        const manifestRaw = Buffer.from(JSON.stringify(manifest), "utf8");
+        const manifestStored = zstd(manifestRaw);
+        const manifestDigest = (0, node_crypto_1.createHash)("sha256").update(manifestRaw).digest();
+        const manifestHead = Buffer.alloc(MANIFEST_HEADER_BYTES);
+        manifestHead.write(exports.MANIFEST_MAGIC, 0, "latin1");
+        manifestHead.writeBigUInt64LE(BigInt(manifestRaw.length), 4);
+        manifestHead.writeBigUInt64LE(BigInt(manifestStored.length), 12);
+        manifestDigest.copy(manifestHead, 20);
+        const manifestRecord = Buffer.concat([manifestHead, manifestStored]);
+        const manifestOffset = await append(manifestRecord);
+        const footer = Buffer.alloc(FOOTER_BYTES);
+        footer.write(exports.FOOTER_MAGIC, 0, "latin1");
+        footer.writeBigUInt64LE(BigInt(manifestOffset), 4);
+        footer.writeBigUInt64LE(BigInt(manifestRecord.length), 12);
+        manifestDigest.copy(footer, 20);
+        await append(footer);
+        await handle.sync();
+        await handle.close();
+        await (0, promises_1.rm)(request.target, { force: true });
+        await (0, promises_1.rename)(partial, request.target);
+        return {
+            archiveBytes: offset,
+            sourceBytes,
+            uniqueChunks: Object.keys(chunks).length,
+            compressedChunks,
+            duplicateBytes,
+        };
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        await (0, promises_1.rm)(partial, { force: true });
+        throw error;
+    }
+}
+/** Read a bundle's manifest without touching a single chunk payload. */
+async function readManifest(source) {
+    const handle = await (0, promises_1.open)(source, "r");
+    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");
+        }
+        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");
+        }
+        const version = header.readUInt16LE(4);
+        if (!SUPPORTED_FORMAT_VERSIONS.has(version)) {
+            throw new Error(`This bundle needs a newer CodeRook (format ${version})`);
+        }
+        const footer = Buffer.alloc(FOOTER_BYTES);
+        await handle.read(footer, 0, FOOTER_BYTES, size - FOOTER_BYTES);
+        if (footer.subarray(0, 4).toString("latin1") !== exports.FOOTER_MAGIC) {
+            throw new Error("That bundle is incomplete");
+        }
+        const manifestOffset = Number(footer.readBigUInt64LE(4));
+        const recordLength = Number(footer.readBigUInt64LE(12));
+        const expected = footer.subarray(20, 52).toString("hex");
+        const record = Buffer.alloc(recordLength);
+        await handle.read(record, 0, recordLength, manifestOffset);
+        if (record.subarray(0, 4).toString("latin1") !== exports.MANIFEST_MAGIC) {
+            throw new Error("That bundle's manifest record is not where it should be");
+        }
+        const rawLength = Number(record.readBigUInt64LE(4));
+        const storedLength = Number(record.readBigUInt64LE(12));
+        if (record.subarray(20, 52).toString("hex") !== expected) {
+            throw new Error("That bundle's manifest digests disagree");
+        }
+        const stored = record.subarray(MANIFEST_HEADER_BYTES, MANIFEST_HEADER_BYTES + storedLength);
+        const raw = (0, node_zlib_1.zstdDecompressSync)(stored);
+        if (raw.length !== rawLength || sha256(raw) !== expected) {
+            throw new Error("That bundle's manifest does not match its checksum");
+        }
+        return JSON.parse(raw.toString("utf8"));
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Extract a bundle into `destination`. Everything is written to a staging
+ * directory beside it and moved into place only once every file has been
+ * verified against the digest the manifest recorded, so a damaged archive
+ * cannot leave a half-written tree looking like a finished project.
+ */
+async function unpackBundle(source, destination, report) {
+    const manifest = await readManifest(source);
+    const handle = await (0, promises_1.open)(source, "r");
+    const staging = `${destination}.incoming`;
+    await (0, promises_1.rm)(staging, { recursive: true, force: true });
+    // Solid packs mean several small files share one decoded chunk, so a
+    // bounded cache stops the same block being decompressed for each of them.
+    const cache = new Map();
+    let cached = 0;
+    const chunkBytes = async (digest) => {
+        const held = cache.get(digest);
+        if (held)
+            return held;
+        const record = manifest.chunks[digest];
+        if (!record)
+            throw new Error(`The bundle is missing chunk ${digest.slice(0, 12)}`);
+        const stored = Buffer.alloc(record.stored_size);
+        await handle.read(stored, 0, record.stored_size, record.payload_offset);
+        if (sha256(stored) !== record.stored_sha256) {
+            throw new Error("A chunk in that bundle is damaged");
+        }
+        const raw = record.codec === CODEC_ZSTD ? (0, node_zlib_1.zstdDecompressSync)(stored) : stored;
+        if (raw.length !== record.raw_size || sha256(raw) !== digest) {
+            throw new Error("A chunk in that bundle does not match its identity");
+        }
+        if (cached + raw.length <= 64 * 1024 * 1024) {
+            cache.set(digest, raw);
+            cached += raw.length;
+        }
+        return raw;
+    };
+    try {
+        const totalBytes = manifest.files.reduce((total, file) => total + file.size, 0);
+        let written = 0;
+        let bytes = 0;
+        for (const directory of manifest.directories ?? []) {
+            const parts = safeParts(directory);
+            if (parts.length)
+                await (0, promises_1.mkdir)(node_path_1.default.join(staging, ...parts), { recursive: true });
+        }
+        for (const record of manifest.files) {
+            report?.({
+                files: written,
+                totalFiles: manifest.files.length,
+                bytes,
+                totalBytes,
+                path: record.path,
+                percent: Math.round((bytes / Math.max(totalBytes, 1)) * 100),
+            });
+            const parts = safeParts(record.path);
+            if (!parts.length)
+                throw new Error(`Unsafe path in bundle: ${record.path}`);
+            const full = node_path_1.default.join(staging, ...parts);
+            await (0, promises_1.mkdir)(node_path_1.default.dirname(full), { recursive: true });
+            const pieces = [];
+            if (record.segments) {
+                for (const segment of record.segments) {
+                    const raw = await chunkBytes(segment.chunk);
+                    const end = segment.offset + segment.length;
+                    if (segment.offset < 0 || end > raw.length) {
+                        throw new Error(`Invalid solid segment in ${record.path}`);
+                    }
+                    pieces.push(raw.subarray(segment.offset, end));
+                }
+            }
+            else {
+                for (const digest of record.chunks ?? [])
+                    pieces.push(await chunkBytes(digest));
+            }
+            const contents = Buffer.concat(pieces);
+            if (contents.length !== record.size || sha256(contents) !== record.sha256) {
+                throw new Error(`${record.path} did not survive the bundle intact`);
+            }
+            await (0, promises_1.writeFile)(full, contents);
+            written += 1;
+            bytes += contents.length;
+        }
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(node_path_1.default.resolve(destination)), { recursive: true });
+        await (0, promises_1.rm)(destination, { recursive: true, force: true });
+        await (0, promises_1.rename)(staging, destination);
+        report?.({
+            files: written,
+            totalFiles: manifest.files.length,
+            bytes,
+            totalBytes,
+            path: "Done",
+            percent: 100,
+        });
+        return { files: written, bytes };
+    }
+    catch (error) {
+        await (0, promises_1.rm)(staging, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Reject anything that would escape the destination before it is used. */
+function safeParts(relative) {
+    const parts = relative.split(/[\\/]/).filter((part) => part && part !== ".");
+    if (parts.some((part) => part === ".." || part.includes("\0")))
+        return [];
+    if (node_path_1.default.isAbsolute(relative) || /^[a-zA-Z]:/.test(relative))
+        return [];
+    return parts;
+}
+/** Every file under `root`, relative and POSIX-separated, sorted. */
+async function collectEntries(root) {
+    const found = [];
+    const walk = async (directory) => {
+        for (const entry of await (0, promises_1.readdir)(directory, { withFileTypes: true })) {
+            const full = node_path_1.default.join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else if (entry.isFile()) {
+                found.push(node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/"));
+            }
+        }
+    };
+    await walk(root);
+    return found.sort();
+}

package/dist/desktop-app/src/main/credentials.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });