@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/workspace/import.js

@@ -0,0 +1,190 @@
+import { createWriteStream } from "node:fs";
+import { lstat, mkdir, realpath, rm } from "node:fs/promises";
+import { cp } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { basename, isAbsolute, resolve, sep } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { os } from "../../../core/modules/os/index.js";
+import { HttpError } from "../http/index.js";
+import { mutationLocation, trashProjectEntry, validateEntryName } from "./files.js";
+/** Один загруженный из браузера файл не больше этого размера. */
+export const MAX_UPLOAD_BYTES = 512 * 1024 * 1024;
+const exists = (path) => lstat(path).then(() => true, (error) => {
+    if (error.code === "ENOENT")
+        return false;
+    throw error;
+});
+async function targetDirectory(root, directory) {
+    const parent = await mutationLocation(root, directory, true);
+    if (!(await lstat(parent)).isDirectory())
+        throw new HttpError(400, "Выберите папку назначения");
+    return parent;
+}
+/** `name (2).ext`, `name (3).ext`… — первое свободное имя рядом с занятым. */
+async function freeName(parent, name, taken) {
+    const dot = name.lastIndexOf(".");
+    const [stem, extension] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    for (let index = 2;; index++) {
+        const candidate = `${stem} (${index})${extension}`;
+        if (!taken.has(candidate) && !(await exists(resolve(parent, candidate))))
+            return candidate;
+    }
+}
+/** Какие из имён уже заняты в папке назначения и под каким именем их можно оставить рядом. */
+export async function checkImportNames(root, directory, names) {
+    const parent = await targetDirectory(root, directory);
+    const taken = new Set(names);
+    const conflicts = [];
+    for (const name of names) {
+        await validateEntryName(name);
+        if (!(await exists(resolve(parent, name))))
+            continue;
+        const free = await freeName(parent, name, taken);
+        taken.add(free);
+        conflicts.push({ name, free });
+    }
+    return { conflicts };
+}
+/** Освобождает имена: занятые записи уходят в `.projector-trash`, как при удалении. */
+export async function clearImportNames(root, directory, names) {
+    const parent = await targetDirectory(root, directory);
+    for (const name of names) {
+        await validateEntryName(name);
+        if (await exists(resolve(parent, name)))
+            await trashProjectEntry(root, directory ? `${directory}/${name}` : name);
+    }
+}
+/**
+ * Копирует записи с диска в папку проекта под заданными именами. Источник не меняется,
+ * существующие записи не перезаписываются: занятое имя — 409 до начала копирования.
+ */
+export async function importProjectEntries(root, directory, entries) {
+    const parent = await targetDirectory(root, directory);
+    const realParent = await realpath(parent);
+    const names = new Set();
+    const sources = [];
+    for (const { source, name } of entries) {
+        if (!isAbsolute(source) || source.includes("\0"))
+            throw new HttpError(400, "Укажите абсолютный путь к файлу");
+        await validateEntryName(name);
+        if (names.has(name))
+            throw new HttpError(409, `Имя «${name}» повторяется`);
+        names.add(name);
+        // Ссылка верхнего уровня копируется как её содержимое, ссылки внутри папок остаются ссылками.
+        const real = await realpath(source).catch(() => {
+            throw new HttpError(404, `Не найден: ${basename(source)}`);
+        });
+        const info = await lstat(real);
+        if (!info.isFile() && !info.isDirectory())
+            throw new HttpError(400, `Нельзя скопировать ${basename(source)}: это не файл и не папка`);
+        if (realParent === real || realParent.startsWith(real + sep))
+            throw new HttpError(400, "Нельзя копировать папку внутрь себя");
+        if (await exists(resolve(parent, name)))
+            throw new HttpError(409, `В папке назначения уже есть «${name}»`);
+        sources.push({ source: real, name });
+    }
+    const copied = [];
+    for (const { source, name } of sources) {
+        const target = resolve(parent, name);
+        const temporary = resolve(parent, `.projector-${randomUUID()}.tmp`);
+        try {
+            // Копия собирается целиком до публикации: оборванное копирование ничего не оставляет.
+            await cp(source, temporary, {
+                recursive: true,
+                dereference: false,
+                verbatimSymlinks: true,
+                force: false,
+                errorOnExist: true,
+            });
+            try {
+                await os.tools.moveNoReplace(temporary, target);
+            }
+            catch (error) {
+                if (!(await exists(target)))
+                    throw error;
+            }
+            if (await exists(temporary))
+                throw new HttpError(409, `В папке назначения уже есть «${name}»`);
+        }
+        finally {
+            await rm(temporary, { recursive: true, force: true });
+        }
+        copied.push(directory ? `${directory}/${name}` : name);
+    }
+    return { copied };
+}
+/** Создаёт недостающие папки вдоль относительного пути; ссылки и файлы на пути — ошибка. */
+async function ensureDirectories(parent, parts) {
+    let current = parent;
+    for (const part of parts) {
+        await validateEntryName(part);
+        current = resolve(current, part);
+        try {
+            await mkdir(current);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (!(await lstat(current)).isDirectory())
+                throw new HttpError(409, `«${part}» уже существует и не является папкой`);
+        }
+    }
+    return current;
+}
+/**
+ * Принимает один файл (или пустую папку) из браузера. `path` — относительный путь внутри
+ * `directory`; файл пишется во временный файл и публикуется без перезаписи.
+ */
+export async function uploadProjectEntry(root, directory, path, body, options = {}) {
+    const parts = path.split("/");
+    if (!path || parts.some((part) => !part) || path.includes("\\"))
+        throw new HttpError(400, "Некорректный путь файла");
+    const parent = await targetDirectory(root, directory);
+    const name = parts.pop();
+    await validateEntryName(name);
+    const folder = await ensureDirectories(parent, parts);
+    const destination = [directory, ...parts, name].filter(Boolean).join("/");
+    const target = resolve(folder, name);
+    if (options.directory) {
+        body.resume();
+        try {
+            await mkdir(target);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (!(await lstat(target)).isDirectory())
+                throw new HttpError(409, `«${name}» уже существует и не является папкой`);
+        }
+        return { destination };
+    }
+    if (await exists(target)) {
+        body.resume();
+        throw new HttpError(409, `В папке назначения уже есть «${name}»`);
+    }
+    const limit = options.limit ?? MAX_UPLOAD_BYTES;
+    const temporary = resolve(folder, `.projector-${randomUUID()}.tmp`);
+    let size = 0;
+    try {
+        await pipeline(body, new Transform({
+            transform(chunk, _encoding, done) {
+                size += chunk.length;
+                done(size > limit ? new HttpError(413, "Файл слишком большой для загрузки") : null, chunk);
+            },
+        }), createWriteStream(temporary, { flags: "wx", mode: 0o644 }));
+        try {
+            await os.tools.moveNoReplace(temporary, target);
+        }
+        catch (error) {
+            if (!(await exists(target)))
+                throw error;
+        }
+        if (await exists(temporary))
+            throw new HttpError(409, `В папке назначения уже есть «${name}»`);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { destination };
+}

package/packages/server/modules/workspace/index.js

@@ -0,0 +1,15 @@
+export { listProjectDirectory, readProjectFile, saveProjectFile, readProjectImage, previewProjectFile, moveProjectEntry, mutateProjectEntry, } from "./files.js";
+export { checkImportNames, clearImportNames, importProjectEntries, uploadProjectEntry, } from "./import.js";
+export { revealProjectEntry } from "./reveal.js";
+export { watchProject, bindWorkspaceEvents } from "./watcher.js";
+export { openProjectSiteFile } from "./site.js";
+export { searchProject, searchProjectGit } from "./search.js";
+export { findProjectPaths } from "./find-paths.js";
+export { projectGit, projectGithubRepository, projectGitlabRepository, projectComparison, projectGutter, mutateProjectGit, } from "./git.js";
+export { projectBranches, mutateProjectBranch } from "./git-branches.js";
+export { mutateProjectSync } from "./git-sync.js";
+export { previewExternalFile, readExternalImage } from "./external-files.js";
+export { projectLog, projectCommit, projectCommitComparison } from "./git-history.js";
+export { listProjectGitTree, readProjectGitFile, readProjectGitImage } from "./git-tree.js";
+export { compareProjectChanges, compareProjectFile } from "./git-compare.js";
+export { readFilesExclude, writeFilesExclude, excludePatterns, pathIsExcluded, withFilesExclude, } from "./files-exclude.js";

package/packages/server/modules/workspace/paths.js

@@ -0,0 +1,38 @@
+import { execFile } from "node:child_process";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { realpath } from "node:fs/promises";
+import { promisify } from "node:util";
+import { HttpError } from "../http/index.js";
+import { excludePatterns, pathIsExcluded } from "./files-exclude.js";
+export const exec = promisify(execFile);
+export const MAX_BYTES = 1024 * 1024;
+export { excludePatterns, pathIsExcluded };
+export function within(root, path) {
+    const rel = relative(root, path);
+    return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+export function validatePath(path) {
+    if (isAbsolute(path) || path.split(/[\\/]/).includes("..") || path.includes("\0"))
+        throw new HttpError(403, "Путь должен находиться внутри проекта");
+}
+export async function location(root, path) {
+    validatePath(path);
+    const base = await realpath(root);
+    const full = await realpath(resolve(base, path));
+    if (!within(base, full))
+        throw new HttpError(403, "Путь выходит за пределы проекта");
+    return full;
+}
+export function decode(buffer) {
+    if (buffer.includes(0))
+        throw new HttpError(415, "Бинарный файл — просмотр текста недоступен");
+    return buffer.toString("utf8");
+}
+export async function pathExcluded(path) {
+    if (!path || path.split("/").some((part) => !part || part === "."))
+        return true;
+    return pathIsExcluded(path);
+}
+export async function nameExcluded(name) {
+    return pathIsExcluded(name);
+}

package/packages/server/modules/workspace/reveal.js

@@ -0,0 +1,14 @@
+import { os } from "../../../core/modules/os/index.js";
+import { HttpError } from "../http/index.js";
+import { location } from "./paths.js";
+/**
+ * Shows a project entry in the file manager of the machine running the server. The path is
+ * resolved inside the project first, so the tree cannot reveal arbitrary disk locations.
+ */
+export async function revealProjectEntry(root, path) {
+    if (path.includes("\\"))
+        throw new HttpError(403, "Некорректный путь");
+    const full = await location(root, path);
+    await os.revealInFileManager(full);
+    return { path };
+}

package/packages/server/modules/workspace/search.js

@@ -0,0 +1,136 @@
+import { os } from "../../../core/modules/os/index.js";
+import { realpath } from "node:fs/promises";
+import { HttpError } from "../http/index.js";
+import { MAX_BYTES, excludePatterns } from "./paths.js";
+import { git } from "./git.js";
+import { resolveRevision } from "./git-tree.js";
+import { isExcludedPath, searchMatches, } from "../../../core/modules/workspace/index.js";
+export async function searchProject(root, query, options = {}) {
+    if (!query.trim())
+        return { hits: [], truncated: false };
+    if (query.length > 200)
+        throw new HttpError(400, "Запрос длиннее 200 символов");
+    const base = await realpath(root);
+    let output;
+    try {
+        const args = [
+            "--json",
+            "--hidden",
+            "--no-require-git",
+            "--max-count",
+            "5",
+            "--max-filesize",
+            "1M",
+        ];
+        if (!options.regex)
+            args.push("--fixed-strings");
+        args.push(options.caseSensitive ? "--case-sensitive" : "--ignore-case");
+        if (options.wholeWord)
+            args.push("--word-regexp");
+        for (const pattern of await excludePatterns()) {
+            args.push("--glob", `!${pattern}`);
+            if (!pattern.endsWith("/**"))
+                args.push("--glob", `!${pattern}/**`);
+        }
+        args.push("--", query, ".");
+        const result = await os.tools.searchFiles(args, {
+            cwd: base,
+            maxBuffer: 4 * MAX_BYTES,
+            timeout: 10000,
+        });
+        output = result.stdout;
+    }
+    catch (error) {
+        const failure = error;
+        if (failure.code === 1)
+            return { hits: [], truncated: false };
+        if (failure.code === "ENOENT")
+            throw new HttpError(503, "Для поиска нужен ripgrep (rg)");
+        throw new HttpError(400, "Поиск слишком большой или недоступен. Уточните запрос.");
+    }
+    const hits = [];
+    for (const row of output.split("\n")) {
+        if (!row)
+            continue;
+        const event = JSON.parse(row);
+        if (event.type !== "match" || !event.data.path.text || !event.data.lines.text)
+            continue;
+        const data = event.data;
+        const lineText = data.lines.text;
+        const text = lineText.trimEnd().slice(0, 500);
+        const charOffset = (byte) => Buffer.from(lineText).subarray(0, byte).toString("utf8").length;
+        const matches = [];
+        for (const submatch of data.submatches ?? []) {
+            const start = charOffset(submatch.start);
+            if (start >= text.length)
+                continue;
+            matches.push({ start, end: Math.min(charOffset(submatch.end), text.length) });
+        }
+        hits.push({
+            path: (os.platform === "win32"
+                ? data.path.text.replaceAll("\\", "/")
+                : data.path.text).replace(/^\.\//, ""),
+            line: data.line_number,
+            column: charOffset(data.submatches?.[0]?.start ?? 0) + 1,
+            text,
+            matches,
+        });
+        if (hits.length > 200)
+            break;
+    }
+    return { hits: hits.slice(0, 200), truncated: hits.length > 200 };
+}
+/** Search a committed tree with `git grep`; paths stay relative to the project folder. */
+export async function searchProjectGit(root, rev, query, options = {}) {
+    if (!query.trim())
+        return { hits: [], truncated: false };
+    if (query.length > 200)
+        throw new HttpError(400, "Запрос длиннее 200 символов");
+    const commit = await resolveRevision(root, rev);
+    const args = ["grep", "-n", "-I", "-z", options.regex ? "-E" : "-F"];
+    if (!options.caseSensitive)
+        args.push("-i");
+    if (options.wholeWord)
+        args.push("-w");
+    args.push("-e", query, commit, "--");
+    let output;
+    try {
+        output = await git(root, args, 4 * MAX_BYTES);
+    }
+    catch (error) {
+        const failure = error;
+        if (failure.code === 1)
+            return { hits: [], truncated: false };
+        throw new HttpError(400, "Поиск по снимку недоступен. Уточните запрос.");
+    }
+    const patterns = await excludePatterns();
+    const hits = [];
+    for (const row of output.split("\n")) {
+        if (!row)
+            continue;
+        const first = row.indexOf("\0");
+        const second = row.indexOf("\0", first + 1);
+        if (first < 0 || second < 0)
+            continue;
+        const location = row.slice(0, first);
+        const line = Number(row.slice(first + 1, second));
+        const colon = location.indexOf(":");
+        if (colon < 0 || !Number.isSafeInteger(line) || line < 1)
+            continue;
+        const path = location.slice(colon + 1);
+        if (!path || isExcludedPath(path, patterns))
+            continue;
+        const text = row.slice(second + 1).slice(0, 500);
+        const matches = searchMatches(text, query, options);
+        hits.push({
+            path,
+            line,
+            column: (matches[0]?.start ?? 0) + 1,
+            text,
+            matches,
+        });
+        if (hits.length > 200)
+            break;
+    }
+    return { hits: hits.slice(0, 200), truncated: hits.length > 200 };
+}

package/packages/server/modules/workspace/site.js

@@ -0,0 +1,62 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { HttpError } from "../http/index.js";
+import { location } from "./paths.js";
+const TYPES = {
+    html: "text/html; charset=utf-8",
+    htm: "text/html; charset=utf-8",
+    xhtml: "application/xhtml+xml; charset=utf-8",
+    css: "text/css; charset=utf-8",
+    js: "text/javascript; charset=utf-8",
+    mjs: "text/javascript; charset=utf-8",
+    json: "application/json; charset=utf-8",
+    map: "application/json; charset=utf-8",
+    txt: "text/plain; charset=utf-8",
+    xml: "application/xml; charset=utf-8",
+    svg: "image/svg+xml",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    wasm: "application/wasm",
+    pdf: "application/pdf",
+};
+/**
+ * Файл проекта для просмотра как части сайта. Каталог без завершающего `/` возвращает
+ * `redirect`: относительные ссылки документа резолвятся от адреса со слэшем.
+ */
+export async function openProjectSiteFile(root, path) {
+    if (path.split("/").includes(".git"))
+        throw new HttpError(403, "Каталог .git недоступен");
+    let full = await location(root, path).catch((error) => {
+        if (error.code === "ENOENT")
+            throw new HttpError(404, "Файл не найден");
+        throw error;
+    });
+    let info = await stat(full);
+    if (info.isDirectory()) {
+        if (path && !path.endsWith("/"))
+            return { redirect: true };
+        full = await location(root, join(path, "index.html")).catch(() => {
+            throw new HttpError(404, "В каталоге нет index.html");
+        });
+        info = await stat(full);
+    }
+    if (!info.isFile())
+        throw new HttpError(400, "Выберите файл");
+    const type = TYPES[full.split(".").at(-1)?.toLowerCase() ?? ""] ?? "application/octet-stream";
+    return { type, size: info.size, stream: createReadStream(full) };
+}

package/packages/server/modules/workspace/watcher.js

@@ -0,0 +1,176 @@
+import { watch } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { posix, resolve } from "node:path";
+import { broadcastEvent, onEventClientClose } from "../events/index.js";
+import { pathExcluded, validatePath, within } from "./paths.js";
+// Vite reloads the API modules without closing watchers: keep them across reloads.
+const host = globalThis;
+const registry = (host.projectorFileWatch ??= {
+    clients: new Map(),
+    directories: new Map(),
+    bound: false,
+});
+/** The watcher registry survives HMR; its page-close callback has an explicit owner. */
+export function bindWorkspaceEvents() {
+    registry.off?.();
+    const off = onEventClientClose((id) => {
+        registry.clients.delete(id);
+        void reconcile();
+    });
+    registry.off = off;
+    registry.bound = true;
+    return () => {
+        off();
+        if (registry.off === off)
+            registry.off = undefined;
+    };
+}
+const DEBOUNCE_MS = 60;
+const LISTING_DEBOUNCE_MS = 150;
+const MAX_FILES = 200;
+const MAX_DIRECTORIES = 300;
+function closeDirectory(key) {
+    const entry = registry.directories.get(key);
+    if (!entry)
+        return;
+    registry.directories.delete(key);
+    entry.watcher.close();
+    for (const timer of entry.timers.values())
+        clearTimeout(timer);
+}
+function schedule(entry, id, delay, send) {
+    clearTimeout(entry.timers.get(id));
+    entry.timers.set(id, setTimeout(() => {
+        entry.timers.delete(id);
+        send();
+    }, delay));
+}
+function changed(entry, name) {
+    const fileChanged = (path) => schedule(entry, `f:${path}`, DEBOUNCE_MS, () => broadcastEvent("file-changed", { projectId: entry.projectId, path }));
+    if (entry.listed)
+        schedule(entry, "d", LISTING_DEBOUNCE_MS, () => broadcastEvent("dir-changed", { projectId: entry.projectId, directory: entry.directory }));
+    if (name === undefined)
+        return void entry.files.forEach(fileChanged);
+    const path = posix.join(entry.directory, name);
+    if (entry.files.has(path))
+        fileChanged(path);
+}
+/** Running out of inotify watches is the one failure the user can fix: tell the pages. */
+function reportFailure(projectId, error) {
+    const code = error?.code;
+    if (code === "ENOSPC" || code === "EMFILE")
+        broadcastEvent("watch-error", {
+            projectId,
+            message: "Не удалось следить за файлами: исчерпан лимит наблюдателей ОС (fs.inotify.max_user_watches)",
+        });
+}
+/** Opens the directory watchers that the pages need and closes the ones nobody needs. */
+async function reconcile() {
+    const wanted = new Map();
+    const want = (projectId, root, directory) => {
+        const key = `${projectId}\0${directory}`;
+        const item = wanted.get(key) ?? {
+            projectId,
+            root,
+            directory,
+            files: new Set(),
+            listed: false,
+        };
+        wanted.set(key, item);
+        return item;
+    };
+    for (const projects of registry.clients.values())
+        for (const [projectId, { root, paths, directories }] of projects) {
+            for (const path of paths) {
+                const directory = posix.dirname(path) === "." ? "" : posix.dirname(path);
+                want(projectId, root, directory).files.add(path);
+            }
+            for (const directory of directories)
+                want(projectId, root, directory).listed = true;
+        }
+    for (const key of [...registry.directories.keys()])
+        if (!wanted.has(key))
+            closeDirectory(key);
+    for (const [key, item] of wanted) {
+        const current = registry.directories.get(key);
+        if (current) {
+            current.files = item.files;
+            current.listed = item.listed;
+            continue;
+        }
+        try {
+            const base = await realpath(item.root);
+            const full = await realpath(resolve(base, item.directory));
+            if (!within(base, full) && full !== base)
+                continue;
+            const entry = {
+                projectId: item.projectId,
+                directory: item.directory,
+                files: item.files,
+                listed: item.listed,
+                timers: new Map(),
+                watcher: watch(full, { persistent: false }, (_type, name) => {
+                    const file = name ? String(name) : undefined;
+                    // Own temporary files of atomic saves, and everything the project hides.
+                    if (file?.startsWith(".projector-"))
+                        return;
+                    if (file && entry.listed && !entry.files.has(posix.join(entry.directory, file)))
+                        void pathExcluded(posix.join(entry.directory, file)).then((hidden) => hidden || changed(entry, file), () => changed(entry, file));
+                    else
+                        changed(entry, file);
+                }),
+            };
+            entry.watcher.on("error", (error) => {
+                closeDirectory(key);
+                reportFailure(item.projectId, error);
+            });
+            registry.directories.set(key, entry);
+        }
+        catch (error) {
+            // The folder is gone or unreadable: the page learns about it when it re-reads the listing.
+            reportFailure(item.projectId, error);
+        }
+    }
+}
+function checked(values, limit, allowRoot) {
+    const result = new Set();
+    for (const value of values.slice(0, limit)) {
+        if (typeof value !== "string" || value.includes("\\"))
+            continue;
+        if (allowRoot && value === "")
+            result.add(value);
+        else if (value) {
+            validatePath(value);
+            result.add(value);
+        }
+    }
+    return result;
+}
+/**
+ * Replaces what a page shows in a project: the open files (`paths`) and the folders expanded
+ * in the tree (`directories`); a field that is left out stays as it was.
+ * The pages get `file-changed` and `dir-changed` events.
+ */
+export async function watchProject(clientId, projectId, root, patch) {
+    if (!registry.off)
+        bindWorkspaceEvents();
+    const projects = registry.clients.get(clientId) ?? new Map();
+    const current = projects.get(projectId) ?? {
+        root,
+        paths: new Set(),
+        directories: new Set(),
+    };
+    if (patch.paths)
+        current.paths = checked(patch.paths, MAX_FILES, false);
+    if (patch.directories)
+        current.directories = checked(patch.directories, MAX_DIRECTORIES, true);
+    if (current.paths.size || current.directories.size)
+        projects.set(projectId, current);
+    else
+        projects.delete(projectId);
+    if (projects.size)
+        registry.clients.set(clientId, projects);
+    else
+        registry.clients.delete(clientId);
+    await reconcile();
+}

package/packages/server/routes/api/agent-answer-repair.js

@@ -0,0 +1,35 @@
+import { accessAllowed } from "../../modules/access/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { repairAnswer } from "../../modules/agents/projector/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** One asynchronous Answer Doctor turn: the page validates the result and may ask again. */
+export const routes = [
+    {
+        method: "POST",
+        path: "/api/agent/answer-repair",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Восстановление ответа доступно только со страницы Projector");
+            const body = await readBody(req);
+            const answer = asString(body.answer);
+            const error = asString(body.error);
+            if (!answer.trim())
+                throw new Error("Не передан ответ для восстановления");
+            const selection = body.selection && typeof body.selection === "object" && !Array.isArray(body.selection)
+                ? Object.fromEntries(Object.entries(body.selection)
+                    .filter(([, value]) => typeof value === "string")
+                    .slice(0, 20))
+                : undefined;
+            const abort = new AbortController();
+            res.on("close", () => abort.abort());
+            const repaired = await repairAnswer({
+                answer,
+                error,
+                history: asString(body.history),
+                selection,
+                signal: abort.signal,
+            });
+            json(res, 200, { answer: repaired });
+        },
+    },
+];