@coderook/cli 0.1.0

package/LICENSE.txt

@@ -0,0 +1,46 @@
+CodeRook Desktop - Terms of Use
+
+Copyright (c) 2026 CodeRook. All rights reserved.
+
+1. Licence
+
+CodeRook grants you a personal, non-exclusive, non-transferable licence to
+install and use CodeRook Desktop on computers you own or control, for the
+purpose of working with your own CodeRook projects.
+
+2. What this software does
+
+CodeRook Desktop reads folders you choose on this computer and uploads the
+files you select to your CodeRook account. It shows you what will be sent
+before anything leaves the machine, and it never uploads a folder you have
+not opened.
+
+3. Your content
+
+Your files remain yours. CodeRook stores them so you can retrieve them, and
+does not claim ownership of anything you upload.
+
+4. Credentials
+
+Your access token is stored using the operating system's credential vault. It
+is not written to disk in plain text. Signing out removes it from this
+computer.
+
+5. No warranty
+
+This software is provided "as is", without warranty of any kind, express or
+implied, including but not limited to the warranties of merchantability,
+fitness for a particular purpose and non-infringement. Keep your own backups
+of anything you cannot afford to lose.
+
+6. Limitation of liability
+
+In no event shall CodeRook be liable for any claim, damages or other
+liability, whether in an action of contract, tort or otherwise, arising from,
+out of or in connection with the software or the use or other dealings in the
+software.
+
+7. Privacy and terms
+
+Use of your CodeRook account is additionally governed by the terms and privacy
+policy published at https://coderook.com/terms and https://coderook.com/privacy.

package/README.md

@@ -0,0 +1,99 @@
+# CodeRook CLI
+
+CodeRook from the terminal, on Windows, macOS and Linux alike. It uses the
+same engines as the desktop application — the same scanner, the same
+`.gitignore` rules, the same upload, download and `.cbx` bundling — so a
+project moved by one is understood by the other.
+
+## Install
+
+Requires Node 20.11 or later, and nothing else.
+
+```
+npm install --global @coderook/cli
+```
+
+Or from this repository:
+
+```
+cd cli
+npm install
+npm run build
+npm link
+```
+
+## Sign in
+
+Create a personal access token in **Settings** on coderook.com, then:
+
+```
+coderook sign-in
+```
+
+The token is written to a file only your account can read:
+
+| Platform | Location |
+| --- | --- |
+| Windows | `%APPDATA%\CodeRook` |
+| macOS | `~/Library/Application Support/CodeRook` |
+| Linux | `$XDG_CONFIG_HOME/coderook`, or `~/.config/coderook` |
+
+For automation, set `CODEROOK_TOKEN` instead and nothing is written to disk.
+`CODEROOK_API_URL` points the tool at a different service.
+
+## Everyday use
+
+```
+coderook status                    what is here that is not saved yet
+coderook submit -m "Fixed the parser"
+coderook get                       fetch the latest version over this folder
+coderook clone my-project          fetch a project into a new folder
+```
+
+`status` and `submit` act on the current directory unless you name another.
+The first time either runs in a folder, it looks for a project on your account
+whose name matches and links the two, so a folder you already uploaded from
+the desktop is recognised rather than treated as new.
+
+`submit` sends only what changed. Files the service already holds are not
+uploaded again, and the version it records still names every file in the
+project — a version is a snapshot, not a difference.
+
+## Ignore rules
+
+```
+coderook rules            show the rules in force
+coderook rules --init     write a starter .gitignore
+```
+
+Rules live in the project's own `.gitignore`, so CodeRook, git, the website
+and the desktop application all read one file. A `!` line puts something back.
+Personal exclusions that should not reach a collaborator belong in
+`.git/info/exclude`.
+
+## Bundles
+
+```
+coderook bundle                    pack this project as <name>.cbx
+coderook unbundle backup.cbx       extract one
+coderook inspect backup.cbx        see what it holds  (--files to list them)
+```
+
+A `.cbx` is the CodeBox bundle format: content-defined chunks, Zstandard where
+it helps, raw where it does not, and a SHA-256 for every chunk and file.
+Extraction is verified and atomic — a damaged bundle fails rather than leaving
+a half-written tree.
+
+## Checking things
+
+```
+coderook doctor
+```
+
+Reports the tool's version, where its configuration lives, whether the service
+is reachable, and who this machine is signed in as.
+
+## Exit codes
+
+`0` on success, `1` on failure. Every command prints why it failed on standard
+error, so a script can branch on the status and log the reason.

