@coderook/cli 0.1.0

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

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Downloader = exports.DownloadCancelled = void 0;
+/**
+ * Bringing a project down: the file list for a version, then its bytes.
+ *
+ * The server stores each file as a content-addressed object and serves it
+ * decoded, so this writes plain bytes and verifies each one against the
+ * digest the version recorded. Anything that does not match is a failure,
+ * not a file quietly written wrong.
+ */
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+class DownloadCancelled extends Error {
+    constructor() {
+        super("Download cancelled");
+    }
+}
+exports.DownloadCancelled = DownloadCancelled;
+class Downloader {
+    credentials;
+    aborted = false;
+    controller = new AbortController();
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    cancel() {
+        this.aborted = true;
+        this.controller.abort();
+    }
+    check() {
+        if (this.aborted)
+            throw new DownloadCancelled();
+    }
+    async request(route) {
+        const token = await this.credentials.token();
+        if (!token)
+            throw new Error("Sign in again before downloading");
+        const response = await fetch(`${this.credentials.origin()}${route}`, {
+            headers: {
+                authorization: `Bearer ${token}`,
+                "user-agent": "CodeRook/0.1",
+            },
+            signal: this.controller.signal,
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            let message = `${route} failed (${response.status})`;
+            try {
+                message = JSON.parse(text)?.error?.message ?? message;
+            }
+            catch {
+                /* the body was not JSON; the status will have to do */
+            }
+            throw new Error(message);
+        }
+        return response;
+    }
+    async versions(repositoryId) {
+        const body = (await (await this.request(`/v1/repositories/${repositoryId}/versions`)).json());
+        return (body.versions ?? []).map((row) => ({
+            id: String(row.id ?? ""),
+            sequence: Number(row.sequence ?? 0),
+            message: String(row.message ?? ""),
+            fileCount: Number(row.fileCount ?? 0),
+            sourceSize: Number(row.sourceSize ?? 0),
+            createdAt: String(row.createdAt ?? ""),
+            authorName: String(row.authorName ?? ""),
+        }));
+    }
+    async files(repositoryId, versionId) {
+        const body = (await (await this.request(`/v1/repositories/${repositoryId}/versions/${versionId}/files`)).json());
+        return (body.files ?? []).map((row) => ({
+            path: String(row.path ?? ""),
+            sha256: String(row.sha256 ?? ""),
+            sourceSize: Number(row.sourceSize ?? 0),
+        }));
+    }
+    /**
+     * Write a version into `destination`. Files land in a staging directory
+     * and are moved into place only once every one has arrived and verified,
+     * so a failed download never leaves a half-project behind.
+     */
+    async run(repositoryId, versionId, destination, report) {
+        const files = await this.files(repositoryId, versionId);
+        if (!files.length)
+            throw new Error("That version has no files");
+        const totalBytes = files.reduce((total, file) => total + file.sourceSize, 0);
+        const staging = `${destination}.incoming`;
+        await (0, promises_1.rm)(staging, { recursive: true, force: true });
+        const manifest = {};
+        try {
+            let written = 0;
+            let bytes = 0;
+            for (const file of files) {
+                this.check();
+                report({
+                    files: written,
+                    totalFiles: files.length,
+                    bytes,
+                    totalBytes,
+                    path: file.path,
+                    percent: Math.round((bytes / Math.max(totalBytes, 1)) * 100),
+                });
+                // A path that climbs out of the destination is refused outright.
+                const parts = file.path.split("/").filter(Boolean);
+                if (parts.some((part) => part === ".." || part.includes("\0"))) {
+                    throw new Error(`That version contains an unsafe path: ${file.path}`);
+                }
+                const response = await this.request(`/v1/repositories/${repositoryId}/versions/${versionId}/file` +
+                    `?path=${encodeURIComponent(file.path)}`);
+                const body = Buffer.from(await response.arrayBuffer());
+                const digest = (0, node_crypto_1.createHash)("sha256").update(body).digest("hex");
+                if (file.sha256 && digest !== file.sha256) {
+                    throw new Error(`${file.path} did not arrive intact`);
+                }
+                const full = node_path_1.default.join(staging, ...parts);
+                await (0, promises_1.mkdir)(node_path_1.default.dirname(full), { recursive: true });
+                await (0, promises_1.writeFile)(full, body);
+                manifest[file.path] = digest;
+                written += 1;
+                bytes += body.length;
+            }
+            await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+            await (0, promises_1.rm)(destination, { recursive: true, force: true });
+            await (0, promises_1.rename)(staging, destination);
+            report({
+                files: written,
+                totalFiles: files.length,
+                bytes,
+                totalBytes,
+                path: "Done",
+                percent: 100,
+            });
+            return { files: written, bytes, manifest };
+        }
+        catch (error) {
+            await (0, promises_1.rm)(staging, { recursive: true, force: true });
+            throw error;
+        }
+    }
+}
+exports.Downloader = Downloader;

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

@@ -0,0 +1,172 @@
+"use strict";
+/** Ignore/keep rule parsing and matching, with gitignore precedence. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNCOUNTED_DIRECTORIES = void 0;
+exports.isUncounted = isUncounted;
+exports.parseRules = parseRules;
+exports.ruleMatches = ruleMatches;
+exports.lastMatchingRule = lastMatchingRule;
+exports.decide = decide;
+exports.excludes = excludes;
+exports.negationReachesInto = negationReachesInto;
+exports.isIgnored = isIgnored;
+/** Names that can never form part of a version, whatever their type. */
+exports.UNCOUNTED_DIRECTORIES = new Set([
+    ".git",
+    ".hg",
+    ".svn",
+    ".coderook",
+]);
+/**
+ * Whether an entry is version-control plumbing rather than project content.
+ *
+ * This deliberately ignores whether the entry is a directory: inside a linked
+ * git worktree `.git` is a *file* holding an absolute path to the real
+ * repository, which is both useless elsewhere and a leak of a local path.
+ */
+function isUncounted(name) {
+    return exports.UNCOUNTED_DIRECTORIES.has(name);
+}
+function parseRules(text) {
+    const rules = [];
+    for (const line of text.split(/\r?\n/)) {
+        let value = line.trim();
+        if (!value || value.startsWith("#"))
+            continue;
+        const negated = value.startsWith("!");
+        if (negated)
+            value = value.slice(1);
+        if (!value)
+            continue;
+        const directoryOnly = value.endsWith("/");
+        value = value.replace(/\/+$/, "");
+        const anchored = value.startsWith("/");
+        value = value.replace(/^\/+/, "");
+        if (value)
+            rules.push({ pattern: value, negated, directoryOnly, anchored });
+    }
+    return rules;
+}
+/** Translate one glob segment into a regular expression source. */
+function globToSource(pattern) {
+    let source = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "*") {
+            if (pattern[index + 1] === "*") {
+                source += ".*";
+                index += 1;
+                // A trailing slash after ** should not require one in the subject.
+                if (pattern[index + 1] === "/")
+                    index += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (character === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += character.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+        }
+    }
+    return source;
+}
+const cache = new Map();
+function matcher(pattern) {
+    let expression = cache.get(pattern);
+    if (!expression) {
+        expression = new RegExp(`^${globToSource(pattern)}$`);
+        cache.set(pattern, expression);
+    }
+    return expression;
+}
+function ruleMatches(relativePath, isDirectory, rule) {
+    const expression = matcher(rule.pattern);
+    if (rule.directoryOnly) {
+        if (rule.anchored || rule.pattern.includes("/")) {
+            return (expression.test(relativePath) ||
+                relativePath.startsWith(`${rule.pattern.replace(/\/+$/, "")}/`));
+        }
+        const segments = relativePath.split("/");
+        // A file inside an ignored directory is matched by its parent segments.
+        const scope = isDirectory ? segments : segments.slice(0, -1);
+        return scope.some((segment) => expression.test(segment));
+    }
+    if (rule.anchored || rule.pattern.includes("/")) {
+        return expression.test(relativePath);
+    }
+    return relativePath.split("/").some((segment) => expression.test(segment));
+}
+/** The last matching rule wins, as it does in gitignore. */
+function lastMatchingRule(relativePath, isDirectory, rules) {
+    let found = null;
+    for (const rule of rules) {
+        if (ruleMatches(relativePath, isDirectory, rule))
+            found = rule;
+    }
+    return found;
+}
+/**
+ * The layers that could speak about this path, shallowest first, so a plain
+ * last-match-wins scan across them gives deeper files the final word.
+ */
+function layersFor(relativePath, layers) {
+    return layers
+        .filter((layer) => !layer.base || relativePath.startsWith(`${layer.base}/`))
+        .sort((left, right) => left.base.length - right.base.length);
+}
+/** The last rule that matched, across every layer that governs the path. */
+function decide(relativePath, isDirectory, layers) {
+    let found = null;
+    for (const layer of layersFor(relativePath, layers)) {
+        // A nested file's patterns are written relative to its own directory.
+        const scoped = layer.base
+            ? relativePath.slice(layer.base.length + 1)
+            : relativePath;
+        const matched = lastMatchingRule(scoped, isDirectory, layer.rules);
+        if (matched)
+            found = matched;
+    }
+    return found;
+}
+/** Whether these layers exclude the path, negations included. */
+function excludes(relativePath, isDirectory, layers) {
+    const rule = decide(relativePath, isDirectory, layers);
+    return Boolean(rule && !rule.negated);
+}
+/**
+ * Whether a negation could rescue something inside this directory.
+ *
+ * Skipping an excluded directory outright is what keeps a scan fast, but a
+ * `!` rule exists precisely to bring something back from inside one, so the
+ * subtree can only be skipped when no negation could apply below it.
+ */
+function negationReachesInto(relativePath, layers) {
+    for (const layer of layers) {
+        // A nested file below this directory can always speak about its contents.
+        if (layer.base && layer.base.startsWith(`${relativePath}/`))
+            return true;
+        for (const rule of layer.rules) {
+            if (!rule.negated)
+                continue;
+            const prefix = layer.base ? `${layer.base}/` : "";
+            // A bare glob is matched against every segment, so it reaches anywhere.
+            if (!rule.anchored && !rule.pattern.includes("/"))
+                return true;
+            // A wildcard that spans separators can descend to any depth.
+            if (rule.pattern.includes("**"))
+                return true;
+            const target = `${prefix}${rule.pattern.replace(/\/+$/, "")}`;
+            if (target === relativePath || target.startsWith(`${relativePath}/`)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isIgnored(relativePath, isDirectory, rules) {
+    const rule = lastMatchingRule(relativePath, isDirectory, rules);
+    return Boolean(rule && !rule.negated);
+}