@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/routes/api/agent-chats.js

@@ -0,0 +1,77 @@
+import { archiveLiveChat, forgetChat, listArchivedChats, openArchivedChat, readRecentChats, removeArchivedChat, renameArchivedChat, } from "../../modules/agent/index.js";
+import { accessAllowed } from "../../modules/access/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+const pageOnly = (req) => {
+    if (!accessAllowed(req, true))
+        throw new HttpError(403, "Изменение доступно только со страницы Projector");
+};
+/** Past chats of the Projector agent: the live chat is put aside, listed, brought back or dropped. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/chats",
+        handler: ({ res, url }) => {
+            json(res, 200, { chats: listArchivedChats(url.searchParams.get("key") ?? "") });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/agent/chats/recent",
+        handler: ({ res, url }) => {
+            const project = url.searchParams.get("projectId") ?? "";
+            const backend = url.searchParams.get("backend") || undefined;
+            json(res, 200, { chats: readRecentChats(project, backend) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/chats/archive",
+        handler: async ({ req, res }) => {
+            pageOnly(req);
+            const body = await readBody(req);
+            json(res, 200, { id: (await archiveLiveChat(asString(body.key))) ?? null });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/chats/open",
+        handler: async ({ req, res }) => {
+            pageOnly(req);
+            const body = await readBody(req);
+            json(res, 200, { turns: await openArchivedChat(asString(body.key), asString(body.id)) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/chats/update",
+        handler: async ({ req, res }) => {
+            pageOnly(req);
+            const body = await readBody(req);
+            renameArchivedChat(asString(body.id), {
+                ...(typeof body.title === "string" ? { title: body.title } : {}),
+                ...(typeof body.pinned === "boolean" ? { pinned: body.pinned } : {}),
+            });
+            json(res, 200, { ok: true });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/chats/delete",
+        handler: async ({ req, res }) => {
+            pageOnly(req);
+            const body = await readBody(req);
+            removeArchivedChat(asString(body.id));
+            json(res, 200, { ok: true });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/chats/forget",
+        handler: async ({ req, res }) => {
+            pageOnly(req);
+            const body = await readBody(req);
+            json(res, 200, { ok: forgetChat(asString(body.projectId), asString(body.chat)) });
+        },
+    },
+];

package/packages/server/routes/api/agent-features.js

@@ -0,0 +1,36 @@
+import { featureSettings, setFeatureAgent } from "../../modules/agent-features/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** Optional abilities of the chat agents: which feature is on for which agent. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/features",
+        handler: async ({ res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 200, await featureSettings());
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/agent/features",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            const body = await readBody(req);
+            const feature = asString(body.feature);
+            const agent = asString(body.agent);
+            if (!feature)
+                throw new HttpError(400, "Укажите feature");
+            if (!agent)
+                throw new HttpError(400, "Укажите agent");
+            if (typeof body.enabled !== "boolean")
+                throw new HttpError(400, "enabled должен быть boolean");
+            try {
+                json(res, 200, await setFeatureAgent(feature, agent, body.enabled));
+            }
+            catch (error) {
+                throw new HttpError(400, error.message);
+            }
+        },
+    },
+];

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

@@ -0,0 +1,35 @@
+import { accessAllowed } from "../../modules/access/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { repairForm } from "../../modules/agents/projector/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** One asynchronous Form Doctor turn: the page validates the result and may ask again. */
+export const routes = [
+    {
+        method: "POST",
+        path: "/api/agent/form-repair",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Восстановление формы доступно только со страницы Projector");
+            const body = await readBody(req);
+            const form = asString(body.form);
+            const error = asString(body.error);
+            if (!form.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 repairForm({
+                form,
+                error,
+                history: asString(body.history),
+                selection,
+                signal: abort.signal,
+            });
+            json(res, 200, { form: repaired });
+        },
+    },
+];

package/packages/server/routes/api/agent-hooks.js

