@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/agent-roles/project.js

@@ -0,0 +1,231 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readFile, realpath, rename, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { os } from "../../../core/modules/os/index.js";
+import { isServiceRoleId, normalizeAgentRole, } from "../../../core/modules/agent-role/index.js";
+import { loadProjects } from "../projects/index.js";
+/** Roles a project keeps in its repository; inert until the user trusts this exact file. */
+export const projectRolesRelativeFile = ".projector/roles.json";
+export const projectRolesTrustFile = () => join(dataDir(), "agent", "role-trust.json");
+const hashOf = (text) => createHash("sha256").update(text).digest("hex");
+async function projectRoot(projectId) {
+    const project = (await loadProjects()).find((item) => item.id === projectId);
+    if (!project)
+        throw new Error("Проект не найден");
+    return realpath(project.path);
+}
+function readTrustFile(text) {
+    try {
+        const value = JSON.parse(text);
+        const projects = {};
+        if (value?.projects && typeof value.projects === "object" && !Array.isArray(value.projects))
+            for (const [path, item] of Object.entries(value.projects)) {
+                const row = item;
+                if (typeof row?.hash === "string" && typeof row.at === "string")
+                    projects[path] = { hash: row.hash, at: row.at };
+            }
+        return { version: 1, projects };
+    }
+    catch {
+        return { version: 1, projects: {} };
+    }
+}
+async function readTrust() {
+    try {
+        return readTrustFile(await readFile(projectRolesTrustFile(), "utf8"));
+    }
+    catch {
+        return { version: 1, projects: {} };
+    }
+}
+let queue = Promise.resolve();
+async function writeTrust(file) {
+    const path = projectRolesTrustFile();
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(file, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await rename(temporary, path);
+    await os.tools.restrictToOwner(path);
+}
+/** Rejects a `.projector` folder or roles file that escapes the project through a symlink. */
+async function safeProjectFile(root, file) {
+    const real = await realpath(file);
+    const rel = relative(root, real);
+    if (rel.startsWith("..") || isAbsolute(rel))
+        throw new Error("Файл ролей проекта указывает за его пределы");
+    return real;
+}
+function rolesOf(text) {
+    const value = JSON.parse(text);
+    if (!Array.isArray(value?.roles))
+        throw new Error("В файле ролей проекта нет roles");
+    const roles = [];
+    for (const item of value.roles) {
+        const role = normalizeAgentRole(item);
+        if (!role || role.kind !== "chat" || isServiceRoleId(role.id))
+            continue;
+        if (roles.some((known) => known.id === role.id))
+            continue;
+        roles.push(role);
+    }
+    return roles;
+}
+/** The project's role file and its trust decision; a broken or unsafe file is reported, not used. */
+export async function projectRoleState(projectId) {
+    const root = await projectRoot(projectId);
+    const file = join(root, projectRolesRelativeFile);
+    const trust = await readTrust();
+    try {
+        const raw = await readFile(file, "utf8");
+        const real = await safeProjectFile(root, file);
+        const hash = hashOf(raw);
+        let roles;
+        try {
+            roles = rolesOf(raw);
+        }
+        catch (error) {
+            return {
+                projectId,
+                path: root,
+                file: real,
+                exists: true,
+                trusted: false,
+                hash,
+                roles: [],
+                problem: error instanceof Error && error.message.startsWith("В файле")
+                    ? error.message
+                    : "Файл ролей проекта повреждён",
+            };
+        }
+        return {
+            projectId,
+            path: root,
+            file: real,
+            exists: true,
+            trusted: trust.projects[root]?.hash === hash,
+            hash,
+            roles: roles.map((role) => ({ ...role, inherited: false })),
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {
+                projectId,
+                path: root,
+                file,
+                exists: false,
+                trusted: false,
+                roles: [],
+            };
+        return {
+            projectId,
+            path: root,
+            file,
+            exists: false,
+            trusted: false,
+            roles: [],
+            problem: error instanceof Error ? error.message : "Не удалось прочитать роли проекта",
+        };
+    }
+}
+function projectRolesFile(root) {
+    return join(root, projectRolesRelativeFile);
+}
+function newRoleId(existing) {
+    for (;;) {
+        const id = `role-${randomBytes(4).toString("hex")}`;
+        if (!isServiceRoleId(id) && !existing.some((role) => role.id === id))
+            return id;
+    }
+}
+async function writeRoles(root, roles) {
+    const file = projectRolesFile(root);
+    const directory = dirname(file);
+    await mkdir(directory, { recursive: true });
+    // `.projector` itself may be a symlink out of the project.
+    const realDirectory = await realpath(directory);
+    const rel = relative(root, realDirectory);
+    if (rel.startsWith("..") || isAbsolute(rel))
+        throw new Error("Папка .projector указывает за пределы проекта");
+    const temporary = `${file}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(temporary, `${JSON.stringify({ version: 1, roles }, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o644,
+    });
+    await rename(temporary, file);
+}
+async function modify(projectId, action) {
+    const task = queue.then(async () => {
+        const state = await projectRoleState(projectId);
+        if (state.problem)
+            throw new Error(state.problem);
+        const roles = state.roles.map(({ inherited: _inherited, ...role }) => role);
+        await writeRoles(state.path, action(roles));
+        return projectRoleState(projectId);
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** Creates a project role; the new file is untrusted until the user approves its hash. */
+export async function createProjectRole(projectId, value) {
+    const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    return modify(projectId, (roles) => {
+        const id = newRoleId(roles);
+        const role = normalizeAgentRole({ ...input, id, kind: "chat" });
+        if (!role || role.kind !== "chat" || isServiceRoleId(role.id))
+            throw new Error("Некорректная роль: укажите название и агента");
+        return [...roles, role];
+    });
+}
+/** Replaces one project role; the file hash changes, so trust must be granted again. */
+export async function saveProjectRole(projectId, id, value) {
+    if (isServiceRoleId(id))
+        throw new Error("Служебная роль настраивается отдельно");
+    return modify(projectId, (roles) => {
+        if (!roles.some((role) => role.id === id))
+            throw new Error(`Неизвестная роль: ${id}`);
+        const role = normalizeAgentRole({ ...value, id, kind: "chat" });
+        if (!role || role.kind !== "chat")
+            throw new Error("Некорректная роль: укажите название и агента");
+        return roles.map((item) => (item.id === id ? role : item));
+    });
+}
+export async function deleteProjectRole(projectId, id) {
+    if (isServiceRoleId(id))
+        throw new Error("Служебную роль нельзя удалить");
+    return modify(projectId, (roles) => {
+        if (!roles.some((role) => role.id === id))
+            throw new Error(`Неизвестная роль: ${id}`);
+        return roles.filter((role) => role.id !== id);
+    });
+}
+/** Trusts (or stops trusting) the current contents of the project's role file. */
+export async function setProjectRoleTrust(projectId, trusted) {
+    const state = await projectRoleState(projectId);
+    if (trusted && !state.exists)
+        throw new Error("В проекте нет файла ролей");
+    if (trusted && (!state.hash || state.problem))
+        throw new Error("Файл ролей проекта нельзя доверять");
+    const task = queue.then(async () => {
+        const file = await readTrust();
+        if (trusted)
+            file.projects[state.path] = { hash: state.hash, at: new Date().toISOString() };
+        else
+            delete file.projects[state.path];
+        await writeTrust(file);
+        return projectRoleState(projectId);
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** The role of a trusted project file; untrusted roles never reach chats, jobs or tasks. */
+export async function readProjectAgentRole(projectId, id) {
+    const state = await projectRoleState(projectId);
+    if (!state.trusted)
+        return undefined;
+    return state.roles.find((role) => role.id === id);
+}

package/packages/server/modules/agent-roles/runtime.js

@@ -0,0 +1,68 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+/** The same spelling the Projector skill loader accepts; a role name must not escape its folder. */
+const RESOURCE_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+/** Where a skill or command may live: the user's folder, then the project's two conventions. */
+function resourceRoots(cwd) {
+    return [
+        join(dataDir(), "agent"),
+        ...(cwd ? [join(cwd, ".projector"), join(cwd, ".claude")] : []),
+    ];
+}
+/** The readable file of a selected skill (`SKILL.md`) or command (`commands/<name>.md`). */
+async function resourceFile(name, cwd) {
+    if (!RESOURCE_NAME.test(name))
+        return undefined;
+    for (const root of resourceRoots(cwd)) {
+        for (const file of [
+            join(root, "skills", name, "SKILL.md"),
+            join(root, "commands", `${name}.md`),
+        ]) {
+            if (await access(file).then(() => true, () => false))
+                return file;
+        }
+    }
+    return undefined;
+}
+/** The role's own instructions, framed for any backend; empty when the role has none. */
+export function rolePromptText(role) {
+    const prompt = role?.prompt?.trim();
+    if (!prompt)
+        return "";
+    return `Роль «${role?.name ?? "Projector"}»: дополнительные инструкции, которым следуй в этом чате.\n\n${prompt}`;
+}
+/**
+ * Context an external agent gets before its first message: the role prompt and the selected
+ * skills with readable paths. The agent opens a skill only when the task needs it.
+ */
+export async function roleContext(role, cwd) {
+    const parts = [rolePromptText(role)].filter(Boolean);
+    if (!role || role.skills === undefined)
+        return parts.join("\n\n");
+    if (!role.skills.length) {
+        parts.push("Навыки в этой роли отключены.");
+        return parts.join("\n\n");
+    }
+    const found = [];
+    const missing = [];
+    for (const name of role.skills) {
+        const file = await resourceFile(name, cwd);
+        if (file)
+            found.push(`- ${name}: ${file}`);
+        else
+            missing.push(name);
+    }
+    if (found.length)
+        parts.push(`Навыки роли (прочитай файл, когда он подходит задаче):\n${found.join("\n")}`);
+    if (missing.length)
+        parts.push(`Навыки роли не найдены: ${missing.join(", ")}.`);
+    return parts.join("\n\n");
+}
+/** Keeps only the servers a role names; an omitted list keeps every configured server. */
+export function selectedNames(items, names) {
+    if (names === undefined)
+        return [...items];
+    const wanted = new Set(names);
+    return items.filter((item) => wanted.has(item.name));
+}

package/packages/server/modules/agent-roles/store.js

@@ -0,0 +1,190 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { BUILTIN_SERVICE_ROLES, SERVICE_ROLE_IDS, isServiceRoleId, normalizeAgentRole, normalizeRoleSelection, serviceRoleInheritsModel, } from "../../../core/modules/agent-role/index.js";
+import { projectRoleState } from "./project.js";
+/** The user's choices for the built-in service roles: `$XDG_DATA_HOME/projector/agent/roles.json`. */
+export const rolesFile = () => join(dataDir(), "agent", "roles.json");
+const empty = () => ({ version: 1, roles: [], builtins: {} });
+/** Reads only the fields this version understands; malformed JSON is left to `readState`. */
+function stateOf(text) {
+    const data = JSON.parse(text);
+    const roles = [];
+    if (Array.isArray(data?.roles))
+        for (const item of data.roles) {
+            const role = normalizeAgentRole(item);
+            if (!role || role.kind !== "chat" || isServiceRoleId(role.id))
+                continue;
+            if (roles.some((known) => known.id === role.id))
+                continue;
+            roles.push(role);
+        }
+    const builtins = {};
+    if (data?.builtins && typeof data.builtins === "object" && !Array.isArray(data.builtins))
+        for (const id of SERVICE_ROLE_IDS) {
+            const row = data.builtins[id];
+            if (!row || typeof row !== "object" || Array.isArray(row))
+                continue;
+            const selection = normalizeRoleSelection(row.selection);
+            if (Object.keys(selection).length)
+                builtins[id] = { selection };
+        }
+    return { version: 1, roles, builtins };
+}
+async function readState() {
+    try {
+        return stateOf(await readFile(rolesFile(), "utf8"));
+    }
+    catch (error) {
+        // A broken file is kept next to the settings instead of being silently overwritten.
+        if (error.code !== "ENOENT")
+            await rename(rolesFile(), `${rolesFile()}.broken-${Date.now()}`).catch(() => undefined);
+        return empty();
+    }
+}
+/** One write at a time: two settings requests must not lose each other's change. */
+let queue = Promise.resolve();
+/** Writes through a temporary file, with the owner-only mode secrets-adjacent settings use. */
+async function writeState(state) {
+    const path = rolesFile();
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await rename(temporary, path);
+}
+function serviceRoleView(role, selection) {
+    return {
+        ...role,
+        selection,
+        inherited: serviceRoleInheritsModel({ selection }),
+    };
+}
+function chatRoleView(role) {
+    return { ...role, inherited: false };
+}
+/** The built-in service roles and the user's chat roles, in one list for the settings. */
+export async function roleSettings() {
+    const state = await readState();
+    return {
+        roles: [
+            ...BUILTIN_SERVICE_ROLES.map((role) => serviceRoleView(role, state.builtins[role.id]?.selection ?? {})),
+            ...state.roles.map(chatRoleView),
+        ],
+        file: rolesFile(),
+    };
+}
+/** One role by id, for opening a chat or capturing its snapshot. */
+export async function readAgentRole(id, projectId) {
+    if (projectId) {
+        const project = await projectRoleState(projectId);
+        const projectRole = project.roles.find((role) => role.id === id);
+        // A project role with this id shadows the global one even when the file is not trusted.
+        if (projectRole)
+            return project.trusted ? projectRole : undefined;
+    }
+    const state = await readState();
+    if (isServiceRoleId(id)) {
+        const role = BUILTIN_SERVICE_ROLES.find((item) => item.id === id);
+        return role ? serviceRoleView(role, state.builtins[id]?.selection ?? {}) : undefined;
+    }
+    const role = state.roles.find((item) => item.id === id);
+    return role ? chatRoleView(role) : undefined;
+}
+/** Stores one service role's selection; an empty selection returns it to the chat's model. */
+export async function saveServiceRole(id, value) {
+    if (!isServiceRoleId(id))
+        throw new Error(`Неизвестная служебная роль: ${id}`);
+    const selection = normalizeRoleSelection(value);
+    const task = queue.then(async () => {
+        const state = await readState();
+        if (Object.keys(selection).length)
+            state.builtins[id] = { selection };
+        else
+            delete state.builtins[id];
+        await writeState(state);
+        return roleSettings();
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** Removes the service role's own model: it follows the chat again. */
+export async function resetServiceRole(id) {
+    if (!isServiceRoleId(id))
+        throw new Error(`Неизвестная служебная роль: ${id}`);
+    const task = queue.then(async () => {
+        const state = await readState();
+        delete state.builtins[id];
+        await writeState(state);
+        return roleSettings();
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** Generates a stable id for a role created in the settings. */
+function newRoleId(existing) {
+    for (;;) {
+        const id = `role-${randomBytes(4).toString("hex")}`;
+        if (!isServiceRoleId(id) && !existing.some((role) => role.id === id))
+            return id;
+    }
+}
+/** Creates a chat role; service roles are never user-created. */
+export async function createChatRole(value) {
+    const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    const task = queue.then(async () => {
+        const state = await readState();
+        const id = newRoleId(state.roles);
+        const role = normalizeAgentRole({ ...input, id, kind: "chat" });
+        if (!role || role.kind !== "chat" || isServiceRoleId(role.id))
+            throw new Error("Некорректная роль: укажите название и агента");
+        state.roles = [...state.roles, role];
+        await writeState(state);
+        const settings = await roleSettings();
+        return { ...settings, created: chatRoleView(role) };
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** Replaces an existing chat role; the id is part of the address and cannot be changed here. */
+export async function saveChatRole(id, value) {
+    if (isServiceRoleId(id))
+        throw new Error("Служебная роль настраивается отдельно");
+    const task = queue.then(async () => {
+        const state = await readState();
+        const index = state.roles.findIndex((role) => role.id === id);
+        if (index < 0)
+            throw new Error(`Неизвестная роль: ${id}`);
+        const role = normalizeAgentRole({ ...value, id, kind: "chat" });
+        if (!role || role.kind !== "chat")
+            throw new Error("Некорректная роль: укажите название и агента");
+        state.roles = state.roles.map((item) => (item.id === id ? role : item));
+        await writeState(state);
+        return roleSettings();
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** Deletes a chat role; chats that already started keep their saved snapshot. */
+export async function deleteChatRole(id) {
+    if (isServiceRoleId(id))
+        throw new Error("Служебную роль нельзя удалить");
+    const task = queue.then(async () => {
+        const state = await readState();
+        if (!state.roles.some((role) => role.id === id))
+            throw new Error(`Неизвестная роль: ${id}`);
+        state.roles = state.roles.filter((role) => role.id !== id);
+        await writeState(state);
+        return roleSettings();
+    });
+    queue = task.catch(() => undefined);
+    return task;
+}
+/** The model the service call should use: the role's own provider over the chat's fallback. */
+export async function serviceRoleSelection(id, fallback) {
+    const state = await readState();
+    return { ...fallback, ...state.builtins[id]?.selection };
+}