@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/routes/api/docker.js

@@ -0,0 +1,74 @@
+import { dockerSnapshot, configureDocker, bindDocker, dockerAction, dockerLogs, startDockerDaemon, } from "../../modules/docker/index.js";
+import { findProject } from "../../modules/projects/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { json, readBody, } from "../../modules/transport/index.js";
+import { accessAllowed } from "../../modules/access/index.js";
+async function dockerContext(context) {
+    context.res.setHeader("Cache-Control", "no-store");
+    if (context.method !== "GET" && !accessAllowed(context.req, true))
+        throw new HttpError(403, "Docker-действия доступны со страницы Projector");
+    const projectId = context.url.searchParams.get("projectId");
+    const project = projectId ? await findProject(projectId) : undefined;
+    if (projectId && !project)
+        throw new HttpError(404, "Проект не найден");
+    return project;
+}
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/docker",
+        handler: async (context) => {
+            const project = await dockerContext(context);
+            json(context.res, 200, await dockerSnapshot(project ?? undefined, context.url.searchParams.get("context") ?? undefined));
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/docker/settings",
+        handler: async (context) => {
+            await dockerContext(context);
+            json(context.res, 200, await configureDocker(await readBody(context.req)));
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/docker/binding",
+        handler: async (context) => {
+            const project = await dockerContext(context);
+            if (!project)
+                throw new HttpError(400, "Укажите projectId");
+            json(context.res, 200, {
+                binding: await bindDocker(project.id, project.path, await readBody(context.req)),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/docker/action",
+        handler: async (context) => {
+            const project = await dockerContext(context);
+            if (!project)
+                throw new HttpError(400, "Укажите projectId");
+            json(context.res, 201, await dockerAction(project, await readBody(context.req)));
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/docker/daemon/start",
+        handler: async (context) => {
+            await dockerContext(context);
+            const body = (await readBody(context.req));
+            if (typeof body.context !== "string")
+                throw new HttpError(400, "Укажите Docker context");
+            json(context.res, 200, await startDockerDaemon(body.context));
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/docker/logs",
+        handler: async (context) => {
+            await dockerContext(context);
+            json(context.res, 200, await dockerLogs(context.url.searchParams.get("context") ?? "", context.url.searchParams.get("containerId") ?? ""));
+        },
+    },
+];

package/packages/server/routes/api/events.js

@@ -0,0 +1,25 @@
+import { attachSse, updateEventPages } from "../../modules/events/index.js";
+import { json, readBody } from "../../modules/transport/index.js";
+const ids = (value) => Array.isArray(value)
+    ? value.filter((id) => typeof id === "string" && !!id && id.length <= 100)
+    : [];
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/events",
+        handler: ({ req, res }) => {
+            attachSse(req, res);
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/events/pages",
+        handler: async ({ req, res }) => {
+            const body = await readBody(req);
+            const stream = typeof body.stream === "string" ? body.stream : "";
+            json(res, 200, {
+                ok: stream !== "" && updateEventPages(stream, ids(body.add), ids(body.remove)),
+            });
+        },
+    },
+];

package/packages/server/routes/api/health.js

@@ -0,0 +1,20 @@
+import { appUrl, readNetworkMode } from "../../../core/modules/app-paths/index.js";
+import { hasLanPassword, lanUrl } from "../../modules/access/index.js";
+import { json } from "../../modules/transport/index.js";
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/health",
+        handler: ({ res }) => {
+            const { projectorRuntimeMode: mode } = globalThis;
+            json(res, 200, {
+                ok: true,
+                app: "projector",
+                pid: process.pid,
+                url: appUrl(),
+                mode,
+                network: { mode: readNetworkMode(), passwordRequired: hasLanPassword(), lanUrl: lanUrl() },
+            });
+        },
+    },
+];

package/packages/server/routes/api/hub.js

@@ -0,0 +1,26 @@
+import { isLocalRequest } from "../../modules/access/index.js";
+import { configureHub, hubStatus } from "../../modules/hub/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { json, readBody } from "../../modules/transport/index.js";
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/hub",
+        handler: ({ req, res }) => {
+            if (!isLocalRequest(req))
+                throw new HttpError(403, "Настройки Hub доступны только локально");
+            json(res, 200, hubStatus());
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/hub",
+        handler: async ({ req, res }) => {
+            if (!isLocalRequest(req))
+                throw new HttpError(403, "Подключение Hub доступно только локально");
+            const body = await readBody(req);
+            configureHub(body);
+            json(res, 200, hubStatus());
+        },
+    },
+];

package/packages/server/routes/api/ide/commands.js

@@ -0,0 +1,72 @@
+import { accessAllowed } from "../../../modules/access/index.js";
+import { HttpError } from "../../../modules/http/index.js";
+import { claimIdeCommand, completeIdeCommand, ideMcpTokenMatches, requestIdeCommand, } from "../../../modules/ide/index.js";
+import { asString, json, readBody, } from "../../../modules/transport/index.js";
+function commandCall(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new HttpError(400, "Некорректный запрос команды");
+    const body = value;
+    const operation = asString(body.operation);
+    if (!["list", "describe", "execute"].includes(operation))
+        throw new HttpError(400, "operation: list, describe или execute");
+    return {
+        operation: operation,
+        ...(typeof body.query === "string" ? { query: body.query.slice(0, 400) } : {}),
+        ...(typeof body.command === "string" ? { command: body.command.slice(0, 200) } : {}),
+        ...(typeof body.scope === "string" ? { scope: body.scope.slice(0, 200) } : {}),
+        ...(body.args === undefined ? {} : { args: body.args }),
+    };
+}
+/**
+ * The bridge of the built-in IDE MCP server: an external agent's tool call arrives here with the
+ * server's key, the open page claims it and returns the result of the live command registry.
+ */
+export const routes = [
+    {
+        method: "POST",
+        path: "/api/ide/command-request",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Доступ запрещён");
+            const header = req.headers.authorization;
+            const token = header?.startsWith("Bearer ") ? header.slice("Bearer ".length) : null;
+            if (!(await ideMcpTokenMatches(token)))
+                throw new HttpError(403, "Неверный ключ MCP");
+            const body = await readBody(req);
+            const projectId = asString(body.projectId);
+            if (!projectId)
+                throw new HttpError(400, "Укажите projectId");
+            const session = asString(body.session) || projectId;
+            json(res, 200, {
+                output: await requestIdeCommand(projectId, session, commandCall(body.request)),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/ide/command-request/claim",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Доступно только странице Projector");
+            const body = await readBody(req);
+            json(res, 200, { claimed: claimIdeCommand(asString(body.id), asString(body.page)) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/ide/command-request/result",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Доступно только странице Projector");
+            const body = await readBody(req);
+            const accepted = completeIdeCommand(asString(body.id), asString(body.page), {
+                output: body.output,
+                error: asString(body.error) || undefined,
+            });
+            json(res, accepted ? 200 : 410, { accepted });
+        },
+    },
+];

package/packages/server/routes/api/ide/editor.js

@@ -0,0 +1,37 @@
+import { readEditorSettings, writeEditorSettings } from "../../../modules/ide/index.js";
+import { json, readBody } from "../../../modules/transport/index.js";
+import { accessAllowed } from "../../../modules/access/index.js";
+import { HttpError } from "../../../modules/http/index.js";
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/ide/editor",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 200, await readEditorSettings());
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/ide/editor",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            const body = await readBody(req);
+            json(res, 200, await writeEditorSettings(body.theme));
+        },
+    },
+    {
+        method: "",
+        path: "/api/ide/editor",
+        handler: ({ req, res }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 405, { error: "Метод не поддерживается" });
+        },
+    },
+];

