@coderook/cli 0.12.0 → 0.14.0

package/dist/cli/src/mcp.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * CodeRook as a tool an assistant can use.
+ *
+ * Claude Code and Codex both take integrations the same way: a small process
+ * speaking JSON-RPC over its own stdin and stdout, launched by the assistant
+ * and shut down with it. One server therefore covers both, and shipping it
+ * inside the CLI means the install is the install somebody already did — no
+ * second package, no second sign-in, no second copy of the upload engine.
+ *
+ * Written against the wire rather than against a library. The protocol here
+ * is a handshake and two methods; the CLI has no runtime dependencies at all,
+ * which is a large part of why installing it globally is safe, and adding a
+ * dependency tree to gain three hundred lines is a poor trade.
+ *
+ * What it will not do matters as much as what it will. Everything here reads.
+ * Nothing writes to an account, nothing deletes, and nothing signs anything
+ * in or out — an assistant that has gone wrong can waste your time but cannot
+ * cost you work. Saving a version stays a thing a person types.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandMcp = commandMcp;
+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 download_js_1 = require("../../desktop-app/src/main/download.js");
+const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+/** What the protocol calls itself. Both clients accept this revision. */
+const PROTOCOL_VERSION = "2024-11-05";
+/** Beyond this a file is described rather than pasted into a conversation. */
+const READ_LIMIT = 256 * 1024;
+function text(value) {
+    return { content: [{ type: "text", text: 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`;
+}
+/**
+ * The project a call is about, named or taken from the folder.
+ *
+ * Assistants are usually already sitting in a project directory, so a tool
+ * that insists on being told which project every time is a tool that gets
+ * called wrongly. Naming one still wins when it is given.
+ */
+async function resolve(named) {
+    const wanted = (typeof named === "string" && named.trim()) ||
+        (await (0, config_js_1.readLink)(node_process_1.default.cwd()))?.slug;
+    if (!wanted) {
+        throw new Error("No project named, and this folder is not linked to one. Pass `project`.");
+    }
+    const found = await (0, api_js_1.findProject)(wanted);
+    if (!found)
+        throw new Error(`No project matching "${wanted}" on your account.`);
+    return { id: found.id, slug: found.slug };
+}
+/**
+ * Whether this project's owner allows machines to read it.
+ *
+ * The four switches on a project are the owner's answer about automated
+ * access, and an assistant reading on somebody's behalf is exactly what they
+ * describe. Checked here rather than left to the service, so the refusal says
+ * why in words the assistant can pass on rather than arriving as a status
+ * code it will most likely retry.
+ */
+async function assertMayRead(repositoryId, slug) {
+    const access = await (0, api_js_1.aiAccess)(repositoryId);
+    if (!access.aiRead) {
+        throw new Error(`The owner of "${slug}" has asked that machines not read it. ` +
+            "A person can still open it in the desktop application or the browser.");
+    }
+}
+async function withVersion(projectId, wanted) {
+    const saved = await (0, api_js_1.versions)(projectId);
+    if (!saved.length)
+        throw new Error("This project has no saved versions yet.");
+    if (wanted === undefined || wanted === null || wanted === "latest") {
+        return { id: saved[0].id, sequence: saved[0].sequence };
+    }
+    const sequence = Number(wanted);
+    const found = saved.find((one) => one.sequence === sequence);
+    if (!found)
+        throw new Error(`No version ${wanted} in this project.`);
+    return { id: found.id, sequence: found.sequence };
+}
+const TOOLS = [
+    {
+        name: "coderook_projects",
+        description: "Every project on the signed-in CodeRook account, with how much each " +
+            "holds and when it last changed.",
+        inputSchema: { type: "object", properties: {} },
+        run: async () => {
+            const all = await (0, api_js_1.projects)();
+            if (!all.length)
+                return "No projects on this account yet.";
+            return all
+                .map((one) => `${one.slug}  ${one.visibility}  ${one.versionCount} version${one.versionCount === 1 ? "" : "s"}  ${bytes(one.storedBytes ?? 0)}`)
+                .join("\n");
+        },
+    },
+    {
+        name: "coderook_versions",
+        description: "What has been saved to a project, newest first. Each version is a " +
+            "complete snapshot, not a difference from the one before it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                project: { type: "string", description: "Slug. Defaults to this folder's project." },
+            },
+        },
+        run: async (input) => {
+            const project = await resolve(input.project);
+            await assertMayRead(project.id, project.slug);
+            const saved = await (0, api_js_1.versions)(project.id);
+            if (!saved.length)
+                return "No versions saved yet.";
+            return saved
+                .map((one) => `v${one.sequence}  ${one.createdAt.slice(0, 10)}  ${one.fileCount} files  ` +
+                `${bytes(one.storedSize)}  ${one.message || "(no message)"}`)
+                .join("\n");
+        },
+    },
+    {
+        name: "coderook_files",
+        description: "The files a version contains, with their sizes. Use before reading " +
+            "one, so a path is known to exist rather than guessed at.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                project: { type: "string" },
+                version: {
+                    type: ["number", "string"],
+                    description: 'Version number, or "latest". Defaults to latest.',
+                },
+            },
+        },
+        run: async (input) => {
+            const project = await resolve(input.project);
+            await assertMayRead(project.id, project.slug);
+            const version = await withVersion(project.id, input.version);
+            const files = await new download_js_1.Downloader(config_js_1.credentials).files(project.id, version.id);
+            if (!files.length)
+                return `v${version.sequence} holds no files.`;
+            const shown = files.slice(0, 2000);
+            const lines = shown.map((file) => `${file.path}  ${bytes(file.sourceSize)}`);
+            if (files.length > shown.length) {
+                lines.push(`… and ${files.length - shown.length} more`);
+            }
+            return `v${version.sequence} · ${files.length} files\n${lines.join("\n")}`;
+        },
+    },
+    {
+        name: "coderook_read_file",
+        description: "The contents of one file at one version, as stored. Verified against " +
+            "the digest the version recorded.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path within the project." },
+                project: { type: "string" },
+                version: { type: ["number", "string"] },
+            },
+            required: ["path"],
+        },
+        run: async (input) => {
+            const wanted = String(input.path ?? "").trim();
+            if (!wanted)
+                throw new Error("Which file? Pass `path`.");
+            const project = await resolve(input.project);
+            await assertMayRead(project.id, project.slug);
+            const version = await withVersion(project.id, input.version);
+            const downloader = new download_js_1.Downloader(config_js_1.credentials);
+            const files = await downloader.files(project.id, version.id);
+            const file = files.find((one) => one.path === wanted);
+            if (!file)
+                throw new Error(`No file "${wanted}" in v${version.sequence}.`);
+            if (file.sourceSize > READ_LIMIT) {
+                return (`${wanted} is ${bytes(file.sourceSize)}, larger than this tool will ` +
+                    `paste into a conversation. Fetch the project with \`coderook get\` ` +
+                    `and read it from disk.`);
+            }
+            /*
+              Through the same download path a person uses, temporary file and all,
+              rather than a second way of fetching bytes. That path verifies each
+              piece against the digest the version recorded — the check that caught
+              a 7.34 GB file arriving as 5.09 GB under a clean 200.
+            */
+            const scratch = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "coderook-mcp-"));
+            try {
+                const target = node_path_1.default.join(scratch, node_path_1.default.basename(wanted) || "file");
+                await downloader.fileTo(project.id, version.id, file, target);
+                const held = await (0, promises_1.readFile)(target);
+                if (held.includes(0)) {
+                    return `${wanted} is binary (${bytes(file.sourceSize)}); not shown.`;
+                }
+                return held.toString("utf8");
+            }
+            finally {
+                await (0, promises_1.rm)(scratch, { recursive: true, force: true });
+            }
+        },
+    },
+    {
+        name: "coderook_status",
+        description: "What has changed in a local folder since its last saved version — " +
+            "added, edited and removed files. Reads the folder; changes nothing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                folder: { type: "string", description: "Defaults to the working directory." },
+            },
+        },
+        run: async (input) => {
+            const folder = node_path_1.default.resolve(typeof input.folder === "string" && input.folder.trim()
+                ? input.folder
+                : node_process_1.default.cwd());
+            const link = await (0, config_js_1.readLink)(folder);
+            const rules = await (0, worktree_js_1.readRules)(folder);
+            const changed = await (0, worktree_js_1.changedFiles)(folder, rules, null);
+            if (!changed.length)
+                return "Nothing here has changed since the last version.";
+            /*
+              Said in the words the scan actually produces: a file the folder no
+              longer has is a deletion, one with nothing removed is new, and the
+              rest are edits with their line counts, because "changed" on its own
+              tells an assistant nothing about how much.
+            */
+            const lines = changed.slice(0, 500).map((file) => {
+                if (file.deleted)
+                    return `deleted  ${file.path}`;
+                if (!file.removed)
+                    return `added    ${file.path}  +${file.added}`;
+                return `edited   ${file.path}  +${file.added} -${file.removed}`;
+            });
+            if (changed.length > lines.length) {
+                lines.push(`… and ${changed.length - lines.length} more`);
+            }
+            const where = link ? `${link.slug} (v${link.sequence})` : "not linked to a project";
+            return `${folder} — ${where}\n${changed.length} changed\n${lines.join("\n")}`;
+        },
+    },
+];
+/* ------------------------------------------------------------------ wire */
+function reply(id, result) {
+    node_process_1.default.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+}
+function fail(id, code, message) {
+    node_process_1.default.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`);
+}
+async function handle(request) {
+    const { id, method, params } = request;
+    /*
+      Notifications carry no id and expect no answer. Replying to one is a
+      protocol error, and the client that receives it is entitled to hang up.
+    */
+    const isNotification = id === undefined || id === null;
+    if (method === "initialize") {
+        reply(id, {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: { name: "coderook", version: node_process_1.default.env.CODEROOK_CLI_VERSION ?? "0.13.0" },
+        });
+        return;
+    }
+    if (method === "notifications/initialized" || method === "notifications/cancelled") {
+        return;
+    }
+    if (method === "tools/list") {
+        reply(id, {
+            tools: TOOLS.map(({ name, description, inputSchema }) => ({
+                name,
+                description,
+                inputSchema,
+            })),
+        });
+        return;
+    }
+    if (method === "tools/call") {
+        const name = String(params?.name ?? "");
+        const tool = TOOLS.find((one) => one.name === name);
+        if (!tool) {
+            if (!isNotification)
+                fail(id, -32602, `No tool called "${name}".`);
+            return;
+        }
+        try {
+            const answer = await tool.run(params?.arguments ?? {});
+            reply(id, text(answer));
+        }
+        catch (error) {
+            /*
+              Returned as a result rather than a protocol error. A refusal — the
+              owner does not allow machines, the file is not there — is an answer
+              the assistant should read and act on, where a JSON-RPC error is
+              something it will most likely retry or surface as a crash.
+            */
+            reply(id, {
+                ...text(error instanceof Error ? error.message : String(error)),
+                isError: true,
+            });
+        }
+        return;
+    }
+    if (!isNotification)
+        fail(id, -32601, `Unsupported method "${method}".`);
+}
+/**
+ * Read newline-delimited JSON from stdin until it closes.
+ *
+ * Buffered by line rather than by chunk, because a chunk boundary falls
+ * wherever the pipe decides and a half-read message parses as nothing.
+ */
+async function commandMcp() {
+    node_process_1.default.stdin.setEncoding("utf8");
+    let buffer = "";
+    await new Promise((done) => {
+        node_process_1.default.stdin.on("data", (piece) => {
+            buffer += piece;
+            let cut = buffer.indexOf("\n");
+            while (cut >= 0) {
+                const line = buffer.slice(0, cut).trim();
+                buffer = buffer.slice(cut + 1);
+                cut = buffer.indexOf("\n");
+                if (!line)
+                    continue;
+                try {
+                    void handle(JSON.parse(line));
+                }
+                catch {
+                    /* Not JSON. Nothing to answer, and nobody to answer to. */
+                }
+            }
+        });
+        node_process_1.default.stdin.on("end", () => done());
+        node_process_1.default.stdin.on("close", () => done());
+    });
+    return 0;
+}

package/dist/cli/src/track_commands.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Lines of work, from a terminal.
+ *
+ * The desktop grew tracks — a project can have more than one line, so two
+ * people can save without one of them landing on top of the other — and the
+ * command line was left knowing only how to finish a merge somebody else had
+ * started. It could see the wreckage and not the thing that caused it: no way
+ * to list the lines, none to start one, and no way to say which line a save
+ * was meant for. A folder driven from a terminal could only ever write to the
+ * default.
+ *
+ * The service and the desktop already agree about all of this; what follows
+ * is the same three ideas said in a shell. The `Tracks` client is the
+ * desktop's own, imported rather than reimplemented, because two clients for
+ * one API is two sets of behaviour to keep in step.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TRACK = void 0;
+exports.trackFor = trackFor;
+exports.commandTracks = commandTracks;
+exports.commandTrack = commandTrack;
+const node_process_1 = __importDefault(require("node:process"));
+const tracks_js_1 = require("../../desktop-app/src/main/tracks.js");
+const config_js_1 = require("./config.js");
+const project_commands_js_1 = require("./project_commands.js");
+const dim = (value) => `${value}`;
+const bold = (value) => `${value}`;
+const red = (value) => `${value}`;
+const green = (value) => `${value}`;
+const accent = (value) => `${value}`;
+/** The line a folder saves to when nobody has said otherwise. */
+exports.DEFAULT_TRACK = "main";
+function client() {
+    return new tracks_js_1.Tracks(config_js_1.credentials);
+}
+/**
+ * Which line this folder is on.
+ *
+ * Read from the folder's own record rather than from the account, because it
+ * is a fact about this copy: two checkouts of the same project can sit on
+ * different lines, which is most of the point of having them.
+ */
+async function trackFor(localPath) {
+    const link = await (0, config_js_1.readLink)(localPath);
+    return link?.track?.trim() || exports.DEFAULT_TRACK;
+}
+function describe(track, current) {
+    const here = track.name === current;
+    const mark = here ? accent("*") : " ";
+    const name = here ? bold(track.name) : track.name;
+    const notes = [];
+    if (track.kind === "merge")
+        notes.push("waiting on a decision");
+    if (track.protected)
+        notes.push("protected");
+    if (!track.headVersionId)
+        notes.push("nothing saved yet");
+    return `${mark} ${name}${notes.length ? dim(`  ${notes.join(" · ")}`) : ""}`;
+}
+/**
+ * Every line and unfinished merge on the project.
+ *
+ * Merges are listed beside the lines rather than hidden, because a merge is
+ * a line the service is holding open until somebody decides — and somebody
+ * looking for "where can I save" needs to see the one they cannot.
+ */
+async function commandTracks(parsed) {
+    const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[0]);
+    if (!project)
+        return 1;
+    const tracks = await client().list(project.id);
+    if (!tracks.length) {
+        console.log(dim("No lines recorded yet. The first save creates ") + bold(exports.DEFAULT_TRACK) + dim("."));
+        return 0;
+    }
+    const current = await trackFor(node_process_1.default.cwd());
+    const lines = tracks.filter((track) => track.kind === "line");
+    const merges = tracks.filter((track) => track.kind === "merge");
+    console.log(bold(`Lines on ${project.slug}`));
+    for (const track of lines)
+        console.log(`  ${describe(track, current)}`);
+    if (merges.length) {
+        console.log("");
+        console.log(bold("Waiting on a decision"));
+        for (const track of merges)
+            console.log(`  ${describe(track, current)}`);
+        console.log(dim("  Finish one with ") + "coderook merge");
+    }
+    console.log("");
+    console.log(dim("This folder saves to ") + accent(current));
+    return 0;
+}
+/**
+ * Show, switch, or start the line this folder saves to.
+ *
+ * Switching is a statement about where the next save goes and nothing else:
+ * no files move and nothing is fetched, which is why it is instant and why
+ * it is safe to change your mind. Getting the other line's files is
+ * `coderook get`, deliberately a separate act.
+ */
+async function commandTrack(parsed) {
+    const folder = node_process_1.default.cwd();
+    const link = await (0, config_js_1.readLink)(folder);
+    if (!link) {
+        console.error(red("This folder is not linked to a project. Run ") + "coderook get" + red(" first."));
+        return 1;
+    }
+    const wanted = parsed.positional[0];
+    const current = link.track?.trim() || exports.DEFAULT_TRACK;
+    if (!wanted) {
+        console.log(accent(current));
+        console.log(dim("Switch with ") + "coderook track <name>");
+        return 0;
+    }
+    const starting = parsed.flags.has("new") || parsed.flags.has("n");
+    const tracks = await client().list(link.repositoryId);
+    const existing = tracks.find((track) => track.name === wanted);
+    if (existing && starting) {
+        console.error(red(`There is already a line called "${wanted}".`));
+        return 1;
+    }
+    if (!existing && !starting) {
+        /*
+          Refused rather than created quietly. A typo in a branch name is a
+          normal thing to do, and silently starting a line called `mian` puts
+          work somewhere nobody will look for it.
+        */
+        console.error(red(`No line called "${wanted}" on this project.`));
+        console.error(dim("Start one with ") + `coderook track ${wanted} --new`);
+        return 1;
+    }
+    if (existing?.kind === "merge") {
+        console.error(red(`"${wanted}" is a merge waiting on a decision, not a line to save onto.`));
+        console.error(dim("Finish it with ") + "coderook merge");
+        return 1;
+    }
+    if (starting) {
+        try {
+            await client().create(link.repositoryId, wanted);
+        }
+        catch (error) {
+            console.error(red(error instanceof Error ? error.message : String(error)));
+            return 1;
+        }
+        console.log(green(`Started ${bold(wanted)} from where the project is now.`));
+    }
+    await (0, config_js_1.writeLink)(folder, { ...link, track: wanted });
+    console.log(dim("This folder now saves to ") + accent(wanted));
+    if (existing) {
+        console.log(dim("Its files are not here yet — fetch them with ") + `coderook get`);
+    }
+    return 0;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksCompressed = looksCompressed;
+exports.encodeForUpload = encodeForUpload;
+/**
+ * Compressing an object before it is sent.
+ *
+ * The service stores an object either as it arrived or gzipped, and records
+ * which on the row: the digest in the path is always the *original* bytes, so
+ * an object keeps one identity however it happened to travel. That is what
+ * lets the same file be sent compressed by one client and plain by another
+ * and still be recognised as the file it already has.
+ *
+ * The desktop app never used it. Every upload went as raw bytes, which is why
+ * the account overview reports nothing saved — there was nothing to report.
+ * The cost was paid twice: once in the person's upload time, and again in the
+ * storage they are charged for.
+ *
+ * Two rules keep this from being a pessimisation:
+ *
+ * Already-compressed formats are left alone. Gzipping a PNG, a zip or an mp4
+ * spends real time to make the file slightly bigger, and those are exactly the
+ * large files where the wasted effort is most noticeable.
+ *
+ * And a result that did not save anything is thrown away. The check is on the
+ * outcome rather than on the guess — a ".bin" that turns out to be text gets
+ * compressed, a ".txt" full of random data does not stay compressed.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_zlib_1 = require("node:zlib");
+const node_util_1 = require("node:util");
+const deflate = (0, node_util_1.promisify)(node_zlib_1.gzip);
+/*
+  Extensions whose contents are already compressed. Matching on the name is a
+  guess, but it is the cheap half of the decision — the expensive half, below,
+  is measured rather than guessed, so a wrong entry here costs a little time
+  and never a wrong result.
+*/
+const ALREADY_COMPRESSED = new Set([
+    ".7z", ".aac", ".avi", ".br", ".bz2", ".cbx", ".docx", ".flac", ".gif",
+    ".gz", ".heic", ".jpeg", ".jpg", ".jxl", ".m4a", ".m4v", ".mkv", ".mov",
+    ".mp3", ".mp4", ".odp", ".ods", ".odt", ".ogg", ".opus", ".pdf", ".png",
+    ".pptx", ".rar", ".safetensors", ".webm", ".webp", ".xlsx", ".xz", ".zip",
+    ".zst",
+]);
+/**
+ * Below this, compression is not worth the round trip through zlib — the
+ * saving is measured in bytes and every file pays the CPU.
+ */
+const SMALLEST_WORTH_TRYING = 4 * 1024;
+/**
+ * Keep the compressed form only if it saved something worth having. A file
+ * that shrinks by two percent is not worth the service decompressing it on
+ * every read for the rest of its life.
+ */
+const WORTHWHILE = 0.95;
+function looksCompressed(relativePath) {
+    const dot = relativePath.lastIndexOf(".");
+    if (dot < 0)
+        return false;
+    return ALREADY_COMPRESSED.has(relativePath.slice(dot).toLowerCase());
+}
+/**
+ * Decide how one object should travel.
+ *
+ * Never throws for compression reasons: if anything goes wrong the original
+ * bytes are sent, because a failed optimisation must not become a failed
+ * upload.
+ */
+async function encodeForUpload(original, relativePath, allowGzip) {
+    const plain = {
+        body: original,
+        encoding: "identity",
+        storedSha256: "",
+    };
+    if (!allowGzip)
+        return plain;
+    if (original.byteLength < SMALLEST_WORTH_TRYING)
+        return plain;
+    if (looksCompressed(relativePath))
+        return plain;
+    try {
+        const packed = await deflate(original, { level: 6 });
+        if (packed.byteLength >= original.byteLength * WORTHWHILE)
+            return plain;
+        return {
+            body: new Uint8Array(packed),
+            encoding: "gzip",
+            storedSha256: (0, node_crypto_1.createHash)("sha256").update(packed).digest("hex"),
+        };
+    }
+    catch {
+        return plain;
+    }
+}