@coderook/cli 0.34.11 → 0.35.0

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

package/README.md

@@ -462,6 +462,46 @@ https://api.coderook.com/v1/public/projects/OWNER/SLUG/releases
 https://api.coderook.com/v1/public/projects/OWNER/SLUG/updates      electron-updater's generic provider
 ```
 
+## Mod repositories for games
+
+A mod repository is where a game's players get mods from. The game's maker
+sets one up and its rules; modders publish with their own accounts; nothing is
+listed until it passes those rules and a malware scan.
+
+```
+cbx mods create my-game --name "My Game" --allow .png,.ogg,.json --nested .pak
+cbx mods builds my-game --new                 a build secret for the game, shown once
+cbx mods builds my-game --register secret.bin or your own, never printed
+cbx mods info my-game                         the address and public key to pin
+cbx mods settings my-game --uploads owner     change the rules
+```
+
+Rules: `--allow` and `--block` for file types (programs and scripts such as
+`.exe`, `.dll`, `.ps1` and `.js` are refused in every repository, and so is a
+file that is really a program whatever it is called), `--nested` for archive
+types that are opened and checked too, `--manifest` and `--fields` for the
+manifest each part carries (`mod.json` by default) and which of its fields must
+match, `--max-part`, `--max-files`, `--max-parts` and `--max-ratio` for size,
+and `--uploads anyone|owner`.
+
+```
+cbx mods publish ./BetterTrees --repo my-game              zip, upload, wait for the checks
+cbx mods publish ./HD-Art --repo my-game --part animals    one part of a bigger mod
+cbx mods list my-game                                      your mods and how their checks went
+cbx mods remove better-trees --repo my-game
+```
+
+`publish` reads the folder's manifest for the mod's id, name, folder and
+version (`--id`, `--name`, `--folder` and `--version` override it), writes the
+manifest the repository expects into the zip, uploads in pieces that are
+retried, and waits up to 30 minutes for the result; `--no-wait` returns
+straight away. A rejected part says what was wrong, file by file.
+
+The owner also has `cbx mods reports`, `cbx mods block <username> --take-down`,
+`cbx mods list --all`, `cbx mods remove --as-owner` and `cbx mods delete`.
+How the game signs its requests and checks the catalogue is at
+<https://coderook.com/docs#mod-repositories>.
+
 ## Building for every platform
 
 ```

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

@@ -1614,10 +1614,29 @@ const SECRET_SUFFIXES = [".pem", ".key", ".p12", ".pfx", ".keystore", ".jks"];
   the answer be a rule — one line in .gitignore covers the lot, where a list
   of the files inside it would go stale the moment the program ran again.
 */
