@coderook/cli 0.9.0 → 0.10.0

package/dist/cli/src/project_commands.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * The project commands that had no home in the original CLI.
+ *
+ * Kept beside the main file rather than inside it. `cli.ts` was already 1,400
+ * lines of argument handling and worktree logic, and the commands here are
+ * about a project on the account rather than a folder on the disk — a
+ * different subject, and one that will keep growing as more of the service
+ * becomes reachable from a terminal.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProject = resolveProject;
+exports.commandAi = commandAi;
+exports.commandVersions = commandVersions;
+const node_process_1 = __importDefault(require("node:process"));
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+const dim = (value) => `${value}`;
+const bold = (value) => `${value}`;
+const red = (value) => `${value}`;
+const green = (value) => `${value}`;
+const accent = (value) => `${value}`;
+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(0)} KB`;
+    return `${value} B`;
+}
+/**
+ * Which project a command is about.
+ *
+ * Named explicitly, or the one this folder is linked to. Falling back to the
+ * folder is what makes these usable from inside a project without repeating
+ * its name every time.
+ */
+async function resolveProject(reference) {
+    const wanted = reference ?? (await (0, config_js_1.readLink)(node_process_1.default.cwd()))?.slug;
+    if (!wanted) {
+        console.error(red("Which project? Name one, or run this inside a linked folder."));
+        return null;
+    }
+    const project = await (0, api_js_1.findProject)(wanted);
+    if (!project) {
+        console.error(red(`No project matching "${wanted}" on your account.`));
+        return null;
+    }
+    return project;
+}
+/** The four answers, in the order the site shows them. */
+const AI_SWITCHES = [
+    [
+        "read",
+        "aiRead",
+        "Can AI read this?",
+        "reading, indexing, summarising and model training",
+    ],
+    [
+        "download",
+        "aiDownload",
+        "Can AI download this?",
+        "taking the files, one at a time or as an archive",
+    ],
+    [
+        "contribute",
+        "aiContribute",
+        "Can AI contribute to this?",
+        "automated clients opening contributions",
+    ],
+    [
+        "request",
+        "aiRequest",
+        "Can AI make requests?",
+        "automated clients calling this project's endpoints",
+    ],
+];
+/**
+ * Show or change what a project says about machines.
+ *
+ * The one part of the product with no command at all. Showing is the default
+ * because most of the time the question is "what is this set to", and a
+ * command that needs arguments to answer that is one people stop using.
+ */
+async function commandAi(parsed) {
+    const project = await resolveProject(parsed.positional[0]);
+    if (!project)
+        return 1;
+    const change = {};
+    for (const [name, field] of AI_SWITCHES) {
+        const value = parsed.flags.get(name);
+        if (value === undefined)
+            continue;
+        /*
+          `--read off` and `--read=false` both read naturally, and a bare `--read`
+          means on, because that is what a flag without a value means everywhere
+          else in this tool.
+        */
+        const text = typeof value === "string" ? value.trim().toLowerCase() : "";
+        change[field] =
+            value === true ? true : !["off", "false", "no", "n", "0"].includes(text);
+    }
+    if (Object.keys(change).length) {
+        await (0, api_js_1.setAiAccess)(project.id, change);
+        console.log(green(`Updated ${project.name}.`));
+    }
+    const access = await (0, api_js_1.aiAccess)(project.id);
+    console.log("");
+    console.log(bold(project.name));
+    for (const [name, field, question, meaning] of AI_SWITCHES) {
+        const mark = access[field] ? green("allowed") : red("refused");
+        console.log(`  ${question.padEnd(30)} ${mark}  ${dim("--" + name)}`);
+        console.log(`  ${dim(meaning)}`);
+    }
+    console.log("");
+    console.log(dim("Everything is allowed until you say otherwise. Turning reading off is the"));
+    console.log(dim("one that refuses model training."));
+    return 0;
+}
+/** Every saved version of a project, newest first. */
+async function commandVersions(parsed) {
+    const project = await resolveProject(parsed.positional[0]);
+    if (!project)
+        return 1;
+    const saved = await (0, api_js_1.versions)(project.id);
+    if (!saved.length) {
+        console.log(dim("Nothing has been saved to this project yet."));
+        return 0;
+    }
+    const asked = Number(parsed.flags.get("limit") ?? 20);
+    const limit = Number.isFinite(asked) && asked > 0 ? asked : 20;
+    console.log(bold(project.name));
+    for (const version of saved.slice(0, limit)) {
+        const when = version.createdAt
+            ? new Date(version.createdAt).toLocaleString()
+            : "";
+        console.log(`  ${accent(`v${version.sequence}`).padEnd(16)} ${when.padEnd(22)}` +
+            `${String(version.fileCount).padStart(5)} files  ${bytes(version.storedSize)}`);
+        if (version.message)
+            console.log(`    ${dim(version.message)}`);
+    }
+    if (saved.length > limit) {
+        console.log(dim(`  … ${saved.length - limit} older. Use --limit to see more.`));
+    }
+    return 0;
+}

package/dist/cli/src/registry.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * One table that both runs the commands and describes them.
+ *
+ * The usage text used to be a hand-written string beside a separate dispatch
+ * table, which is the arrangement where help slowly stops being true: a
+ * command gets added and the text does not mention it, or an option is renamed
+ * and the text still lists the old one. Nobody notices, because nothing checks.
+ *
+ * Here the description is part of the command. `coderook help` is generated
+ * from the same rows that decide what runs, so the two cannot disagree — and a
+ * command added without a summary is a type error rather than an omission.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GROUP_ORDER = void 0;
+exports.buildRegistry = buildRegistry;
+exports.nearestCommand = nearestCommand;
+/** The order groups appear in help, which is the order somebody meets them. */
+exports.GROUP_ORDER = [
+    "Getting started",
+    "Working with a folder",
+    "Your projects",
+    "People",
+    "When somebody saved first",
+    "Bundles",
+    "Actions",
+    "Other",
+];
+function buildRegistry(specs) {
+    const lookup = new Map();
+    for (const spec of specs) {
+        lookup.set(spec.name, spec);
+        for (const alias of spec.aliases ?? [])
+            lookup.set(alias, spec);
+    }
+    return { specs, lookup };
+}
+/**
+ * The nearest command to something mistyped.
+ *
+ * Levenshtein distance, capped so that a genuinely unrelated word gets no
+ * suggestion at all — "did you mean bundle?" in answer to "deploy" is worse
+ * than saying nothing, because it sends somebody to read the wrong help.
+ */
+function nearestCommand(registry, typed) {
+    let best = null;
+    for (const name of registry.lookup.keys()) {
+        const distance = editDistance(typed, name);
+        if (!best || distance < best.distance)
+            best = { name, distance };
+    }
+    if (!best)
+        return null;
+    const tolerance = typed.length <= 4 ? 1 : 3;
+    return best.distance <= tolerance ? best.name : null;
+}
+function editDistance(a, b) {
+    /*
+      One row at a time rather than a full matrix. Both are short, so this is
+      not about speed — a flat array of numbers is simply easier to convince a
+      type checker about than a grid of possibly-absent rows.
+    */
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= a.length; row += 1) {
+        const current = [row];
+        for (let column = 1; column <= b.length; column += 1) {
+            const cost = a[row - 1] === b[column - 1] ? 0 : 1;
+            current[column] = Math.min((previous[column] ?? 0) + 1, (current[column - 1] ?? 0) + 1, (previous[column - 1] ?? 0) + cost);
+        }
+        previous = current;
+    }
+    return previous[b.length] ?? 0;
+}

package/dist/cli/src/runner.js

@@ -0,0 +1,423 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withoutCredentials = withoutCredentials;
+exports.claim = claim;
+exports.defaultLabels = defaultLabels;
+exports.uploadArtifacts = uploadArtifacts;
+exports.performRun = performRun;
+exports.report = report;
+/**
+ * The machine that does the work.
+ *
+ * CodeRook records runs; it does not execute them. This is the other half of
+ * that arrangement: a small agent somebody installs on a machine they already
+ * own, which asks a project whether there is anything to do, does it there,
+ * and reports back. The service never holds a sandbox, never writes an egress
+ * policy, and never pays for compute — and the button on the Actions screen
+ * still does a real thing.
+ *
+ * It is the same shape as a GitHub self-hosted runner, deliberately, because
+ * that is the arrangement people already understand.
+ *
+ * The trust boundary is worth stating plainly, and the agent states it out
+ * loud at startup: anybody who can set a workflow's command on this project
+ * can run that command on this machine, as whoever started the agent. That is
+ * not a flaw to be fixed, it is what a runner is — but it should be a
+ * decision somebody made rather than one they discovered.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_os_2 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const download_js_1 = require("../../desktop-app/src/main/download.js");
+const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const config_js_1 = require("./config.js");
+/** How often to tell the service the machine is still working. */
+const HEARTBEAT_MS = 30_000;
+/** How often log lines are sent up while a command is running. */
+const FLUSH_MS = 2_000;
+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}`,
+            ...(0, identify_js_1.clientHeaders)(),
+            ...(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) {
+        throw new Error(body?.error?.message ?? `${route} failed (${response.status})`);
+    }
+    return body;
+}
+/**
+ * Send output up in batches rather than a line at a time.
+ *
+ * A build that prints ten thousand lines would otherwise be ten thousand
+ * requests, and the run would spend longer reporting than working. Lines are
+ * numbered from where the last batch ended, so what arrives is in the order
+ * it was printed even when a flush is slow.
+ */
+class LogShipper {
+    repositoryId;
+    runId;
+    pending = [];
+    sent = 0;
+    failed = false;
+    constructor(repositoryId, runId) {
+        this.repositoryId = repositoryId;
+        this.runId = runId;
+    }
+    add(chunk, stream) {
+        for (const line of chunk.split(/\r?\n/)) {
+            if (line !== "")
+                this.pending.push({ line: line.slice(0, 2000), stream });
+        }
+    }
+    async flush() {
+        if (!this.pending.length || this.failed)
+            return;
+        const batch = this.pending.splice(0, 500);
+        try {
+            await call(`/v1/repositories/${this.repositoryId}/runs/${this.runId}/logs`, {
+                method: "POST",
+                body: {
+                    lines: batch.map((entry, at) => ({
+                        line: entry.line,
+                        stream: entry.stream,
+                        lineNumber: this.sent + at,
+                    })),
+                },
+            });
+            this.sent += batch.length;
+        }
+        catch (error) {
+            /*
+              Losing the log is not a reason to lose the run. The verdict still
+              matters — and it is the thing somebody is waiting for — so a shipper
+              that cannot deliver says so once and stops trying.
+            */
+            this.failed = true;
+            console.error(`  (log upload stopped: ${errorText(error)})`);
+        }
+    }
+}
+/**
+ * The environment a workflow command gets, minus this machine's own keys.
+ *
+ * Running somebody's command on your machine is the deal a runner makes, and
+ * it is stated at every startup. Handing them the token that machine signs in
+ * with is not: `coderook runner` reads CODEROOK_TOKEN from the environment so
+ * automated runs can supply it, and every child process inherited it. A
+ * workflow set to `env` by anyone with write access printed it straight into
+ * the run log, which read access is enough to see — so a collaborator could
+ * walk off with the account of whoever was hosting the runner.
+ *
+ * The rest of the environment is left alone. PATH, HOME and the compiler
+ * settings are what makes a build possible, and stripping them would break
+ * every real workflow to guard against a risk the runner already announces.
+ */
+function withoutCredentials(source) {
+    const safe = { ...source };
+    for (const name of Object.keys(safe)) {
+        if (/^CODEROOK_(TOKEN|SECRET|PASSWORD|API_KEY)$/i.test(name)) {
+            delete safe[name];
+        }
+    }
+    return safe;
+}
+/**
+ * Where the command is allowed to run.
+ *
+ * `path.join` resolves `..`, so a working directory of `../../..` walks out
+ * of the throwaway folder and runs the command somewhere on this machine
+ * instead — the project's own directory, a home folder, anywhere. The service
+ * refuses to store one now, but a row written before it did is still a row,
+ * and this is the side that actually starts the process.
+ *
+ * Refused rather than clamped. Silently running somewhere other than where a
+ * workflow asked would be its own kind of surprise.
+ */
+function insideWorkspace(workspace, requested) {
+    const root = node_path_1.default.resolve(workspace);
+    const resolved = node_path_1.default.resolve(root, requested);
+    if (resolved !== root && !resolved.startsWith(root + node_path_1.default.sep)) {
+        throw new Error(`This workflow asks to run outside its own folder (${requested})`);
+    }
+    return resolved;
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Ask for work. Null means the queue is empty, which is the usual answer. */
+async function claim(repositoryId, runner, version, labels) {
+    const body = await call(`/v1/repositories/${repositoryId}/runs/claim`, {
+        method: "POST",
+        body: {
+            runner,
+            platform: `${node_os_2.default.platform()}-${node_os_2.default.arch()}`,
+            version,
+            labels,
+        },
+    });
+    return body.run ?? null;
+}
+/**
+ * What this machine answers to when nobody says.
+ *
+ * The platform it actually is, because that is what somebody means when they
+ * write a workflow that has to produce a Windows installer — and getting it
+ * wrong is not a crash, it is a build that runs on the wrong operating system
+ * and fails for a reason nobody asked about.
+ */
+function defaultLabels() {
+    const platform = node_os_2.default.platform();
+    if (platform === "win32")
+        return ["windows"];
+    if (platform === "darwin")
+        return ["macos"];
+    return ["linux"];
+}
+/**
+ * Hand back what the run built.
+ *
+ * The bytes go up through the object store's own route, which verifies the
+ * digest on arrival — the same route versions use, rather than a second way
+ * to put bytes in that would be a second place to get that wrong. Then the
+ * run is told which object was which file.
+ *
+ * Failing to upload does not fail the run. The verdict is what somebody is
+ * waiting for, and losing a build that passed because the network went odd
+ * afterwards would be a worse answer than a pass with a missing download.
+ */
+async function uploadArtifacts(repositoryId, runId, workspace, patterns, say) {
+    const wanted = await collectArtifacts(workspace, patterns);
+    let kept = 0;
+    for (const file of wanted) {
+        try {
+            const bytes = await (0, promises_1.readFile)(file.absolute);
+            const digest = (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+            const token = await (0, config_js_1.loadToken)();
+            const stored = await fetch(`${(0, config_js_1.apiOrigin)()}/v1/repositories/${repositoryId}` +
+                `/objects/${digest}?kind=chunk&role=chunk`, {
+                method: "PUT",
+                headers: {
+                    authorization: `Bearer ${token}`,
+                    "content-type": "application/octet-stream",
+                    "content-length": String(bytes.byteLength),
+                    ...(0, identify_js_1.clientHeaders)(),
+                },
+                body: bytes,
+            });
+            if (!stored.ok)
+                throw new Error(`upload failed (${stored.status})`);
+            const object = (await stored.json());
+            await call(`/v1/repositories/${repositoryId}/runs/${runId}/artifacts`, {
+                method: "POST",
+                body: {
+                    path: file.relative,
+                    objectId: object.objectId,
+                    sizeBytes: bytes.byteLength,
+                },
+            });
+            kept += 1;
+            say(`Kept ${file.relative} (${bytes.byteLength} bytes)`);
+        }
+        catch (error) {
+            say(`Could not keep ${file.relative}: ${errorText(error)}`);
+        }
+    }
+    return kept;
+}
+/**
+ * Find the files a workflow asked to keep.
+ *
+ * Patterns are shell-ish rather than a full glob library: a directory keeps
+ * everything under it, and a `*` matches within one path segment. That covers
+ * `dist/`, `build/*.exe` and `out/**` — which is what people write — without
+ * taking a dependency to parse the rest.
+ */
+async function collectArtifacts(workspace, patterns) {
+    const everything = [];
+    const walk = async (directory) => {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const at = node_path_1.default.join(directory, entry.name);
+            if (entry.isDirectory())
+                await walk(at);
+            else if (entry.isFile())
+                everything.push(at);
+        }
+    };
+    await walk(workspace);
+    const found = new Map();
+    for (const raw of patterns) {
+        const pattern = normalisePattern(raw);
+        if (!pattern)
+            continue;
+        const matcher = patternMatcher(pattern);
+        for (const absolute of everything) {
+            const relative = node_path_1.default.relative(workspace, absolute).split(node_path_1.default.sep).join("/");
+            if (matcher(relative))
+                found.set(relative, { absolute, relative });
+        }
+    }
+    return [...found.values()];
+}
+/** Tidy a pattern, and refuse one that tries to leave the checkout. */
+function normalisePattern(raw) {
+    const cleaned = raw.split("\\").join("/").replace(/^\/+/, "").trim();
+    if (!cleaned)
+        return null;
+    return cleaned.split("/").includes("..") ? null : cleaned;
+}
+/**
+ * Match one path against one pattern.
+ *
+ * `dist` keeps everything under it, `*` matches within a segment and `**`
+ * across them. Built by escaping the pattern and then putting the wildcards
+ * back, rather than by escaping around them — doing it the other way is how
+ * a dot in `*.exe` quietly becomes "any character".
+ */
+function patternMatcher(pattern) {
+    const expression = new RegExp(`^${pattern
+        .split("/")
+        .map((part) => part === "**"
+        ? "[SPAN]"
+        : part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").split("\\*").join("[^/]*"))
+        .join("/")
+        .split("[SPAN]")
+        .join(".*")}$`);
+    return (candidate) => expression.test(candidate) || candidate.startsWith(`${pattern}/`);
+}
+/**
+ * Carry out one run, from a fresh copy of the version to a verdict.
+ *
+ * The version is materialised into a throwaway directory rather than into
+ * anybody's working folder: a run that wrote over the checkout somebody was
+ * editing would be a way to lose work, and a run that reused the last one's
+ * directory would let one job's leftovers decide the next job's result.
+ */
+async function performRun(repositoryId, run, runner) {
+    const logs = new LogShipper(repositoryId, run.runId);
+    const started = Date.now();
+    const workspace = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "coderook-run-"));
+    let beating;
+    let flushing;
+    try {
+        beating = setInterval(() => {
+            void call(`/v1/repositories/${repositoryId}/runs/${run.runId}/heartbeat`, {
+                method: "POST",
+                body: { runner },
+            }).catch(() => {
+                /*
+                  A lost lease means the service has given this run to somebody else,
+                  and the local process is now doing work nobody will accept. Stopping
+                  the heartbeat is enough: the report at the end will be refused too,
+                  and the run that matters is the one the other machine is doing.
+                */
+            });
+        }, HEARTBEAT_MS);
+        if (run.versionId) {
+            logs.add(`Fetching v${run.versionSequence ?? "?"}…`, "stdout");
+            const downloader = new download_js_1.Downloader(config_js_1.credentials);
+            const got = await downloader.run(repositoryId, run.versionId, workspace, () => { }, null, "replace");
+            logs.add(`Fetched ${got.files} files.`, "stdout");
+        }
+        else {
+            logs.add("This run has no version; running in an empty folder.", "stdout");
+        }
+        await logs.flush();
+        const command = run.command?.trim();
+        if (!command) {
+            return { status: "failed", summary: "This workflow has no command" };
+        }
+        const directory = run.workingDirectory
+            ? insideWorkspace(workspace, run.workingDirectory)
+            : workspace;
+        flushing = setInterval(() => void logs.flush(), FLUSH_MS);
+        const code = await new Promise((settle) => {
+            /*
+              Through a shell, because the command is one shell line and people
+              write them expecting a shell — pipes, `&&`, an environment variable.
+              Which shell is the platform's own, so a Windows machine reads it the
+              way a Windows user wrote it.
+            */
+            const child = (0, node_child_process_1.spawn)(command, {
+                cwd: directory,
+                shell: true,
+                env: {
+                    ...withoutCredentials(process.env),
+                    CI: "true",
+                    CODEROOK_RUN: String(run.number),
+                    CODEROOK_VERSION: run.versionSequence
+                        ? `v${run.versionSequence}`
+                        : "",
+                },
+            });
+            child.stdout?.on("data", (chunk) => logs.add(chunk.toString("utf8"), "stdout"));
+            child.stderr?.on("data", (chunk) => logs.add(chunk.toString("utf8"), "stderr"));
+            child.on("error", (error) => {
+                logs.add(errorText(error), "stderr");
+                settle(1);
+            });
+            child.on("close", (status) => settle(status ?? 1));
+        });
+        /*
+          What it built, before the folder goes.
+    
+          Kept whether the run passed or failed: a failed build often produces the
+          very log or partial output somebody needs to work out why, and throwing
+          that away is exactly when they would have wanted it.
+        */
+        if (run.artifactPaths?.length) {
+            const kept = await uploadArtifacts(repositoryId, run.runId, workspace, run.artifactPaths, (line) => logs.add(line, "stdout"));
+            if (!kept) {
+                logs.add("Nothing matched the paths this workflow keeps.", "stdout");
+            }
+        }
+        await logs.flush();
+        const seconds = Math.round((Date.now() - started) / 1000);
+        return code === 0
+            ? { status: "passed", summary: `Passed in ${seconds}s` }
+            : { status: "failed", summary: `Exited ${code} after ${seconds}s` };
+    }
+    catch (error) {
+        logs.add(errorText(error), "stderr");
+        await logs.flush();
+        return { status: "failed", summary: errorText(error).slice(0, 200) };
+    }
+    finally {
+        if (beating)
+            clearInterval(beating);
+        if (flushing)
+            clearInterval(flushing);
+        await logs.flush();
+        await (0, promises_1.rm)(workspace, { recursive: true, force: true }).catch(() => { });
+    }
+}
+/** Say how it went. */
+async function report(repositoryId, runId, verdict, durationMs) {
+    await call(`/v1/repositories/${repositoryId}/runs/${runId}`, {
+        method: "PATCH",
+        body: { ...verdict, durationMs },
+    });
+}