@@ -0,0 +1,35 @@
+import { listHooks, readUserHooks, writeUserHooks } from "../../modules/agents/projector/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** Hooks of the Projector agent: `GET` the user's file and what applies to the project, `PUT` saves the file. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/hooks",
+        handler: async ({ res, url }) => {
+            res.setHeader("Cache-Control", "no-store");
+            const cwd = url.searchParams.get("path") || undefined;
+            const hooks = (await listHooks(cwd)).map((item) => ({
+                event: item.event,
+                source: item.source,
+                command: item.command,
+                matcher: item.matcher?.source,
+            }));
+            json(res, 200, { text: await readUserHooks(), hooks });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/agent/hooks",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            try {
+                await writeUserHooks(asString((await readBody(req)).text));
+            }
+            catch (error) {
+                throw new HttpError(400, error.message);
+            }
+            json(res, 200, { ok: true });
+        },
+    },
+];

package/packages/server/routes/api/agent-jobs.js

@@ -0,0 +1,322 @@
+import { stat } from "node:fs/promises";
+import { answerJob, createWorktree, injectMessage, isAgentAvailable, isAgentBackend, isFinished, isHostedAgent, jobDiff, followUpJob, forkJob, listAgentBackends, listJobs, readJob, removeJob, removeWorktree, retryJob, selectionFrom, settleJobWorktree, startJob, stopJob, waitForJob, worktreeStatus, } from "../../modules/agent/index.js";
+import { readAgentRole } from "../../modules/agent-roles/index.js";
+import { snapshotOfRole } from "../../../core/modules/agent-role/index.js";
+import { accessAllowed } from "../../modules/access/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { loadProjects } from "../../modules/projects/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** The longest task text. */
+const TASK_LIMIT = 20_000;
+/** The longest wait of a long poll, in seconds. */
+const WAIT_LIMIT = 45;
+const pageOnly = (req) => {
+    if (!accessAllowed(req, true))
+        throw new HttpError(403, "Доступно только со страницы Projector");
+};
+/** A new job from the body of `POST /api/agent/jobs`; everything the client sends is checked here. */
+async function startFrom(body) {
+    const projectId = asString(body.projectId);
+    const roleId = asString(body.role).trim();
+    const role = roleId ? await readAgentRole(roleId, projectId) : undefined;
+    if (roleId && !role)
+        throw new Error(`Неизвестная или недоверенная роль: ${roleId}`);
+    if (role && role.kind !== "chat")
+        throw new Error("Служебную роль нельзя запустить как фоновое задание");
+    const backend = asString(body.backend).trim() || role?.agent || "";
+    if (role && backend !== role.agent)
+        throw new Error(`Роль «${role.name}» принадлежит агенту ${role.agent}`);
+    const catalog = listAgentBackends();
+    const isBuiltin = catalog.some(({ id, builtin }) => id === backend && builtin);
+    if (!backend || isBuiltin || !isAgentBackend(backend)) {
+        const names = catalog
+            .filter(({ builtin }) => !builtin)
+            .map(({ label }) => label)
+            .join(", ");
+        throw new Error(`Укажите внешнего агента: ${names}`);
+    }
+    if (!isHostedAgent(backend))
+        throw new Error("Этот агент не умеет работать в фоне");
+    if (!isAgentAvailable(backend))
+        throw new Error("Программа этого агента не установлена");
+    const task = asString(body.task).trim();
+    if (!task)
+        throw new Error("Опишите задание агенту");
+    if (task.length > TASK_LIMIT)
+        throw new Error(`Задание длиннее ${TASK_LIMIT} символов`);
+    const project = (await loadProjects()).find((item) => item.id === asString(body.projectId));
+    if (!project)
+        throw new Error("Проект не найден");
+    if (!(await stat(project.path).catch(() => null))?.isDirectory())
+        throw new Error("Папка проекта не найдена");
+    const selection = { ...role?.selection, ...selectionFrom(body.selection) };
+    const mode = asString(body.mode) ||
+        asString(body.permissionMode) ||
+        role?.permissionMode ||
+        selection.mode ||
+        selection["permission-mode"] ||
+        "";
+    // Every agent reads the mode its own way: from `permissionMode` or from the selection.
+    if (mode) {
+        selection.mode = mode;
+        selection["permission-mode"] = mode;
+    }
+    let cwd = project.path;
+    let worktree;
+    if (body.isolate === true || role?.isolate === true) {
+        const copy = await createWorktree(project.id, project.path);
+        cwd = copy.cwd;
+        worktree = { id: copy.id, branch: copy.branch };
+    }
+    try {
+        return await startJob({
+            backend,
+            task,
+            projectId: project.id,
+            cwd,
+            worktree,
+            origin: asString(body.origin) || undefined,
+            permissionMode: mode || undefined,
+            selection,
+            role: role ? snapshotOfRole(role) : undefined,
+            unattended: body.unattended === true,
+        });
+    }
+    catch (error) {
+        if (worktree)
+            await removeWorktree(project.id, worktree.id, project.path).catch(() => { });
+        throw error;
+    }
+}
+/** Background agent jobs: start, list, read with the journal, stop, answer and remove. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/jobs",
+        handler: async ({ res, url }) => {
+            json(res, 200, { jobs: await listJobs(url.searchParams.get("projectId") || undefined) });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs",
+        handler: async ({ req, res }) => {
+            pageOnly(req);
+            json(res, 201, { job: await startFrom(await readBody(req)) });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})",
+        handler: async ({ res, url, params }) => {
+            const id = params.id;
+            const wait = Math.min(Math.max(Number(url.searchParams.get("wait")) || 0, 0), WAIT_LIMIT);
+            const rev = Number(url.searchParams.get("rev"));
+            const found = wait && Number.isFinite(rev) ? await waitForJob(id, rev, wait) : await readJob(id);
+            if (!found)
+                throw new HttpError(404, "Задание не найдено");
+            json(res, 200, found);
+        },
+    },
+    {
+        method: "DELETE",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})",
+        handler: async ({ req, res, params }) => {
+            pageOnly(req);
+            await removeJob(params.id);
+            json(res, 200, { ok: true });
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/diff",
+        handler: async ({ res, url, params }) => {
+            const found = await readJob(params.id);
+            if (!found)
+                throw new HttpError(404, "Задание не найдено");
+            if (found.job.worktreeCleared)
+                throw new HttpError(409, "Изолированная копия удалена или передана другому заданию");
+            const limit = Number(url.searchParams.get("limit"));
+            json(res, 200, {
+                diff: await jobDiff(found.job.cwd, limit || undefined, found.job.base, found.job.dirty),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/send",
+        handler: async ({ req, res, params }) => {
+            const id = params.id;
+            pageOnly(req);
+            const found = await readJob(id);
+            if (!found)
+                throw new HttpError(404, "Задание не найдено");
+            const text = asString((await readBody(req)).text).trim();
+            if (!text)
+                throw new HttpError(400, "Напишите уточнение агенту");
+            if (isFinished(found.job.status)) {
+                // A finished job takes a follow-up as a new run in the same record, copy and session.
+                try {
+                    const job = await followUpJob(id, text);
+                    if (!job)
+                        throw new HttpError(404, "Задание не найдено");
+                    json(res, 200, { accepted: true, continued: true, job });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "";
+                    if (/ещё работает|уже занята/.test(message))
+                        throw new HttpError(409, message);
+                    throw error;
+                }
+                return;
+            }
+            const accepted = await injectMessage(found.job.messageId, text);
+            json(res, 200, { accepted, continued: false });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/retry",
+        handler: async ({ req, res, params }) => {
+            const id = params.id;
+            pageOnly(req);
+            const body = await readBody(req);
+            const task = asString(body.task).trim() || undefined;
+            if (task && task.length > TASK_LIMIT)
+                throw new Error(`Задание длиннее ${TASK_LIMIT} символов`);
+            const found = await readJob(id);
+            if (!found)
+                throw new HttpError(404, "Задание не найдено");
+            if (!isHostedAgent(found.job.backend) || !isAgentAvailable(found.job.backend))
+                throw new Error("Агент этого задания больше не может работать в фоне");
+            let job;
+            try {
+                job = await retryJob(id, task, body.append === true);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "";
+                if (/ещё работает|уже занята/.test(message))
+                    throw new HttpError(409, message);
+                throw error;
+            }
+            json(res, 201, { job });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/fork",
+        handler: async ({ req, res, params }) => {
+            const id = params.id;
+            pageOnly(req);
+            const task = asString((await readBody(req)).task).trim() || undefined;
+            if (task && task.length > TASK_LIMIT)
+                throw new Error(`Задание длиннее ${TASK_LIMIT} символов`);
+            try {
+                const job = await forkJob(id, task);
+                if (!job)
+                    throw new HttpError(404, "Задание не найдено");
+                json(res, 201, { job });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "";
+                if (/Дождитесь|уже занята/.test(message))
+                    throw new HttpError(409, message);
+                throw error;
+            }
+        },
+    },
+    {
+        method: "GET",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/worktree",
+        handler: async ({ res, params }) => {
+            const found = await readJob(params.id);
+            if (!found)
+                throw new HttpError(404, "Задание не найдено");
+            if (!found.job.worktree) {
+                json(res, 200, { worktree: null });
+                return;
+            }
+            const project = (await loadProjects()).find((item) => item.id === found.job.projectId);
+            if (!project)
+                throw new HttpError(404, "Проект не найден");
+            json(res, 200, {
+                worktree: await worktreeStatus(project.id, found.job.worktree.id, project.path),
+            });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/worktree/merge",
+        handler: async ({ req, res, params }) => {
+            pageOnly(req);
+            try {
+                const result = await settleJobWorktree(params.id, "merge");
+                if (!result)
+                    throw new HttpError(404, "Задание не найдено");
+                json(res, 200, result);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "";
+                if (/Дождитесь|уже занята/.test(message))
+                    throw new HttpError(409, message);
+                if (/Проект не найден/.test(message))
+                    throw new HttpError(404, message);
+                throw error;
+            }
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/worktree/discard",
+        handler: async ({ req, res, params }) => {
+            pageOnly(req);
+            try {
+                const result = await settleJobWorktree(params.id, "discard");
+                if (!result)
+                    throw new HttpError(404, "Задание не найдено");
+                json(res, 200, result);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "";
+                if (/Дождитесь|уже занята/.test(message))
+                    throw new HttpError(409, message);
+                if (/Проект не найден/.test(message))
+                    throw new HttpError(404, message);
+                throw error;
+            }
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/stop",
+        handler: async ({ req, res, params }) => {
+            pageOnly(req);
+            const job = await stopJob(params.id);
+            if (!job)
+                throw new HttpError(404, "Задание не найдено");
+            json(res, 200, { job });
+        },
+    },
+    {
+        method: "POST",
+        path: "/api/agent/jobs/:id([0-9a-f]{12})/answer",
+        handler: async ({ req, res, params }) => {
+            pageOnly(req);
+            const body = await readBody(req);
+            const answers = body.answers;
+            json(res, 200, {
+                job: await answerJob(params.id, {
+                    request: asString(body.request) || undefined,
+                    allow: typeof body.allow === "boolean" ? body.allow : undefined,
+                    always: typeof body.always === "boolean" ? body.always : undefined,
+                    text: asString(body.text) || undefined,
+                    answers: answers === null
+                        ? null
+                        : answers && typeof answers === "object"
+                            ? answers
+                            : undefined,
+                }),
+            });
+        },
+    },
+];

package/packages/server/routes/api/agent-judge.js

@@ -0,0 +1,33 @@
+import { readJudgeSettings, writeJudgeSettings } from "../../modules/judge/index.js";
+import { accessAllowed } from "../../modules/access/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { json, readBody } from "../../modules/transport/index.js";
+/** Global Projector Judge settings; a chat may override them in its own history. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/judge",
+        handler: async ({ req, res }) => {
+            // A same-origin GET carries no Origin header; a change still has to come from the page.
+            if (!accessAllowed(req, false))
+                throw new HttpError(403, "Судья доступен только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 200, await readJudgeSettings());
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/agent/judge",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Судья доступен только со страницы Projector");
+            res.setHeader("Cache-Control", "no-store");
+            try {
+                json(res, 200, await writeJudgeSettings(await readBody(req)));
+            }
+            catch (error) {
+                throw new HttpError(400, error instanceof Error ? error.message : "Неверные настройки");
+            }
+        },
+    },
+];

package/packages/server/routes/api/agent-lens.js

@@ -0,0 +1,27 @@
+import { accessAllowed } from "../../modules/access/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { lensRequestFrom } from "../../modules/agent/index.js";
+import { runLens } from "../../modules/agents/projector/index.js";
+import { json, readBody } from "../../modules/transport/index.js";
+/**
+ * Lens: a short caption of the chat's current work, held by the request itself. Unlike `/api/agent`
+ * it creates no run record and writes no history; it only reads what the page already shows.
+ */
+export const routes = [
+    {
+        method: "POST",
+        path: "/api/agent/lens",
+        handler: async ({ req, res }) => {
+            if (!accessAllowed(req, true))
+                throw new HttpError(403, "Lens доступен только со страницы Projector");
+            const body = await readBody(req);
+            const request = lensRequestFrom(body);
+            if (!request.history.length && !request.busy)
+                throw new Error("Пока нечего показывать: в чате ещё нет работы");
+            const abort = new AbortController();
+            res.on("close", () => abort.abort());
+            const text = await runLens({ ...request, signal: abort.signal });
+            json(res, 200, { text, at: Date.now() });
+        },
+    },
+];

