@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/git-import/container.js

@@ -0,0 +1,57 @@
+import { join } from "node:path";
+import { realpath, writeFile, rm } from "node:fs/promises";
+import { os } from "../../../core/modules/os/index.js";
+import { runEnvironmentCommand } from "../environments/index.js";
+import { HttpError } from "../http/index.js";
+const cloneScript = (username, tokenEnv) => String.raw `cat > /tmp/askpass <<'ASKPASS'
+#!/bin/sh
+case "$1" in
+  *Username*) printf "%s\n" "${username}" ;;
+  *) printf "%s\n" "$${tokenEnv}" ;;
+esac
+ASKPASS
+chmod 700 /tmp/askpass
+export GIT_ASKPASS=/tmp/askpass GIT_TERMINAL_PROMPT=0
+exec git -c credential.helper= -c core.hooksPath=/dev/null -c http.followRedirects=false clone -- "$1" /workspace/checkout`;
+/**
+ * HTTPS clone inside the project's Docker environment. The credential reaches the container only
+ * through a 0600 `--env-file`, and the URL stays an argument so no token appears in the command.
+ */
+export async function cloneInContainer({ url, staging, token, environment, signal, username, tokenEnv, id, failure, }) {
+    if (token.includes("\n") || token.includes("\r"))
+        throw new HttpError(400, failure);
+    const credentials = join(staging, ".clone-credentials");
+    await writeFile(credentials, `${tokenEnv}=${token}\n`, { mode: 0o600 });
+    await os.tools.restrictToOwner(credentials);
+    const project = {
+        id,
+        name: url,
+        path: await realpath(staging),
+        url: "",
+        icon: "",
+        mode: "server",
+        commands: [],
+        defaultCommandId: "",
+        createdAt: new Date().toISOString(),
+        environment: { ...environment, network: "bridge", ports: [] },
+    };
+    try {
+        await runEnvironmentCommand(project, [
+            "/bin/bash",
+            "--noprofile",
+            "--norc",
+            "-c",
+            cloneScript(username, tokenEnv),
+            "projector-clone",
+            url,
+        ], 300_000, signal, credentials);
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        throw new HttpError(400, failure);
+    }
+    finally {
+        await rm(credentials, { force: true });
+    }
+}

package/packages/server/modules/git-import/import.js

@@ -0,0 +1,82 @@
+import { mkdir, mkdtemp, rm, lstat, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { os } from "../../../core/modules/os/index.js";
+import { HttpError } from "../http/index.js";
+import { expandPath, inspectProject, loadProjects, updateProjects } from "../projects/index.js";
+const imports = new Set();
+/** Moves the finished checkout into place without ever overwriting an existing folder. */
+async function publish(checkout, destination) {
+    try {
+        await os.tools.publishDirectory(checkout, destination);
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            throw new HttpError(409, "Папка уже существует");
+        throw error;
+    }
+}
+/**
+ * Host-independent import: claims the destination, clones into staging, describes the project
+ * and registers it. Nothing is installed or run; existing folders are never overwritten.
+ */
+export async function importRepository({ directory: base, segments, clone, environment, hooks = {}, }) {
+    const directory = expandPath(base);
+    const destination = join(directory, ...segments);
+    if (imports.has(destination))
+        throw new HttpError(409, "Этот репозиторий уже импортируется");
+    imports.add(destination);
+    let staging = "";
+    try {
+        if ((await loadProjects()).some((project) => project.path === destination))
+            throw new HttpError(409, "Проект уже добавлен");
+        if (await lstat(destination).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }))
+            throw new HttpError(409, "Папка уже существует. Добавьте её как локальный проект или выберите другую папку импорта");
+        const parent = join(directory, ...segments.slice(0, -1));
+        await mkdir(parent, { recursive: true });
+        staging = await mkdtemp(join(parent, ".projector-import-"));
+        const checkout = join(staging, "checkout");
+        hooks.signal?.throwIfAborted();
+        hooks.phase?.("cloning");
+        await clone({ staging, checkout });
+        hooks.signal?.throwIfAborted();
+        hooks.phase?.("finishing");
+        let draft;
+        if (await lstat(join(checkout, "package.json")).catch(() => null)) {
+            draft = await inspectProject(checkout);
+            draft.icon = draft.icon ? draft.icon.replace(checkout, destination) : "";
+        }
+        else {
+            const command = { id: randomUUID(), name: "git status", cmd: "git status" };
+            draft = {
+                name: segments[segments.length - 1],
+                url: "",
+                icon: "",
+                mode: "server",
+                commands: [command],
+                defaultCommandId: command.id,
+            };
+        }
+        await publish(checkout, destination);
+        const project = {
+            ...draft,
+            path: await realpath(destination),
+            environment,
+            id: randomUUID(),
+            createdAt: new Date().toISOString(),
+        };
+        await updateProjects((projects) => {
+            projects.unshift(project);
+        });
+        return { project };
+    }
+    finally {
+        imports.delete(destination);
+        if (staging)
+            await rm(staging, { recursive: true, force: true });
+    }
+}

