@coderook/cli 0.34.10 → 0.35.0

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

@@ -170,11 +170,70 @@ function ruleMatches(relativePath, isDirectory, rule) {
     }
     return relativePath.split("/").some((segment) => expression.test(segment));
 }
+const NONE = [];
+const indexes = new WeakMap();
+function indexFor(rules) {
+    let index = indexes.get(rules);
+    if (index)
+        return index;
+    const kinds = rules.map((rule) => {
+        if (rule.directoryOnly) {
+            const bare = trailingSlashOff(rule.pattern);
+            return rule.anchored || bare.includes("/") ? "wholePath" : "ownName";
+        }
+        return rule.anchored || rule.pattern.includes("/") ? "wholePath" : "segment";
+    });
+    const named = kinds.flatMap((kind, at) => (kind === "wholePath" ? [] : [at]));
+    index = { kinds, named, answers: new Map() };
+    indexes.set(rules, index);
+    return index;
+}
+function namedMatches(index, rules, name) {
+    let found = index.answers.get(name);
+    if (found)
+        return found;
+    found = NONE;
+    for (const at of index.named) {
+        if (matcher(rules[at].pattern).test(name)) {
+            if (found === NONE)
+                found = [];
+            found.push(at);
+        }
+    }
+    index.answers.set(name, found);
+    return found;
+}
 /** The last matching rule wins, as it does in gitignore. */
 function lastMatchingRule(relativePath, isDirectory, rules) {
+    if (!rules.length)
+        return null;
+    const index = indexFor(rules);
+    const segments = relativePath.split("/");
+    /* Which named rules some segment satisfies, and which the last one does. */
+    const anySegment = new Uint8Array(rules.length);
+    const ownName = new Uint8Array(rules.length);
+    for (let at = 0; at < segments.length; at += 1) {
+        const hits = namedMatches(index, rules, segments[at]);
+        for (const hit of hits)
+            anySegment[hit] = 1;
+        if (at === segments.length - 1)
+            for (const hit of hits)
+                ownName[hit] = 1;
+    }
     let found = null;
-    for (const rule of rules) {
-        if (ruleMatches(relativePath, isDirectory, rule))
+    for (let at = 0; at < rules.length; at += 1) {
+        const rule = rules[at];
+        const kind = index.kinds[at];
+        let matched;
+        if (kind === "segment")
+            matched = anySegment[at] === 1;
+        else if (kind === "ownName")
+            matched = isDirectory && ownName[at] === 1;
+        else if (rule.directoryOnly && !isDirectory)
+            matched = false;
+        else
+            matched = matcher(rule.pattern).test(relativePath);
+        if (matched)
             found = rule;
     }
     return found;
@@ -223,8 +282,10 @@ function decidingRule(relativePath, isDirectory, layers, remembered) {
     }
     return decide(relativePath, isDirectory, layers);
 }
-function excludes(relativePath, isDirectory, layers) {
-    const rule = decidingRule(relativePath, isDirectory, layers);
+function excludes(relativePath, isDirectory, layers, 
+/* Folder answers to reuse; see FolderAnswers. Only for one fixed set of rules. */
+remembered) {
+    const rule = decidingRule(relativePath, isDirectory, layers, remembered);
     return Boolean(rule && !rule.negated);
 }
 /**

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

@@ -1110,6 +1110,12 @@ onFound) {
     const layers = await collectLayers(root, rules);
     const tracked = await gitTracked(root);
     const found = [];
+    /*
+      Every entry asks about each folder above it; those answers do not change
+      during one walk, so each folder is decided once rather than once per file
+      beneath it.
+    */
+    const folderAnswers = new Map();
     /*
       A level at a time, eight in flight.
   
@@ -1142,7 +1148,7 @@ onFound) {
                         continue;
                     const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
                     if (entry.isDirectory()) {
-                        if ((0, rules_js_1.excludes)(relative, true, layers) &&
+                        if ((0, rules_js_1.excludes)(relative, true, layers, folderAnswers) &&
                             !(0, rules_js_1.negationReachesInto)(relative, layers) &&
                             !tracked?.folders.has(relative)) {
                             continue;
@@ -1152,7 +1158,7 @@ onFound) {
                     }
                     if (!entry.isFile())
                         continue;
-                    if ((0, rules_js_1.excludes)(relative, false, layers) && !tracked?.files.has(relative))
+                    if ((0, rules_js_1.excludes)(relative, false, layers, folderAnswers) && !tracked?.files.has(relative))
                         continue;
                     here.push({ full, relative });
                 }
@@ -1608,11 +1614,30 @@ 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" },
     { match: /^\.ssh$/i, because: "SSH keys" },
@@ -1661,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");
@@ -1656,14 +1657,33 @@ trackName) {
         });
     }
     const line = progressLine();
-    const result = await downloader.run(repositoryId, latest.id, destination, (progress) => {
-        line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
-            `${progress.files}/${progress.totalFiles}  ` +
-            dim(progress.path.slice(-40)));
-    }, 
-    // What this folder received last time, so a file the project has since
-    // dropped is removed while everything untracked is left alone.
-    held, mode);
+    let result;
+    try {
+        result = await downloader.run(repositoryId, latest.id, destination, (progress) => {
+            line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+                `${progress.files}/${progress.totalFiles}  ` +
+                dim(progress.path.slice(-40)));
+        }, 
+        // What this folder received last time, so a file the project has since
+        // dropped is removed while everything untracked is left alone.
+        held, mode);
+    }
+    catch (error) {
+        done(line);
+        if (!(error instanceof download_js_1.DownloadFailed))
+            throw error;
+        /*
+          Named, and with what it did not do. A transfer fails before anything
+          is put in place, so the folder is as it was and the staging copy is
+          gone — which is what someone deciding whether to run it again needs.
+        */
+        console.error(red(error.message));
+        console.error(dim(((0, node_fs_1.existsSync)(destination)
+            ? `Nothing in ${destination} was changed.`
+            : `No folder was made at ${destination}.`) +
+            " Run the same command again to retry."));
+        return 1;
+    }
     done(line);
     /*
       Said, not hidden. The files are right, but the service sent them still
@@ -2773,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",