@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/server/modules/hub/hub.js

@@ -0,0 +1,142 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { isDeviceId } from "../../../core/modules/hub/index.js";
+import { connectHub } from "./connector.js";
+const path = () => join(dataDir(), "hub.json");
+const root = globalThis;
+const state = (root.projectorHub ??= { online: false });
+state.connections ??= state.config ? [state.config] : [];
+export function hubStatus() {
+    return {
+        enabled: !!state.config,
+        online: state.online,
+        url: state.config?.url,
+        deviceId: state.config?.deviceId,
+        error: state.error,
+        connections: state.connections.map(({ url, deviceId }) => ({ url, deviceId })),
+    };
+}
+function connectionConfig(value) {
+    let config;
+    if (value !== null) {
+        const input = value;
+        if (!input ||
+            typeof input.url !== "string" ||
+            !isDeviceId(input.deviceId) ||
+            typeof input.token !== "string" ||
+            !input.token ||
+            input.token.length > 4096)
+            throw new Error("Нужны url, deviceId и token");
+        const url = new URL(input.url);
+        if (url.username || url.password || url.search || url.hash || url.pathname !== "/")
+            throw new Error("Укажите origin Hub без пути и credentials");
+        const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+        if (url.protocol !== "https:" && !(url.protocol === "http:" && local))
+            throw new Error("Для удалённого Hub требуется HTTPS");
+        config = { url: url.origin, deviceId: input.deviceId, token: input.token };
+    }
+    return config;
+}
+/** An origin identifies one saved Hub. Only config owns a running connector. */
+export function configureHub(value) {
+    let connections = [...state.connections];
+    let config = state.config;
+    if (value === null) {
+        connections = [];
+        config = undefined;
+    }
+    else {
+        const input = value;
+        if (!input || typeof input !== "object" || Array.isArray(input))
+            throw new Error("Нужны параметры подключения Hub");
+        if (input.enabled === false)
+            config = undefined;
+        else if (input.action === "activate" || input.action === "delete") {
+            const saved = connections.find((item) => item.url === input.url);
+            if (!saved)
+                throw new Error("Hub не найден");
+            if (input.action === "activate")
+                config = saved;
+            else {
+                connections = connections.filter((item) => item !== saved);
+                if (config?.url === saved.url)
+                    config = undefined;
+            }
+        }
+        else {
+            if (input.action && input.action !== "save")
+                throw new Error("Неизвестное действие Hub");
+            const saved = typeof input.url === "string"
+                ? connections.find((item) => item.url === new URL(input.url).origin)
+                : undefined;
+            const next = connectionConfig({
+                ...input,
+                token: input.token === "" || input.token === undefined ? saved?.token : input.token,
+            });
+            connections = connections.filter((item) => item.url !== next.url);
+            connections.push(next);
+            // Legacy PUT connects immediately; saving a profile only updates an active match.
+            if (input.action !== "save" || config?.url === next.url)
+                config = next;
+        }
+    }
+    mkdirSync(dataDir(), { recursive: true });
+    const temporary = path() + ".tmp";
+    writeFileSync(temporary, JSON.stringify({ connections, activeUrl: config?.url ?? null }), {
+        mode: 0o600,
+    });
+    chmodSync(temporary, 0o600);
+    renameSync(temporary, path());
+    const changed = JSON.stringify(state.config) !== JSON.stringify(config);
+    state.connections = connections;
+    state.config = config;
+    if (changed)
+        state.apply?.(config);
+}
+export function bindHub(handlers) {
+    let stop;
+    let epoch = 0;
+    const apply = (config) => {
+        const current = ++epoch;
+        stop?.();
+        stop = undefined;
+        state.online = false;
+        state.error = undefined;
+        if (config)
+            stop = connectHub(config, handlers, (online, error) => {
+                if (epoch === current) {
+                    state.online = online;
+                    state.error = error;
+                }
+            });
+    };
+    // Runtime rebind must dispose the previous connector before installing a replacement.
+    state.apply?.(undefined);
+    state.apply = apply;
+    try {
+        const stored = JSON.parse(readFileSync(path(), "utf8"));
+        if (stored && Array.isArray(stored.connections)) {
+            const connections = stored.connections.map((item) => connectionConfig(item));
+            if (connections.some((item) => !item) ||
+                new Set(connections.map((item) => item.url)).size !== connections.length)
+                throw new Error("Некорректный список Hub");
+            state.connections = connections;
+            state.config = connections.find((item) => item.url === stored.activeUrl);
+        }
+        else {
+            state.config = connectionConfig(stored);
+            state.connections = state.config ? [state.config] : [];
+        }
+    }
+    catch {
+        state.connections = [];
+        state.config = undefined;
+    }
+    apply(state.config);
+    return () => {
+        stop?.();
+        if (state.apply === apply)
+            state.apply = undefined;
+    };
+}

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