package/packages/server/modules/git-import/index.js

@@ -0,0 +1,4 @@
+export { cloneOverHttps } from "./clone.js";
+export { cloneInContainer } from "./container.js";
+export { importRepository } from "./import.js";
+export { startCloneJob, cloneJob, cancelCloneJob } from "./jobs.js";

package/packages/server/modules/git-import/jobs.js

@@ -0,0 +1,68 @@
+import { randomUUID } from "node:crypto";
+import { HttpError } from "../http/index.js";
+const MESSAGES = {
+    queued: "В очереди",
+    preparing: "Проверяю Docker и образ",
+    pulling: "Скачиваю образ Docker",
+    cloning: "Клонирую репозиторий",
+    finishing: "Добавляю проект",
+    done: "Готово",
+    cancelled: "Клонирование отменено",
+};
+const FINISHED = new Set(["done", "error", "cancelled"]);
+const KEEP = 20;
+const jobs = new Map();
+const active = (entry) => !FINISHED.has(entry.job.phase);
+function prune() {
+    const finished = [...jobs.values()].filter((entry) => !active(entry));
+    for (const entry of finished.slice(0, Math.max(0, finished.length - KEEP)))
+        jobs.delete(entry.job.id);
+}
+/** Starts a clone in the background; the caller polls `cloneJob` and may `cancelCloneJob`. */
+export function startCloneJob(body, run) {
+    const repository = typeof body.repository === "string" ? body.repository : "";
+    const controller = new AbortController();
+    const job = {
+        id: randomUUID(),
+        repository,
+        phase: "queued",
+        message: MESSAGES.queued,
+        startedAt: Date.now(),
+    };
+    const entry = { job, controller };
+    jobs.set(job.id, entry);
+    const set = (phase, message = MESSAGES[phase] ?? "") => {
+        // The first terminal state wins: a late phase update must not resurrect a cancelled job.
+        if (!FINISHED.has(job.phase))
+            Object.assign(job, { phase, message });
+    };
+    void run(body, { signal: controller.signal, phase: set })
+        .then(({ project }) => {
+        if (controller.signal.aborted)
+            return;
+        job.project = project;
+        set("done");
+    })
+        .catch((error) => {
+        if (controller.signal.aborted)
+            set("cancelled");
+        else
+            set("error", error.message || "Не удалось клонировать репозиторий");
+    })
+        .finally(prune);
+    return job;
+}
+export function cloneJob(id) {
+    const entry = jobs.get(id);
+    if (!entry)
+        throw new HttpError(404, "Задача клонирования не найдена");
+    return entry.job;
+}
+export function cancelCloneJob(id) {
+    const entry = jobs.get(id);
+    if (!entry)
+        throw new HttpError(404, "Задача клонирования не найдена");
+    if (active(entry))
+        entry.controller.abort();
+    return entry.job;
+}

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