package/packages/server/routes/api/agent-mcp.js

@@ -0,0 +1,41 @@
+import { mcpServerConfigs, readUserMcp, writeUserMcp, } from "../../modules/agents/projector/index.js";
+import { loadProjects } from "../../modules/projects/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** MCP servers of the Projector agent: `GET` the user's list and what the project adds, `PUT` saves the list. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/mcp",
+        handler: async ({ res, url }) => {
+            res.setHeader("Cache-Control", "no-store");
+            const projectId = url.searchParams.get("projectId") ?? "";
+            const project = projectId
+                ? (await loadProjects()).find((item) => item.id === projectId)
+                : undefined;
+            if (projectId && !project)
+                throw new HttpError(404, "Проект не найден");
+            const cwd = project ? project.path : url.searchParams.get("path") || undefined;
+            const servers = (await mcpServerConfigs(cwd)).map((item) => ({
+                name: item.name,
+                source: item.source,
+                kind: "command" in item ? "stdio" : item.sse ? "sse" : "http",
+            }));
+            json(res, 200, { text: await readUserMcp(), servers });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/agent/mcp",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            try {
+                await writeUserMcp(asString((await readBody(req)).text));
+            }
+            catch (error) {
+                throw new HttpError(400, error.message);
+            }
+            json(res, 200, { ok: true });
+        },
+    },
+];

package/packages/server/routes/api/agent-memory.js

@@ -0,0 +1,33 @@
+import { projectMemories, readMemory, writeMemory } from "../../modules/agents/projector/index.js";
+import { HttpError } from "../../modules/http/index.js";
+import { asString, json, readBody } from "../../modules/transport/index.js";
+/** Notes of the Projector agent: `GET` lists them, `PUT` replaces the notes of one scope. */
+export const routes = [
+    {
+        method: "GET",
+        path: "/api/agent/memory",
+        handler: async ({ res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            json(res, 200, { user: await readMemory("user"), projects: await projectMemories() });
+        },
+    },
+    {
+        method: "PUT",
+        path: "/api/agent/memory",
+        handler: async ({ req, res }) => {
+            res.setHeader("Cache-Control", "no-store");
+            const body = await readBody(req);
+            const scope = body.scope === "project" ? "project" : "user";
+            const project = asString(body.path);
+            if (scope === "project" && !project)
+                throw new HttpError(400, "Укажите проект");
+            try {
+                const text = await writeMemory(scope, project || undefined, asString(body.text));
+                json(res, 200, { text });
+            }
+            catch (error) {
+                throw new HttpError(400, error.message);
+            }
+        },
+    },
+];