@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/gitlab/api.js

@@ -0,0 +1,257 @@
+import { integrationConfig, updateIntegration, fieldText as text, } from "../integration-store/index.js";
+import { HttpError } from "../http/index.js";
+import { GITLAB_DEFAULT_INSTANCE, GITLAB_PREFIX, normalizeGitlabInstance, normalizeGitlabProjectPath, } from "../../../core/modules/gitlab/index.js";
+import { GITLAB_URL, gitlabBaseUrl } from "./base.js";
+import { gitlabStatus } from "./connection.js";
+import { clearGitlabSessions, gitlabTokenExpiring, refreshGitlabToken } from "./oauth.js";
+export { GITLAB_DIRECTORY, GITLAB_URL, gitlabBaseUrl } from "./base.js";
+export { beginGitlabLogin, configureGitlab, disconnectGitlab, gitlabStatus, pollGitlabLogin, revealGitlabToken, } from "./connection.js";
+export { refreshGitlabToken } from "./oauth.js";
+/** `group/subgroup/project` from a path or a link to the configured instance. */
+export function gitlabProjectName(value, base = GITLAB_URL) {
+    let name = text(value);
+    if (name.startsWith(`${base}/`))
+        name = name.slice(base.length + 1);
+    name = name
+        .split(/[?#]/)[0]
+        .replace(/\/-\/.*$/, "")
+        .replace(/^\/+|\/+$/g, "")
+        .replace(/\.git$/, "");
+    const parts = name.split("/");
+    if (parts.length < 2 ||
+        parts.some((part) => !/^[A-Za-z0-9_][A-Za-z0-9_.-]*$/.test(part) || /\.(git|atom)$/.test(part)))
+        throw new HttpError(400, "Укажите group/project или ссылку на проект GitLab");
+    return name;
+}
+/** `<authority>/<group>/<project>` split into an instance and a path. */
+function gitlabRepositoryParts(value, configuredBase = GITLAB_URL) {
+    let raw = text(value);
+    if (raw.startsWith(GITLAB_PREFIX))
+        raw = raw.slice(GITLAB_PREFIX.length);
+    let instance;
+    let path;
+    try {
+        if (raw.includes("://")) {
+            const url = new URL(raw);
+            instance = normalizeGitlabInstance(url.origin);
+            path = normalizeGitlabProjectPath(raw, instance);
+            // A link carries the install prefix; the API path must not.
+            const prefix = new URL(configuredBase).pathname.replace(/^\/+|\/+$/g, "");
+            if (instance === normalizeGitlabInstance(new URL(configuredBase).origin) &&
+                prefix &&
+                path.startsWith(`${prefix}/`))
+                path = path.slice(prefix.length + 1);
+        }
+        else {
+            const slash = raw.indexOf("/");
+            if (slash < 1)
+                throw new Error("Укажите group/project или ссылку на проект GitLab");
+            instance = normalizeGitlabInstance(raw.slice(0, slash));
+            path = normalizeGitlabProjectPath(raw.slice(slash + 1), instance);
+        }
+    }
+    catch (error) {
+        throw new HttpError(400, error.message);
+    }
+    return { instance, path };
+}
+export function gitlabCredentialsTokenType(credentials) {
+    return credentials.kind === "oauth" ? "oauth" : "pat";
+}
+/** Refreshes an expiring OAuth access token before it is used; PAT tokens never refresh. */
+export async function gitlabAccessToken(base, credentials) {
+    const token = credentials.token || "";
+    if (!token)
+        return "";
+    if (gitlabTokenExpiring(credentials))
+        return refreshGitlabToken(base);
+    return token;
+}
+async function gitlabTargetToken(config, base) {
+    if (!config.enabled)
+        return { token: "" };
+    const token = await gitlabAccessToken(base, config.credentials);
+    if (!token)
+        return { token: "" };
+    return config.credentials.kind === "oauth" ? { token, tokenType: "oauth" } : { token };
+}
+/**
+ * The only hosts Projector may reach: `gitlab.com` anonymously, or the exact instance from settings.
+ * The token never goes to a host that is not the configured base.
+ */
+export async function gitlabTarget(repository) {
+    const config = await integrationConfig("gitlab");
+    const configuredBase = gitlabBaseUrl(config.settings.url);
+    const configuredInstance = normalizeGitlabInstance(new URL(configuredBase).origin);
+    const { instance, path } = gitlabRepositoryParts(repository, configuredBase);
+    if (instance === GITLAB_DEFAULT_INSTANCE) {
+        // A token for a self-hosted instance must not follow a gitlab.com link.
+        const access = configuredInstance === GITLAB_DEFAULT_INSTANCE
+            ? await gitlabTargetToken(config, GITLAB_URL)
+            : { token: "" };
+        return { instance, path, base: GITLAB_URL, ...access };
+    }
+    if (instance === configuredInstance) {
+        const access = await gitlabTargetToken(config, configuredBase);
+        return { instance, path, base: configuredBase, ...access };
+    }
+    throw new HttpError(403, "Проект на другом хосте GitLab недоступен. Откройте проект на gitlab.com или настройте этот инстанс");
+}
+/**
+ * Clone target from a relative `group/project`, a canonical `<authority>/<path>`, `gl:/…` or a
+ * link. A relative path belongs to the configured instance; anything that names a host goes
+ * through `gitlabTarget`, so the allowlist and the token rules stay in one place.
+ */
+export async function gitlabCloneTarget(value) {
+    const raw = text(value);
+    if (!raw)
+        throw new HttpError(400, "Укажите group/project или ссылку на проект GitLab");
+    const config = await integrationConfig("gitlab");
+    const configuredInstance = normalizeGitlabInstance(new URL(gitlabBaseUrl(config.settings.url)).origin);
+    const first = raw.split("/", 1)[0] ?? "";
+    let explicit = raw.startsWith(GITLAB_PREFIX) || raw.includes("://");
+    if (!explicit) {
+        try {
+            const authority = normalizeGitlabInstance(first);
+            explicit = authority === configuredInstance || authority === GITLAB_DEFAULT_INSTANCE;
+        }
+        catch {
+            // The first segment is a group, not a host.
+        }
+    }
+    if (explicit)
+        return gitlabTarget(raw);
+    let path;
+    try {
+        path = normalizeGitlabProjectPath(raw, configuredInstance);
+    }
+    catch (error) {
+        throw new HttpError(400, error.message);
+    }
+    return gitlabTarget(`${configuredInstance}/${path}`);
+}
+function gitlabError(response) {
+    if (response.status === 401)
+        return new HttpError(401, "Авторизация GitLab истекла или недействительна. Войдите снова");
+    if (response.status === 404)
+        return new HttpError(404, "Проект не найден или нет доступа");
+    if (response.status === 429)
+        return new HttpError(429, "Превышен лимит GitLab. Повторите позже");
+    if (response.status === 403)
+        return new HttpError(403, "GitLab запретил доступ. Проверьте права токена");
+    return new HttpError(response.status, `GitLab вернул ${response.status}. Проверьте права токена и лимит API`);
+}
+/** Low-level response for endpoints that are not JSON, such as raw file bytes. */
+export async function gitlabFetch(base, path, token = "", init = {}) {
+    const { tokenType = "pat", ...request } = init;
+    let response;
+    try {
+        response = await fetch(`${base}/api/v4${path}`, {
+            ...request,
+            headers: {
+                ...(token
+                    ? tokenType === "oauth"
+                        ? { Authorization: `Bearer ${token}` }
+                        : { "PRIVATE-TOKEN": token }
+                    : {}),
+                Accept: "application/json",
+                "User-Agent": "Projector",
+                ...request.headers,
+            },
+            signal: AbortSignal.timeout(30_000),
+            redirect: "error",
+        });
+    }
+    catch (error) {
+        if (error instanceof HttpError)
+            throw error;
+        throw new HttpError(400, "GitLab недоступен. Проверьте адрес и сеть");
+    }
+    if (!response.ok)
+        throw gitlabError(response);
+    return response;
+}
+/** JSON request with the pagination headers still available to the caller. */
+export async function gitlabRequest(base, path, token = "", init = {}) {
+    const response = await gitlabFetch(base, path, token, init);
+    const data = (response.status === 204 ? undefined : await response.json());
+    return { data, headers: response.headers };
+}
+/** Raw bytes for assets; the caller decides the MIME type. */
+export async function gitlabBytes(base, path, token = "", init = {}) {
+    const response = await gitlabFetch(base, path, token, init);
+    return { bytes: Buffer.from(await response.arrayBuffer()), headers: response.headers };
+}
+/**
+ * One repository-bound reader: target selection and OAuth recovery stay in one place. An OAuth 401
+ * gets exactly one forced refresh and one retry; a PAT 401 is returned to the caller unchanged.
+ */
+export async function gitlabReader(repository) {
+    const target = await gitlabTarget(repository);
+    const send = (path, init = {}) => gitlabRequest(target.base, path, target.token, {
+        ...init,
+        tokenType: target.tokenType,
+    });
+    const recover = async (run) => {
+        try {
+            return await run();
+        }
+        catch (error) {
+            if (!(error instanceof HttpError) || error.status !== 401 || target.tokenType !== "oauth")
+                throw error;
+            target.token = await refreshGitlabToken(target.base, true);
+            return run();
+        }
+    };
+    const request = (path, init = {}) => recover(() => send(path, init));
+    const raw = (path, init = {}) => recover(() => gitlabFetch(target.base, path, target.token, { ...init, tokenType: target.tokenType }));
+    return {
+        target,
+        request,
+        get: async (path, init) => (await request(path, init)).data,
+        fetch: raw,
+    };
+}
+export async function gitlab(base, path, token = "", init = {}) {
+    return (await gitlabRequest(base, path, token, init)).data;
+}
+export async function gitlabAuthorized() {
+    const config = await integrationConfig("gitlab");
+    if (!config.enabled)
+        throw new HttpError(400, "Включите интеграцию GitLab в настройках");
+    if (!config.credentials.token)
+        throw new HttpError(401, "Подключите GitLab в настройках интеграции");
+    return { ...config, base: gitlabBaseUrl(config.settings.url) };
+}
+export async function connectGitlab(body) {
+    const token = text(body.token);
+    if (!token || /[\r\n]/.test(token))
+        throw new HttpError(400, "Укажите корректный токен GitLab");
+    const config = await integrationConfig("gitlab");
+    if (!config.enabled)
+        throw new HttpError(400, "Включите интеграцию GitLab в настройках");
+    const base = gitlabBaseUrl(config.settings.url);
+    const account = await gitlab(base, "/user", token);
+    await updateIntegration("gitlab", (current) => {
+        if (!current.enabled || gitlabBaseUrl(current.settings.url) !== base)
+            throw new HttpError(400, "Настройки изменились. Подключитесь заново");
+        return { ...current, credentials: { token, login: account.username } };
+    });
+    clearGitlabSessions();
+    return gitlabStatus();
+}
+const mapProject = (project) => ({
+    fullName: project.path_with_namespace,
+    description: project.description ?? "",
+    private: project.visibility !== "public",
+    url: project.web_url,
+});
+export async function gitlabRepositories(page) {
+    const config = await gitlabAuthorized();
+    if (!Number.isInteger(page) || page < 1 || page > 1000)
+        throw new HttpError(400, "Неверная страница");
+    const tokenType = gitlabCredentialsTokenType(config.credentials);
+    const token = await gitlabAccessToken(config.base, config.credentials);
+    const projects = await gitlab(config.base, `/projects?membership=true&simple=true&order_by=last_activity_at&per_page=50&page=${page}`, token, { tokenType });
+    return { repositories: projects.map(mapProject), page, hasMore: projects.length === 50 };
+}

package/packages/server/modules/gitlab/base.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import { HttpError } from "../http/index.js";
+import { fieldText as text } from "../integration-store/index.js";
+import { os } from "../../../core/modules/os/index.js";
+export const GITLAB_URL = "https://gitlab.com";
+export const GITLAB_DIRECTORY = join(os.homeDirectory(), "Projects");
+/** Normalized instance origin (`https://gitlab.example.com[/prefix]`); credentials and queries are rejected. */
+export function gitlabBaseUrl(value) {
+    const raw = text(value) || GITLAB_URL;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new HttpError(400, "Укажите адрес GitLab вида https://gitlab.example.com");
+    }
+    if (!["https:", "http:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash)
+        throw new HttpError(400, "Укажите адрес GitLab вида https://gitlab.example.com");
+    return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}

package/packages/server/modules/gitlab/blob-search.js

@@ -0,0 +1,110 @@
+import { HttpError } from "../http/index.js";
+import { searchMatches, } from "../../../core/modules/workspace/index.js";
+import { gitlabReader } from "./api.js";
+import { projectId } from "./browser.js";
+const PAGE_SIZE = 100;
+const HIT_LIMIT = 200;
+/** GitLab returns a plain snippet; find the matched line and its offsets ourselves. */
+function lineMatches(text, query, options) {
+    const matches = searchMatches(text, query, options);
+    if (!options.wholeWord)
+        return matches;
+    return matches.filter((match) => {
+        const before = text[match.start - 1] ?? "";
+        const after = text[match.end] ?? "";
+        return !/\w/.test(before) && !/\w/.test(after);
+    });
+}
+function resultHit(item, query, options) {
+    const path = item.path?.trim();
+    if (!path)
+        return undefined;
+    const startline = Number(item.startline);
+    if (!Number.isSafeInteger(startline) || startline < 1)
+        return undefined;
+    const lines = (item.data ?? "").split(/\r?\n/);
+    let lineText = lines[0] ?? "";
+    let lineOffset = 0;
+    let matches = lineMatches(lineText, query, options);
+    for (let index = 1; index < lines.length; index++) {
+        const candidate = lineMatches(lines[index] ?? "", query, options);
+        if (!candidate.length)
+            continue;
+        lineText = lines[index] ?? "";
+        lineOffset = index;
+        matches = candidate;
+        break;
+    }
+    if ((options.wholeWord || options.caseSensitive || options.regex) && !matches.length)
+        return undefined;
+    const text = lineText.trimEnd().slice(0, 500);
+    return {
+        path,
+        line: startline + lineOffset,
+        column: (matches[0]?.start ?? 0) + 1,
+        text,
+        matches,
+    };
+}
+/**
+ * Search a GitLab project at a ref. GitLab's blob search is part of Advanced Search; a CE
+ * instance without it answers 400/404 and gets a readable error instead of a false empty result.
+ */
+export async function searchGitlabBlobs(repository, params) {
+    const query = params.q ?? params.query ?? "";
+    const options = {
+        caseSensitive: params.case === "true",
+        wholeWord: params.word === "true",
+        regex: params.regex === "true",
+    };
+    const ref = params.rev || params.sha || "";
+    if (!query.trim())
+        return { hits: [], truncated: false };
+    if (query.length > 200)
+        throw new HttpError(400, "Запрос длиннее 200 символов");
+    if (ref && !/^[a-f0-9]{7,40}$/i.test(ref))
+        throw new HttpError(400, "Некорректный хеш коммита");
+    if (options.regex) {
+        try {
+            new RegExp(query, options.caseSensitive ? "" : "i");
+        }
+        catch {
+            throw new HttpError(400, "Некорректное регулярное выражение");
+        }
+    }
+    const reader = await gitlabReader(repository);
+    const id = projectId(reader.target.path);
+    const hits = [];
+    let page = 1;
+    let next = "";
+    do {
+        const queryParams = new URLSearchParams({
+            scope: "blobs",
+            search: query,
+            per_page: String(PAGE_SIZE),
+            page: String(page),
+        });
+        if (ref)
+            queryParams.set("ref", ref);
+        let response;
+        try {
+            response = await reader.request(`/projects/${id}/search?${queryParams}`);
+        }
+        catch (error) {
+            if (error instanceof HttpError && (error.status === 400 || error.status === 404))
+                throw new HttpError(400, "Поиск по коду GitLab недоступен: включите Advanced Search на инстансе");
+            throw error;
+        }
+        const rows = Array.isArray(response.data) ? response.data : [];
+        for (const row of rows) {
+            const hit = resultHit(row, query, options);
+            if (hit)
+                hits.push(hit);
+            if (hits.length >= HIT_LIMIT)
+                break;
+        }
+        next = response.headers.get("X-Next-Page") ?? "";
+        page++;
+    } while (next && hits.length < HIT_LIMIT && page <= 2);
+    return { hits, truncated: !!next || hits.length >= HIT_LIMIT };
+}

package/packages/server/modules/gitlab/browser.js

@@ -0,0 +1,296 @@
+import { HttpError } from "../http/index.js";
+import { gitlabBytes, gitlabReader } from "./api.js";
+const FILE_LIMIT = 5 * 1024 * 1024;
+const TREE_LIMIT = 1000;
+export const DIFF_LIMIT = 300;
+export const LOG_PAGE_SIZE = 30;
+export const SEARCH_LIMIT = 500;
+const IMAGE_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif",
+    ico: "image/x-icon",
+    svg: "image/svg+xml",
+};
+const BINARY_EXTENSIONS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "avif",
+    "ico",
+    "pdf",
+    "zip",
+    "gz",
+    "bz2",
+    "xz",
+    "7z",
+    "rar",
+    "tar",
+    "woff",
+    "woff2",
+    "ttf",
+    "otf",
+    "eot",
+    "mp3",
+    "mp4",
+    "mov",
+    "avi",
+    "wasm",
+    "exe",
+    "dll",
+    "so",
+    "dylib",
+    "bin",
+    "class",
+    "jar",
+    "dat",
+    "sqlite",
+]);
+export const projectId = (path) => encodeURIComponent(path);
+function extension(path) {
+    return path.split(".").pop()?.toLowerCase() || "";
+}
+export function safePath(path, message = "Неверный путь файла") {
+    if (!path ||
+        path.includes("\\") ||
+        path.includes("\0") ||
+        path.split("/").some((part) => !part || part === "." || part === ".."))
+        throw new HttpError(400, message);
+    return path;
+}
+function safeTreePath(path) {
+    return path ? safePath(path, "Неверный путь папки") : "";
+}
+/** Next page from `X-Next-Page`, with a length-based fallback for hosts without the header. */
+export function nextPage(headers, page, count, size) {
+    const raw = headers.get("X-Next-Page");
+    if (raw !== null) {
+        const next = Number(raw);
+        return Number.isInteger(next) && next > page ? next : null;
+    }
+    return count === size ? page + 1 : null;
+}
+function refQuery(ref) {
+    return ref ? `?${new URLSearchParams({ ref })}` : "";
+}
+function commitSubject(data) {
+    return data.title || data.message?.split("\n")[0] || "";
+}
+export function commitRow(data) {
+    return {
+        hash: data.id || data.sha || "",
+        parents: data.parent_ids ?? [],
+        subject: commitSubject(data),
+        author: data.author_name || "",
+        email: data.author_email || "",
+        date: data.authored_date || "",
+        refs: [],
+        unpushed: false,
+    };
+}
+export function diffCounts(diff = "") {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            additions++;
+        else if (line.startsWith("-") && !line.startsWith("---"))
+            deletions++;
+    }
+    return { additions, deletions };
+}
+export function diffStatus(file) {
+    if (file.new_file)
+        return "A";
+    if (file.deleted_file)
+        return "D";
+    if (file.copied_file)
+        return "C";
+    if (file.renamed_file || file.old_path !== file.new_path)
+        return "R";
+    if (file.a_mode && file.b_mode && file.a_mode.slice(0, 3) !== file.b_mode.slice(0, 3))
+        return "T";
+    return "M";
+}
+export function isBinaryDiff(file) {
+    return !file.diff && BINARY_EXTENSIONS.has(extension(file.new_path || file.old_path));
+}
+/** GitLab returns namespace avatars as `/uploads/...` on some endpoints. */
+function absoluteUrl(value, base) {
+    if (!value)
+        return "";
+    try {
+        return new URL(value, base).href;
+    }
+    catch {
+        return value;
+    }
+}
+export async function browseGitlabRepository(repository, ref = "") {
+    const reader = await gitlabReader(repository);
+    const id = projectId(reader.target.path);
+    const project = await reader.get(`/projects/${id}?license=true`);
+    let languages = {};
+    try {
+        const value = await reader.get(`/projects/${id}/languages`);
+        if (value && typeof value === "object" && !Array.isArray(value))
+            languages = value;
+    }
+    catch {
+        // Languages are optional: old instances and disabled endpoints must not break the card.
+    }
+    const defaultBranch = project.default_branch || "";
+    const branch = ref || defaultBranch;
+    let commit = "";
+    let empty = project.empty_repo === true;
+    if (!empty) {
+        if (!branch)
+            empty = true;
+        else
+            try {
+                const head = await reader.get(`/projects/${id}/repository/commits/${encodeURIComponent(branch)}`);
+                commit = head.id || head.sha || "";
+            }
+            catch (error) {
+                if (error instanceof HttpError && error.status === 404)
+                    empty = true;
+                else
+                    throw error;
+            }
+    }
+    const visibility = project.visibility || "private";
+    const fullName = project.path_with_namespace || reader.target.path;
+    const webUrl = project.web_url || "";
+    const avatar = project.avatar_url || project.namespace?.avatar_url || project.owner?.avatar_url || "";
+    const primary = Object.entries(languages).sort(([, left], [, right]) => (right ?? 0) - (left ?? 0))[0]?.[0] ??
+        "";
+    let openIssues = project.open_issues_count ?? 0;
+    let openMergeRequests = project.open_merge_requests_count ?? 0;
+    if (!empty &&
+        (project.open_issues_count === undefined || project.open_merge_requests_count === undefined)) {
+        const [statistics, mergeRequests] = await Promise.all([
+            project.open_issues_count === undefined
+                ? reader
+                    .get(`/projects/${id}/issues_statistics`)
+                    .catch(() => null)
+                : Promise.resolve(null),
+            project.open_merge_requests_count === undefined
+                ? reader
+                    .request(`/projects/${id}/merge_requests?state=opened&per_page=1`)
+                    .catch(() => null)
+                : Promise.resolve(null),
+        ]);
+        const opened = statistics?.statistics?.counts?.opened;
+        if (typeof opened === "number")
+            openIssues = opened;
+        const total = Number(mergeRequests?.headers.get("X-Total"));
+        if (Number.isFinite(total))
+            openMergeRequests = total;
+    }
+    return {
+        fullName,
+        description: project.description || "",
+        defaultBranch,
+        branch,
+        commit,
+        private: visibility !== "public",
+        empty,
+        archived: project.archived === true,
+        visibility,
+        webUrl,
+        httpUrlToRepo: project.http_url_to_repo || "",
+        owner: project.namespace?.name || project.owner?.name || fullName.split("/")[0] || "",
+        avatarUrl: absoluteUrl(avatar, webUrl || reader.target.base),
+        stars: project.star_count ?? 0,
+        forks: project.forks_count ?? 0,
+        openIssues,
+        openMergeRequests,
+        language: primary,
+        languages,
+        license: project.license?.name || project.license?.spdx_identifier || "",
+        homepage: "",
+        topics: Array.isArray(project.topics) ? project.topics : [],
+        createdAt: project.created_at || "",
+        updatedAt: project.last_activity_at || project.updated_at || "",
+    };
+}
+async function treePage(reader, ref, path, page) {
+    const params = new URLSearchParams({ path, per_page: "100", page: String(page) });
+    if (ref)
+        params.set("ref", ref);
+    return reader.request(`/projects/${projectId(reader.target.path)}/repository/tree?${params}`);
+}
+export async function browseGitlabTree(repository, ref, path = "") {
+    const reader = await gitlabReader(repository);
+    const entries = [];
+    const safe = safeTreePath(path);
+    const pages = Math.ceil(TREE_LIMIT / 100);
+    let truncated = false;
+    let page = 1;
+    for (let fetched = 0; fetched < pages; fetched++) {
+        const response = await treePage(reader, ref, safe, page);
+        const rows = Array.isArray(response.data) ? response.data : [];
+        entries.push(...rows.map((row) => ({ ...row, mode: row.mode || "" })));
+        const next = nextPage(response.headers, page, rows.length, 100);
+        if (!next)
+            break;
+        if (fetched === pages - 1) {
+            truncated = true;
+            break;
+        }
+        page = next;
+    }
+    if (entries.length > TREE_LIMIT) {
+        entries.length = TREE_LIMIT;
+        truncated = true;
+    }
+    entries.sort((left, right) => Number(right.type === "tree") - Number(left.type === "tree") ||
+        left.name.localeCompare(right.name));
+    return { entries, truncated };
+}
+export async function browseGitlabFile(repository, ref, path) {
+    const reader = await gitlabReader(repository);
+    return readGitlabFileAt(reader, projectId(reader.target.path), ref, path);
+}
+/** Read one file from an already resolved project id or path; used for both sides of an MR diff. */
+export async function readGitlabFileAt(reader, project, ref, path) {
+    safePath(path);
+    const file = await reader.get(`/projects/${project}/repository/files/${encodeURIComponent(path)}${refQuery(ref)}`);
+    if ((file.size ?? 0) > FILE_LIMIT)
+        throw new HttpError(413, "Файл больше 5 MiB");
+    let bytes;
+    if (!file.encoding || file.encoding === "text")
+        bytes = Buffer.from(file.content || "", "utf8");
+    else if (file.encoding === "base64")
+        bytes = Buffer.from(file.content || "", "base64");
+    else
+        throw new HttpError(400, "GitLab вернул неподдерживаемую кодировку");
+    if (bytes.length > FILE_LIMIT)
+        throw new HttpError(413, "Файл больше 5 MiB");
+    const content = bytes.toString("utf8");
+    const binary = bytes.includes(0) || !Buffer.from(content, "utf8").equals(bytes);
+    const mime = IMAGE_MIME[extension(path)];
+    return {
+        content: binary ? "" : content,
+        image: mime ? `data:${mime};base64,${bytes.toString("base64")}` : null,
+        binary,
+        size: bytes.length,
+    };
+}
+export async function browseGitlabAsset(repository, ref, path) {
+    safePath(path);
+    const { target } = await gitlabReader(repository);
+    const { bytes, headers } = await gitlabBytes(target.base, `/projects/${projectId(target.path)}/repository/files/${encodeURIComponent(path)}/raw${refQuery(ref)}`, target.token, { tokenType: target.tokenType });
+    const declared = Number(headers.get("Content-Length") || 0);
+    if (declared > FILE_LIMIT || bytes.length > FILE_LIMIT)
+        throw new HttpError(413, "Файл больше 5 MiB");
+    const content = headers.get("Content-Type")?.split(";")[0]?.trim().toLowerCase() || "";
+    const mime = IMAGE_MIME[extension(path)] ||
+        (content && content !== "application/octet-stream" ? content : "application/octet-stream");
+    return { mime, bytes };
+}