@@ -0,0 +1,260 @@
+import { os } from "../../../core/modules/os/index.js";
+import { join } from "node:path";
+import { integrationConfig, updateIntegration, revealIntegrationToken, fieldText as text, } from "../integration-store/index.js";
+import { randomUUID } from "node:crypto";
+import { HttpError } from "../http/index.js";
+import { expandPath } from "../projects/index.js";
+export const DEFAULT_DIRECTORY = join(os.homeDirectory(), "Projects");
+const sessions = new Map();
+export function repositoryName(value) {
+    const name = text(value)
+        .replace(/^https:\/\/github\.com\//, "")
+        .replace(/\/$/, "")
+        .replace(/\.git$/, "");
+    if (!/^[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9_.-]+$/.test(name) ||
+        [".", ".."].includes(name.split("/")[1]))
+        throw new HttpError(400, "Укажите owner/repository или ссылку github.com");
+    return name;
+}
+/** One raw REST response; redirects stay manual for endpoints that answer with a signed link (job logs). */
+export async function githubResponse(path, token = "", init = {}) {
+    return fetch(`https://api.github.com${path}`, {
+        ...init,
+        headers: {
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "User-Agent": "Projector",
+            ...init.headers,
+        },
+        signal: AbortSignal.timeout(30_000),
+        redirect: init.redirect ?? "error",
+    });
+}
+export async function github(path, token = "") {
+    const response = await githubResponse(path, token);
+    if (!response.ok)
+        throw new HttpError([401, 403, 404, 409, 429].includes(response.status) ? response.status : 400, response.status === 401
+            ? "Авторизация GitHub истекла. Войдите снова"
+            : response.status === 404
+                ? "Репозиторий не найден или нет доступа"
+                : `GitHub вернул ${response.status}. Проверьте права доступа и лимит API`);
+    return (await response.json());
+}
+/** GraphQL v4: Discussions exist only there, and it answers only to a signed-in token. */
+export async function githubGraphql(query, variables, token) {
+    if (!token)
+        throw new HttpError(401, "Для Discussions войдите в GitHub: GraphQL API работает только с токеном");
+    const response = await fetch("https://api.github.com/graphql", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "User-Agent": "Projector",
+        },
+        body: JSON.stringify({ query, variables }),
+        signal: AbortSignal.timeout(30_000),
+        redirect: "error",
+    });
+    if (!response.ok)
+        throw new HttpError([401, 403, 429].includes(response.status) ? response.status : 400, response.status === 401
+            ? "Авторизация GitHub истекла. Войдите снова"
+            : `GitHub вернул ${response.status}. Проверьте права доступа и лимит API`);
+    const body = (await response.json());
+    if (body.errors?.length || !body.data) {
+        const notFound = body.errors?.some((error) => error.type === "NOT_FOUND");
+        throw new HttpError(notFound ? 404 : 400, notFound
+            ? "Репозиторий или обсуждение не найдены или нет доступа"
+            : "GitHub отклонил запрос Discussions");
+    }
+    return body.data;
+}
+async function oauth(path, body) {
+    const response = await fetch(`https://github.com/login/${path}`, {
+        method: "POST",
+        headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams(body),
+        signal: AbortSignal.timeout(30_000),
+        redirect: "error",
+    });
+    if (!response.ok)
+        throw new HttpError(400, `GitHub OAuth вернул ${response.status}`);
+    return await response.json();
+}
+export async function authorized() {
+    const config = await integrationConfig("github");
+    if (!config.enabled)
+        throw new HttpError(400, "Включите интеграцию GitHub в настройках");
+    if (!config.credentials.token)
+        throw new HttpError(401, "Войдите в GitHub в настройках интеграции");
+    return config;
+}
+export async function githubStatus() {
+    const config = await integrationConfig("github");
+    return {
+        id: "github",
+        name: "GitHub",
+        description: "Импорт репозиториев в локальный каталог проектов",
+        enabled: config.enabled,
+        settings: {
+            clientId: config.settings.clientId ?? "",
+            directory: config.settings.directory || DEFAULT_DIRECTORY,
+        },
+        connected: !!config.credentials.token,
+        account: config.credentials.login || null,
+    };
+}
+export const revealGithubToken = () => revealIntegrationToken("github");
+export async function configureGithub(body) {
+    if (typeof body.enabled !== "boolean")
+        throw new HttpError(400, "Укажите состояние интеграции");
+    const directory = text(body.directory);
+    if (!directory)
+        throw new HttpError(400, "Укажите папку для импорта");
+    const clientId = text(body.clientId);
+    await updateIntegration("github", (config) => ({
+        ...config,
+        enabled: body.enabled,
+        settings: { clientId, directory: expandPath(directory) },
+    }));
+    sessions.clear();
+    return githubStatus();
+}
+async function connect(token, expectedClientId, sessionId) {
+    if (!token || /[\r\n]/.test(token))
+        throw new HttpError(400, "Укажите корректный токен GitHub");
+    const account = await github("/user", token);
+    await updateIntegration("github", (config) => {
+        if ((sessionId && !sessions.has(sessionId)) ||
+            !config.enabled ||
+            (expectedClientId !== undefined && config.settings.clientId !== expectedClientId))
+            throw new HttpError(400, "Настройки изменились. Начните авторизацию заново");
+        return { ...config, credentials: { token, login: account.login } };
+    });
+    sessions.clear();
+    return githubStatus();
+}
+export async function connectGithub(body) {
+    return connect(text(body.token));
+}
+export async function disconnectGithub() {
+    sessions.clear();
+    await updateIntegration("github", (config) => ({ ...config, credentials: {} }));
+    return githubStatus();
+}
+export async function beginGithubLogin() {
+    const config = await integrationConfig("github");
+    if (!config.enabled || !config.settings.clientId)
+        throw new HttpError(400, "Включите GitHub и сохраните Client ID OAuth App с Device Flow");
+    const data = await oauth("device/code", { client_id: config.settings.clientId, scope: "repo" });
+    if (data.error ||
+        !data.device_code ||
+        !data.user_code ||
+        data.verification_uri !== "https://github.com/login/device")
+        throw new HttpError(400, "Не удалось начать вход. Проверьте Client ID и включение Device Flow в OAuth App");
+    sessions.clear();
+    const session = {
+        id: randomUUID(),
+        code: data.device_code,
+        clientId: config.settings.clientId,
+        expiresAt: Date.now() + Number(data.expires_in) * 1000,
+        interval: Number(data.interval) || 5,
+        nextPoll: 0,
+    };
+    session.nextPoll = Date.now() + session.interval * 1000;
+    sessions.set(session.id, session);
+    return {
+        id: session.id,
+        userCode: data.user_code,
+        verificationUri: data.verification_uri,
+        expiresAt: session.expiresAt,
+        interval: session.interval,
+    };
+}
+export async function pollGithubLogin(body) {
+    const session = sessions.get(text(body.id));
+    if (!session || session.expiresAt <= Date.now()) {
+        if (session)
+            sessions.delete(session.id);
+        throw new HttpError(400, "Код входа истёк. Начните авторизацию заново");
+    }
+    if (Date.now() < session.nextPoll)
+        return {
+            pending: true,
+            interval: Math.max(1, Math.ceil((session.nextPoll - Date.now()) / 1000)),
+        };
+    session.nextPoll = Date.now() + 30_000;
+    const data = await oauth("oauth/access_token", {
+        client_id: session.clientId,
+        device_code: session.code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    });
+    if (sessions.get(session.id) !== session)
+        throw new HttpError(400, "Авторизация отменена");
+    if (data.error === "authorization_pending" || data.error === "slow_down") {
+        if (data.error === "slow_down")
+            session.interval += 5;
+        session.nextPoll = Date.now() + session.interval * 1000;
+        return { pending: true, interval: session.interval };
+    }
+    if (!data.access_token) {
+        sessions.delete(session.id);
+    }
+    if (!data.access_token)
+        throw new HttpError(400, data.error === "access_denied"
+            ? "Вход отменён в GitHub"
+            : "Не удалось завершить вход. Попробуйте снова");
+    return {
+        pending: false,
+        integration: await connect(data.access_token, session.clientId, session.id),
+    };
+}
+export async function githubRepositories(page) {
+    const config = await authorized();
+    if (!Number.isInteger(page) || page < 1 || page > 1000)
+        throw new HttpError(400, "Неверная страница");
+    const repos = await github(`/user/repos?per_page=50&page=${page}&sort=updated&affiliation=owner,collaborator,organization_member`, config.credentials.token);
+    return {
+        repositories: repos.map((repo) => ({
+            fullName: repo.full_name,
+            description: repo.description,
+            private: repo.private,
+            url: repo.html_url,
+        })),
+        page,
+        hasMore: repos.length === 50,
+    };
+}
+/**
+ * Launcher search over repositories. Empty text lists the account's most recently updated repositories;
+ * `owner/part` narrows to one owner. Public search works without a token.
+ */
+export async function searchGithubRepositories(text) {
+    const config = await integrationConfig("github");
+    const token = config.enabled ? config.credentials.token || "" : "";
+    const query = text.trim();
+    if (!query) {
+        if (!token)
+            throw new HttpError(401, "Войдите в GitHub в настройках интеграции");
+        return (await githubRepositories(1)).repositories.slice(0, 10).map((repo) => ({
+            fullName: repo.fullName,
+            description: repo.description ?? "",
+            private: repo.private,
+        }));
+    }
+    const slash = query.indexOf("/");
+    const owner = slash > 0 ? query.slice(0, slash) : "";
+    const rest = slash > 0 ? query.slice(slash + 1) : query;
+    if (owner && !/^[A-Za-z0-9][A-Za-z0-9-]*$/.test(owner))
+        throw new HttpError(400, "Неверное имя владельца");
+    const terms = rest.replace(/[^\w.\- ]/g, " ").trim();
+    const q = owner
+        ? `${terms ? `${terms} in:name ` : ""}user:${owner}`
+        : `${terms} in:name,description`;
+    const found = await github(`/search/repositories?q=${encodeURIComponent(q)}&per_page=10`, token);
+    return found.items.map((repo) => ({
+        fullName: repo.full_name,
+        description: repo.description ?? "",
+        private: repo.private,
+    }));
+}

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