package/packages/server/routes/api/ide/files-exclude.js

@@ -0,0 +1,37 @@
+import { readFilesExclude, writeFilesExclude } from "../../../modules/workspace/index.js";
+import { json, readBody } from "../../../modules/transport/index.js";
+import { accessAllowed } from "../../../modules/access/index.js";
+import { HttpError } from "../../../modules/http/index.js";
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/ide/files-exclude",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 200, { exclude: await readFilesExclude() });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/ide/files-exclude",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            const body = await readBody(req);
+            json(res, 200, { exclude: await writeFilesExclude(body.exclude ?? body) });
+        },
+    },
+    {
+        method: "",
+        path: "/api/ide/files-exclude",
+        handler: ({ req, res }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 405, { error: "Метод не поддерживается" });
+        },
+    },
+];

package/packages/server/routes/api/ide/keybindings.js

@@ -0,0 +1,37 @@
+import { readKeybindings, writeKeybindings } from "../../../modules/ide/index.js";
+import { json, readBody } from "../../../modules/transport/index.js";
+import { accessAllowed } from "../../../modules/access/index.js";
+import { HttpError } from "../../../modules/http/index.js";
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/ide/keybindings",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 200, await readKeybindings());
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/ide/keybindings",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            const body = await readBody(req);
+            json(res, 200, await writeKeybindings(body.bindings));
+        },
+    },
+    {
+        method: "",
+        path: "/api/ide/keybindings",
+        handler: ({ req, res }) => {
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Настройки доступны только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 405, { error: "Метод не поддерживается" });
+        },
+    },
+];