package/dist/cli/src/api.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoami = whoami;
+exports.projects = projects;
+exports.findProject = findProject;
+exports.health = health;
+/** The small part of the API the command-line tool needs directly. */
+const config_js_1 = require("./config.js");
+async function call(route, options = {}) {
+    const token = await (0, config_js_1.loadToken)();
+    if (!token) {
+        throw new Error("Not signed in. Run: coderook sign-in");
+    }
+    const response = await fetch(`${(0, config_js_1.apiOrigin)()}${route}`, {
+        method: options.method ?? "GET",
+        headers: {
+            accept: "application/json",
+            authorization: `Bearer ${token}`,
+            "user-agent": "CodeRook-CLI/0.1",
+            ...(options.body ? { "content-type": "application/json" } : {}),
+        },
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    const text = await response.text();
+    const body = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("That token was not accepted. Run: coderook sign-in");
+        }
+        throw new Error(body?.error?.message ?? `${route} failed (${response.status})`);
+    }
+    return body;
+}
+async function whoami() {
+    const body = await call("/v1/auth/session");
+    if (!body.user)
+        throw new Error("That token does not belong to an account");
+    return body.user;
+}
+async function projects() {
+    const body = await call("/v1/repositories");
+    return (body.repositories ?? []).map((row) => ({
+        id: String(row.id ?? ""),
+        slug: String(row.slug ?? ""),
+        name: String(row.displayName || row.slug || "Untitled"),
+        visibility: String(row.visibility ?? "private"),
+        versionCount: Number(row.versionCount ?? 0),
+        fileCount: Number(row.fileCount ?? 0),
+        storedBytes: Number(row.storedSize ?? 0),
+        updatedAt: String(row.updatedAt ?? row.createdAt ?? ""),
+    }));
+}
+/** Find a project by slug or display name, so either reads naturally. */
+async function findProject(reference) {
+    const wanted = reference.trim().toLowerCase();
+    const all = await projects();
+    return (all.find((project) => project.slug.toLowerCase() === wanted) ??
+        all.find((project) => project.name.toLowerCase() === wanted) ??
+        null);
+}
+/** Whether the service is reachable, and what encodings it accepts. */
+async function health() {
+    const response = await fetch(`${(0, config_js_1.apiOrigin)()}/health?t=${Date.now()}`, {
+        headers: { "cache-control": "no-cache" },
+    });
+    return (await response.json());
+}

