@coderook/cli 0.22.2 → 0.24.0

package/dist/cli/src/git_remote.js

@@ -0,0 +1,1118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+/**
+ * `git push coderook` — a git remote helper.
+ *
+ * Git looks for a program called `git-remote-<scheme>` on PATH when it meets a
+ * remote URL it does not recognise, hands it the remote name and URL, and then
+ * talks a small line protocol over stdin and stdout. This is that program for
+ * `coderook://` URLs, which is what lets every editor's built-in git panel work
+ * with CodeRook without any per-editor work.
+ *
+ * Both directions are implemented: `push` publishes commits as versions, and
+ * `import` rebuilds a git history from versions so `git clone` and `git fetch`
+ * work.
+ *
+ * ## Why the `push` capability rather than `export`
+ *
+ * A helper may declare `export`, in which case git runs `git fast-export` and
+ * pipes the stream in. It is less code and it is the wrong shape here:
+ * fast-export states each commit as a *delta against its parent*, so replaying
+ * it onto one working tree is only correct while the history is a straight
+ * line. The moment a branch or a merge appears, the tree a commit is applied to
+ * is not the tree it was written against, and the version published is a blend
+ * of two commits that never existed. That failure is silent — every file is
+ * valid, the push reports success, and the contents are wrong.
+ *
+ * Declaring `push` instead means git tells us which refs to move and leaves the
+ * method to us, so each commit is read as a *complete tree* and parentage never
+ * has to be reconstructed. It also lets us diff any two commits directly, which
+ * is what keeps the upload incremental.
+ *
+ * ## What is deliberately not supported
+ *
+ * Named here rather than discovered by failure:
+ *
+ * - **Tag kind.** A tag becomes a release and a release becomes a tag, but
+ *   fast-import can only create annotated tags — so a lightweight tag pushed
+ *   comes back annotated. CodeRook has no notion of the difference to record.
+ * - **Force pushes and deletions.** CodeRook versions are immutable, so there
+ *   is nothing to rewind to. Both are refused rather than silently ignored.
+ * - **Submodules.** A gitlink is a pointer into another repository and there
+ *   are no bytes to publish. Skipped on push, and said out loud.
+ * - **File modes.** Everything is imported as `100644`. CodeRook records an
+ *   executable bit but git's mode is not round-tripped yet, so a script
+ *   cloned back needs `chmod +x`.
+ *
+ * ## What a round trip does and does not preserve
+ *
+ * Push then clone returns the same *contents*, not the same *commits*. The
+ * rebuilt commits have different ids, because a git commit id covers its
+ * author, committer and timestamps, and CodeRook stores who published a
+ * version but not the original stamps. So a clone of a pushed project is a
+ * faithful copy of the files and an honest approximation of the history.
+ *
+ * Merges are asymmetric, and the asymmetry is in the service rather than here.
+ * A publish states one base version, so pushing a git merge commit records one
+ * parent and the second is lost — the merged *tree* is exact, the fork in the
+ * history is not. Reading back is the richer direction: a version states its
+ * parents in order, so a version that genuinely has two is rebuilt as a real
+ * git merge commit. Push then clone therefore returns a straight line even
+ * where the original branched.
+ */
+const node_child_process_1 = require("node:child_process");
+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 upload_js_1 = require("../../desktop-app/src/main/upload.js");
+const tracks_js_1 = require("../../desktop-app/src/main/tracks.js");
+const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const config_js_1 = require("./config.js");
+const publish_js_1 = require("./publish.js");
+const git_history_js_1 = require("./git_history.js");
+const api_js_1 = require("./api.js");
+/** Everything the helper writes for a person goes to stderr; stdout is protocol. */
+function say(text) {
+    node_process_1.default.stderr.write(`${text}\n`);
+}
+function send(text) {
+    node_process_1.default.stdout.write(`${text}\n`);
+}
+/** Run git and return stdout as text. Throws with git's own message. */
+function git(args) {
+    const result = (0, node_child_process_1.spawnSync)("git", args, {
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024 * 256,
+    });
+    if (result.status !== 0) {
+        throw new Error(`git ${args.slice(0, 3).join(" ")} failed: ${(result.stderr || "").trim()}`);
+    }
+    return result.stdout;
+}
+/** Run git for its exit status alone. False rather than throwing. */
+function gitOk(args) {
+    return ((0, node_child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: "ignore" }).status === 0);
+}
+/**
+ * One long-lived `git cat-file --batch` process.
+ *
+ * A push reads one blob per changed path per commit, and starting a git process
+ * for each costs more than the reading does. GitLab measured the same walk as
+ * 70% faster with a single batch process, which is the whole reason this is a
+ * class rather than a function that shells out.
+ *
+ * The protocol is: write `<object>\n`, read a header line
+ * `<oid> <type> <size>\n`, then exactly `<size>` bytes, then one newline.
+ */
+class CatFile {
+    child = (0, node_child_process_1.spawn)("git", ["cat-file", "--batch"], {
+        stdio: ["pipe", "pipe", "inherit"],
+    });
+    buffer = Buffer.alloc(0);
+    waiters = [];
+    closed = false;
+    constructor() {
+        this.child.stdout.on("data", (chunk) => {
+            this.buffer = Buffer.concat([this.buffer, chunk]);
+            const waiting = this.waiters;
+            this.waiters = [];
+            for (const wake of waiting)
+                wake();
+        });
+        this.child.stdout.on("end", () => {
+            this.closed = true;
+            for (const wake of this.waiters)
+                wake();
+            this.waiters = [];
+        });
+    }
+    async more() {
+        if (this.closed)
+            throw new Error("git cat-file closed unexpectedly");
+        await new Promise((resolve) => this.waiters.push(resolve));
+    }
+    async readLine() {
+        for (;;) {
+            const at = this.buffer.indexOf(0x0a);
+            if (at !== -1) {
+                const line = this.buffer.subarray(0, at).toString("utf8");
+                this.buffer = this.buffer.subarray(at + 1);
+                return line;
+            }
+            await this.more();
+        }
+    }
+    async readBytes(count) {
+        while (this.buffer.length < count)
+            await this.more();
+        const out = this.buffer.subarray(0, count);
+        this.buffer = this.buffer.subarray(count);
+        return Buffer.from(out);
+    }
+    /** The bytes of one blob, named as `<commit>:<path>` or by object id. */
+    async blob(reference) {
+        this.child.stdin.write(`${reference}\n`);
+        const header = await this.readLine();
+        if (header.endsWith(" missing")) {
+            throw new Error(`git has no object for ${reference}`);
+        }
+        const size = Number(header.split(" ")[2]);
+        const body = await this.readBytes(size);
+        await this.readBytes(1); // the trailing newline
+        return body;
+    }
+    close() {
+        this.child.stdin.end();
+        this.child.kill();
+    }
+}
+/**
+ * Bring the scratch tree from one commit to another, and say what moved.
+ *
+ * Renames are asked for as a delete plus an add (`--no-renames`) rather than
+ * as a rename. CodeRook is content-addressed, so the added path costs nothing
+ * to store when the bytes already exist, and the alternative is carrying a
+ * second change shape through every branch below for no benefit.
+ */
+async function applyCommit(catFile, scratch, fromCommit, toCommit) {
+    const raw = git([
+        "diff",
+        "--name-status",
+        "--no-renames",
+        "-z",
+        fromCommit,
+        toCommit,
+    ]);
+    const fields = raw.split("\0").filter((field) => field.length > 0);
+    const written = [];
+    const deleted = [];
+    const skipped = [];
+    for (let index = 0; index + 1 < fields.length; index += 2) {
+        const status = fields[index];
+        const filePath = fields[index + 1];
+        const target = node_path_1.default.join(scratch, filePath);
+        if (status.startsWith("D")) {
+            await (0, promises_1.rm)(target, { force: true });
+            deleted.push(filePath);
+            continue;
+        }
+        /*
+          A gitlink has a mode but no bytes. Writing the commit id it points at as
+          the file's contents would produce a forty-byte text file where a
+          directory belongs, which is worse than not publishing it.
+        */
+        const mode = git(["ls-tree", "-z", toCommit, "--", filePath])
+            .split("\0")[0]
+            ?.split(/\s+/)[0];
+        if (mode === "160000") {
+            skipped.push(filePath);
+            continue;
+        }
+        const bytes = await catFile.blob(`${toCommit}:${filePath}`);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(target), { recursive: true });
+        await (0, promises_1.writeFile)(target, bytes);
+        written.push(filePath);
+    }
+    return { written, deleted, skipped };
+}
+/**
+ * The refs the remote already holds, as far as we can tell.
+ *
+ * Git uses this to work out which commits to send, so being wrong here is
+ * expensive in both directions: claim too much and work is silently dropped,
+ * claim too little and a history is published twice.
+ */
+async function remoteRefs(repositoryId) {
+    const known = new Map();
+    if (!repositoryId)
+        return known;
+    const state = await remoteState(repositoryId);
+    const marks = await readMarks();
+    for (const track of state.tracks) {
+        if (track.kind !== "line" || !track.headVersionId)
+            continue;
+        const sha = headCommit(track.headVersionId, state, marks);
+        if (sha)
+            known.set(`refs/heads/${track.name}`, sha);
+    }
+    return known;
+}
+/**
+ * Which commit *in this repository* holds a version.
+ *
+ * There are two answers and they are not interchangeable. The message marker
+ * names the commit a version was published from, which is the right answer in
+ * the repository that published it. The mark table names the commit this
+ * repository built when it imported that version, which is the right answer in
+ * a clone. A repository that cloned and then pushes has both, and they disagree
+ * permanently — the imported commit is a different object with a different id.
+ *
+ * The mark wins, because git is about to be told this id and has to be able to
+ * find it. Offering the marker instead makes every push from a clone fail with
+ * "the remote has a commit you do not have", naming a commit that only exists
+ * on somebody else's machine — which is precisely the loop this closed.
+ */
+function headCommit(versionId, state, marks) {
+    const mark = marks?.ofVersion.get(versionId);
+    const imported = mark === undefined ? undefined : marks?.sha.get(mark);
+    return imported ?? state.shaOfVersion.get(versionId);
+}
+/**
+ * Everything about the project that a push needs to decide anything.
+ *
+ * Gathered once per push rather than per branch: it is two calls, both of
+ * which were being made repeatedly, and having one snapshot removes the
+ * possibility of two decisions in the same push disagreeing about what the
+ * remote holds.
+ */
+async function remoteState(repositoryId) {
+    const tracks = await new tracks_js_1.Tracks(config_js_1.credentials).list(repositoryId);
+    const { versions } = await Promise.resolve().then(() => __importStar(require("./api.js")));
+    const all = await versions(repositoryId);
+    const versionOfSha = new Map();
+    const shaOfVersion = new Map();
+    for (const version of all) {
+        const sha = (0, git_history_js_1.commitFromMessage)(version.message);
+        if (!sha)
+            continue;
+        versionOfSha.set(sha, version.id);
+        shaOfVersion.set(version.id, sha);
+    }
+    return { tracks, versionOfSha, shaOfVersion, versionCount: all.length };
+}
+/**
+ * The commit this branch should fork from, and the version that holds it.
+ *
+ * Walking the branch's own ancestry newest-first and stopping at the first
+ * commit the project already has is the same answer `git merge-base` would
+ * give against every pushed branch at once, without having to ask which
+ * branches those are.
+ */
+function forkPoint(tip, versionOfSha) {
+    const ancestry = git(["rev-list", tip])
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (const sha of ancestry) {
+        const versionId = versionOfSha.get(sha);
+        if (versionId)
+            return { sha, versionId };
+    }
+    return null;
+}
+async function readMarks() {
+    let gitDir;
+    try {
+        gitDir = git(["rev-parse", "--absolute-git-dir"]).trim();
+    }
+    catch {
+        return null;
+    }
+    if (!gitDir)
+        return null;
+    const dir = node_path_1.default.join(gitDir, "coderook");
+    const marks = {
+        file: node_path_1.default.join(dir, "marks"),
+        ofVersion: new Map(),
+        sha: new Map(),
+        dir,
+    };
+    try {
+        const table = await (0, promises_1.readFile)(node_path_1.default.join(dir, "versions"), "utf8");
+        for (const line of table.split("\n")) {
+            const [versionId, mark] = line.trim().split(/\s+/);
+            if (versionId && mark)
+                marks.ofVersion.set(versionId, Number(mark));
+        }
+    }
+    catch {
+        // No table yet. Every version is new, which is correct for a clone.
+    }
+    try {
+        const table = await (0, promises_1.readFile)(marks.file, "utf8");
+        for (const line of table.split("\n")) {
+            const match = line.trim().match(/^:(\d+)\s+([0-9a-f]{40})$/);
+            if (match)
+                marks.sha.set(Number(match[1]), match[2]);
+        }
+    }
+    catch {
+        // Likewise.
+    }
+    /*
+      Drop any version whose mark no object ever got.
+  
+      The two files are written by different things at different moments, so a
+      run that dies between them leaves a version claiming a mark that names
+      nothing. Believing it is the worst outcome available: the next fetch
+      reports the project already imported and hands back an empty history,
+      silently, with no error to notice. Cross-checking here makes a half-write
+      cost a re-import instead of a wrong answer.
+    */
+    for (const [versionId, mark] of [...marks.ofVersion]) {
+        if (!marks.sha.has(mark))
+            marks.ofVersion.delete(versionId);
+    }
+    return marks;
+}
+async function writeMarks(marks) {
+    await (0, promises_1.mkdir)(marks.dir, { recursive: true });
+    const body = [...marks.ofVersion]
+        .map(([versionId, mark]) => `${versionId} ${mark}`)
+        .join("\n");
+    await (0, promises_1.writeFile)(node_path_1.default.join(marks.dir, "versions"), `${body}\n`, "utf8");
+}
+/**
+ * Record commits this repository *pushed* in the same table imports use.
+ *
+ * Without this, pushing and fetching keep separate ideas of what a version is.
+ * A repository that pushes gets a tracking ref pointing at its own commits; a
+ * later fetch rebuilds those same versions as new commits with new ids, and
+ * git refuses to move the ref because the two histories share no ancestor:
+ *
+ *   not updating refs/coderook/main (new tip … does not contain …)
+ *
+ * Writing the pushed commits here means a later import recognises those
+ * versions as already present, skips them, and hangs anything new off the
+ * commit that is genuinely in this repository. One identity space, both ways.
+ *
+ * The fast-import marks file is written directly rather than left to
+ * fast-import, because no import ran — the objects are already here.
+ */
+async function recordPushedCommits(marks) {
+    await (0, promises_1.mkdir)(marks.dir, { recursive: true });
+    const table = [...marks.sha]
+        .sort(([left], [right]) => left - right)
+        .map(([mark, sha]) => `:${mark} ${sha}`)
+        .join("\n");
+    await (0, promises_1.writeFile)(marks.file, table ? `${table}\n` : "", "utf8");
+    await writeMarks(marks);
+}
+/**
+ * Rebuild a git history from a project's versions and write it to stdout as a
+ * fast-import stream.
+ *
+ * Each version becomes one commit holding that version's complete file list,
+ * stated with `deleteall` followed by every path. Emitting a delta instead
+ * would be smaller and would mean tracking what the previous commit held on
+ * every branch of the graph; restating the tree is bounded work per commit and
+ * cannot drift.
+ *
+ * Contents are deduplicated by SHA-256 across the whole history, so a file
+ * unchanged across a thousand versions is downloaded and sent to git once.
+ */
+async function doImport(refs, url) {
+    const { slug } = (0, git_history_js_1.parseRemoteUrl)(url);
+    const project = await (0, api_js_1.findProject)(slug);
+    if (!project) {
+        say(`No CodeRook project called "${slug}", or you cannot read it.`);
+        send("done");
+        return;
+    }
+    const repositoryId = project.id;
+    const state = await remoteState(repositoryId);
+    const { versions } = await Promise.resolve().then(() => __importStar(require("./api.js")));
+    const all = await versions(repositoryId);
+    const wanted = new Map();
+    for (const ref of refs) {
+        const branch = (0, git_history_js_1.branchOf)(ref);
+        if (!branch)
+            continue;
+        const track = state.tracks.find((candidate) => candidate.name === branch && candidate.kind === "line");
+        if (track?.headVersionId)
+            wanted.set(ref, track.headVersionId);
+        else
+            say(`  no line called "${branch}" on ${slug}`);
+    }
+    if (!wanted.size) {
+        send("done");
+        return;
+    }
+    const order = (0, git_history_js_1.versionsInOrder)([...wanted.values()], all);
+    const marks = await readMarks();
+    /** SHA-256 of the contents to the fast-import mark already carrying it. */
+    const blobMark = new Map();
+    /** Version id to the mark of the commit built from it. */
+    const commitMark = new Map(marks?.ofVersion ?? []);
+    /*
+      Numbering continues above every mark this repository already holds.
+      Restarting at 1 would hand a new commit a mark that already names a
+      different object, and fast-import would happily believe us.
+    */
+    let nextMark = 1;
+    for (const mark of commitMark.values())
+        nextMark = Math.max(nextMark, mark + 1);
+    const fresh = order.filter((version) => !commitMark.has(version.id));
+    if (!fresh.length) {
+        say(`Already up to date with ${slug}.`);
+        send("done");
+        return;
+    }
+    say(`Importing ${fresh.length} version${fresh.length === 1 ? "" : "s"} from ${slug}` +
+        (order.length > fresh.length
+            ? ` (${order.length - fresh.length} already here)`
+            : "") +
+        ".");
+    const { Downloader } = await Promise.resolve().then(() => __importStar(require("../../desktop-app/src/main/download.js")));
+    const downloader = new Downloader(config_js_1.credentials);
+    const scratch = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "coderook-fetch-"));
+    try {
+        send("feature done");
+        if (marks) {
+            /*
+              `-if-exists` because the first import has no file yet, and plain
+              `import-marks` is a hard error when the file is missing.
+            */
+            send(`feature import-marks-if-exists=${marks.file.replaceAll("\\", "/")}`);
+            send(`feature export-marks=${marks.file.replaceAll("\\", "/")}`);
+        }
+        let done = 0;
+        for (const version of fresh) {
+            const files = await downloader.files(repositoryId, version.id);
+            // Blobs first: fast-import requires a mark to exist before a commit
+            // names it.
+            for (const file of files) {
+                if (blobMark.has(file.sha256))
+                    continue;
+                const target = node_path_1.default.join(scratch, "blob.bin");
+                await (0, promises_1.rm)(target, { force: true });
+                await downloader.fileTo(repositoryId, version.id, file, target);
+                const bytes = await (0, promises_1.readFile)(target);
+                const mark = nextMark++;
+                blobMark.set(file.sha256, mark);
+                send("blob");
+                send(`mark :${mark}`);
+                send(`data ${bytes.length}`);
+                node_process_1.default.stdout.write(bytes);
+                node_process_1.default.stdout.write("\n");
+            }
+            const mark = nextMark++;
+            commitMark.set(version.id, mark);
+            marks?.ofVersion.set(version.id, mark);
+            const ref = [...wanted.entries()].find(([, head]) => head === version.id)?.[0] ??
+                `refs/heads/${state.tracks.find((track) => track.headVersionId === version.id)?.name ?? "main"}`;
+            const parents = version.parentVersionIds
+                .map((parent) => commitMark.get(parent))
+                .filter((value) => value !== undefined);
+            const author = version.authorName || "CodeRook";
+            const when = `${(0, git_history_js_1.stamp)(version.createdAt)} +0000`;
+            const message = (0, git_history_js_1.messageWithoutMarker)(version.message) || `Version ${version.sequence}`;
+            const body = Buffer.from(message, "utf8");
+            send(`commit ${(0, git_history_js_1.importRef)(ref)}`);
+            send(`mark :${mark}`);
+            /*
+              No email is invented. CodeRook records who published a version, not an
+              address, and a plausible-looking address that belongs to nobody is
+              worse than an obviously synthetic one: it survives being copied into a
+              mailing list or a CONTRIBUTORS file.
+            */
+            send(`author ${author} <noreply@coderook.com> ${when}`);
+            send(`committer ${author} <noreply@coderook.com> ${when}`);
+            send(`data ${body.length}`);
+            node_process_1.default.stdout.write(body);
+            node_process_1.default.stdout.write("\n");
+            if (parents[0] !== undefined)
+                send(`from :${parents[0]}`);
+            for (const extra of parents.slice(1))
+                send(`merge :${extra}`);
+            send("deleteall");
+            for (const file of files) {
+                send(`M 100644 :${blobMark.get(file.sha256)} ${(0, git_history_js_1.quotePath)(file.path)}`);
+            }
+            send("");
+            done += 1;
+            if (done % 10 === 0 || done === fresh.length) {
+                say(`  ${done}/${fresh.length} versions`);
+            }
+        }
+        /*
+          Releases come back as tags, because that is the same statement in the
+          other vocabulary: a version somebody gave a name to.
+    
+          Emitted after every commit, so the mark a tag points at is certain to
+          exist. A release naming a version outside the branches being imported is
+          skipped rather than guessed at — the tag would have nothing to point to.
+        */
+        try {
+            const { releases } = await Promise.resolve().then(() => __importStar(require("./api.js")));
+            const named = await releases(repositoryId);
+            let tagged = 0;
+            for (const release of named) {
+                const mark = commitMark.get(release.versionId);
+                if (mark === undefined)
+                    continue;
+                const body = Buffer.from(release.notes || release.name, "utf8");
+                send(`tag ${release.name}`);
+                send(`from :${mark}`);
+                send(`tagger ${release.releasedBy || "CodeRook"} <noreply@coderook.com> ` +
+                    `${(0, git_history_js_1.stamp)(release.releasedAt)} +0000`);
+                send(`data ${body.length}`);
+                node_process_1.default.stdout.write(body);
+                node_process_1.default.stdout.write("\n");
+                tagged += 1;
+            }
+            if (tagged)
+                say(`  ${tagged} release${tagged === 1 ? "" : "s"} as tags`);
+        }
+        catch (error) {
+            // A project whose releases cannot be read is still worth importing.
+            say(`  could not read releases: ${error.message}`);
+        }
+        send("done");
+        /*
+          Written after the stream, not during. fast-import only writes its own
+          mark file when it finishes, so a table saved earlier would name marks
+          that no object ever got — and the next fetch would build commits whose
+          parents do not exist.
+        */
+        if (marks)
+            await writeMarks(marks);
+    }
+    finally {
+        await (0, promises_1.rm)(scratch, { recursive: true, force: true });
+    }
+}
+async function doPush(requests, url) {
+    const { slug } = (0, git_history_js_1.parseRemoteUrl)(url);
+    const project = await (0, api_js_1.findProject)(slug);
+    const repositoryId = project?.id ?? null;
+    const state = repositoryId ? await remoteState(repositoryId) : null;
+    const marks = await readMarks();
+    const known = new Map();
+    for (const track of state?.tracks ?? []) {
+        if (track.kind !== "line" || !track.headVersionId)
+            continue;
+        const sha = headCommit(track.headVersionId, state, marks);
+        if (sha)
+            known.set(`refs/heads/${track.name}`, sha);
+    }
+    let nextPushMark = 1;
+    for (const mark of marks?.sha.keys() ?? []) {
+        nextPushMark = Math.max(nextPushMark, mark + 1);
+    }
+    const uploader = new upload_js_1.Uploader(config_js_1.credentials);
+    const catFile = new CatFile();
+    const scratch = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "coderook-push-"));
+    let warnedAboutMerges = false;
+    try {
+        for (const request of requests) {
+            /*
+              A tag names a version, which is exactly what a CodeRook release is:
+              "a Version with a name on it, not a different kind of object". So a tag
+              does not publish anything — it finds the version the tagged commit
+              already became and gives it that name. Pushing a tag for a commit that
+              was never pushed is refused rather than guessed at.
+            */
+            const tag = (0, git_history_js_1.tagOf)(request.dst);
+            if (tag) {
+                if (!request.src) {
+                    send(`error ${request.dst} deleting a tag is not supported`);
+                    continue;
+                }
+                if (!state) {
+                    send(`error ${request.dst} push a branch before tagging it`);
+                    continue;
+                }
+                const target = git(["rev-list", "-n", "1", request.src]).trim();
+                const versionId = state.versionOfSha.get(target);
+                if (!versionId) {
+                    send(`error ${request.dst} commit ${target.slice(0, 8)} has not been pushed to CodeRook yet`);
+                    say(`\n  Push the branch first, then push the tag.\n`);
+                    continue;
+                }
+                /*
+                  An annotated tag carries a message and a lightweight one does not.
+                  `for-each-ref` gives the annotation only for the former, and reading
+                  the commit's message instead would put the commit text on the
+                  release, which is a different thing that happens to be nearby.
+                */
+                /*
+                  Only an annotated tag has a message of its own. `%(contents)` on a
+                  lightweight tag falls through to the commit it points at, so asking
+                  for it unconditionally puts the commit's message on the release —
+                  text nobody wrote about the release, presented as release notes.
+        
+                  `%(objecttype)` separates the two: `tag` for an annotated one, and
+                  `commit` for a lightweight tag, which points straight at the commit
+                  and carries nothing.
+                */
+                const described = git([
+                    "for-each-ref",
+                    "--format=%(objecttype)%0a%(contents)",
+                    request.dst,
+                ]);
+                const newline = described.indexOf("\n");
+                const kind = (newline === -1 ? described : described.slice(0, newline)).trim();
+                const notes = kind === "tag" && newline !== -1 ? described.slice(newline + 1).trim() : "";
+                try {
+                    const { markRelease, releases } = await Promise.resolve().then(() => __importStar(require("./api.js")));
+                    /*
+                      A version carries one name, so two tags on the same commit cannot
+                      both survive — the second renames the release the first made. Git
+                      allows it and CodeRook cannot represent it, and quietly dropping a
+                      release somebody just published is the wrong way to find that out.
+                    */
+                    const existing = await releases(repositoryId).catch(() => []);
+                    const already = existing.find((release) => release.versionId === versionId && release.name !== tag);
+                    if (already) {
+                        say(`  note: v${already.sequence} was already released as "${already.name}".
+` +
+                            `        A version carries one name, so it is now "${tag}".`);
+                    }
+                    await markRelease(repositoryId, versionId, tag, notes || null);
+                    send(`ok ${request.dst}`);
+                    say(`  released "${tag}" at ${target.slice(0, 8)}`);
+                }
+                catch (error) {
+                    send(`error ${request.dst} ${error instanceof Error ? error.message : String(error)}`);
+                }
+                continue;
+            }
+            const branch = (0, git_history_js_1.branchOf)(request.dst);
+            if (!branch) {
+                send(`error ${request.dst} only branches and tags can be pushed to CodeRook`);
+                continue;
+            }
+            if (!request.src) {
+                send(`error ${request.dst} deleting a branch is not supported; CodeRook versions are immutable`);
+                continue;
+            }
+            /*
+              Refused rather than quietly treated as an ordinary push. A force push
+              means "make the remote match me, discarding what is there", and a
+              published version cannot be unpublished — so the one thing the person
+              asked for is the one thing that cannot happen. Accepting it and
+              appending instead would be a different operation wearing its name.
+            */
+            if (request.force) {
+                send(`error ${request.dst} force pushing is not supported; published versions are immutable and cannot be discarded`);
+                continue;
+            }
+            const tip = git(["rev-parse", request.src]).trim();
+            const already = known.get(request.dst);
+            if (already === tip) {
+                send(`ok ${request.dst}`);
+                say(`  ${branch}: already up to date`);
+                continue;
+            }
+            /*
+              Refuse a push that is not a fast-forward, the way git itself does.
+      
+              Left alone, the publish still succeeds: the service notices the
+              divergence, keeps both sides and opens a merge track. That is the right
+              behaviour for the desktop app and exactly the wrong end state here,
+              because the person is standing in git and a merge track is not
+              something git can see, let alone resolve — they would be told the push
+              failed while their work sat in a queue that only `cbx merge` can
+              empty.
+      
+              Rejecting first keeps the whole loop inside git: pull, merge, push.
+              Nothing is uploaded, so there is nothing stranded to clean up.
+            */
+            if (already) {
+                if (!gitOk(["cat-file", "-e", `${already}^{commit}`])) {
+                    send(`error ${request.dst} the remote has commit ${already.slice(0, 8)}, which this repository does not have; run "git fetch" first`);
+                    continue;
+                }
+                if (!gitOk(["merge-base", "--is-ancestor", already, tip])) {
+                    send(`error ${request.dst} non-fast-forward; the remote has work you do not have locally`);
+                    say(`\n  Someone published to "${branch}" since you last fetched.\n` +
+                        `    git pull --rebase coderook ${branch}\n` +
+                        `  then push again. Nothing was uploaded.\n`);
+                    continue;
+                }
+            }
+            /*
+              A project whose versions cannot be tied to any commit is refused
+              rather than appended to. Those versions are real work — published from
+              the desktop app, the CLI or an import — and replaying a git history on
+              top of them would interleave two unrelated sequences with no way back.
+      
+              The test is whether the project came from git *at all*, not whether
+              this particular branch is known. Checking the branch instead refuses
+              the ordinary act of pushing a second branch to a project git already
+              owns, which is the common case and not a conflict of any kind.
+            */
+            if (state && !already && state.versionCount > 0 && state.versionOfSha.size === 0) {
+                send(`error ${request.dst} the project "${slug}" already has ${state.versionCount} version${state.versionCount === 1 ? "" : "s"} that did not come from git; pushing would publish this history a second time`);
+                say(`\n  Push to a new project instead:\n` +
+                    `    git remote set-url coderook coderook://<a-new-name>\n`);
+                continue;
+            }
+            /*
+              A branch the project has never seen starts at the newest commit it
+              *has* seen — its fork point — rather than at the project head. Starting
+              a track at the head would give the branch every change made on the
+              line it forked away from, which is precisely the work the person
+              branched to avoid.
+            */
+            let fork = null;
+            if (!already && state && state.versionOfSha.size > 0) {
+                fork = forkPoint(tip, state.versionOfSha);
+            }
+            const from = already ?? fork?.sha ?? null;
+            const range = from ? `${from}..${tip}` : tip;
+            const commits = git(["rev-list", "--reverse", "--topo-order", range])
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean);
+            if (!commits.length) {
+                /*
+                  Nothing to publish does not mean nothing to do. A branch whose tip
+                  the project already holds — one merged into another branch, most
+                  often — still has to exist as a line, or the push reports a new
+                  branch that is not there and the next push agrees it is up to date.
+                */
+                if (!already && fork && repositoryId) {
+                    try {
+                        await new tracks_js_1.Tracks(config_js_1.credentials).create(repositoryId, branch, fork.versionId);
+                        say(`  created line "${branch}" at ${fork.sha.slice(0, 8)} (already published)`);
+                    }
+                    catch (error) {
+                        const text = error instanceof Error ? error.message : String(error);
+                        if (!/exist/i.test(text)) {
+                            send(`error ${request.dst} ${text}`);
+                            continue;
+                        }
+                    }
+                }
+                send(`ok ${request.dst}`);
+                continue;
+            }
+            /*
+              Said before the work starts, not after. Each commit is a published
+              version and versions are not free to make, so somebody pushing years
+              of history deserves the chance to stop and import a snapshot instead.
+            */
+            const estimate = Math.round((commits.length * 11) / 60);
+            say(`  ${commits.length} commit${commits.length === 1 ? "" : "s"} to publish as version${commits.length === 1 ? "" : "s"}` +
+                (commits.length > 20 ? ` — roughly ${estimate} minute${estimate === 1 ? "" : "s"}` : ""));
+            /*
+              A push that continues a branch has to start from where the branch
+              actually is, in three separate senses, and getting any one of them
+              wrong fails differently:
+      
+              - `previous` is the commit the remote already holds. Diffing from the
+                empty tree instead would mark every file as added and republish the
+                whole project as though it were new.
+              - `baseVersionId` is the version this publish is based on. Sending
+                null claims the project is empty, and the service correctly refuses
+                rather than laying this history over somebody's work.
+              - `local`/`known` is what the remote holds now. Without it, a file
+                present in the version but not in our scratch tree is
+                indistinguishable from one this push deleted — and the service would
+                drop it.
+            */
+            let baseVersionId = null;
+            let manifest = {};
+            let local = {};
+            let previous = git_history_js_1.EMPTY_TREE;
+            let currentRepositoryId = repositoryId;
+            let published = 0;
+            if (from && repositoryId && state) {
+                previous = from;
+                if (already) {
+                    const track = state.tracks.find((candidate) => candidate.name === branch && candidate.kind === "line");
+                    if (!track?.headVersionId) {
+                        send(`error ${request.dst} could not read the current head of "${branch}"`);
+                        continue;
+                    }
+                    baseVersionId = track.headVersionId;
+                }
+                else if (fork) {
+                    /*
+                      The track has to exist before anything can be published onto it,
+                      and it has to start at the fork point. `create` is allowed to fail
+                      with "already exists" — another push may have made it — in which
+                      case the existing one is what we wanted anyway.
+                    */
+                    baseVersionId = fork.versionId;
+                    try {
+                        await new tracks_js_1.Tracks(config_js_1.credentials).create(repositoryId, branch, fork.versionId);
+                        say(`  created line "${branch}" from ${fork.sha.slice(0, 8)}`);
+                    }
+                    catch (error) {
+                        const text = error instanceof Error ? error.message : String(error);
+                        if (!/exist/i.test(text))
+                            throw error;
+                    }
+                }
+                const { Downloader } = await Promise.resolve().then(() => __importStar(require("../../desktop-app/src/main/download.js")));
+                const held = await new Downloader(config_js_1.credentials).files(repositoryId, baseVersionId);
+                manifest = Object.fromEntries(held.map((file) => [file.path, file.sha256]));
+                local = { ...manifest };
+            }
+            for (const sha of commits) {
+                const parents = git(["rev-list", "--parents", "-n", "1", sha])
+                    .trim()
+                    .split(/\s+/)
+                    .slice(1);
+                if (parents.length > 1 && !warnedAboutMerges) {
+                    warnedAboutMerges = true;
+                    say(`  note: merge commits are published as one version holding the ` +
+                        `merged tree.\n        The contents are exact; the branch shape is not kept.`);
+                }
+                const changes = await applyCommit(catFile, scratch, previous, sha);
+                previous = sha;
+                if (changes.skipped.length) {
+                    say(`  skipped ${changes.skipped.length} submodule path(s) in ${sha.slice(0, 8)}`);
+                }
+                if (!changes.written.length && !changes.deleted.length) {
+                    // An empty commit, or one that only touched submodules. Nothing to
+                    // publish, but the ref still has to end up pointing at it.
+                    published += 1;
+                    continue;
+                }
+                const subject = git(["log", "-1", "--format=%B", sha]).trim();
+                /*
+                  Built by the shared description rather than assembled here. Every
+                  sharp edge in that contract — deletions in both lists, `known`,
+                  compare-and-swap on the base version — was learned once by
+                  `cbx submit` and then learned again here, as a bug.
+                */
+                const uploadRequest = (0, publish_js_1.uploadRequestFor)({
+                    localPath: scratch,
+                    changed: changes.written,
+                    deleted: changes.deleted,
+                    message: (0, git_history_js_1.messageWithCommit)(subject || `Commit ${sha.slice(0, 8)}`, sha),
+                    projectName: slug,
+                    repositoryId: currentRepositoryId,
+                    baseVersionId,
+                    track: branch,
+                    allowIgnored: true,
+                    ...(Object.keys(manifest).length ? { known: local } : {}),
+                });
+                let result;
+                try {
+                    const plan = await uploader.plan(uploadRequest, () => { });
+                    result = await uploader.execute(uploadRequest, plan, () => { });
+                }
+                catch (error) {
+                    const failure = (0, publish_js_1.classifyPublishFailure)(error);
+                    if (failure?.kind === "interrupted") {
+                        /*
+                          Said rather than left to be assumed. The service records the
+                          attempt, so pushing again is answered with the version it
+                          already made — somebody not told this will assume the push half
+                          happened and go looking for a way to undo it.
+                        */
+                        send(`error ${request.dst} the connection failed part way through`);
+                        say(`
+  ${published} of ${commits.length} commits were published.
+` +
+                            `  Push again — commits already published are not sent twice.
+`);
+                        throw error;
+                    }
+                    if (failure?.kind === "conflict") {
+                        send(`error ${request.dst} somebody published to "${branch}" while this push was running`);
+                        say(`
+  git fetch, then push again.
+`);
+                        throw error;
+                    }
+                    throw error;
+                }
+                if (result.mergeTrack) {
+                    send(`error ${request.dst} somebody else published to "${branch}" during this push; it is waiting on a merge`);
+                    throw new Error("push interrupted by a concurrent publish");
+                }
+                currentRepositoryId = result.repositoryId;
+                baseVersionId = result.versionId;
+                /*
+                  The version and the commit it came from are the same thing in this
+                  repository from here on. Recorded so a later fetch does not rebuild
+                  it as a second, different commit.
+                */
+                if (marks) {
+                    const mark = nextPushMark++;
+                    marks.ofVersion.set(result.versionId, mark);
+                    marks.sha.set(mark, sha);
+                }
+                manifest = result.manifest;
+                local = result.local;
+                published += 1;
+                say(`  [${published}/${commits.length}] v${result.sequence}  ${sha.slice(0, 8)}  ${subject.split("\n")[0].slice(0, 48)}`);
+            }
+            send(`ok ${request.dst}`);
+        }
+    }
+    finally {
+        catFile.close();
+        await (0, promises_1.rm)(scratch, { recursive: true, force: true });
+        if (marks)
+            await recordPushedCommits(marks);
+    }
+    send("");
+}
+/** Read stdin as lines. The push protocol is text throughout. */
+async function* lines() {
+    let buffer = "";
+    for await (const chunk of node_process_1.default.stdin) {
+        buffer += chunk.toString("utf8");
+        let at = buffer.indexOf("\n");
+        while (at !== -1) {
+            yield buffer.slice(0, at);
+            buffer = buffer.slice(at + 1);
+            at = buffer.indexOf("\n");
+        }
+    }
+    if (buffer.length)
+        yield buffer;
+}
+async function main(argv) {
+    const url = argv[1] ?? argv[0] ?? "";
+    (0, identify_js_1.declareClient)("cli", "git-remote");
+    const pending = [];
+    const importing = [];
+    for await (const line of lines()) {
+        const command = line.trim();
+        if (command === "capabilities") {
+            // `push` rather than `export`, and `import` rather than `fetch`; see the
+            // note at the top of this file.
+            send("import");
+            send("push");
+            send("refspec refs/heads/*:refs/coderook/*");
+            send("option");
+            send("");
+            continue;
+        }
+        if (command.startsWith("option ")) {
+            // Nothing here changes behaviour yet, and claiming otherwise would make
+            // git believe a setting took effect.
+            send("unsupported");
+            continue;
+        }
+        if (command === "list" || command === "list for-push") {
+            try {
+                const { slug } = (0, git_history_js_1.parseRemoteUrl)(url);
+                const project = await (0, api_js_1.findProject)(slug);
+                if (command === "list for-push") {
+                    const known = await remoteRefs(project?.id ?? null);
+                    for (const [ref, sha] of known)
+                        send(`${sha} ${ref}`);
+                    send("");
+                    continue;
+                }
+                /*
+                  A line whose head this clone has imported before is advertised by
+                  its real commit id; one it has not is advertised as `?`.
+        
+                  `?` is the format's way of saying "I cannot tell you", and it is the
+                  honest answer the first time: the git commits are built during the
+                  import that follows, from versions that are not git commits, so their
+                  ids do not exist yet. It is the wrong answer on every fetch after
+                  that, because git cannot then see that nothing has changed and asks
+                  for the history again. The mark table is what turns the second and
+                  later answers into real ids.
+                */
+                const state = project ? await remoteState(project.id) : null;
+                const lines = (state?.tracks ?? []).filter((track) => track.kind === "line" && track.headVersionId);
+                const marks = await readMarks();
+                for (const track of lines) {
+                    const mark = marks?.ofVersion.get(track.headVersionId);
+                    const sha = mark === undefined ? undefined : marks?.sha.get(mark);
+                    send(`${sha ?? "?"} refs/heads/${track.name}`);
+                }
+                const head = lines.find((track) => track.name === "main") ?? lines[0];
+                if (head)
+                    send(`@refs/heads/${head.name} HEAD`);
+            }
+            catch (error) {
+                say(`Could not read the remote: ${error.message}`);
+            }
+            send("");
+            continue;
+        }
+        if (command.startsWith("import ")) {
+            /*
+              Deduplicated. Git asks for the same ref more than once in one batch —
+              observed twice for a clone, once for the branch and once resolving
+              HEAD — and importing it twice would rebuild and re-send the entire
+              history for no reason.
+            */
+            const ref = command.slice("import ".length).trim();
+            if (!importing.includes(ref))
+                importing.push(ref);
+            continue;
+        }
+        if (command.startsWith("push ")) {
+            const spec = command.slice("push ".length);
+            const force = spec.startsWith("+");
+            const [src, dst] = (force ? spec.slice(1) : spec).split(":");
+            pending.push({ src: src ?? "", dst: dst ?? "", force });
+            continue;
+        }
+        if (command === "") {
+            if (importing.length) {
+                const batch = importing.splice(0, importing.length);
+                try {
+                    await doImport(batch, url);
+                }
+                catch (error) {
+                    say(`Import failed: ${error instanceof Error ? error.message : String(error)}`);
+                    // `done` regardless, so fast-import closes cleanly instead of git
+                    // waiting on a stream that will never end.
+                    send("done");
+                }
+                continue;
+            }
+            if (pending.length) {
+                const batch = pending.splice(0, pending.length);
+                try {
+                    const account = await (0, api_js_1.whoami)();
+                    say(`Pushing to CodeRook as ${account.username || account.displayName}.`);
+                }
+                catch {
+                    say("Not signed in. Run `cbx sign-in` first.");
+                    for (const request of batch) {
+                        send(`error ${request.dst} not signed in to CodeRook`);
+                    }
+                    send("");
+                    continue;
+                }
+                await doPush(batch, url);
+            }
+            continue;
+        }
+    }
+    return 0;
+}