@@ -0,0 +1 @@
+export { bindHub, configureHub, hubStatus } from "./hub.js";

package/packages/server/modules/ide/editor-settings.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { defaultEditorTheme, isEditorTheme, } from "../../../core/modules/editor-themes/index.js";
+const settingsPath = () => join(dataDir(), "editor.json");
+let pending = Promise.resolve();
+export async function readEditorSettings() {
+    try {
+        const data = JSON.parse(await readFile(settingsPath(), "utf8"));
+        return { theme: isEditorTheme(data?.theme) ? data.theme : defaultEditorTheme };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { theme: defaultEditorTheme };
+        throw error;
+    }
+}
+export async function writeEditorSettings(theme) {
+    if (!isEditorTheme(theme))
+        throw new Error("Неизвестная тема редактора");
+    const task = pending.then(async () => {
+        await mkdir(dataDir(), { recursive: true });
+        const path = settingsPath();
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, JSON.stringify({ theme }, null, 2) + "\n", { mode: 0o600 });
+            await rename(temporary, path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        return { theme };
+    });
+    pending = task.catch(() => undefined);
+    return task;
+}

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

@@ -0,0 +1,3 @@
+export { readKeybindings, writeKeybindings } from "./keybindings.js";
+export { readEditorSettings, writeEditorSettings } from "./editor-settings.js";
+export { bindIdeCommandEvents, claimIdeCommand, completeIdeCommand, ensureIdeMcpToken, ideMcpTokenFile, ideMcpTokenMatches, ideOwnerPage, requestIdeCommand, } from "./mcp-bridge.js";

