@coderook/cli 0.12.0 → 0.14.0

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

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Knowing the whole project before uploading any of it, then sending it in
+ * bounded stages.
+ *
+ * Two separate failures made this necessary.
+ *
+ * The first was silent. `changedFiles` stops after twenty thousand rows —
+ * correctly, because that is a limit on what a list can usefully show — and
+ * the upload used the same function to decide what to send. A project past
+ * that many files produced a version containing whatever the walk reached
+ * first, with nothing anywhere saying the rest existed. A limit meant for a
+ * scrollbar was silently deciding what got backed up.
+ *
+ * The second was unbounded work. Everything was sent in one pass, so memory,
+ * progress and the blast radius of an interruption all scaled with the size of
+ * the project. A ten gigabyte upload was one attempt that either finished or
+ * did not.
+ *
+ * So: survey everything first, cheaply and without a cap, then divide it into
+ * sections with a fixed byte budget. A small project is one section and behaves
+ * exactly as it did. A large one is many, each finishing before the next
+ * begins, which keeps the working set the same size whatever the project is.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECTION_FILES = exports.SECTION_BYTES = exports.DIRECT_LIMIT = exports.CHUNK_THRESHOLD = exports.PACKABLE_LIMIT = void 0;
+exports.bandOf = bandOf;
+exports.survey = survey;
+exports.planSections = planSections;
+exports.describePlan = describePlan;
+/**
+ * How each file travels, decided by size alone.
+ *
+ * The bands are the existing routes named: small files compress together into
+ * a pack, ordinary ones go as their own object, large ones are cut into
+ * content-defined chunks, and anything past the direct limit needs a multipart
+ * session. Naming them here means the plan can be inspected before a byte
+ * moves.
+ */
+exports.PACKABLE_LIMIT = 64 * 1024;
+exports.CHUNK_THRESHOLD = 16 * 1024 * 1024;
+exports.DIRECT_LIMIT = 95 * 1024 * 1024;
+function bandOf(size) {
+    if (size <= exports.PACKABLE_LIMIT)
+        return "packable";
+    if (size <= exports.CHUNK_THRESHOLD)
+        return "ordinary";
+    if (size <= exports.DIRECT_LIMIT)
+        return "chunked";
+    return "multipart";
+}
+function survey(files) {
+    const bands = { packable: 0, ordinary: 0, chunked: 0, multipart: 0 };
+    let totalBytes = 0;
+    for (const file of files) {
+        bands[bandOf(file.size)] += 1;
+        totalBytes += file.size;
+    }
+    return { files, totalBytes, bands };
+}
+/**
+ * How much source a single section may carry.
+ *
+ * Chosen so the working set stays the same whatever the project is: a section
+ * is read, packed, sent and finished before the next one starts, so a thirty
+ * gigabyte upload holds no more in memory than a two hundred megabyte one. Big
+ * enough that a small project is still one section and behaves exactly as it
+ * did before any of this existed.
+ */
+exports.SECTION_BYTES = 256 * 1024 * 1024;
+/** How many files one section may carry, however small they are. */
+exports.SECTION_FILES = 4000;
+/**
+ * Divide a survey into sections.
+ *
+ * Files are grouped by band first, so a section is mostly one kind of work —
+ * a pack of small files, or a run of large ones — rather than a mixture that
+ * makes progress lurch. Within a band they keep their order, so a resumed
+ * upload repeats the same plan and skips the same completed sections.
+ *
+ * A file larger than the whole budget gets a section to itself. It cannot be
+ * split across sections, and pretending otherwise would either overflow the
+ * budget silently or strand the file.
+ */
+function planSections(files, budget = exports.SECTION_BYTES, fileLimit = exports.SECTION_FILES) {
+    const order = ["packable", "ordinary", "chunked", "multipart"];
+    const grouped = new Map();
+    for (const file of files) {
+        const band = bandOf(file.size);
+        const held = grouped.get(band) ?? [];
+        held.push(file);
+        grouped.set(band, held);
+    }
+    const sections = [];
+    let current = [];
+    let bytes = 0;
+    const close = () => {
+        if (!current.length)
+            return;
+        sections.push({ index: sections.length, files: current, bytes });
+        current = [];
+        bytes = 0;
+    };
+    for (const band of order) {
+        for (const file of grouped.get(band) ?? []) {
+            /*
+              One file bigger than the budget is its own section. Splitting it here
+              would mean a section that overflows or a file that never fits, and the
+              chunker below the plan already knows how to send it in pieces.
+            */
+            if (file.size >= budget) {
+                close();
+                sections.push({ index: sections.length, files: [file], bytes: file.size });
+                continue;
+            }
+            if (bytes + file.size > budget || current.length >= fileLimit)
+                close();
+            current.push(file);
+            bytes += file.size;
+        }
+        /*
+          Sections do not straddle bands. A section of small files and a section of
+          large ones are different shapes of work, and mixing them makes the time
+          one takes unpredictable from its size.
+        */
+        close();
+    }
+    close();
+    return sections;
+}
+/** A short description of the plan, for somebody deciding whether to start. */
+function describePlan(surveyed, sections) {
+    const mb = (bytes) => `${(bytes / 1048576).toFixed(1)} MB`;
+    return [
+        `${surveyed.files.length} files, ${mb(surveyed.totalBytes)}`,
+        `${sections.length} section${sections.length === 1 ? "" : "s"}`,
+        `${surveyed.bands.packable} packed, ${surveyed.bands.ordinary} ordinary, ` +
+            `${surveyed.bands.chunked} chunked, ${surveyed.bands.multipart} multipart`,
+    ].join(" · ");
+}

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracks = void 0;
+const identify_js_1 = require("./identify.js");
+const retry_js_1 = require("./retry.js");
+class Tracks {
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    async call(route, init) {
+        let wait = retry_js_1.RETRY_FIRST_WAIT_MS;
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                return await this.attempt(route, init);
+            }
+            catch (error) {
+                if (attempt >= retry_js_1.RETRY_ATTEMPTS || !(0, retry_js_1.worthRetrying)(error))
+                    throw error;
+                await (0, retry_js_1.pauseFor)(AbortSignal.timeout(wait * 4), wait).catch(() => undefined);
+                wait *= 2;
+            }
+        }
+    }
+    async attempt(route, init) {
+        const token = await this.credentials.token();
+        if (!token)
+            throw new Error("Sign in again");
+        const response = await fetch(`${this.credentials.origin()}${route}`, {
+            method: init?.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${token}`,
+                "user-agent": "CodeRook/0.1",
+                ...(0, identify_js_1.clientHeaders)(),
+                ...(init?.body ? { "content-type": "application/json" } : {}),
+            },
+            ...(init?.body ? { body: init.body } : {}),
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            let message = `${route} failed (${response.status})`;
+            if (text.trimStart().startsWith("{")) {
+                try {
+                    message =
+                        JSON.parse(text).error
+                            ?.message ?? message;
+                }
+                catch {
+                    /* keep the generic message */
+                }
+            }
+            throw Object.assign(new Error(message), { status: response.status });
+        }
+        return (text ? JSON.parse(text) : {});
+    }
+    /**
+     * Every line and merge this project has.
+     *
+     * Answers an empty list rather than throwing when the account cannot be
+     * reached: the tracks panel is context, and a project that cannot be
+     * examined offline should still open.
+     */
+    async list(repositoryId) {
+        try {
+            const body = await this.call(`/v1/repositories/${repositoryId}/tracks`);
+            return body.tracks ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Start a new line, from wherever the project currently is.
+     *
+     * The service decides the starting point and refuses a name it cannot
+     * accept, so this passes the name through rather than pre-judging it —
+     * a rule enforced in two places is a rule that will disagree with itself.
+     */
+    async create(repositoryId, name) {
+        const body = await this.call(`/v1/repositories/${repositoryId}/tracks`, { method: "POST", body: JSON.stringify({ name }) });
+        return body.track;
+    }
+    /** Merges that have not been applied or abandoned. */
+    async merges(repositoryId) {
+        try {
+            const body = await this.call(`/v1/repositories/${repositoryId}/merge-tracks`);
+            return (body.mergeTracks ?? []).filter((one) => one.state === "open" || one.state === "applying");
+        }
+        catch {
+            return [];
+        }
+    }
+    /** One merge and every path it is waiting on. */
+    async merge(mergeTrackId) {
+        const body = await this.call(`/v1/merge-tracks/${mergeTrackId}`);
+        const { conflicts = [], ...track } = body;
+        return { track: track, conflicts };
+    }
+    /** Settle one path. */
+    async resolve(mergeTrackId, conflictId, resolution) {
+        await this.call(`/v1/merge-tracks/${mergeTrackId}/conflicts/${conflictId}`, {
+            method: "PUT",
+            body: JSON.stringify({ resolution }),
+        });
+    }
+    /**
+     * Publish the merge, once every path has been settled.
+     *
+     * The service refuses while anything is unresolved, which is the check that
+     * matters — this is only the request.
+     */
+    async apply(mergeTrackId) {
+        return this.call(`/v1/merge-tracks/${mergeTrackId}/apply`, {
+            method: "POST",
+            body: "{}",
+        });
+    }
+    /**
+     * Abandon it.
+     *
+     * The candidate's versions are not deleted — they stay on their own track,
+     * so nothing that was uploaded is lost by deciding not to merge it.
+     */
+    async cancel(mergeTrackId) {
+        await this.call(`/v1/merge-tracks/${mergeTrackId}/cancel`, {
+            method: "POST",
+            body: "{}",
+        });
+    }
+}
+exports.Tracks = Tracks;