@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/routes/api/projects/[id]/index.js

@@ -0,0 +1,240 @@
+import { mkdir, stat } from "node:fs/promises";
+import { getSnapshot, startProject, stopProject } from "../../../../modules/processes/index.js";
+import { loadProjects, findProject, expandPath, sameLocalPath, updateProjects, resolveProjectIcon, } from "../../../../modules/projects/index.js";
+import { projectAppUrl } from "../../../../../core/modules/app-paths/index.js";
+import { HttpError } from "../../../../modules/http/index.js";
+import { isLocalRequest } from "../../../../modules/access/index.js";
+import { devcontainerState, decideDevcontainer, stopDevcontainer, } from "../../../../modules/devcontainer/index.js";
+import { openBrowser, openWindow } from "../../../../modules/window/index.js";
+import { closeProjectTerminals } from "../../../../modules/terminal/index.js";
+import { projectGithubRepository, projectGitlabRepository, } from "../../../../modules/workspace/index.js";
+import { json, readBody, asString, } from "../../../../modules/transport/index.js";
+import { parseMode, normalizeProject, withRuntime, sendIconFile, sendLetterIcon, launchHtml, } from "../../../../modules/project-presentation/index.js";
+async function requireProject({ res, params }) {
+    const project = await findProject(params.id);
+    if (!project)
+        json(res, 404, { error: "Проект не найден" });
+    return project;
+}
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/projects/:id",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (project)
+                json(context.res, 200, { project: withRuntime(project) });
+        },
+    },
+    {
+        method: "PATCH",
+        path: "/api/projects/:id",
+        handler: async ({ req, res, params }) => {
+            const project = await requireProject({ res, params });
+            if (!project)
+                return;
+            const body = await readBody(req);
+            const next = normalizeProject({ ...project, ...body }, project);
+            await updateProjects((current) => {
+                const currentIndex = current.findIndex((item) => item.id === params.id);
+                if (currentIndex === -1)
+                    throw new HttpError(404, "Проект не найден");
+                current[currentIndex] = next;
+            });
+            json(res, 200, { project: withRuntime(next) });
+        },
+    },
+    {
+        method: "DELETE",
+        path: "/api/projects/:id",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            stopProject(context.params.id);
+            closeProjectTerminals(context.params.id);
+            await updateProjects((current) => {
+                const currentIndex = current.findIndex((item) => item.id === context.params.id);
+                if (currentIndex !== -1)
+                    current.splice(currentIndex, 1);
+            });
+            json(context.res, 200, { ok: true });
+        },
+    },
+    {
+        // Recovery of a project whose folder is gone: recreate it or point the project elsewhere.
+        method: "POST",
+        path: "/api/projects/:id/directory",
+        handler: async ({ req, res, params }) => {
+            const project = await requireProject({ res, params });
+            if (!project)
+                return;
+            const body = await readBody(req);
+            const isDirectory = (dir) => stat(dir).then((info) => info.isDirectory(), () => false);
+            const mode = asString(body.mode);
+            if (mode !== "create" && mode !== "relocate")
+                throw new HttpError(400, "mode: create или relocate");
+            const target = expandPath(mode === "create" ? project.path : asString(body.path));
+            if (mode === "relocate" && !asString(body.path).trim())
+                throw new HttpError(400, "Укажите новый путь");
+            if (mode === "relocate" && !(await isDirectory(target))) {
+                if (body.create !== true)
+                    throw new HttpError(400, "Папка не найдена");
+            }
+            if (!(await isDirectory(target))) {
+                const existing = await stat(target).catch(() => null);
+                if (existing)
+                    throw new HttpError(400, "Путь занят файлом");
+                await mkdir(target, { recursive: true });
+            }
+            if (mode === "relocate" && !sameLocalPath(project.path, target)) {
+                const duplicate = (await loadProjects()).find((item) => item.id !== params.id && sameLocalPath(item.path, target));
+                if (duplicate)
+                    throw new HttpError(409, `Путь уже занят проектом «${duplicate.name}»`);
+                stopProject(params.id);
+                closeProjectTerminals(params.id);
+                await updateProjects((current) => {
+                    const item = current.find((entry) => entry.id === params.id);
+                    if (!item)
+                        throw new HttpError(404, "Проект не найден");
+                    item.path = target;
+                });
+            }
+            json(res, 200, { project: withRuntime({ ...project, path: target }) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/projects/:id/start",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            const body = await readBody(context.req);
+            const runtime = startProject(project, asString(body.commandId) || undefined, parseMode(body.mode));
+            json(context.res, 200, { runtime });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/projects/:id/stop",
+        handler: async (context) => {
+            if (!(await requireProject(context)))
+                return;
+            json(context.res, 200, { runtime: stopProject(context.params.id) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/projects/:id/open",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            const body = await readBody(context.req);
+            const runtime = getSnapshot(context.params.id);
+            const target = runtime.url || project.url;
+            if (!target)
+                throw new Error("Нет адреса для открытия");
+            if (parseMode(body.mode) === "window")
+                openWindow(projectAppUrl(context.params.id));
+            else
+                openBrowser(target);
+            json(context.res, 200, { ok: true, url: target });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/projects/:id/github",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            context.res.setHeader("Cache-Control", "no-store");
+            json(context.res, 200, {
+                repository: project.environment ? null : await projectGithubRepository(project.path),
+            });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/projects/:id/gitlab",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            context.res.setHeader("Cache-Control", "no-store");
+            json(context.res, 200, {
+                repository: project.environment ? null : await projectGitlabRepository(project.path),
+            });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/projects/:id/devcontainer",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            context.res.setHeader("Cache-Control", "no-store");
+            json(context.res, 200, devcontainerState(project));
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/projects/:id/devcontainer",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            // Trust is granted at the keyboard of this machine: never over LAN, never by the agent.
+            if (!isLocalRequest(context.req))
+                throw new HttpError(403, "Доверие к репозиторию задаётся только на локальной машине");
+            const body = await readBody(context.req);
+            if (body.decision !== "trusted" && body.decision !== "declined" && body.decision !== "forget")
+                throw new HttpError(400, "decision: trusted, declined или forget");
+            json(context.res, 200, await decideDevcontainer(project, body.decision, body.hash));
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/projects/:id/devcontainer-stop",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            json(context.res, 200, await stopDevcontainer(project));
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/projects/:id/icon",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            const file = await resolveProjectIcon(project.path, project.icon);
+            if (file)
+                sendIconFile(context.res, file);
+            else
+                sendLetterIcon(context.res, project.name);
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/projects/:id/app",
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            const runtime = getSnapshot(context.params.id);
+            const target = runtime.url || project.url;
+            if (!target)
+                throw new Error("Нет адреса для открытия");
+            context.res.statusCode = 200;
+            context.res.setHeader("Content-Type", "text/html; charset=utf-8");
+            context.res.setHeader("Cache-Control", "no-store");
+            context.res.end(launchHtml(project, target));
+        },
+    },
+];

package/packages/server/routes/api/projects/[id]/site.js

@@ -0,0 +1,59 @@
+import { pipeline } from "node:stream/promises";
+import { findProject } from "../../../../modules/projects/index.js";
+import { HttpError } from "../../../../modules/http/index.js";
+import { json } from "../../../../modules/transport/index.js";
+import { accessAllowed } from "../../../../modules/access/index.js";
+import { openProjectSiteFile } from "../../../../modules/workspace/index.js";
+const sitePath = "/api/projects/:id/site/**";
+/**
+ * Файлы проекта по обычным путям, чтобы относительные ссылки HTML-документа работали
+ * без переписывания. Документ исполняется в песочнице без origin Projector: его скрипты
+ * не получают доступ к API (терминалы, запись файлов).
+ */
+export const routes = [
+    {
+        method: ["GET", "HEAD"],
+        path: sitePath,
+        handler: async ({ req, res, url, method, path, params }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Просмотр доступен только со страницы Projector");
+            const project = await findProject(decodeURIComponent(params.id));
+            if (!project) {
+                json(res, 404, { error: "Проект не найден" });
+                return;
+            }
+            let relative;
+            try {
+                relative = (params["0"] ?? "").split("/").map(decodeURIComponent).join("/");
+            }
+            catch {
+                throw new HttpError(400, "Некорректный путь");
+            }
+            const file = await openProjectSiteFile(project.path, relative);
+            if ("redirect" in file) {
+                res.writeHead(307, { Location: `${path}/${url.search}` }).end();
+                return;
+            }
+            res.setHeader("Cache-Control", "no-store");
+            res.setHeader("X-Content-Type-Options", "nosniff");
+            // Cross-origin for the opaque sandbox origin: fonts, modules and fetch() need CORS.
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Content-Security-Policy", "sandbox allow-scripts allow-forms allow-popups allow-modals");
+            res.setHeader("Content-Type", file.type);
+            res.setHeader("Content-Length", file.size);
+            if (method === "HEAD") {
+                file.stream.destroy();
+                res.end();
+                return;
+            }
+            await pipeline(file.stream, res).catch(() => res.destroy());
+        },
+    },
+    {
+        method: "",
+        path: sitePath,
+        handler: () => {
+            throw new HttpError(405, "Допустим только GET");
+        },
+    },
+];

package/packages/server/routes/api/projects/[id]/terminals.js

@@ -0,0 +1,38 @@
+import { findProject } from "../../../../modules/projects/index.js";
+import { HttpError } from "../../../../modules/http/index.js";
+import { json, readBody, } from "../../../../modules/transport/index.js";
+import { uploadTerminalFile } from "../../../../modules/terminal/index.js";
+import { terminalControl } from "../../../../modules/terminal-control/index.js";
+import { accessAllowed } from "../../../../modules/access/index.js";
+/** HTTP compatibility and binary upload; the browser controls sessions over WS. */
+async function control({ req, res, url, method, params }, sessionId) {
+    const body = method === "GET" ? {} : await readBody(req);
+    const result = await terminalControl(params.id, method, sessionId, body, url.searchParams.get("link") ?? undefined);
+    res.setHeader("Cache-Control", "no-store");
+    json(res, result.error ? 409 : method === "POST" && (!sessionId || body.action === "restart") ? 201 : 200, result);
+}
+export const routes = [
+    {
+        method: "PUT",
+        path: "/api/projects/:id/terminals/:sessionId",
+        handler: async ({ req, res, url, params }) => {
+            if (!(await findProject(params.id)))
+                throw new HttpError(404, "Проект не найден");
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Загрузка доступна только со страницы Projector");
+            json(res, 201, {
+                path: await uploadTerminalFile(params.id, params.sessionId, req, url.searchParams.get("name") ?? ""),
+            });
+        },
+    },
+    {
+        method: ["GET", "POST", "DELETE"],
+        path: "/api/projects/:id/terminals",
+        handler: (context) => control(context),
+    },
+    {
+        method: ["GET", "POST", "DELETE"],
+        path: "/api/projects/:id/terminals/:sessionId",
+        handler: (context) => control(context, context.params.sessionId),
+    },
+];

package/packages/server/routes/api/projects/[id]/workspace-read.js

@@ -0,0 +1,126 @@
+import { findProject } from "../../../../modules/projects/index.js";
+import { HttpError } from "../../../../modules/http/index.js";
+import { json, } from "../../../../modules/transport/index.js";
+import { accessAllowed } from "../../../../modules/access/index.js";
+import { listProjectDirectory, previewExternalFile, readExternalImage, previewProjectFile, searchProject, searchProjectGit, findProjectPaths, projectGit, projectComparison, projectGutter, projectLog, projectBranches, projectCommit, projectCommitComparison, listProjectGitTree, readProjectGitFile, readProjectGitImage, compareProjectChanges, compareProjectFile, readProjectImage, } from "../../../../modules/workspace/index.js";
+async function requireProject({ res, params }) {
+    const project = await findProject(params.id);
+    if (!project)
+        json(res, 404, { error: "Проект не найден" });
+    return project;
+}
+const text = (url, key) => url.searchParams.get(key) ?? "";
+const params = (url) => Object.fromEntries(url.searchParams);
+function route(method, path, access, message, handler) {
+    return {
+        method,
+        path,
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            if (!accessAllowed(context.req, access))
+                throw new HttpError(403, message);
+            await handler(context, project);
+        },
+    };
+}
+const view = (path, handler) => route("GET", path, false, "Обзор доступен только со страницы Projector", async (context, project) => {
+    context.res.setHeader("Cache-Control", "no-store");
+    await handler(context, project);
+});
+async function sendAsset(context, project, external) {
+    const filePath = context.url.searchParams.get("path") ?? "";
+    const rev = context.url.searchParams.get("rev") ?? "";
+    const image = external
+        ? await readExternalImage(filePath)
+        : rev
+            ? await readProjectGitImage(project.path, rev, filePath)
+            : await readProjectImage(project.path, filePath);
+    context.res.setHeader("Content-Type", image.type);
+    context.res.setHeader("X-Content-Type-Options", "nosniff");
+    context.res.setHeader("Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'");
+    context.res.end(image.content);
+}
+export const routes = [
+    view("/api/projects/:id/workspace/asset", (context, project) => sendAsset(context, project, false)),
+    view("/api/projects/:id/workspace/external-asset", (context, project) => sendAsset(context, project, true)),
+    view("/api/projects/:id/workspace/external", async ({ res, url }) => {
+        json(res, 200, await previewExternalFile(text(url, "path"), { ask: text(url, "ask") === "1" }));
+    }),
+    view("/api/projects/:id/workspace/root", ({ res }, project) => {
+        json(res, 200, { root: project.path });
+    }),
+    view("/api/projects/:id/workspace/tree", async ({ res, url }, project) => {
+        const path = text(url, "path");
+        json(res, 200, text(url, "rev")
+            ? await listProjectGitTree(project.path, text(url, "rev"), path, params(url))
+            : await listProjectDirectory(project.path, path, params(url)));
+    }),
+    view("/api/projects/:id/workspace/file", async ({ res, url }, project) => {
+        const path = text(url, "path");
+        const rev = text(url, "rev");
+        const ask = text(url, "ask") === "1";
+        json(res, 200, rev
+            ? await readProjectGitFile(project.path, rev, path, { ask })
+            : await previewProjectFile(project.path, path, { ask }));
+    }),
+    view("/api/projects/:id/workspace/changes", async ({ res, url }, project) => {
+        const from = text(url, "from");
+        const to = text(url, "to");
+        if (!from || !to)
+            throw new HttpError(400, "Укажите оба снимка для сравнения");
+        json(res, 200, await compareProjectChanges(project.path, from, to));
+    }),
+    view("/api/projects/:id/workspace/compare-file", async ({ res, url }, project) => {
+        const path = text(url, "path");
+        const from = text(url, "from");
+        const to = text(url, "to");
+        if (!from || !to)
+            throw new HttpError(400, "Укажите оба снимка для сравнения");
+        json(res, 200, await compareProjectFile(project.path, from, to, path, url.searchParams.get("originalPath") || path));
+    }),
+    view("/api/projects/:id/workspace/search", async ({ res, url }, project) => {
+        const rev = text(url, "rev");
+        const options = {
+            caseSensitive: text(url, "case") === "true",
+            wholeWord: text(url, "word") === "true",
+            regex: text(url, "regex") === "true",
+        };
+        json(res, 200, rev
+            ? await searchProjectGit(project.path, rev, text(url, "q"), options)
+            : await searchProject(project.path, text(url, "q"), options));
+    }),
+    view("/api/projects/:id/workspace/paths", async ({ res, url }, project) => {
+        json(res, 200, { paths: await findProjectPaths(project.path, text(url, "q")) });
+    }),
+    view("/api/projects/:id/workspace/git", async ({ res }, project) => {
+        json(res, 200, await projectGit(project.path));
+    }),
+    view("/api/projects/:id/workspace/branches", async ({ res }, project) => {
+        json(res, 200, await projectBranches(project.path));
+    }),
+    view("/api/projects/:id/workspace/log", async ({ res, url }, project) => {
+        json(res, 200, await projectLog(project.path, {
+            skip: Number(text(url, "skip")) || 0,
+            limit: Number(text(url, "limit")) || undefined,
+            query: text(url, "q"),
+            all: text(url, "all") === "true",
+        }));
+    }),
+    view("/api/projects/:id/workspace/commit", async ({ res, url }, project) => {
+        json(res, 200, await projectCommit(project.path, text(url, "hash")));
+    }),
+    view("/api/projects/:id/workspace/commit-diff", async ({ res, url }, project) => {
+        json(res, 200, await projectCommitComparison(project.path, text(url, "hash"), text(url, "path")));
+    }),
+    view("/api/projects/:id/workspace/gutter", async ({ res, url }, project) => {
+        json(res, 200, await projectGutter(project.path, text(url, "path")));
+    }),
+    view("/api/projects/:id/workspace/diff", async ({ res, url }, project) => {
+        json(res, 200, await projectComparison(project.path, text(url, "path"), text(url, "staged") === "true"));
+    }),
+    view("/api/projects/:id/workspace/:session", ({ res }) => {
+        json(res, 404, { error: "Не найден" });
+    }),
+];

package/packages/server/routes/api/projects/[id]/workspace.js

@@ -0,0 +1,147 @@
+import { findProject } from "../../../../modules/projects/index.js";
+import { HttpError } from "../../../../modules/http/index.js";
+import { json, readBody, } from "../../../../modules/transport/index.js";
+import { accessAllowed, isLocalRequest } from "../../../../modules/access/index.js";
+import { mutateProjectBranch, mutateProjectGit, mutateProjectSync, moveProjectEntry, mutateProjectEntry, saveProjectFile, checkImportNames, clearImportNames, importProjectEntries, uploadProjectEntry, revealProjectEntry, watchProject, } from "../../../../modules/workspace/index.js";
+async function requireProject({ res, params }) {
+    const project = await findProject(params.id);
+    if (!project)
+        json(res, 404, { error: "Проект не найден" });
+    return project;
+}
+function route(method, path, access, message, handler) {
+    return {
+        method,
+        path,
+        handler: async (context) => {
+            const project = await requireProject(context);
+            if (!project)
+                return;
+            if (!accessAllowed(context.req, access))
+                throw new HttpError(403, message);
+            await handler(context, project);
+        },
+    };
+}
+const mutation = (method, path, message, handler) => route(method, path, true, message, handler);
+export const routes = [
+    mutation("PUT", "/api/projects/:id/workspace/file", "Сохранение доступно только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        if (typeof body.path !== "string" ||
+            typeof body.content !== "string" ||
+            typeof body.original !== "string")
+            throw new HttpError(400, "Укажите путь, текст и исходное содержимое файла");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await saveProjectFile(project.path, body.path, body.content, body.original));
+    }),
+    route("PUT", "/api/projects/:id/workspace/watch", false, "Обзор доступен только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        const list = (value) => value === undefined ||
+            (Array.isArray(value) && value.every((item) => typeof item === "string"));
+        if (typeof body.client !== "string" ||
+            !body.client ||
+            !list(body.paths) ||
+            !list(body.directories))
+            throw new HttpError(400, "Укажите страницу, пути открытых файлов и раскрытые папки");
+        await watchProject(body.client, project.id, project.path, {
+            paths: body.paths,
+            directories: body.directories,
+        });
+        json(res, 200, { ok: true });
+    }),
+    mutation("POST", "/api/projects/:id/workspace/reveal", "Показ в проводнике доступен только со страницы Projector", async ({ req, res }, project) => {
+        if (!isLocalRequest(req))
+            throw new HttpError(403, "Показ в проводнике доступен только на этом компьютере");
+        const body = await readBody(req);
+        if (typeof body.path !== "string")
+            throw new HttpError(400, "Укажите путь");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await revealProjectEntry(project.path, body.path));
+    }),
+    mutation("POST", "/api/projects/:id/workspace/import", "Импорт доступен только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        const names = (value) => Array.isArray(value) && value.every((item) => typeof item === "string")
+            ? value
+            : undefined;
+        if (typeof body.directory !== "string")
+            throw new HttpError(400, "Укажите папку назначения");
+        res.setHeader("Cache-Control", "no-store");
+        if (body.action === "check" || body.action === "clear") {
+            const list = names(body.names);
+            if (!list)
+                throw new HttpError(400, "Укажите имена записей");
+            json(res, 200, body.action === "check"
+                ? await checkImportNames(project.path, body.directory, list)
+                : (await clearImportNames(project.path, body.directory, list), { ok: true }));
+            return;
+        }
+        if (body.action === "copy") {
+            // Пути диска имеют смысл только на машине сервера: удалённая страница загружает файлы.
+            if (!isLocalRequest(req))
+                throw new HttpError(403, "Копирование по пути доступно только на этом компьютере");
+            const entries = body.entries;
+            if (!Array.isArray(entries) ||
+                !entries.every((entry) => entry && typeof entry.source === "string" && typeof entry.name === "string"))
+                throw new HttpError(400, "Укажите пути и имена записей");
+            json(res, 200, await importProjectEntries(project.path, body.directory, entries));
+            return;
+        }
+        throw new HttpError(400, "Неизвестное действие импорта");
+    }),
+    mutation("PUT", "/api/projects/:id/workspace/upload", "Загрузка доступна только со страницы Projector", async ({ req, res, url }, project) => {
+        const directory = url.searchParams.get("directory") ?? "";
+        const entry = url.searchParams.get("path") ?? "";
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await uploadProjectEntry(project.path, directory, entry, req, {
+            directory: url.searchParams.get("kind") === "directory",
+        }));
+    }),
+    mutation("POST", "/api/projects/:id/workspace/move", "Перенос доступен только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        if (typeof body.path !== "string" || typeof body.directory !== "string")
+            throw new HttpError(400, "Укажите файл и папку назначения");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await moveProjectEntry(project.path, body.path, body.directory));
+    }),
+    mutation("POST", "/api/projects/:id/workspace/entry", "Операции доступны только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        for (const key of ["action", "path", "directory", "name"])
+            if (typeof body[key] !== "string")
+                throw new HttpError(400, "Некорректные параметры операции");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await mutateProjectEntry(project.path, body.action, body.path, body.directory, body.name));
+    }),
+    mutation("POST", "/api/projects/:id/workspace/branch", "Операции доступны только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        for (const key of ["name", "newName", "from"])
+            if (body[key] !== undefined && typeof body[key] !== "string")
+                throw new HttpError(400, "Некорректные параметры ветки");
+        if (typeof body.action !== "string")
+            throw new HttpError(400, "Укажите действие с веткой");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await mutateProjectBranch(project.path, body.action, {
+            name: body.name,
+            newName: body.newName,
+            from: body.from,
+            checkout: body.checkout === false ? false : undefined,
+            force: body.force === true,
+        }));
+    }),
+    mutation("POST", "/api/projects/:id/workspace/sync", "Операции доступны только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        if (typeof body.action !== "string")
+            throw new HttpError(400, "Укажите действие синхронизации");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await mutateProjectSync(project.path, body.action));
+    }),
+    mutation("POST", "/api/projects/:id/workspace/git", "Операции доступны только со страницы Projector", async ({ req, res }, project) => {
+        const body = await readBody(req);
+        const paths = body.paths ?? body.path;
+        if (typeof body.action !== "string" ||
+            !(typeof paths === "string" ||
+                (Array.isArray(paths) && paths.every((path) => typeof path === "string"))))
+            throw new HttpError(400, "Укажите действие Git и пути файлов");
+        res.setHeader("Cache-Control", "no-store");
+        json(res, 200, await mutateProjectGit(project.path, body.action, paths));
+    }),
+];