+/** Chromium's disk cache: an index beside data_N blocks, Cache_Data, or the js/wasm code cache. */
+async function looksLikeBrowserCache(directory) {
+    const names = new Set((await (0, promises_1.readdir)(directory).catch(() => [])).map((name) => name.toLowerCase()));
+    if (names.has("cache_data") || names.has("index-dir"))
+        return true;
+    if (names.has("index") && names.has("data_0"))
+        return true;
+    return names.has("js") && names.has("wasm");
+}
 const PRIVATE_DIRECTORIES = [
     {
-        match: /^(Local Storage|Session Storage|IndexedDB|Service Worker|Cache|Code Cache|GPUCache)$/i,
+        match: /^(Local Storage|Session Storage|IndexedDB|Service Worker)$/i,
+        because: "a browser profile, which holds the sites you are signed in to",
+    },
+    /*
+      "Cache" is also an ordinary name for source: FreeType keeps ftcache.c in
+      `src/cache`, and a Godot checkout was refused as "a browser profile" for
+      it. So these three only count when what is inside is a browser's cache.
+    */
+    {
+        match: /^(Cache|Code Cache|GPUCache)$/i,
         because: "a browser profile, which holds the sites you are signed in to",
+        inside: looksLikeBrowserCache,
     },
     { match: /^\.wrangler$/i, because: "local service state, including emulated databases" },
     { match: /^\.aws$/i, because: "cloud credentials" },
@@ -1667,7 +1686,15 @@ async function detectPrivateDirectories(root) {
                 continue;
             const full = node_path_1.default.join(directory, entry.name);
             const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
-            const rule = PRIVATE_DIRECTORIES.find((candidate) => candidate.match.test(entry.name));
+            let rule;
+            for (const candidate of PRIVATE_DIRECTORIES) {
+                if (!candidate.match.test(entry.name))
+                    continue;
+                if (candidate.inside && !(await candidate.inside(full)))
+                    continue;
+                rule = candidate;
+                break;
+            }
             if (rule) {
                 found.push({
                     path: relative,

package/dist/cli/src/cli.js

@@ -31,6 +31,7 @@ const attach_command_js_1 = require("./attach_command.js");
 const build_command_js_1 = require("./build_command.js");
 const node_check_js_1 = require("./node_check.js");
 const pages_command_js_1 = require("./pages_command.js");
+const mods_command_js_1 = require("./mods_command.js");
 const project_commands_js_1 = require("./project_commands.js");
 const track_commands_js_1 = require("./track_commands.js");
 const tracks_js_1 = require("../../cbx/src/core/tracks.js");
@@ -2792,6 +2793,72 @@ const SPECS = [
         ],
         run: pages_command_js_1.commandPages,
     },
+    {
+        name: "mods",
+        group: "Your projects",
+        summary: "mod repositories for games: set one up, publish to one",
+        usage: "mods <create|repos|info|settings|builds|list|publish|remove|block|reports|delete> …",
+        detail: "A mod repository is where a game's players get mods from. Its owner\n" +
+            "sets the rules — which file types a mod may hold, archives opened and\n" +
+            "checked too, the manifest each upload carries, size limits, and whether\n" +
+            "anybody or only the owner may upload. Modders publish with their own\n" +
+            "CodeRook accounts; nothing is listed until it passes the rules and a\n" +
+            "malware scan, and anything that runs (.exe, .dll, scripts) is refused\n" +
+            "in every repository. The game's client reads a catalogue signed with\n" +
+            "the repository's own key: see coderook.com/docs#mod-repositories.\n\n" +
+            "  create <repo> --name \"Game\"   set one up; prints its address and public key\n" +
+            "  repos                          the repositories you run\n" +
+            "  info <repo>                    a repository's rules, for anybody\n" +
+            "  settings <repo> [rules…]       change the rules (owner)\n" +
+            "  builds <repo>                  game builds allowed to read it (owner)\n" +
+            "  publish <folder|zip> --repo <repo>   upload a mod; waits for its checks\n" +
+            "  list <repo> [--all]            your mods and how their checks went\n" +
+            "  remove <mod> --repo <repo>     take a mod down\n" +
+            "  block <username> --repo <repo> stop an uploader (owner)\n" +
+            "  reports <repo>                 what players reported (owner)\n" +
+            "  delete <repo>                  delete a repository and everything in it",
+        options: [
+            { flags: "--name <text>", description: "create/settings: the game's name" },
+            { flags: "--allow <exts>", description: "create/settings: file types a mod may hold, e.g. .png,.json" },
+            { flags: "--nested <exts>", description: "create/settings: archives inside a mod that are opened and checked too" },
+            { flags: "--manifest <file|none>", description: "create/settings: the manifest every part carries (default mod.json)" },
+            { flags: "--fields <list>", description: "create/settings: manifest fields that must match: id,name,folder,version" },
+            { flags: "--uploads <anyone|owner>", description: "create/settings: who may upload" },
+            { flags: "--max-part <size>", description: "create/settings: largest part, e.g. 2GB" },
+            { flags: "--register <file>", description: "builds: register the build secret in this file (never printed)" },
+            { flags: "--new", description: "builds: have the service make a build secret (shown once)" },
+            { flags: "--off <id>", description: "builds: turn a build off" },
+            { flags: "--repo <repo>", description: "publish/list/remove/block: which repository" },
+            { flags: "--part <id>", description: "publish: which part of the mod this is (default main)" },
+            { flags: "--id <mod>", description: "publish: the mod's id (default: manifest, then folder name)" },
+            { flags: "--version <v>", description: "publish: the mod's version" },
+            { flags: "--folder <name>", description: "publish: the folder the game installs it into" },
+            { flags: "--part-name <text>", description: "publish: a readable name for the part" },
+            { flags: "--about <text>", description: "create/settings/publish: a description" },
+            { flags: "--notice <text>", description: "publish: a notice shown with the mod (credits, licences)" },
+            { flags: "--block <exts>", description: "create/settings: more file types to refuse" },
+            { flags: "--max-files <n>", description: "create/settings: most files in a part" },
+            { flags: "--max-ratio <n>", description: "create/settings: how many times its size a part may unpack to" },
+            { flags: "--max-parts <n>", description: "create/settings: most parts in a mod" },
+            { flags: "--expires <date>", description: "builds: when a registered build stops working" },
+            { flags: "--all", description: "list: every mod in the repository (owner)" },
+            { flags: "--as-owner", description: "remove: as the repository's owner, any mod" },
+            { flags: "--disable", description: "settings: stop serving and taking uploads" },
+            { flags: "--enable", description: "settings: start again" },
+            { flags: "--undo", description: "block: let the uploader back in" },
+            { flags: "-y, --yes", description: "remove/delete: without asking" },
+            { flags: "--no-wait", description: "publish: do not wait for the checks" },
+            { flags: "--take-down", description: "block: also hide the uploader's mods" },
+        ],
+        examples: [
+            'cbx mods create my-game --name "My Game" --allow .png,.ogg,.json --nested .pak',
+            "cbx mods builds my-game --register release/build-secret.bin",
+            "cbx mods publish ./mods/BetterTrees --repo my-game",
+            "cbx mods list my-game",
+            "cbx mods publish ./HD-Art --repo zt1 --part animals",
+        ],
+        run: mods_command_js_1.commandMods,
+    },
     {
         name: "issues",
         group: "Your projects",

package/dist/cli/src/mods_command.js

@@ -0,0 +1,518 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandMods = commandMods;
+/**
+ * cbx mods — mod repositories for games.
+ *
+ * A game's developer sets one up (`cbx mods create`) and gets an address and
+ * a public key to build into the game; modders publish to it with their own
+ * CodeRook accounts (`cbx mods publish`), and nothing they send is listed
+ * until it passes the repository's checks and a malware scan. The game's own
+ * client reads the signed catalogue and downloads; that side is a protocol,
+ * described in the docs, not something this command does.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const promises_2 = require("node:readline/promises");
+const config_js_1 = require("./config.js");
+const colour_js_1 = require("./colour.js");
+const zip_writer_js_1 = require("./zip_writer.js");
+const ROOT = "/v1/modrepo";
+function modsOrigin() {
+    return (node_process_1.default.env.CODEROOK_MODS_URL ?? "https://mods.coderook.com").replace(/\/+$/, "");
+}
+const flag = (parsed, ...names) => {
+    for (const name of names) {
+        const value = parsed.flags.get(name);
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+};
+const has = (parsed, ...names) => names.some((name) => parsed.flags.has(name));
+async function call(route, method = "GET", body, raw, auth = true) {
+    const headers = { accept: "application/json", "user-agent": "CodeRook-CLI/0.1" };
+    if (auth) {
+        const token = await (0, config_js_1.loadToken)();
+        if (!token)
+            throw new Error("Not signed in. Run: cbx sign-in");
+        headers.authorization = `Bearer ${token}`;
+    }
+    if (body !== undefined)
+        headers["content-type"] = "application/json";
+    if (raw)
+        headers["content-type"] = "application/octet-stream";
+    const response = await fetch(`${modsOrigin()}${route}`, {
+        method,
+        headers,
+        body: raw ?? (body === undefined ? undefined : JSON.stringify(body)),
+    });
+    const text = await response.text();
+    let parsed = {};
+    try {
+        parsed = text ? JSON.parse(text) : {};
+    }
+    catch {
+        parsed = { message: text.slice(0, 200) };
+    }
+    return { status: response.status, body: parsed };
+}
+function fail(answer, doing) {
+    if (answer.status === 401) {
+        console.error((0, colour_js_1.red)(`${doing}: not allowed. Sign in with cbx sign-in, and check you own this repository.`));
+    }
+    else {
+        console.error((0, colour_js_1.red)(`${doing}: ${answer.body.message ?? answer.body.error ?? `failed (${answer.status})`}`));
+    }
+    return 1;
+}
+const list = (text) => text === undefined ? undefined : text.split(",").map((one) => one.trim()).filter(Boolean).map((e) => (e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`));
+/** Rules named on the command line, for create and settings. */
+function settingsFrom(parsed) {
+    const settings = {};
+    const allowed = list(flag(parsed, "allow"));
+    const blocked = list(flag(parsed, "block"));
+    const nested = list(flag(parsed, "nested"));
+    if (allowed)
+        settings.allowed = allowed;
+    if (blocked)
+        settings.blocked = blocked;
+    if (nested)
+        settings.nested = nested;
+    const manifest = flag(parsed, "manifest");
+    if (manifest !== undefined)
+        settings.manifest = manifest === "none" ? null : manifest;
+    const fields = flag(parsed, "fields");
+    if (fields !== undefined)
+        settings.manifestFields = fields.split(",").map((f) => f.trim()).filter(Boolean);
+    for (const [name, key] of [["max-files", "maxFiles"], ["max-ratio", "maxRatio"], ["max-parts", "maxParts"]]) {
+        const value = flag(parsed, name);
+        if (value !== undefined)
+            settings[key] = Number(value);
+    }
+    const maxPart = flag(parsed, "max-part");
+    if (maxPart !== undefined)
+        settings.maxPartBytes = parseSize(maxPart);
+    const uploads = flag(parsed, "uploads");
+    if (uploads !== undefined)
+        settings.uploads = uploads;
+    return settings;
+}
+function parseSize(text) {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(text.trim());
+    if (!match)
+        return Number.NaN;
+    const unit = (match[2] ?? "b").toLowerCase();
+    const factor = unit === "gb" ? 1024 ** 3 : unit === "mb" ? 1024 ** 2 : unit === "kb" ? 1024 : 1;
+    return Math.round(Number(match[1]) * factor);
+}
+function bytes(n) {
+    if (n === null || n === undefined)
+        return "—";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = n;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(unit ? 1 : 0)} ${units[unit]}`;
+}
+function printRepo(view) {
+    console.log(`${(0, colour_js_1.bold)(view.name)}  ${(0, colour_js_1.dim)(view.repo)}`);
+    if (view.about)
+        console.log((0, colour_js_1.dim)(view.about));
+    console.log(`Address     ${(0, colour_js_1.accent)(view.base)}`);
+    console.log(`Public key  ${view.publicKey}`);
+    console.log(`Uploads     ${view.rules.uploads === "anyone" ? "any CodeRook account" : "the owner only"}`);
+    console.log(`Allowed     ${view.rules.allowed.join(" ") || "(nothing)"}`);
+    if (view.rules.nested.length)
+        console.log(`Opened too  ${view.rules.nested.join(" ")} (files inside may have no extension)`);
+    console.log(`Manifest    ${view.rules.manifest ? `${view.rules.manifest}, matching ${view.rules.manifestFields.join(", ")}` : "none"}`);
+    console.log(`Limits      ${view.rules.maxFiles.toLocaleString()} files, ${bytes(view.rules.maxPartBytes)} a part, ${view.rules.maxParts} parts, unpacked ≤ ${view.rules.maxRatio}× the zip`);
+    console.log((0, colour_js_1.dim)(`Never allowed: ${view.rules.blocked.join(" ")}`));
+}
+/* ------------------------------------------------------------------ subcommands */
+async function create(parsed) {
+    const slug = parsed.positional[1];
+    const name = flag(parsed, "name");
+    if (!slug || !name) {
+        console.error((0, colour_js_1.red)('Usage: cbx mods create <repo> --name "Game name" [--allow .png,.json] [--nested .pak] [--manifest mod.json] [--uploads anyone|owner]'));
+        return 1;
+    }
+    const answer = await call(ROOT, "POST", { repo: slug, name, about: flag(parsed, "about"), settings: settingsFrom(parsed) });
+    if (answer.status !== 201)
+        return fail(answer, "Creating the repository");
+    console.log((0, colour_js_1.green)(`Created ${answer.body.repo}.`));
+    printRepo(answer.body);
+    console.log((0, colour_js_1.dim)("\nBuild the public key into your game to check the catalogue's signature, and register your\n") +
+        (0, colour_js_1.dim)("game's build secret with: ") + (0, colour_js_1.accent)(`cbx mods builds ${answer.body.repo} --register <file>`));
+    return 0;
+}
+async function repos() {
+    const answer = await call(`${ROOT}/mine`);
+    if (answer.status !== 200)
+        return fail(answer, "Listing your repositories");
+    if (!answer.body.repos.length) {
+        console.log((0, colour_js_1.dim)("You have no mod repositories. Create one with: ") + (0, colour_js_1.accent)('cbx mods create <repo> --name "Game"'));
+        return 0;
+    }
+    for (const view of answer.body.repos)
+        console.log(`${(0, colour_js_1.accent)(view.repo.padEnd(24))} ${view.name}  ${(0, colour_js_1.dim)(view.base)}`);
+    return 0;
+}
+async function info(parsed) {
+    const slug = parsed.positional[1];
+    if (!slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods info <repo>"));
+        return 1;
+    }
+    const answer = await call(`${ROOT}/${encodeURIComponent(slug)}/info`, "GET", undefined, undefined, false);
+    if (answer.status !== 200)
+        return fail(answer, `Reading ${slug}`);
+    printRepo(answer.body);
+    return 0;
+}
+async function settings(parsed) {
+    const slug = parsed.positional[1];
+    if (!slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods settings <repo> [--allow …] [--uploads anyone|owner] …"));
+        return 1;
+    }
+    const changes = settingsFrom(parsed);
+    const name = flag(parsed, "name");
+    const about = flag(parsed, "about");
+    const body = {};
+    if (Object.keys(changes).length)
+        body.settings = changes;
+    if (name !== undefined)
+        body.name = name;
+    if (about !== undefined)
+        body.about = about;
+    if (has(parsed, "disable"))
+        body.disabled = true;
+    if (has(parsed, "enable"))
+        body.disabled = false;
+    const route = `${ROOT}/${encodeURIComponent(slug)}/admin/settings`;
+    const answer = Object.keys(body).length ? await call(route, "PUT", body) : await call(route);
+    if (answer.status !== 200)
+        return fail(answer, `Settings for ${slug}`);
+    if (Object.keys(body).length)
+        console.log((0, colour_js_1.green)("Saved."));
+    printRepo(answer.body);
+    return 0;
+}
+async function builds(parsed) {
+    const slug = parsed.positional[1];
+    if (!slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods builds <repo> [--register <file> | --new | --off <id>]"));
+        return 1;
+    }
+    const base = `${ROOT}/${encodeURIComponent(slug)}/admin/builds`;
+    const off = flag(parsed, "off");
+    if (off) {
+        const answer = await call(`${base}/${encodeURIComponent(off)}`, "DELETE");
+        if (answer.status !== 200)
+            return fail(answer, `Turning off ${off}`);
+        console.log((0, colour_js_1.green)(`Build ${off} is off: its signatures are refused from now on.`));
+        return 0;
+    }
+    const register = flag(parsed, "register");
+    const expires = flag(parsed, "expires");
+    if (register || has(parsed, "new")) {
+        let body = {};
+        if (register) {
+            /* The secret is read from a file and sent straight to the service; it is never printed or passed on a command line. */
+            const secret = (await (0, promises_1.readFile)(register, "utf8")).trim().toLowerCase();
+            const hexSecret = /^[0-9a-f]{64}$/.test(secret) ? secret : Buffer.from(await (0, promises_1.readFile)(register)).length === 32 ? Buffer.from(await (0, promises_1.readFile)(register)).toString("hex") : "";
+            if (!hexSecret) {
+                console.error((0, colour_js_1.red)("The file must hold the 32-byte build secret, raw or as 64 hex characters."));
+                return 1;
+            }
+            body = { secret: hexSecret };
+        }
+        if (expires)
+            body.expires = expires;
+        const answer = await call(base, "POST", body);
+        if (answer.status !== 201)
+            return fail(answer, "Registering the build");
+        console.log((0, colour_js_1.green)(`Build ${answer.body.build} registered.`));
+        if (answer.body.secret) {
+            console.log((0, colour_js_1.bold)("Secret (shown once — compile it into this build and keep it out of any repository):"));
+            console.log(answer.body.secret);
+        }
+        return 0;
+    }
+    const answer = await call(base);
+    if (answer.status !== 200)
+        return fail(answer, `Builds of ${slug}`);
+    if (!answer.body.builds.length)
+        console.log((0, colour_js_1.dim)("No builds registered yet."));
+    for (const b of answer.body.builds) {
+        console.log(`${b.disabled ? (0, colour_js_1.dim)(b.build) : (0, colour_js_1.accent)(b.build)}  ${b.disabled ? (0, colour_js_1.red)("off") : (0, colour_js_1.green)("on ")}  ${(0, colour_js_1.dim)(`since ${b.created.slice(0, 10)}${b.expires ? `, until ${b.expires.slice(0, 10)}` : ""}`)}`);
+    }
+    return 0;
+}
+function printMod(mod) {
+    console.log(`${(0, colour_js_1.bold)(mod.entry.name)}  ${(0, colour_js_1.dim)(mod.mod)}${mod.entry.version ? (0, colour_js_1.dim)(`  v${mod.entry.version}`) : ""}${mod.hidden ? (0, colour_js_1.red)("  hidden") : ""}`);
+    for (const part of mod.parts) {
+        const state = part.check.state;
+        const colour = state === "live" ? colour_js_1.green : state === "rejected" || state === "error" ? colour_js_1.red : colour_js_1.accent;
+        const live = part.live ? (0, colour_js_1.dim)(`  live: ${bytes(part.live.size)}, ${part.live.files.toLocaleString()} files`) : (0, colour_js_1.dim)("  not listed");
+        console.log(`  ${part.part.padEnd(16)} ${colour(state)}${live}`);
+        for (const problem of part.check.problems ?? [])
+            console.log(`    ${(0, colour_js_1.red)("·")} ${problem}`);
+        for (const found of part.check.infected ?? [])
+            console.log(`    ${(0, colour_js_1.red)("✗")} ${found.path}: ${found.signature}`);
+    }
+}
+async function mine(parsed) {
+    const slug = flag(parsed, "repo") ?? parsed.positional[1];
+    if (!slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods list <repo>"));
+        return 1;
+    }
+    const route = has(parsed, "all") ? `${ROOT}/${encodeURIComponent(slug)}/admin/mods` : `${ROOT}/${encodeURIComponent(slug)}/my/mods`;
+    const answer = await call(route);
+    if (answer.status !== 200)
+        return fail(answer, `Mods in ${slug}`);
+    if (!answer.body.mods.length)
+        console.log((0, colour_js_1.dim)("No mods yet. Publish one with: ") + (0, colour_js_1.accent)(`cbx mods publish <folder> --repo ${slug}`));
+    for (const mod of answer.body.mods)
+        printMod(mod);
+    return 0;
+}
+async function sha256File(file) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    for await (const chunk of (0, node_fs_1.createReadStream)(file))
+        hash.update(chunk);
+    return hash.digest("hex");
+}
+async function readChunk(file, start, length) {
+    const parts = [];
+    for await (const chunk of (0, node_fs_1.createReadStream)(file, { start, end: start + length - 1 }))
+        parts.push(chunk);
+    return new Uint8Array(Buffer.concat(parts));
+}
+async function publish(parsed) {
+    const target = parsed.positional[1];
+    const slug = flag(parsed, "repo");
+    if (!target || !slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods publish <folder|zip> --repo <repo> [--part <id>] [--id <mod>] [--name <text>] [--version <v>]"));
+        return 1;
+    }
+    const source = node_path_1.default.resolve(target);
+    if (!(0, node_fs_1.existsSync)(source)) {
+        console.error((0, colour_js_1.red)(`${target} does not exist.`));
+        return 1;
+    }
+    const base = `${ROOT}/${encodeURIComponent(slug)}`;
+    const rules = await call(`${base}/info`, "GET", undefined, undefined, false);
+    if (rules.status !== 200)
+        return fail(rules, `Reading ${slug}`);
+    const manifestName = rules.body.rules.manifest;
+    /* The mod's identity: flags first, then the manifest in the folder, then the folder's name. */
+    const isZip = (await (0, promises_1.stat)(source)).isFile();
+    let manifest = {};
+    if (!isZip && manifestName && (0, node_fs_1.existsSync)(node_path_1.default.join(source, manifestName))) {
+        try {
+            manifest = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(source, manifestName), "utf8"));
+        }
+        catch {
+            console.error((0, colour_js_1.red)(`${manifestName} in that folder is not valid JSON.`));
+            return 1;
+        }
+    }
+    const folderName = node_path_1.default.basename(source).replace(/\.zip$/i, "");
+    const id = (flag(parsed, "id") ?? manifest.id ?? folderName.toLowerCase().replace(/[^a-z0-9._-]+/g, "-")).toLowerCase();
+    const name = flag(parsed, "name") ?? manifest.name ?? folderName;
+    const folder = flag(parsed, "folder") ?? manifest.folder ?? folderName.replace(/[^A-Za-z0-9 ._-]+/g, "-");
+    const version = flag(parsed, "version") ?? manifest.version;
+    const partId = (flag(parsed, "part") ?? "main").toLowerCase();
+    /* Keep the parts the mod already declares, and add this one. */
+    const existing = await call(`${base}/my/mods/${encodeURIComponent(id)}`);
+    const parts = existing.status === 200 ? [...existing.body.entry.parts] : [];
+    if (!parts.some((p) => p.id === partId))
+        parts.push({ id: partId, name: flag(parsed, "part-name") ?? partId });
+    const entry = {
+        id, name, folder, parts,
+        ...(version ? { version } : {}),
+        ...(flag(parsed, "about") ? { about: flag(parsed, "about") } : existing.status === 200 && existing.body.entry.about ? { about: existing.body.entry.about } : {}),
+        ...(flag(parsed, "notice") ? { notice: flag(parsed, "notice") } : {}),
+    };
+    const saved = await call(`${base}/my/mods`, "POST", entry);
+    if (saved.status !== 200 && saved.status !== 201)
+        return fail(saved, "Saving the mod's entry");
+    /* A folder is zipped here, with the manifest written to match the entry; a zip is sent as it is. */
+    let zipPath = source;
+    let scratch = null;
+    try {
+        if (!isZip) {
+            scratch = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "cbx-mod-"));
+            zipPath = node_path_1.default.join(scratch, `${id}-${partId}.zip`);
+            const files = await (0, zip_writer_js_1.listFiles)(source, (relative) => relative === ".git" || relative === ".coderook" || relative.endsWith(".DS_Store"));
+            const extra = manifestName
+                ? [{ path: manifestName, bytes: new TextEncoder().encode(JSON.stringify({ ...manifest, id, name, folder, ...(version ? { version } : {}) }, null, 2) + "\n") }]
+                : [];
+            node_process_1.default.stdout.write((0, colour_js_1.dim)(`Zipping ${files.length.toLocaleString()} files… `));
+            const zipped = await (0, zip_writer_js_1.writeZip)(source, files, zipPath, extra);
+            console.log((0, colour_js_1.dim)(bytes(zipped.bytes)));
+        }
+        const size = (await (0, promises_1.stat)(zipPath)).size;
+        if (size > rules.body.rules.maxPartBytes) {
+            console.error((0, colour_js_1.red)(`The part is ${bytes(size)}; ${slug} takes up to ${bytes(rules.body.rules.maxPartBytes)} a part. Split it with --part.`));
+            return 1;
+        }
+        const sha256 = await sha256File(zipPath);
+        const begun = await call(`${base}/my/mods/${encodeURIComponent(id)}/parts/${encodeURIComponent(partId)}`, "PUT", { size, sha256 });
+        if (begun.status !== 201)
+            return fail(begun, "Starting the upload");
+        for (let n = 1; n <= begun.body.chunks; n += 1) {
+            const start = (n - 1) * begun.body.chunkBytes;
+            const chunk = await readChunk(zipPath, start, Math.min(begun.body.chunkBytes, size - start));
+            let sent = null;
+            for (let attempt = 1; attempt <= 3; attempt += 1) {
+                try {
+                    sent = await call(`${base}/my/mods/${encodeURIComponent(id)}/parts/${encodeURIComponent(partId)}/chunks/${n}?upload=${encodeURIComponent(begun.body.upload)}`, "PUT", undefined, chunk);
+                    if (sent.status === 200)
+                        break;
+                }
+                catch {
+                    /* tried again below */
+                }
+            }
+            if (!sent || sent.status !== 200)
+                return fail(sent ?? { status: 0, body: { message: "the connection kept failing" } }, `Sending chunk ${n}`);
+            node_process_1.default.stdout.write(`\r${(0, colour_js_1.dim)(`Sent ${n} of ${begun.body.chunks} (${bytes(Math.min(size, n * begun.body.chunkBytes))} of ${bytes(size)})`)}   `);
+        }
+        console.log("");
+        const done = await call(`${base}/my/mods/${encodeURIComponent(id)}/parts/${encodeURIComponent(partId)}/complete`, "POST", { upload: begun.body.upload });
+        if (done.status !== 202)
+            return fail(done, "Finishing the upload");
+        console.log((0, colour_js_1.green)(`Uploaded ${id}/${partId}.`) + (0, colour_js_1.dim)(" It is listed once its checks pass."));
+    }
+    finally {
+        if (scratch)
+            await (0, promises_1.rm)(scratch, { recursive: true, force: true });
+    }
+    if (has(parsed, "no-wait")) {
+        console.log((0, colour_js_1.dim)("See how the checks went with: ") + (0, colour_js_1.accent)(`cbx mods list ${slug}`));
+        return 0;
+    }
+    node_process_1.default.stdout.write((0, colour_js_1.dim)("Checking (structure, file types, malware scan)… "));
+    const started = Date.now();
+    for (;;) {
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        const now = await call(`${base}/my/mods/${encodeURIComponent(id)}`);
+        const part = now.body.parts?.find((p) => p.part === partId);
+        const state = part?.check.state ?? "queued";
+        if (!["queued", "checking"].includes(state)) {
+            console.log("");
+            printMod(now.body);
+            return state === "live" ? 0 : 1;
+        }
+        if (Date.now() - started > 30 * 60 * 1000) {
+            console.log("");
+            console.log((0, colour_js_1.dim)("Still checking after 30 minutes; it carries on without you. Look later with ") + (0, colour_js_1.accent)(`cbx mods list ${slug}`));
+            return 0;
+        }
+    }
+}
+async function remove(parsed) {
+    const id = parsed.positional[1];
+    const slug = flag(parsed, "repo");
+    if (!id || !slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods remove <mod> --repo <repo> [--yes]"));
+        return 1;
+    }
+    if (!has(parsed, "yes", "y")) {
+        const prompt = (0, promises_2.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+        const typed = (await prompt.question(`This takes ${id} out of ${slug} and deletes its files. Type its id to confirm: `)).trim();
+        prompt.close();
+        if (typed !== id) {
+            console.error((0, colour_js_1.red)("That did not match. Nothing was removed."));
+            return 1;
+        }
+    }
+    const owner = has(parsed, "as-owner") ? "admin" : "my";
+    const answer = await call(`${ROOT}/${encodeURIComponent(slug)}/${owner}/mods/${encodeURIComponent(id)}`, "DELETE");
+    if (answer.status !== 200)
+        return fail(answer, `Removing ${id}`);
+    console.log((0, colour_js_1.green)(`Removed ${id}.`));
+    return 0;
+}
+async function block(parsed) {
+    const account = parsed.positional[1];
+    const slug = flag(parsed, "repo");
+    if (!account || !slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods block <username> --repo <repo> [--take-down] | --undo"));
+        return 1;
+    }
+    const verb = has(parsed, "undo") ? "unblock" : "block";
+    const answer = await call(`${ROOT}/${encodeURIComponent(slug)}/admin/uploaders/${encodeURIComponent(account)}/${verb}`, "POST", { takeDown: has(parsed, "take-down") });
+    if (answer.status !== 200)
+        return fail(answer, `${verb === "block" ? "Blocking" : "Unblocking"} ${account}`);
+    console.log((0, colour_js_1.green)(verb === "block" ? `${account} can no longer upload to ${slug}${answer.body.hidden ? ", and their mods are hidden" : ""}.` : `${account} can upload to ${slug} again.`));
+    return 0;
+}
+async function reports(parsed) {
+    const slug = parsed.positional[1];
+    if (!slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods reports <repo>"));
+        return 1;
+    }
+    const answer = await call(`${ROOT}/${encodeURIComponent(slug)}/admin/reports`);
+    if (answer.status !== 200)
+        return fail(answer, `Reports for ${slug}`);
+    if (!answer.body.reports.length)
+        console.log((0, colour_js_1.dim)("No reports."));
+    for (const r of answer.body.reports) {
+        console.log(`${(0, colour_js_1.dim)(r.created.slice(0, 16).replace("T", " "))}  ${(0, colour_js_1.accent)(r.modId)}${r.partId ? (0, colour_js_1.dim)(`/${r.partId}`) : ""}  ${(0, colour_js_1.bold)(r.reason)}${r.detail ? `  ${r.detail}` : ""}`);
+    }
+    return 0;
+}
+async function deleteRepo(parsed) {
+    const slug = parsed.positional[1];
+    if (!slug) {
+        console.error((0, colour_js_1.red)("Usage: cbx mods delete <repo>"));
+        return 1;
+    }
+    const prompt = (0, promises_2.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+    const typed = has(parsed, "yes") ? slug : (await prompt.question(`This deletes ${slug}, every mod in it and every build registration, for good. Type ${slug} to confirm: `)).trim();
+    prompt.close();
+    if (typed !== slug) {
+        console.error((0, colour_js_1.red)("That did not match. Nothing was deleted."));
+        return 1;
+    }
+    const answer = await call(`${ROOT}/${encodeURIComponent(slug)}`, "DELETE", { confirm: slug });
+    if (answer.status !== 200)
+        return fail(answer, `Deleting ${slug}`);
+    console.log((0, colour_js_1.green)(`Deleted ${slug}.`));
+    return 0;
+}
+async function commandMods(parsed) {
+    const sub = parsed.positional[0];
+    switch (sub) {
+        case "create": return create(parsed);
+        case "repos": return repos();
+        case "info": return info(parsed);
+        case "settings": return settings(parsed);
+        case "builds": return builds(parsed);
+        case "list": return mine(parsed);
+        case "publish": return publish(parsed);
+        case "remove": return remove(parsed);
+        case "block": return block(parsed);
+        case "reports": return reports(parsed);
+        case "delete": return deleteRepo(parsed);
+        default:
+            console.error((0, colour_js_1.red)(sub ? `cbx mods has no "${sub}". ` : "") + "See: " + (0, colour_js_1.accent)("cbx help mods"));
+            return 1;
+    }
+}

package/dist/cli/src/zip_writer.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crc32 = crc32;
+exports.listFiles = listFiles;
+exports.writeZip = writeZip;
+/**
+ * Write a folder as a zip, one file at a time, to disk.
+ *
+ * Mod repositories take each part as a zip, and a game's mod can hold
+ * hundreds of thousands of files and run to gigabytes — ZT1's art packs do —
+ * so the archive is written as it goes rather than built in memory, and
+ * ZIP64 records are used once sizes, offsets or the file count pass what the
+ * classic format can hold. Each file is deflated, or stored when deflating
+ * would not make it smaller (already-compressed images and audio).
+ */
+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");
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n += 1) {
+        let c = n;
+        for (let k = 0; k < 8; k += 1)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < bytes.length; i += 1)
+        crc = CRC_TABLE[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+const MAX32 = 0xffffffff;
+const MAX16 = 0xffff;
+function dosTime(when) {
+    return {
+        time: (when.getHours() << 11) | (when.getMinutes() << 5) | Math.floor(when.getSeconds() / 2),
+        date: ((Math.max(1980, when.getFullYear()) - 1980) << 9) | ((when.getMonth() + 1) << 5) | when.getDate(),
+    };
+}
+/** Every file under a folder, as zip paths with forward slashes, in a stable order. */
+async function listFiles(root, skip = () => false) {
+    const found = [];
+    const walk = async (dir) => {
+        const entries = (await (0, promises_1.readdir)(node_path_1.default.join(root, dir), { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const relative = dir ? `${dir}/${entry.name}` : entry.name;
+            if (skip(relative))
+                continue;
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                await walk(relative);
+            else if (entry.isFile())
+                found.push(relative);
+        }
+    };
+    await walk("");
+    return found;
+}
+/**
+ * Zip these files (paths relative to root) into `out`. `extra` adds entries
+ * written from memory — a generated manifest, for one.
+ */
+async function writeZip(root, files, out, extra = [], onProgress) {
+    const stream = (0, node_fs_1.createWriteStream)(out);
+    let failed = null;
+    stream.on("error", (error) => {
+        failed = error;
+    });
+    const write = async (chunk) => {
+        if (failed)
+            throw failed;
+        if (!stream.write(chunk))
+            await new Promise((resolve) => stream.once("drain", resolve));
+        if (failed)
+            throw failed;
+    };
+    const written = [];
+    let offset = 0;
+    const { time, date } = dosTime(new Date());
+    const extraNames = new Set(extra.map((one) => one.path));
+    const sources = [
+        ...extra.map((one) => ({ path: one.path, load: async () => one.bytes })),
+        ...files.filter((file) => !extraNames.has(file)).map((file) => ({ path: file, load: () => (0, promises_1.readFile)(node_path_1.default.join(root, file)) })),
+    ];
+    for (const [index, source] of sources.entries()) {
+        const raw = await source.load();
+        const deflated = (0, node_zlib_1.deflateRawSync)(raw, { level: 6 });
+        const store = deflated.length >= raw.length;
+        const body = store ? raw : deflated;
+        const name = Buffer.from(source.path, "utf8");
+        const crc = crc32(raw);
+        const zip64 = raw.length >= MAX32 || body.length >= MAX32;
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(zip64 ? 45 : 20, 4);
+        local.writeUInt16LE(0x0800, 6); /* UTF-8 names */
+        local.writeUInt16LE(store ? 0 : 8, 8);
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(date, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(zip64 ? MAX32 : body.length, 18);
+        local.writeUInt32LE(zip64 ? MAX32 : raw.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        const localExtra = zip64 ? zip64Extra([raw.length, body.length]) : Buffer.alloc(0);
+        local.writeUInt16LE(localExtra.length, 28);
+        await write(local);
+        await write(name);
+        if (localExtra.length)
+            await write(localExtra);
+        await write(body);
+        written.push({ name, crc, method: store ? 0 : 8, compressed: body.length, size: raw.length, offset, time, date });
+        offset += local.length + name.length + localExtra.length + body.length;
+        onProgress?.(index + 1, sources.length);
+    }
+    const centralStart = offset;
+    for (const entry of written) {
+        const big = [entry.size >= MAX32, entry.compressed >= MAX32, entry.offset >= MAX32];
+        const values = [
+            ...(big[0] ? [entry.size] : []),
+            ...(big[1] ? [entry.compressed] : []),
+            ...(big[2] ? [entry.offset] : []),
+        ];
+        const extraField = values.length ? zip64Extra(values) : Buffer.alloc(0);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(values.length ? 45 : 20, 4);
+        central.writeUInt16LE(values.length ? 45 : 20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(entry.method, 10);
+        central.writeUInt16LE(entry.time, 12);
+        central.writeUInt16LE(entry.date, 14);
+        central.writeUInt32LE(entry.crc, 16);
+        central.writeUInt32LE(big[1] ? MAX32 : entry.compressed, 20);
+        central.writeUInt32LE(big[0] ? MAX32 : entry.size, 24);
+        central.writeUInt16LE(entry.name.length, 28);
+        central.writeUInt16LE(extraField.length, 30);
+        central.writeUInt32LE((0o100644 * 0x10000) >>> 0, 38); /* a plain file, never a link */
+        central.writeUInt32LE(big[2] ? MAX32 : entry.offset, 42);
+        await write(central);
+        await write(entry.name);
+        if (extraField.length)
+            await write(extraField);
+        offset += central.length + entry.name.length + extraField.length;
+    }
+    const centralSize = offset - centralStart;
+    const needs64 = written.length >= MAX16 || centralStart >= MAX32 || centralSize >= MAX32;
+    if (needs64) {
+        const record = Buffer.alloc(56);
+        record.writeUInt32LE(0x06064b50, 0);
+        record.writeBigUInt64LE(44n, 4);
+        record.writeUInt16LE(45, 12);
+        record.writeUInt16LE(45, 14);
+        record.writeBigUInt64LE(BigInt(written.length), 24);
+        record.writeBigUInt64LE(BigInt(written.length), 32);
+        record.writeBigUInt64LE(BigInt(centralSize), 40);
+        record.writeBigUInt64LE(BigInt(centralStart), 48);
+        const locator = Buffer.alloc(20);
+        locator.writeUInt32LE(0x07064b50, 0);
+        locator.writeBigUInt64LE(BigInt(offset), 8);
+        locator.writeUInt32LE(1, 16);
+        await write(record);
+        await write(locator);
+    }
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(needs64 ? MAX16 : written.length, 8);
+    end.writeUInt16LE(needs64 ? MAX16 : written.length, 10);
+    end.writeUInt32LE(needs64 ? MAX32 : centralSize, 12);
+    end.writeUInt32LE(needs64 ? MAX32 : centralStart, 16);
+    await write(end);
+    await new Promise((resolve, reject) => stream.end((error) => (error ? reject(error) : resolve())));
+    return { files: written.length, bytes: offset + (needs64 ? 76 : 0) + 22 };
+}
+function zip64Extra(values) {
+    const field = Buffer.alloc(4 + values.length * 8);
+    field.writeUInt16LE(0x0001, 0);
+    field.writeUInt16LE(values.length * 8, 2);
+    values.forEach((value, index) => field.writeBigUInt64LE(BigInt(value), 4 + index * 8));
+    return field;
+}

package/package.json

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

package/skills/coderook/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: coderook
-description: Save, browse and restore versions of a project on CodeRook — a version host where every version is a complete snapshot, reached with the cbx command or with plain git. Use when asked to save, submit or push work to CodeRook, check what has changed, look at a project's versions or files, fetch a project, start or switch a line of work, resolve a save that landed at the same time as somebody else's, or build a project's executables for Windows, Linux and macOS from one machine (cbx build).
+description: Save, browse and restore versions of a project on CodeRook — a version host where every version is a complete snapshot, reached with the cbx command or with plain git. Use when asked to save, submit or push work to CodeRook, check what has changed, look at a project's versions or files, fetch a project, start or switch a line of work, resolve a save that landed at the same time as somebody else's, build a project's executables for Windows, Linux and macOS from one machine (cbx build), or publish a mod to a game's mod repository or set one up (cbx mods).
 allowed-tools: Bash Read
 ---
 
@@ -306,6 +306,31 @@ unasked. `--ship` attaches the results to the newest save, so **ask before
 `--ship`**, as before any save. A project's own build description lives in
 `coderook.build.json`.
 
+## Mod repositories for games
+
+A game's maker can run a mod repository: players' game clients read a signed
+catalogue from it, modders publish to it, and nothing is listed until it
+passes the repository's rules and a malware scan.
+
+```bash
+cbx mods info zt1                                   # a repository's rules, for anybody
+cbx mods publish ./BetterTrees --repo zt1           # zip, upload, wait for the checks
+cbx mods publish ./HD-Art --repo zt1 --part animals # one part of a bigger mod
+cbx mods list zt1                                   # your mods and how their checks went
+cbx mods create my-game --name "My Game" --allow .png,.ogg,.json
+```
+
+`publish` reads the folder's `mod.json` (or the repository's manifest) for the
+mod's id, name, folder and version; `--id`, `--name`, `--folder` and
+`--version` override it. It waits up to 30 minutes for the checks and prints
+what failed, file by file — pass that on as it is. Programs and scripts
+(`.exe`, `.dll`, `.ps1`, `.js` …) are refused in every repository, so do not
+try to rename one past the check. **Ask before `publish`**, as before any
+save: it makes the mod public once it passes. Ask before `remove`, `block`
+and `delete`, which only the person should decide. The game-side protocol
+(signed requests, the catalogue signature, downloads) is at
+https://coderook.com/docs#mod-repositories.
+
 ## Things not to do
 
 - Do not run `cbx delete` unless the person has asked for that project to