package/packages/server/modules/ide/keybindings.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { parseKeybindings } from "../../../core/modules/ide/index.js";
+const settingsPath = () => join(dataDir(), "keybindings.json");
+let pending = Promise.resolve();
+export async function readKeybindings() {
+    let contents;
+    try {
+        contents = await readFile(settingsPath(), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { path: settingsPath(), bindings: [] };
+        throw error;
+    }
+    return { path: settingsPath(), bindings: parseKeybindings(JSON.parse(contents)) };
+}
+export async function writeKeybindings(value) {
+    const bindings = parseKeybindings(value);
+    const task = pending.then(async () => {
+        await mkdir(dataDir(), { recursive: true });
+        const path = settingsPath();
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, JSON.stringify(bindings, null, 2) + "\n", { mode: 0o600 });
+            await rename(temporary, path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        return { path, bindings };
+    });
+    pending = task.catch(() => undefined);
+    return task;
+}

package/packages/server/modules/ide/mcp-bridge.js

@@ -0,0 +1,150 @@
+import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { broadcastEvent, onEventClientClose } from "../events/index.js";
+const host = globalThis;
+const state = (host.projectorIdeBridge ??= {
+    pending: new Map(),
+    owners: new Map(),
+});
+// A hot reload keeps the old object: fill fields added by a newer version instead of crashing.
+if (!state.pending)
+    state.pending = new Map();
+if (!state.owners)
+    state.owners = new Map();
+/** How long the owner page has to take a request before another tab of the project may. */
+const OWNER_GRACE_MS = 3000;
+/** The key of the built-in IDE MCP server: only its holder may ask the page for commands. */
+export const ideMcpTokenFile = () => join(dataDir(), "agent", "ide-mcp.token");
+/** Reads the key, creating it once so a restarted server keeps the key an older MCP process holds. */
+export async function ensureIdeMcpToken() {
+    if (state.token)
+        return state.token;
+    const path = ideMcpTokenFile();
+    try {
+        const existing = (await readFile(path, "utf8")).trim();
+        if (existing)
+            return (state.token = existing);
+    }
+    catch {
+        // Missing or unreadable: create a new one below.
+    }
+    const token = randomBytes(32).toString("hex");
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${token}\n`, { mode: 0o600 });
+    return (state.token = token);
+}
+export async function ideMcpTokenMatches(value) {
+    const expected = await ensureIdeMcpToken();
+    if (!value || value.length !== expected.length)
+        return false;
+    return timingSafeEqual(Buffer.from(value), Buffer.from(expected));
+}
+function broadcast(entry) {
+    const payload = {
+        id: entry.id,
+        session: entry.session,
+        projectId: entry.projectId,
+        request: entry.request,
+        owner: entry.owner,
+        fallbackAt: entry.fallbackAt,
+        expiresAt: entry.expiresAt,
+    };
+    // Every page receives it: the owner answers at once, the others wait for the grace period.
+    broadcastEvent("ide-command-request", payload);
+}
+/**
+ * A page that goes away releases its sessions. A request it had not claimed is offered to the
+ * other tabs of the project; a request it was already running fails instead of running twice.
+ */
+export function bindIdeCommandEvents() {
+    state.off?.();
+    const off = onEventClientClose((page) => {
+        for (const [session, owner] of state.owners) {
+            if (owner !== page)
+                continue;
+            state.owners.delete(session);
+            for (const entry of state.pending.values()) {
+                if (entry.session !== session)
+                    continue;
+                if (entry.claimedBy)
+                    entry.finish({ error: "Страница Projector закрыта" });
+                else {
+                    entry.owner = undefined;
+                    entry.claimedBy = undefined;
+                    broadcast(entry);
+                }
+            }
+        }
+    });
+    state.off = off;
+    return () => {
+        off();
+        if (state.off === off)
+            state.off = undefined;
+    };
+}
+/**
+ * Asks the page that owns the MCP session for a command. The first answer binds the session to
+ * that page, so discovery and execution see the same workbench; another tab may take over only
+ * after a short grace period or when the owner page closes.
+ */
+export function requestIdeCommand(projectId, session, request, timeoutMs = 60_000) {
+    if (!state.off)
+        bindIdeCommandEvents();
+    const id = randomUUID();
+    const now = Date.now();
+    const owner = state.owners.get(session);
+    return new Promise((resolve, reject) => {
+        let timer;
+        const entry = {
+            id,
+            session,
+            projectId,
+            request,
+            expiresAt: now + timeoutMs,
+            fallbackAt: now + Math.min(OWNER_GRACE_MS, Math.floor(timeoutMs / 2)),
+            ...(owner ? { owner } : {}),
+            finish: (result) => {
+                if (!state.pending.delete(id))
+                    return;
+                clearTimeout(timer);
+                if (result.error)
+                    reject(new Error(result.error));
+                else
+                    resolve(result.output);
+            },
+        };
+        timer = setTimeout(() => {
+            // The page may be waiting on a confirmation: tell it the deadline has passed.
+            broadcastEvent("ide-command-cancel", { id }, entry.claimedBy ?? entry.owner);
+            entry.finish({ error: "Projector не ответил на запрос команды" });
+        }, timeoutMs);
+        state.pending.set(id, entry);
+        broadcast(entry);
+    });
+}
+/** The page that answered this MCP session, when it has one. */
+export function ideOwnerPage(session) {
+    return state.owners.get(session);
+}
+/** The owner takes a request at once; another page may take it after the grace period. */
+export function claimIdeCommand(id, page) {
+    const entry = state.pending.get(id);
+    if (!entry || entry.claimedBy || !page || Date.now() >= entry.expiresAt)
+        return false;
+    if (entry.owner && entry.owner !== page && Date.now() < entry.fallbackAt)
+        return false;
+    entry.claimedBy = page;
+    entry.owner = page;
+    state.owners.set(entry.session, page);
+    return true;
+}
+export function completeIdeCommand(id, page, result) {
+    const entry = state.pending.get(id);
+    if (!entry || !page || entry.claimedBy !== page)
+        return false;
+    entry.finish(result);
+    return true;
+}

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

@@ -0,0 +1,2 @@
+export { clearInstance } from "./instance.js";
+export { writeInstance } from "./instance.js";

package/packages/server/modules/instance/instance.js

@@ -0,0 +1,50 @@
+import { readFileSync, unlinkSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { APP_PORT, appUrl, instancePath } from "../../../core/modules/app-paths/index.js";
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function writeInstance(port = APP_PORT) {
+    const file = instancePath();
+    await mkdir(dirname(file), { recursive: true });
+    const info = {
+        pid: process.pid,
+        port,
+        url: appUrl(),
+        startedAt: new Date().toISOString(),
+    };
+    await writeFile(file, `${JSON.stringify(info, null, 2)}\n`, "utf8");
+}
+export async function readInstance() {
+    try {
+        const info = JSON.parse(await readFile(instancePath(), "utf8"));
+        if (!info.pid || !isPidAlive(info.pid)) {
+            await clearInstance();
+            return null;
+        }
+        return info;
+    }
+    catch {
+        return null;
+    }
+}
+/** Also runs during process exit, when asynchronous filesystem work cannot complete. */
+export function clearInstance() {
+    try {
+        const file = instancePath();
+        const info = JSON.parse(readFileSync(file, "utf8"));
+        if (info.pid && info.pid !== process.pid)
+            return;
+        unlinkSync(file);
+    }
+    catch {
+        // Missing, malformed or already removed by another shutdown hook.
+    }
+}

package/packages/server/modules/integration-store/index.js

@@ -0,0 +1,2 @@
+export { readIntegrations, integrationConfig, updateIntegration, revealIntegrationCredential, revealIntegrationToken, fieldText, useIntegrationVault, migrateIntegrationSecrets, integrationsPath, } from "./store.js";
+export { listIntegrations } from "./list.js";

package/packages/server/modules/integration-store/list.js

@@ -0,0 +1,12 @@
+import { vault } from "../secrets/index.js";
+import { integrationsPath, migrateIntegrationSecrets } from "./store.js";
+/** Settings overview: every service supplies its own public status; this adds file and vault info. */
+export async function listIntegrations(statuses) {
+    // Plaintext credentials left by older versions move into the keyring on first view.
+    await migrateIntegrationSecrets().catch((error) => console.error("Перенос секретов в системное хранилище:", error.message));
+    return {
+        file: integrationsPath(),
+        secretStorage: await vault.storage(),
+        integrations: await Promise.all(statuses.map((status) => status())),
+    };
+}

package/packages/server/modules/integration-store/store.js

@@ -0,0 +1,141 @@
+import { mkdir, readFile, writeFile, rename } from "node:fs/promises";
+import { os } from "../../../core/modules/os/index.js";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { vault as systemVault } from "../secrets/index.js";
+import { HttpError } from "../http/index.js";
+let vault = systemVault;
+/** Test hook: replaces the secret vault. */
+export const useIntegrationVault = (next) => {
+    vault = next;
+};
+const account = (id) => `integration:${id}`;
+const empty = () => ({ enabled: false, settings: {}, credentials: {} });
+export const integrationsPath = () => join(dataDir(), "integrations.json");
+let queue = Promise.resolve();
+async function readFileRaw() {
+    try {
+        const parsed = JSON.parse(await readFile(integrationsPath(), "utf8"));
+        if (parsed.version !== 1 || !parsed.integrations || typeof parsed.integrations !== "object")
+            throw new Error("Некорректный файл интеграций");
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, integrations: {} };
+        throw error;
+    }
+}
+async function writeFileRaw(file) {
+    await mkdir(dataDir(), { recursive: true });
+    const tmp = `${integrationsPath()}.${randomUUID()}.tmp`;
+    await writeFile(tmp, JSON.stringify(file, null, 2) + "\n", { mode: 0o600 });
+    await rename(tmp, integrationsPath());
+    await os.tools.restrictToOwner(integrationsPath());
+}
+/** Strict: a locked, denied or broken keyring throws instead of looking like "no credentials". */
+async function openCredentials(id, stored) {
+    if (stored.vault !== "keyring")
+        return stored.credentials ?? {};
+    const secret = await vault.get(account(id));
+    return secret ? JSON.parse(secret) : {};
+}
+async function resolve(id, stored) {
+    const { vault: _vault, ...config } = stored;
+    try {
+        return { ...config, credentials: await openCredentials(id, stored) };
+    }
+    catch (error) {
+        const message = error.message;
+        console.error(`Интеграция ${id}: секреты недоступны: ${message}`);
+        return { ...config, credentials: {}, credentialsError: message };
+    }
+}
+export async function readIntegrations() {
+    const file = await readFileRaw();
+    const integrations = {};
+    for (const [id, stored] of Object.entries(file.integrations))
+        integrations[id] = await resolve(id, stored);
+    return { version: file.version, integrations };
+}
+export async function integrationConfig(id) {
+    return resolve(id, (await readFileRaw()).integrations[id] ?? empty());
+}
+/** Writes credentials to the keyring when available, else keeps them in the 0600 file. */
+async function persistCredentials(id, credentials, previous) {
+    if (!Object.keys(credentials).length) {
+        if (previous.vault === "keyring")
+            await vault.delete(account(id));
+        return { credentials: {} };
+    }
+    if ((await vault.storage()).backend !== "keyring")
+        return { credentials };
+    await vault.set(account(id), `Projector: ${id}`, JSON.stringify(credentials));
+    return { credentials: {}, vault: "keyring" };
+}
+export async function updateIntegration(id, update) {
+    const operation = queue.then(async () => {
+        const file = await readFileRaw();
+        const stored = file.integrations[id] ?? empty();
+        const credentials = await openCredentials(id, stored);
+        const { credentialsError: _error, credentials: next, ...rest } = update({
+            enabled: stored.enabled,
+            settings: stored.settings,
+            credentials,
+        });
+        const persisted = await persistCredentials(id, next, stored);
+        file.integrations[id] = { ...rest, ...persisted };
+        await writeFileRaw(file);
+    });
+    queue = operation.catch(() => { });
+    await operation;
+}
+/**
+ * Moves plaintext credentials into the keyring once it is reachable.
+ * The file is rewritten only after the stored value reads back identically.
+ */
+export async function migrateIntegrationSecrets() {
+    const operation = queue.then(async () => {
+        if ((await vault.storage()).backend !== "keyring")
+            return [];
+        const file = await readFileRaw();
+        const moved = [];
+        for (const [id, stored] of Object.entries(file.integrations)) {
+            if (stored.vault || !Object.keys(stored.credentials ?? {}).length)
+                continue;
+            const payload = JSON.stringify(stored.credentials);
+            await vault.set(account(id), `Projector: ${id}`, payload);
+            if ((await vault.get(account(id))) !== payload)
+                throw new Error(`Не удалось проверить секреты ${id}`);
+            file.integrations[id] = { ...stored, credentials: {}, vault: "keyring" };
+            moved.push(id);
+        }
+        if (moved.length)
+            await writeFileRaw(file);
+        return moved;
+    });
+    queue = operation.then(() => { }, () => { });
+    return operation;
+}
+/**
+ * Returns one credential for display, only while it is protected by the keyring.
+ * Plaintext file credentials are never offered for viewing.
+ */
+export async function revealIntegrationCredential(id, name) {
+    const stored = (await readFileRaw()).integrations[id];
+    if (stored?.vault !== "keyring")
+        return undefined;
+    return (await openCredentials(id, stored))[name];
+}
+/** `{ token }` for the settings «eye»; refuses tokens that live in the plaintext file. */
+export async function revealIntegrationToken(id) {
+    const token = await revealIntegrationCredential(id, "token");
+    if (!token)
+        throw new HttpError(409, "Просмотр доступен только для токена из системного хранилища секретов");
+    return { token };
+}
+/** Trimmed string from untrusted input, or "". */
+export function fieldText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}

package/packages/server/modules/judge/approval.js

@@ -0,0 +1,35 @@
+import { judgeAllows, } from "../../../core/modules/agent-judge/index.js";
+import { judgeAction } from "./verdict.js";
+/**
+ * Wraps the user's approval: the judge explains the action in the card, or lets a low-risk action
+ * run and leaves a visible note. A failed judge never allows anything by itself.
+ */
+export function createJudgedApproval(options) {
+    return async (request) => {
+        if (!options.settings.show && !options.settings.auto)
+            return options.approve(request);
+        const verdict = await (options.judge ?? judgeAction)({
+            tool: request.tool,
+            title: request.title,
+            detail: request.detail,
+            input: request.input,
+            cwd: options.cwd,
+            backend: options.backend,
+            signal: options.signal,
+        });
+        if (judgeAllows(options.settings, verdict)) {
+            options.emit("judge", {
+                tool: request.tool,
+                title: request.title,
+                verdict,
+                decision: "auto",
+                at: Date.now(),
+            });
+            return true;
+        }
+        return options.approve({
+            ...request,
+            ...(options.settings.show ? { judge: verdict } : {}),
+        });
+    };
+}

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

@@ -0,0 +1,3 @@
+export { createJudgedApproval } from "./approval.js";
+export { readJudgeSettings, writeJudgeSettings } from "./settings.js";
+export { clearJudgeCache, judgeAction, judgeFallback, JUDGE_LIMITS, parseJudgeVerdict, } from "./verdict.js";

package/packages/server/modules/judge/settings.js

@@ -0,0 +1,35 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dataDir } from "../../../core/modules/app-paths/index.js";
+import { JUDGE_DEFAULTS, normalizeJudgeSettings, } from "../../../core/modules/agent-judge/index.js";
+import { writeFileAtomic } from "../providers/index.js";
+const file = () => join(dataDir(), "agent", "judge.json");
+/** Global judge settings; a damaged or missing file means the defaults. */
+export async function readJudgeSettings() {
+    try {
+        const parsed = JSON.parse(await readFile(file(), "utf8"));
+        return normalizeJudgeSettings(parsed);
+    }
+    catch {
+        return { ...JUDGE_DEFAULTS };
+    }
+}
+/** Writes only valid values: scores 4 and 5 can never become automatic. */
+export async function writeJudgeSettings(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const row = value;
+        if (row.maxRisk !== undefined && row.maxRisk !== 1 && row.maxRisk !== 2 && row.maxRisk !== 3)
+            throw new Error("maxRisk должен быть 1, 2 или 3: более высокий риск не автоматизируется");
+        if (row.confidence !== undefined &&
+            row.confidence !== "high" &&
+            row.confidence !== "high-medium")
+            throw new Error("confidence должен быть high или high-medium");
+        if (row.show !== undefined && typeof row.show !== "boolean")
+            throw new Error("show должен быть boolean");
+        if (row.auto !== undefined && typeof row.auto !== "boolean")
+            throw new Error("auto должен быть boolean");
+    }
+    const settings = normalizeJudgeSettings(value);
+    await writeFileAtomic(file(), `${JSON.stringify(settings, null, 2)}\n`);
+    return settings;
+}