package/dist/cli/src/cli.js

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * CodeRook from the command line.
+ *
+ * The same engines the desktop application uses — the same scanner, the same
+ * ignore rules, the same upload and download — with a terminal in front of
+ * them instead of a window. Nothing here is Windows-specific, so it runs
+ * wherever Node does.
+ *
+ * The vocabulary follows docs/REPOSITORY_MODEL.md: get latest, save a
+ * version, submit it.
+ */
+const promises_1 = require("node:readline/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+const upload_js_1 = require("../../desktop-app/src/main/upload.js");
+const download_js_1 = require("../../desktop-app/src/main/download.js");
+const cbx_js_1 = require("../../desktop-app/src/main/cbx.js");
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+const VERSION = "0.1.0";
+// ── presentation ────────────────────────────────────────────────────────────
+const colour = node_process_1.default.stdout.isTTY && !node_process_1.default.env.NO_COLOR;
+const dim = (text) => (colour ? `${text}` : text);
+const bold = (text) => (colour ? `${text}` : text);
+const accent = (text) => (colour ? `${text}` : text);
+const red = (text) => (colour ? `${text}` : text);
+function bytes(value) {
+    if (value >= 1024 ** 3)
+        return `${(value / 1024 ** 3).toFixed(2)} GB`;
+    if (value >= 1024 ** 2)
+        return `${(value / 1024 ** 2).toFixed(1)} MB`;
+    if (value >= 1024)
+        return `${(value / 1024).toFixed(1)} KB`;
+    return `${value} B`;
+}
+/** One line that rewrites itself, so progress does not scroll the terminal. */
+function progressLine() {
+    let last = 0;
+    return (text) => {
+        if (!node_process_1.default.stdout.isTTY)
+            return;
+        const padded = text.padEnd(last);
+        last = text.length;
+        node_process_1.default.stdout.write(`\r${padded}`);
+    };
+}
+const done = (line) => {
+    if (node_process_1.default.stdout.isTTY) {
+        line("");
+        node_process_1.default.stdout.write("\r");
+    }
+};
+function parse(argv) {
+    const positional = [];
+    const flags = new Map();
+    for (let at = 0; at < argv.length; at += 1) {
+        const item = argv[at];
+        if (!item.startsWith("-")) {
+            positional.push(item);
+            continue;
+        }
+        const name = item.replace(/^--?/, "");
+        const next = argv[at + 1];
+        if (next && !next.startsWith("-")) {
+            flags.set(name, next);
+            at += 1;
+        }
+        else {
+            flags.set(name, true);
+        }
+    }
+    return { positional, flags };
+}
+const flagText = (parsed, ...names) => {
+    for (const name of names) {
+        const value = parsed.flags.get(name);
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+};
+const hasFlag = (parsed, ...names) => names.some((name) => parsed.flags.has(name));
+const folderFor = (parsed, index = 0) => node_path_1.default.resolve(parsed.positional[index] ?? node_process_1.default.cwd());
+// ── shared behaviour ────────────────────────────────────────────────────────
+/**
+ * Reconcile a folder with the account: which repository it belongs to and
+ * what that repository already holds. The account is the authority, exactly
+ * as it is in the desktop application.
+ */
+async function reconcile(folder, options = {}) {
+    const link = await (0, config_js_1.readLink)(folder);
+    const reference = link?.slug ?? node_path_1.default.basename(folder);
+    const project = link
+        ? (await (0, api_js_1.projects)()).find((candidate) => candidate.id === link.repositoryId)
+        : await (0, api_js_1.findProject)(reference);
+    if (!project?.versionCount) {
+        // Nothing saved on the account, so everything here is outstanding.
+        return { link: link ?? null, baseline: null };
+    }
+    const downloader = new download_js_1.Downloader(config_js_1.credentials);
+    const latest = (await downloader.versions(project.id))[0];
+    if (!latest)
+        return { link: link ?? null, baseline: null };
+    const baseline = new Map();
+    for (const file of await downloader.files(project.id, latest.id)) {
+        baseline.set(file.path, file.sha256);
+    }
+    const fresh = {
+        repositoryId: project.id,
+        slug: project.slug,
+        sequence: latest.sequence,
+        manifest: Object.fromEntries(baseline),
+    };
+    await (0, config_js_1.writeLink)(folder, fresh);
+    if (!options.quiet && !link) {
+        console.log(dim(`Linked this folder to ${project.slug}.`));
+    }
+    return { link: fresh, baseline };
+}
+// ── commands ────────────────────────────────────────────────────────────────
+async function commandSignIn(parsed) {
+    const supplied = flagText(parsed, "token");
+    let token = supplied ?? "";
+    if (!token) {
+        console.log(`Create a personal access token at ${dim("https://coderook.com/?screen=settings")}`);
+        const reader = (0, promises_1.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+        token = (await reader.question("Access token: ")).trim();
+        reader.close();
+    }
+    if (!token) {
+        console.error(red("No token given."));
+        return 1;
+    }
+    await (0, config_js_1.storeToken)(token);
+    try {
+        const account = await (0, api_js_1.whoami)();
+        console.log(`Signed in as ${bold(account.displayName)} ${dim(`<${account.email}>`)} · ${account.plan}`);
+        console.log(dim(`Token stored in ${(0, config_js_1.configDirectory)()}`));
+        return 0;
+    }
+    catch (error) {
+        await (0, config_js_1.clearToken)();
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+}
+async function commandSignOut() {
+    await (0, config_js_1.clearToken)();
+    console.log("Signed out on this machine.");
+    return 0;
+}
+async function commandWhoami() {
+    const account = await (0, api_js_1.whoami)();
+    console.log(`${bold(account.displayName)} <${account.email}> · ${account.plan}`);
+    return 0;
+}
+async function commandProjects() {
+    const all = await (0, api_js_1.projects)();
+    if (!all.length) {
+        console.log("No projects on this account yet.");
+        return 0;
+    }
+    const width = Math.max(...all.map((project) => project.slug.length));
+    for (const project of all) {
+        console.log(`${accent(project.slug.padEnd(width))}  v${String(project.versionCount).padEnd(4)}` +
+            `${String(project.fileCount).padStart(6)} files  ${bytes(project.storedBytes).padStart(9)}` +
+            `  ${dim(project.visibility)}`);
+    }
+    return 0;
+}
+async function commandStatus(parsed) {
+    const folder = folderFor(parsed);
+    const { link, baseline } = await reconcile(folder);
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline);
+    console.log(bold(node_path_1.default.basename(folder)) + dim(`  ${folder}`));
+    console.log(link
+        ? `Account holds ${accent(`v${link.sequence}`)} · ${Object.keys(link.manifest).length} files ${dim(`(${link.slug})`)}`
+        : dim("Not on your account yet — submitting will create it."));
+    if (!files.length) {
+        console.log("Nothing to submit; this folder matches the saved version.");
+        return 0;
+    }
+    console.log(`\n${files.length} file${files.length === 1 ? "" : "s"} to submit:`);
+    for (const file of files.slice(0, 50)) {
+        console.log(`  ${file.deleted ? red("deleted") : accent("changed")}  ${file.path}`);
+    }
+    if (files.length > 50)
+        console.log(dim(`  …and ${files.length - 50} more`));
+    return 0;
+}
+async function commandSubmit(parsed) {
+    const folder = folderFor(parsed);
+    const message = flagText(parsed, "m", "message") ?? "";
+    const { link, baseline } = await reconcile(folder);
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const files = await (0, worktree_js_1.changedFiles)(folder, rules, baseline);
+    if (!files.length) {
+        console.log("Nothing to submit; this folder matches the saved version.");
+        return 0;
+    }
+    if (hasFlag(parsed, "dry-run", "n")) {
+        console.log(`${files.length} file${files.length === 1 ? "" : "s"} would be sent:`);
+        for (const file of files)
+            console.log(`  ${file.path}`);
+        return 0;
+    }
+    const line = progressLine();
+    const uploader = new upload_js_1.Uploader(config_js_1.credentials);
+    const result = await uploader.run({
+        localPath: folder,
+        include: files.map((file) => file.path),
+        message,
+        projectName: link?.slug ?? node_path_1.default.basename(folder),
+        repositoryId: link?.repositoryId ?? null,
+    }, (progress) => {
+        line(`  ${String(progress.percent).padStart(3)}%  ${progress.stage.padEnd(7)} ` +
+            `${progress.files}/${progress.totalFiles}  ${progress.path.slice(-48)}`);
+    });
+    done(line);
+    await (0, config_js_1.writeLink)(folder, {
+        repositoryId: result.repositoryId,
+        slug: link?.slug ?? node_path_1.default.basename(folder),
+        sequence: result.sequence,
+        manifest: result.manifest,
+    });
+    console.log(`Saved ${accent(`v${result.sequence}`)} · sent ${bytes(result.sentBytes)} in ` +
+        `${result.sentFiles} file${result.sentFiles === 1 ? "" : "s"}` +
+        (result.reusedFiles ? `, ${result.reusedFiles} already stored` : "") +
+        ` · version holds ${bytes(result.sourceBytes)}`);
+    return 0;
+}
+async function commandGet(parsed) {
+    const folder = folderFor(parsed);
+    const { link } = await reconcile(folder);
+    if (!link) {
+        console.error(red("This folder is not linked to a project on your account."));
+        return 1;
+    }
+    return fetchInto(link.repositoryId, folder, link.slug);
+}
+async function commandClone(parsed) {
+    const reference = parsed.positional[0];
+    if (!reference) {
+        console.error(red("Which project? Try: coderook clone <project>"));
+        return 1;
+    }
+    const project = await (0, api_js_1.findProject)(reference);
+    if (!project) {
+        console.error(red(`No project named ${reference} on this account.`));
+        return 1;
+    }
+    if (!project.versionCount) {
+        console.error(red(`${project.slug} has no saved version to fetch.`));
+        return 1;
+    }
+    const destination = node_path_1.default.resolve(parsed.positional[1] ?? project.slug);
+    return fetchInto(project.id, destination, project.slug);
+}
+async function fetchInto(repositoryId, destination, slug) {
+    const downloader = new download_js_1.Downloader(config_js_1.credentials);
+    const latest = (await downloader.versions(repositoryId))[0];
+    if (!latest) {
+        console.error(red("That project has no saved version."));
+        return 1;
+    }
+    const line = progressLine();
+    const result = await downloader.run(repositoryId, latest.id, destination, (progress) => {
+        line(`  ${String(progress.percent).padStart(3)}%  ${progress.files}/${progress.totalFiles}` +
+            `  ${progress.path.slice(-48)}`);
+    });
+    done(line);
+    await (0, config_js_1.writeLink)(destination, {
+        repositoryId,
+        slug,
+        sequence: latest.sequence,
+        manifest: result.manifest,
+    });
+    console.log(`${accent(`v${latest.sequence}`)} · ${result.files} files · ${bytes(result.bytes)} into ${destination}`);
+    return 0;
+}
+async function commandRules(parsed) {
+    const folder = folderFor(parsed);
+    if (hasFlag(parsed, "init")) {
+        const existing = await (0, worktree_js_1.readRules)(folder);
+        await (0, worktree_js_1.writeRules)(folder, {
+            shared: existing.shared.trim() ? existing.shared : worktree_js_1.STARTER_IGNORE,
+            local: existing.local,
+        });
+        console.log(`Wrote ${node_path_1.default.join(folder, ".gitignore")}`);
+        return 0;
+    }
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    node_process_1.default.stdout.write(rules.shared);
+    if (rules.local.trim()) {
+        console.log(dim("\n# --- only on this machine (.git/info/exclude) ---"));
+        node_process_1.default.stdout.write(rules.local);
+    }
+    return 0;
+}
+async function commandBundle(parsed) {
+    const folder = folderFor(parsed, 0);
+    const target = node_path_1.default.resolve(parsed.positional[1] ?? `${node_path_1.default.basename(folder)}.cbx`);
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const entries = (await (0, worktree_js_1.changedFiles)(folder, rules, null)).map((file) => file.path);
+    const line = progressLine();
+    const result = await (0, cbx_js_1.packBundle)({ root: folder, target, entries, sourceName: node_path_1.default.basename(folder) }, (progress) => {
+        line(`  ${String(progress.percent).padStart(3)}%  ${progress.path.slice(-48)}`);
+    });
+    done(line);
+    const saved = Math.max(0, 100 - Math.ceil((result.archiveBytes / Math.max(result.sourceBytes, 1)) * 100));
+    console.log(`${target} · ${bytes(result.archiveBytes)} from ${bytes(result.sourceBytes)} ` +
+        `(${saved}% smaller) · ${result.uniqueChunks} chunks`);
+    return 0;
+}
+async function commandUnbundle(parsed) {
+    const source = parsed.positional[0];
+    if (!source) {
+        console.error(red("Which bundle? Try: coderook unbundle <file.cbx> [folder]"));
+        return 1;
+    }
+    const manifest = await (0, cbx_js_1.readManifest)(node_path_1.default.resolve(source));
+    const destination = node_path_1.default.resolve(parsed.positional[1] ?? manifest.source_name);
+    const line = progressLine();
+    const result = await (0, cbx_js_1.unpackBundle)(node_path_1.default.resolve(source), destination, (progress) => {
+        line(`  ${String(progress.percent).padStart(3)}%  ${progress.path.slice(-48)}`);
+    });
+    done(line);
+    console.log(`${result.files} files · ${bytes(result.bytes)} into ${destination}`);
+    return 0;
+}
+async function commandInspect(parsed) {
+    const source = parsed.positional[0];
+    if (!source) {
+        console.error(red("Which bundle? Try: coderook inspect <file.cbx>"));
+        return 1;
+    }
+    const manifest = await (0, cbx_js_1.readManifest)(node_path_1.default.resolve(source));
+    const total = manifest.files.reduce((sum, file) => sum + file.size, 0);
+    console.log(`${bold(manifest.source_name)} · format ${manifest.format} v${manifest.format_version}`);
+    console.log(`${manifest.files.length} files · ${bytes(total)} · ` +
+        `${Object.keys(manifest.chunks).length} chunks`);
+    if (hasFlag(parsed, "files")) {
+        for (const file of manifest.files) {
+            console.log(`  ${bytes(file.size).padStart(9)}  ${file.path}`);
+        }
+    }
+    return 0;
+}
+async function commandDoctor() {
+    const service = await (0, api_js_1.health)().catch(() => null);
+    console.log(`CodeRook CLI ${VERSION} · Node ${node_process_1.default.versions.node} · ${node_process_1.default.platform}`);
+    console.log(`Config: ${(0, config_js_1.configDirectory)()}`);
+    console.log(service
+        ? `Service: ${service.status} · schema ${service.schemaVersion}` +
+            (service.contentEncodings ? ` · accepts ${service.contentEncodings.join(", ")}` : "")
+        : red("Service: unreachable"));
+    const token = await (0, config_js_1.loadToken)();
+    if (!token) {
+        console.log("Account: not signed in");
+        return 0;
+    }
+    try {
+        const account = await (0, api_js_1.whoami)();
+        console.log(`Account: ${account.email} · ${account.plan}`);
+    }
+    catch (error) {
+        console.log(red(`Account: ${error instanceof Error ? error.message : error}`));
+    }
+    return 0;
+}
+const USAGE = `${bold("coderook")} — CodeRook from the command line
+
+${bold("Getting started")}
+  coderook sign-in                 Store a personal access token
+  coderook whoami                  Who this machine is signed in as
+  coderook projects                Every project on your account
+
+${bold("Working with a folder")}
+  coderook status [folder]         What is here that is not saved yet
+  coderook submit [folder] -m "…"  Send the changes as a new version
+  coderook get [folder]            Fetch the latest version over this folder
+  coderook clone <project> [dir]   Fetch a project into a new folder
+  coderook rules [folder]          Show the ignore rules  (--init to start one)
+
+${bold("Bundles")}
+  coderook bundle [folder] [out]   Pack the project as a .cbx
+  coderook unbundle <file> [dir]   Extract a .cbx
+  coderook inspect <file>          What a .cbx contains  (--files to list them)
+
+${bold("Other")}
+  coderook doctor                  Check the service, config and sign-in
+  coderook sign-out                Forget the token on this machine
+
+${bold("Options")}
+  -m, --message   The version message for submit
+  -n, --dry-run   Show what submit would send, without sending
+      --token     Supply the token to sign-in instead of being asked
+
+${dim("The environment variable CODEROOK_TOKEN is used when set, so automated")}
+${dim("runs need nothing on disk. CODEROOK_API_URL points at another service.")}`;
+const COMMANDS = {
+    "sign-in": commandSignIn,
+    login: commandSignIn,
+    "sign-out": commandSignOut,
+    logout: commandSignOut,
+    whoami: () => commandWhoami(),
+    projects: () => commandProjects(),
+    status: commandStatus,
+    submit: commandSubmit,
+    publish: commandSubmit,
+    get: commandGet,
+    clone: commandClone,
+    rules: commandRules,
+    bundle: commandBundle,
+    unbundle: commandUnbundle,
+    inspect: commandInspect,
+    doctor: () => commandDoctor(),
+};
+async function main(argv) {
+    const [name, ...rest] = argv;
+    if (!name || name === "help" || name === "--help" || name === "-h") {
+        console.log(USAGE);
+        return 0;
+    }
+    if (name === "--version" || name === "-v" || name === "version") {
+        console.log(VERSION);
+        return 0;
+    }
+    const command = COMMANDS[name];
+    if (!command) {
+        console.error(red(`Unknown command: ${name}`));
+        console.error(dim("Run coderook help to see what there is."));
+        return 1;
+    }
+    return command(parse(rest));
+}
+/**
+ * Set the status and let Node wind down on its own.
+ *
+ * Calling process.exit here would race the sockets `fetch` keeps alive, and
+ * on Windows that trips a libuv assertion which prints alarming noise after
+ * a perfectly successful command. Unreferencing standard input is what lets
+ * the process finish promptly once the work is done.
+ */
+function leave(code) {
+    node_process_1.default.exitCode = code;
+}
+main(node_process_1.default.argv.slice(2))
+    .then(leave)
+    .catch((error) => {
+    console.error(red(error instanceof Error ? error.message : String(error)));
+    leave(1);
+});