@@ -0,0 +1,185 @@
+import { github, githubGraphql, repositoryName } from "./api.js";
+import { integrationConfig } from "../integration-store/index.js";
+import { HttpError } from "../http/index.js";
+import { fetchRemoteIcon, HTML_FILES, remoteIconCandidates } from "../projects/index.js";
+export async function githubReader(repository) {
+    const name = repositoryName(repository);
+    const config = await integrationConfig("github");
+    const token = config.enabled ? config.credentials.token || "" : "";
+    return (path) => github(`/repos/${name}${path}`, token);
+}
+/** GraphQL counterpart of `githubReader`: variables carry `owner` and `name` of the repository. */
+export async function githubGraphqlReader(repository) {
+    const [owner, name] = repositoryName(repository).split("/");
+    const config = await integrationConfig("github");
+    const token = config.enabled ? config.credentials.token || "" : "";
+    return (query, variables = {}) => githubGraphql(query, { owner, name, ...variables }, token);
+}
+function objectId(sha) {
+    if (!/^[a-f0-9]{40}$/.test(sha))
+        throw new HttpError(400, "Неверный Git object ID");
+    return sha;
+}
+export async function browseGithubRepository(repository, ref = "") {
+    const get = await githubReader(repository);
+    const repo = await get("");
+    const branch = ref || repo.default_branch;
+    const license = repo.license?.spdx_id && repo.license.spdx_id !== "NOASSERTION"
+        ? repo.license.spdx_id
+        : repo.license?.name || "";
+    const result = {
+        fullName: repo.full_name,
+        description: repo.description || "",
+        branch,
+        private: repo.private,
+        owner: repo.owner?.login || repo.full_name.split("/")[0] || "",
+        avatarUrl: repo.owner?.avatar_url || "",
+        htmlUrl: repo.html_url || `https://github.com/${repo.full_name}`,
+        defaultBranch: repo.default_branch,
+        stars: repo.stargazers_count ?? 0,
+        forks: repo.forks_count ?? 0,
+        watchers: repo.subscribers_count ?? 0,
+        openIssues: repo.open_issues_count ?? 0,
+        language: repo.language || "",
+        license,
+        homepage: repo.homepage || "",
+        topics: Array.isArray(repo.topics) ? repo.topics : [],
+        createdAt: repo.created_at || "",
+        updatedAt: repo.updated_at || "",
+    };
+    try {
+        const commit = await get(`/commits/${encodeURIComponent(branch)}`);
+        return { ...result, commit: commit.sha, tree: commit.commit.tree.sha, empty: false };
+    }
+    catch (error) {
+        if (!ref &&
+            error instanceof HttpError &&
+            (error.status === 409 || (error.status === 404 && repo.size === 0)))
+            return { ...result, commit: "", tree: "", empty: true };
+        throw error;
+    }
+}
+export async function browseGithubTree(repository, sha) {
+    objectId(sha);
+    const get = await githubReader(repository);
+    const data = await get(`/git/trees/${sha}`);
+    return {
+        entries: data.tree
+            .map((entry) => ({
+            name: entry.path,
+            sha: entry.sha,
+            type: entry.type,
+            mode: entry.mode,
+            size: entry.size ?? 0,
+        }))
+            .sort((a, b) => Number(b.type === "tree") - Number(a.type === "tree") || a.name.localeCompare(b.name)),
+        truncated: data.truncated,
+    };
+}
+const LIMIT = 5 * 1024 * 1024;
+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",
+};
+export async function browseGithubFile(repository, sha, path) {
+    objectId(sha);
+    const get = await githubReader(repository);
+    const blob = await get(`/git/blobs/${sha}`);
+    if (blob.size > LIMIT)
+        throw new HttpError(413, "Просмотр файлов больше 5 MiB пока недоступен");
+    if (blob.encoding !== "base64")
+        throw new HttpError(400, "GitHub вернул неподдерживаемую кодировку");
+    const bytes = Buffer.from(blob.content, "base64");
+    const extension = path.split(".").pop()?.toLowerCase() || "";
+    const mime = IMAGE_MIME[extension];
+    const content = bytes.toString("utf8");
+    const binary = bytes.includes(0) || !Buffer.from(content).equals(bytes);
+    return {
+        content: binary ? "" : content,
+        image: mime ? `data:${mime};base64,${bytes.toString("base64")}` : null,
+        binary,
+        size: bytes.length,
+    };
+}
+export async function browseGithubCommitAsset(repository, commit, path) {
+    objectId(commit);
+    const get = await githubReader(repository);
+    const info = await get(`/git/commits/${commit}`);
+    return browseGithubAsset(repository, info.tree.sha, path);
+}
+async function githubBlobAsset(repository, sha, path) {
+    const file = await browseGithubFile(repository, sha, path);
+    if (!file.image)
+        throw new HttpError(400, "Неподдерживаемое изображение");
+    const [header, content] = file.image.split(",");
+    return { mime: header.slice(5).split(";")[0], bytes: Buffer.from(content, "base64") };
+}
+export async function browseGithubAsset(repository, root, path) {
+    objectId(root);
+    const parts = path.split("/");
+    if (parts.some((part) => !part || part === "." || part === "..") ||
+        path.includes("\\") ||
+        path.includes("\0"))
+        throw new HttpError(400, "Неверный путь изображения");
+    let sha = root;
+    for (const [index, name] of parts.entries()) {
+        const data = await browseGithubTree(repository, sha);
+        const entry = data.entries.find((item) => item.name === name);
+        if (!entry)
+            throw new HttpError(404, "Изображение не найдено");
+        if (index < parts.length - 1) {
+            if (entry.type !== "tree")
+                throw new HttpError(404, "Папка не найдена");
+            sha = entry.sha;
+        }
+        else {
+            if (entry.type !== "blob" || entry.mode === "120000")
+                throw new HttpError(400, "Выберите изображение");
+            if (entry.size > LIMIT)
+                throw new HttpError(413, "Изображение больше 5 MiB");
+            return githubBlobAsset(repository, entry.sha, path);
+        }
+    }
+    throw new HttpError(404, "Изображение не найдено");
+}
+/**
+ * Project logo from the repository itself: an icon linked by its HTML pages or one of the usual
+ * favicon/logo files. `null` means the repository has no such file.
+ */
+export async function browseGithubIcon(repository, ref = "") {
+    const get = await githubReader(repository);
+    const repo = await get("");
+    const avatar = await fetchRemoteIcon(repo.owner?.avatar_url || "");
+    if (avatar)
+        return avatar;
+    const branch = ref || repo.default_branch || "";
+    if (!branch)
+        return null;
+    const head = await get(`/commits/${encodeURIComponent(branch)}`);
+    const tree = head.commit.tree.sha;
+    const data = await get(`/git/trees/${tree}?recursive=1`);
+    const blobs = new Map();
+    for (const entry of data.tree)
+        if (entry.type === "blob")
+            blobs.set(entry.path, { sha: entry.sha, size: entry.size });
+    const pages = [];
+    for (const path of HTML_FILES) {
+        const entry = blobs.get(path);
+        if (!entry || (entry.size ?? 0) > 512 * 1024)
+            continue;
+        const file = await browseGithubFile(repository, entry.sha, path).catch(() => null);
+        if (file && !file.binary)
+            pages.push({ path, content: file.content });
+    }
+    const iconPath = remoteIconCandidates(pages, new Set(blobs.keys()))[0];
+    if (!iconPath)
+        return null;
+    const entry = blobs.get(iconPath);
+    return entry ? githubBlobAsset(repository, entry.sha, iconPath) : null;
+}