package/packages/server/routes/api/inspect.js

@@ -0,0 +1,21 @@
+import { inspectProject, inspectProjectCommands } from "../../modules/projects/index.js";
+import { json, readBody, asString } from "../../modules/transport/index.js";
+export const routes = [
+    {
+        method: "POST",
+        path: "/api/inspect/commands",
+        handler: async ({ req, res }) => {
+            const body = await readBody(req);
+            json(res, 200, { commands: await inspectProjectCommands(asString(body.path)) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/inspect",
+        handler: async ({ req, res }) => {
+            const body = await readBody(req);
+            const result = await inspectProject(asString(body.path));
+            json(res, 200, result);
+        },
+    },
+];

package/packages/server/routes/api/integrations/[...action].js

@@ -0,0 +1,201 @@
+import { listIntegrations } from "../../../modules/integration-store/index.js";
+import { dockerIntegrationStatus } from "../../../modules/docker/index.js";
+import { startCloneJob, cloneJob, cancelCloneJob } from "../../../modules/git-import/index.js";
+import { configureGithub, revealGithubToken, connectGithub, disconnectGithub, beginGithubLogin, pollGithubLogin, githubRepositories, githubStatus, githubEmojis, importGithubProject, cloneGithubProject, } from "../../../modules/github/index.js";
+import { configureGitlab, connectGitlab, disconnectGitlab, revealGitlabToken, beginGitlabLogin, pollGitlabLogin, gitlabRepositories, gitlabStatus, importGitlabProject, cloneGitlabProject, browseGitlabRepository, browseGitlabDirectories, browseGitlabTree, browseGitlabFile, browseGitlabAsset, browseGitlabIcon, browseGitlabLog, browseGitlabCommit, browseGitlabComparison, browseGitlabCompareChanges, browseGitlabCompareFile, browseGitlabIssues, browseGitlabIssue, browseGitlabMergeRequests, browseGitlabMergeRequest, browseGitlabMergeRequestFiles, browseGitlabMergeRequestDiff, browseGitlabPipelines, browseGitlabPipeline, browseGitlabJob, browseGitlabRelease, browseGitlabReleases, downloadGitlabReleaseSource, searchGitlabBlobs, } from "../../../modules/gitlab/index.js";
+import { isLocalRequest } from "../../../modules/access/index.js";
+import { HttpError, sendDownload } from "../../../modules/http/index.js";
+import { json, readBody, } from "../../../modules/transport/index.js";
+import { sendIconBytes, withRuntime } from "../../../modules/project-presentation/index.js";
+import { letterIconSvg } from "../../../modules/projects/index.js";
+const hosts = {
+    github: {
+        configure: configureGithub,
+        connect: connectGithub,
+        disconnect: disconnectGithub,
+        reveal: revealGithubToken,
+        repositories: githubRepositories,
+    },
+    gitlab: {
+        configure: configureGitlab,
+        connect: connectGitlab,
+        disconnect: disconnectGitlab,
+        reveal: revealGitlabToken,
+        repositories: gitlabRepositories,
+    },
+};
+const text = (url, key) => url.searchParams.get(key) || "";
+function endpoint(method, path, handler) {
+    return {
+        method,
+        path,
+        handler: (context) => {
+            context.res.setHeader("Cache-Control", "no-store");
+            return handler(context);
+        },
+    };
+}
+function hostRoutes(hostName) {
+    const host = hosts[hostName];
+    const base = `/api/integrations/${hostName}`;
+    return [
+        endpoint("PUT", base, async ({ req, res }) => {
+            json(res, 200, await host.configure(await readBody(req)));
+        }),
+        endpoint("POST", `${base}/auth`, async ({ req, res }) => {
+            json(res, 200, await host.connect(await readBody(req)));
+        }),
+        endpoint("DELETE", `${base}/auth`, async ({ res }) => {
+            json(res, 200, await host.disconnect());
+        }),
+        endpoint("POST", `${base}/token`, async ({ req, res }) => {
+            // Secrets are shown only on this machine, never over LAN and never to the agent.
+            if (!isLocalRequest(req))
+                throw new HttpError(403, "Токен можно показать только на локальной машине");
+            json(res, 200, await host.reveal());
+        }),
+        endpoint("GET", `${base}/repositories`, async ({ res, url }) => {
+            json(res, 200, await host.repositories(Number(url.searchParams.get("page") ?? 1)));
+        }),
+    ];
+}
+function jobRoutes(hostName) {
+    const path = `/api/integrations/${hostName}/clone-jobs/:id([0-9a-f-]{36})`;
+    return [
+        endpoint("GET", path, async ({ res, params }) => {
+            const job = cloneJob(params.id);
+            json(res, 200, { job: job.project ? { ...job, project: withRuntime(job.project) } : job });
+        }),
+        endpoint("DELETE", path, async ({ res, params }) => {
+            json(res, 200, { job: cancelCloneJob(params.id) });
+        }),
+    ];
+}
+export const routes = [
+    endpoint("GET", "/api/integrations", async ({ res }) => {
+        json(res, 200, await listIntegrations([githubStatus, gitlabStatus, dockerIntegrationStatus]));
+    }),
+    endpoint("GET", "/api/integrations/github/emojis", async ({ res }) => {
+        res.setHeader("Cache-Control", "private, max-age=3600");
+        json(res, 200, await githubEmojis());
+    }),
+    ...hostRoutes("github"),
+    ...hostRoutes("gitlab"),
+    // GitLab browsing is registered explicitly so `/browse/...` never falls through to host actions.
+    endpoint("GET", "/api/integrations/gitlab/browse/directories", async ({ res, url }) => {
+        json(res, 200, await browseGitlabDirectories(text(url, "path"), url.searchParams.get("complete") === "true"));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/icon", async ({ res, url }) => {
+        const repository = text(url, "repository");
+        const icon = await browseGitlabIcon(repository, text(url, "ref") || text(url, "sha")).catch(() => null);
+        sendIconBytes(res, icon?.mime ?? "image/svg+xml", icon?.bytes ??
+            Buffer.from(letterIconSvg(repository.split("/").filter(Boolean).at(-1) || "GitLab")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/asset", async ({ res, url }) => {
+        const asset = await browseGitlabAsset(text(url, "repository"), text(url, "sha"), text(url, "path"));
+        res.setHeader("Content-Type", asset.mime);
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
+        res.end(asset.bytes);
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/repository", async ({ res, url }) => {
+        json(res, 200, await browseGitlabRepository(text(url, "repository"), text(url, "ref")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/tree", async ({ res, url }) => {
+        json(res, 200, await browseGitlabTree(text(url, "repository"), text(url, "sha"), text(url, "path")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/file", async ({ res, url }) => {
+        json(res, 200, await browseGitlabFile(text(url, "repository"), text(url, "sha"), text(url, "path")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/log", async ({ res, url }) => {
+        json(res, 200, await browseGitlabLog(text(url, "repository"), Object.fromEntries(url.searchParams)));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/commit", async ({ res, url }) => {
+        json(res, 200, await browseGitlabCommit(text(url, "repository"), text(url, "hash")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/commit-diff", async ({ res, url }) => {
+        json(res, 200, await browseGitlabComparison(text(url, "repository"), text(url, "hash"), text(url, "path")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/issues", async ({ res, url }) => {
+        json(res, 200, await browseGitlabIssues(text(url, "repository"), Object.fromEntries(url.searchParams)));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/issue", async ({ res, url }) => {
+        json(res, 200, await browseGitlabIssue(text(url, "repository"), Number(url.searchParams.get("number"))));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/merge-requests", async ({ res, url }) => {
+        json(res, 200, await browseGitlabMergeRequests(text(url, "repository"), Object.fromEntries(url.searchParams)));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/merge-request", async ({ res, url }) => {
+        json(res, 200, await browseGitlabMergeRequest(text(url, "repository"), Number(url.searchParams.get("number"))));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/merge-request-files", async ({ res, url }) => {
+        json(res, 200, await browseGitlabMergeRequestFiles(text(url, "repository"), Number(url.searchParams.get("number"))));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/compare-changes", async ({ res, url }) => {
+        json(res, 200, await browseGitlabCompareChanges(text(url, "repository"), text(url, "from"), text(url, "to")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/compare-file", async ({ res, url }) => {
+        json(res, 200, await browseGitlabCompareFile(text(url, "repository"), text(url, "from"), text(url, "to"), text(url, "path"), url.searchParams.get("originalPath") || undefined));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/search", async ({ res, url }) => {
+        json(res, 200, await searchGitlabBlobs(text(url, "repository"), Object.fromEntries(url.searchParams)));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/merge-request-diff", async ({ res, url }) => {
+        json(res, 200, await browseGitlabMergeRequestDiff(text(url, "repository"), Number(url.searchParams.get("number")), text(url, "path")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/pipelines", async ({ res, url }) => {
+        json(res, 200, await browseGitlabPipelines(text(url, "repository"), Object.fromEntries(url.searchParams)));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/pipeline", async ({ res, url }) => {
+        json(res, 200, await browseGitlabPipeline(text(url, "repository"), text(url, "id")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/job", async ({ res, url }) => {
+        json(res, 200, await browseGitlabJob(text(url, "repository"), text(url, "id")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/releases", async ({ res, url }) => {
+        json(res, 200, await browseGitlabReleases(text(url, "repository"), Object.fromEntries(url.searchParams)));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/release", async ({ res, url }) => {
+        json(res, 200, await browseGitlabRelease(text(url, "repository"), text(url, "tag")));
+    }),
+    endpoint("GET", "/api/integrations/gitlab/browse/release-source", async ({ res, url }) => {
+        const download = await downloadGitlabReleaseSource(text(url, "repository"), text(url, "tag"), text(url, "format"));
+        sendDownload(res, download.response, download.name, download.contentType);
+    }),
+    endpoint("POST", "/api/integrations/github/device", async ({ res }) => {
+        json(res, 200, await beginGithubLogin());
+    }),
+    endpoint("POST", "/api/integrations/github/device/poll", async ({ req, res }) => {
+        json(res, 200, await pollGithubLogin(await readBody(req)));
+    }),
+    endpoint("POST", "/api/integrations/gitlab/device", async ({ res }) => {
+        json(res, 200, await beginGitlabLogin());
+    }),
+    endpoint("POST", "/api/integrations/gitlab/device/poll", async ({ req, res }) => {
+        json(res, 200, await pollGitlabLogin(await readBody(req)));
+    }),
+    endpoint("POST", "/api/integrations/gitlab/import", async ({ req, res }) => {
+        const result = await importGitlabProject(await readBody(req));
+        json(res, 201, { project: withRuntime(result.project) });
+    }),
+    endpoint("POST", "/api/integrations/gitlab/clone", async ({ req, res }) => {
+        const result = await cloneGitlabProject(await readBody(req));
+        json(res, 201, { project: withRuntime(result.project) });
+    }),
+    endpoint("POST", "/api/integrations/gitlab/clone-jobs", async ({ req, res }) => {
+        json(res, 202, { job: startCloneJob(await readBody(req), cloneGitlabProject) });
+    }),
+    ...jobRoutes("gitlab"),
+    endpoint("POST", "/api/integrations/github/clone-jobs", async ({ req, res }) => {
+        json(res, 202, { job: startCloneJob(await readBody(req), cloneGithubProject) });
+    }),
+    ...jobRoutes("github"),
+    endpoint("POST", "/api/integrations/github/clone", async ({ req, res }) => {
+        const result = await cloneGithubProject(await readBody(req));
+        json(res, 201, { project: withRuntime(result.project) });
+    }),
+    endpoint("POST", "/api/integrations/github/import", async ({ req, res }) => {
+        const result = await importGithubProject(await readBody(req));
+        json(res, 201, { project: withRuntime(result.project) });
+    }),
+];