@oneentry/mcp-platform-server 0.1.0 → 0.1.3

package/dist/api/build-catalog.js

@@ -0,0 +1,187 @@
+import { createHash } from 'node:crypto';
+import { capSchema, normalizeSchema } from './normalize-schema.js';
+const API_PREFIX = '/api/admin';
+const METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+const ALWAYS_CONFIRM = [
+    /^\/immutable-settings/,
+    /^\/admins/,
+    /^\/backups/,
+    /^\/modules/,
+    /^\/payments\/webhook/,
+    /^\/auth\/logout\/all-users/,
+    /^\/settings-general/,
+    /^\/system\/captcha-keys/,
+];
+const riskOf = (method) => {
+    if (method === 'get') {
+        return 'read';
+    }
+    return method === 'delete' ? 'destructive' : 'write';
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const asString = (value) => typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+const responseSummary = (responses) => {
+    if (!isRecord(responses)) {
+        return undefined;
+    }
+    for (const code of ['200', '201', '202']) {
+        const entry = responses[code];
+        if (isRecord(entry)) {
+            const description = asString(entry['description']);
+            if (description) {
+                return description.replace(/\s+/g, ' ').slice(0, 300);
+            }
+        }
+    }
+    return undefined;
+};
+const buildParams = (raw, components) => {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const params = [];
+    for (const item of raw) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        const location = asString(item['in']);
+        const name = asString(item['name']);
+        if (!name || (location !== 'path' && location !== 'query' && location !== 'header')) {
+            continue;
+        }
+        params.push({
+            name,
+            location,
+            required: item['required'] === true || location === 'path',
+            description: asString(item['description']),
+            schema: normalizeSchema(item['schema'], components),
+            example: item['example'],
+        });
+    }
+    return params;
+};
+const buildBody = (raw, components) => {
+    if (!isRecord(raw)) {
+        return undefined;
+    }
+    const content = raw['content'];
+    if (!isRecord(content)) {
+        return undefined;
+    }
+    const contentType = Object.keys(content)[0];
+    if (!contentType) {
+        return undefined;
+    }
+    const media = content[contentType];
+    if (!isRecord(media)) {
+        return undefined;
+    }
+    return {
+        contentType,
+        schema: capSchema(normalizeSchema(media['schema'], components)),
+        required: raw['required'] === true,
+    };
+};
+export const buildCatalog = (params) => {
+    const { rawSwagger } = params;
+    const swagger = JSON.parse(rawSwagger);
+    if (!isRecord(swagger) || !isRecord(swagger['paths'])) {
+        throw new Error('The fetched document does not look like an OpenAPI document');
+    }
+    const componentsNode = swagger['components'];
+    const components = isRecord(componentsNode) && isRecord(componentsNode['schemas'])
+        ? componentsNode['schemas']
+        : {};
+    const { byOpId, permissions } = params.permissions;
+    const operations = [];
+    const foreignPaths = [];
+    const withoutOpId = [];
+    for (const [fullPath, pathItem] of Object.entries(swagger['paths'])) {
+        if (!isRecord(pathItem)) {
+            continue;
+        }
+        if (!fullPath.startsWith(API_PREFIX)) {
+            foreignPaths.push(fullPath);
+            continue;
+        }
+        const path = fullPath.slice(API_PREFIX.length) || '/';
+        for (const method of METHODS) {
+            const operation = pathItem[method];
+            if (!isRecord(operation)) {
+                continue;
+            }
+            const opId = asString(operation['operationId']);
+            if (!opId) {
+                withoutOpId.push(`${method.toUpperCase()} ${fullPath}`);
+                continue;
+            }
+            const tags = operation['tags'];
+            const tag = (Array.isArray(tags) ? asString(tags[0]) : undefined) ?? 'Other';
+            const summary = asString(operation['summary']) ?? asString(operation['description']) ?? '';
+            const risk = riskOf(method);
+            const alwaysConfirm = method !== 'get' && ALWAYS_CONFIRM.some((pattern) => pattern.test(path));
+            const permission = byOpId[opId];
+            const entry = {
+                opId,
+                method,
+                path,
+                fullPath,
+                tag,
+                summary,
+                ...(permission ? { permission } : {}),
+                risk,
+                alwaysConfirm,
+                params: buildParams(operation['parameters'], components),
+                ...(buildBody(operation['requestBody'], components)
+                    ? { body: buildBody(operation['requestBody'], components) }
+                    : {}),
+                ...(responseSummary(operation['responses'])
+                    ? { responseSummary: responseSummary(operation['responses']) }
+                    : {}),
+                searchText: '',
+            };
+            entry.searchText = [opId, method.toUpperCase(), path, tag, summary, permission ?? '']
+                .join(' ')
+                .toLowerCase();
+            operations.push(entry);
+        }
+    }
+    operations.sort((a, b) => a.opId.localeCompare(b.opId));
+    const warnings = [];
+    if (foreignPaths.length > 0) {
+        warnings.push(`${String(foreignPaths.length)} path(s) outside ${API_PREFIX} were dropped from the catalog ` +
+            `(e.g. ${foreignPaths.slice(0, 3).join(', ')}). This server exposes the Admin API only.`);
+    }
+    if (withoutOpId.length > 0) {
+        warnings.push(`${String(withoutOpId.length)} operation(s) have no operationId and cannot be called ` +
+            `(e.g. ${withoutOpId.slice(0, 3).join(', ')}). Report it against the CMS.`);
+    }
+    const known = new Set(operations.map((o) => o.opId));
+    const missing = Object.keys(byOpId).filter((opId) => !known.has(opId) && !opId.startsWith('Developer') && !opId.startsWith('Content'));
+    if (missing.length > 0) {
+        warnings.push(`${String(missing.length)} admin operation(s) declare a permission but are absent from the ` +
+            `instance's API document (e.g. ${missing.slice(0, 3).join(', ')}). The bundled permission ` +
+            'map was generated from a different platform revision than this instance runs — update ' +
+            'the package if the catalog looks incomplete.');
+    }
+    const knownPermissions = new Set(permissions);
+    const orphanPermissions = [
+        ...new Set(operations
+            .map((operation) => operation.permission)
+            .filter((value) => value !== undefined && !knownPermissions.has(value))),
+    ];
+    if (orphanPermissions.length > 0) {
+        warnings.push(`${orphanPermissions.length} permission(s) are required by operations but cannot be held by ` +
+            `any admin (${orphanPermissions.join(', ')}). Those operations answer 403 permanently — ` +
+            'treat them as unavailable and report it rather than retrying.');
+    }
+    return {
+        version: 1,
+        builtAt: params.builtAt,
+        apiPrefix: API_PREFIX,
+        swaggerHash: createHash('sha256').update(rawSwagger).digest('hex').slice(0, 16),
+        permissions,
+        warnings,
+        operations,
+    };
+};

package/dist/api/catalog.d.ts

@@ -1,5 +1,6 @@
+import type { Config } from '../config/config.js';
+import { type PermissionMap } from './build-catalog.js';
 import type { Catalog, Operation } from './types.js';
-/** Найденная операция с оценкой релевантности. */
 export interface OperationHit {
     opId: string;
     method: string;
@@ -10,23 +11,16 @@ export interface OperationHit {
     risk: Operation['risk'];
     score: number;
 }
-/**
- * Индекс каталога операций.
- * Поиск здесь примитивный — подсчёт совпадений термов по склеенной строке.
- * Это осознанно: путей 478, они короткие и хорошо самоописаны,
- * полнотекстовый движок дал бы ту же выдачу при большем весе.
- */
 export declare class OperationCatalog {
-    private readonly byOpId;
-    readonly catalog: Catalog;
+    private byOpId;
+    catalog: Catalog;
     constructor(catalog: Catalog);
-    static load(): OperationCatalog;
+    static permissionMap(): PermissionMap;
+    static resolve(config: Config, bearer?: string): Promise<OperationCatalog>;
+    get isEmpty(): boolean;
+    adopt(other: OperationCatalog): void;
     get(opId: string): Operation | undefined;
     operations(): readonly Operation[];
-    /**
-     * Подсказывает похожие `opId` — нужна для внятной ошибки, когда модель
-     * угадала имя операции вместо того, чтобы взять его из поиска.
-     */
     suggest(opId: string, limit?: number): string[];
     search(params: {
         query: string;
@@ -36,4 +30,3 @@ export declare class OperationCatalog {
         limit?: number;
     }): OperationHit[];
 }
-//# sourceMappingURL=catalog.d.ts.map

package/dist/api/catalog.js

@@ -1,12 +1,8 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { dataDir } from '../knowledge/loader.js';
-/**
- * Индекс каталога операций.
- * Поиск здесь примитивный — подсчёт совпадений термов по склеенной строке.
- * Это осознанно: путей 478, они короткие и хорошо самоописаны,
- * полнотекстовый движок дал бы ту же выдачу при большем весе.
- */
+import { buildCatalog } from './build-catalog.js';
+import { fetchSwagger } from './swagger-source.js';
 export class OperationCatalog {
     byOpId;
     catalog;
@@ -14,13 +10,61 @@ export class OperationCatalog {
         if (catalog.version !== 1) {
             throw new Error(`Unsupported catalog version ${String(catalog.version)}`);
         }
-        /** Снапшот приходит из файла, поэтому необязательные поля нормализуем на входе. */
         this.catalog = { ...catalog, warnings: catalog.warnings ?? [] };
         this.byOpId = new Map(catalog.operations.map((o) => [o.opId, o]));
     }
-    static load() {
-        const file = resolve(dataDir(), 'catalog.json');
-        return new OperationCatalog(JSON.parse(readFileSync(file, 'utf8')));
+    static permissionMap() {
+        const file = resolve(dataDir(), 'permissions.json');
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return { byOpId: parsed.byOpId, permissions: parsed.permissions };
+    }
+    static async resolve(config, bearer) {
+        const builtAt = new Date().toISOString();
+        try {
+            const swagger = await fetchSwagger({
+                baseUrl: config.baseUrl,
+                cacheDir: config.cacheDir,
+                timeoutMs: config.requestTimeoutMs,
+                ...(bearer ? { bearer } : {}),
+            });
+            const catalog = buildCatalog({
+                rawSwagger: swagger.raw,
+                permissions: OperationCatalog.permissionMap(),
+                builtAt,
+            });
+            return new OperationCatalog(swagger.origin === 'cache'
+                ? {
+                    ...catalog,
+                    warnings: [
+                        ...catalog.warnings,
+                        `The instance at ${config.baseUrl} was unreachable; this catalog came from the ` +
+                            'on-disk cache and may not match the API that is actually running.',
+                    ],
+                }
+                : catalog);
+        }
+        catch (error) {
+            return new OperationCatalog({
+                version: 1,
+                builtAt,
+                apiPrefix: '/api/admin',
+                swaggerHash: '',
+                permissions: [],
+                warnings: [
+                    `The operation catalog is EMPTY: ${config.baseUrl} did not serve its API document ` +
+                        `(${error instanceof Error ? error.message : String(error)}). ` +
+                        'No API operation can be searched or called until the instance is reachable.',
+                ],
+                operations: [],
+            });
+        }
+    }
+    get isEmpty() {
+        return this.catalog.operations.length === 0;
+    }
+    adopt(other) {
+        this.catalog = other.catalog;
+        this.byOpId = new Map(other.catalog.operations.map((o) => [o.opId, o]));
     }
     get(opId) {
         return this.byOpId.get(opId);
@@ -28,10 +72,6 @@ export class OperationCatalog {
     operations() {
         return this.catalog.operations;
     }
-    /**
-     * Подсказывает похожие `opId` — нужна для внятной ошибки, когда модель
-     * угадала имя операции вместо того, чтобы взять его из поиска.
-     */
     suggest(opId, limit = 5) {
         const needle = opId.toLowerCase();
         return this.catalog.operations
@@ -86,7 +126,6 @@ export class OperationCatalog {
         return hits.slice(0, params.limit ?? 15);
     }
 }
-/** Доля общих триграмм — грубая, но достаточная мера похожести имён операций. */
 const overlap = (a, b) => {
     const grams = (value) => {
         const out = new Set();
@@ -105,4 +144,3 @@ const overlap = (a, b) => {
     }
     return right.size === 0 ? 0 : shared / right.size;
 };
-//# sourceMappingURL=catalog.js.map

package/dist/api/client.d.ts

@@ -1,18 +1,15 @@
 import type { TokenStore } from './auth.js';
 import type { Operation } from './types.js';
-/** Аргументы вызова операции, как их присылает модель. */
 export interface CallArgs {
     path?: Record<string, string | number>;
     query?: Record<string, string | number | boolean>;
     body?: unknown;
 }
-/** Нормализованный неуспех вызова. */
 export interface NormalizedError {
     status: number;
     message: string;
     hint?: string;
 }
-/** Результат вызова: либо тело ответа, либо нормализованная ошибка. */
 export type CallResult = {
     ok: true;
     status: number;
@@ -21,29 +18,10 @@ export type CallResult = {
     ok: false;
     error: NormalizedError;
 };
-/** Ошибка на стороне вызывающего — до отправки запроса. */
 export declare class RequestBuildError extends Error {
 }
-/**
- * Возвращает тело в том виде, в каком его надо сериализовать в запрос.
- * Часть MCP-клиентов передаёт объектный аргумент уже сериализованным в строку;
- * без этой нормализации `JSON.stringify` завернул бы его второй раз, и на сервер
- * ушла бы JSON-строка вместо объекта — любая запись падала бы с невнятным 400.
- * Разворачивается только строка, которая целиком является объектом или массивом:
- * скалярная строка — законное тело, и трогать её нельзя.
- */
 export declare const normalizeBody: (body: unknown) => unknown;
-/**
- * Подставляет path-параметры и собирает query-строку.
- * Отсутствующий обязательный path-параметр — ошибка здесь, а не 404 от сервера:
- * иначе агент получает загадочный ответ вместо указания, чего не хватает.
- */
 export declare const buildUrl: (baseUrl: string, operation: Operation, args: CallArgs) => string;
-/**
- * HTTP-клиент Admin API.
- * Единственный ретрай — на 401 после обновления токена: любой другой повтор
- * на изменяющей операции рискует создать дубль, поэтому его здесь нет.
- */
 export declare class AdminApiClient {
     private readonly baseUrl;
     private readonly tokens;
@@ -54,7 +32,5 @@ export declare class AdminApiClient {
         timeoutMs: number;
     });
     call(operation: Operation, args: CallArgs): Promise<CallResult>;
-    /** Читает набор прав админа. Пустой массив означает «не удалось выяснить». */
     fetchPermissions(adminId: number): Promise<string[]>;
 }
-//# sourceMappingURL=client.d.ts.map

package/dist/api/client.js

@@ -1,14 +1,5 @@
-/** Ошибка на стороне вызывающего — до отправки запроса. */
 export class RequestBuildError extends Error {
 }
-/**
- * Возвращает тело в том виде, в каком его надо сериализовать в запрос.
- * Часть MCP-клиентов передаёт объектный аргумент уже сериализованным в строку;
- * без этой нормализации `JSON.stringify` завернул бы его второй раз, и на сервер
- * ушла бы JSON-строка вместо объекта — любая запись падала бы с невнятным 400.
- * Разворачивается только строка, которая целиком является объектом или массивом:
- * скалярная строка — законное тело, и трогать её нельзя.
- */
 export const normalizeBody = (body) => {
     if (typeof body !== 'string') {
         return body;
@@ -25,11 +16,6 @@ export const normalizeBody = (body) => {
         return body;
     }
 };
-/**
- * Подставляет path-параметры и собирает query-строку.
- * Отсутствующий обязательный path-параметр — ошибка здесь, а не 404 от сервера:
- * иначе агент получает загадочный ответ вместо указания, чего не хватает.
- */
 export const buildUrl = (baseUrl, operation, args) => {
     let path = operation.path;
     const provided = args.path ?? {};
@@ -47,7 +33,7 @@ export const buildUrl = (baseUrl, operation, args) => {
     const leftover = /\{([^}]+)\}/.exec(path);
     if (leftover) {
         throw new RequestBuildError(`Path parameter "${leftover[1] ?? ''}" of ${operation.path} was not provided and is not ` +
-            'declared in the catalog — the swagger snapshot may be stale.');
+            'declared in the catalog — the cached API document may be stale.');
     }
     const search = new URLSearchParams();
     for (const [key, value] of Object.entries(args.query ?? {})) {
@@ -58,23 +44,22 @@ export const buildUrl = (baseUrl, operation, args) => {
     const suffix = search.size > 0 ? `?${search.toString()}` : '';
     return `${baseUrl}${path}${suffix}`;
 };
-/** Подбирает подсказку по коду ответа и метаданным операции. */
 const hintFor = (status, operation) => {
     if (status === 400 || status === 422) {
         const loose = operation.body?.schema['x-loose'] === true;
         return (`Validation rejected the payload. ${loose ? 'This body has loosely typed fields — copy the shape from the example in cms_api_describe. ' : ''}` +
-            `Read ${operation.docLinks.slice(0, 2).join(', ')} with cms_docs_read before retrying.`);
+            'Search the knowledge base with cms_docs_search before retrying.');
     }
     if (status === 403) {
         return operation.permission
             ? `The admin lacks "${operation.permission}". Ask for the grant; retrying will not help.`
-            : 'Forbidden. Check the admin\'s permissions and the module visibility rules (back/docs/user-permissions).';
+            : 'Forbidden. Check the admin\'s permissions and the module visibility rules.';
     }
     if (status === 404) {
-        return 'Not found. The id may belong to another stand — prefer marker-based operations where they exist.';
+        return 'Not found. The id may belong to another instance — prefer marker-based operations where they exist.';
     }
     if (status >= 500) {
-        return 'Server-side failure. Check the dnk-back logs; do not retry blindly.';
+        return 'Server-side failure on the instance. Report it to your operator; do not retry blindly.';
     }
     return undefined;
 };
@@ -105,11 +90,6 @@ const extractMessage = (body, fallback) => {
     }
     return fallback;
 };
-/**
- * HTTP-клиент Admin API.
- * Единственный ретрай — на 401 после обновления токена: любой другой повтор
- * на изменяющей операции рискует создать дубль, поэтому его здесь нет.
- */
 export class AdminApiClient {
     baseUrl;
     tokens;
@@ -148,7 +128,7 @@ export class AdminApiClient {
                 error: {
                     status: 0,
                     message: `Request to ${url} failed: ${error instanceof Error ? error.message : String(error)}`,
-                    hint: 'Is the stand reachable? In local mode dnk-back must be running with API_TYPE=/api/admin.',
+                    hint: 'Is the instance reachable at the configured base URL? It must expose the Admin API under /api/admin.',
                 },
             };
         }
@@ -166,7 +146,6 @@ export class AdminApiClient {
         }
         return { ok: true, status: response.status, body };
     }
-    /** Читает набор прав админа. Пустой массив означает «не удалось выяснить». */
     async fetchPermissions(adminId) {
         try {
             const token = await this.tokens.accessToken();
@@ -193,4 +172,3 @@ export class AdminApiClient {
         }
     }
 }
-//# sourceMappingURL=client.js.map

package/dist/api/normalize-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from './types.js';
+export declare const normalizeSchema: (node: unknown, components: Record<string, unknown>, depth?: number, refStack?: readonly string[]) => JsonSchema;
+export declare const capSchema: (schema: JsonSchema) => JsonSchema;

package/dist/api/normalize-schema.js

@@ -0,0 +1,133 @@
+const VALID_TYPES = new Set(['object', 'array', 'string', 'number', 'integer', 'boolean', 'null']);
+const TYPE_MAP = {
+    date: { type: 'string', format: 'date-time' },
+    Date: { type: 'string', format: 'date-time' },
+    'iso-date': { type: 'string', format: 'date-time' },
+    float: { type: 'number' },
+    int: { type: 'integer' },
+    json: { type: 'object' },
+    list: { type: 'array' },
+    text: { type: 'string' },
+    textWithHeader: { type: 'string' },
+    image: { type: 'object' },
+    file: { type: 'object' },
+    'number[]': { type: 'array', items: { type: 'number' } },
+    'string[]': { type: 'array', items: { type: 'string' } },
+};
+const MAX_DESCRIPTION = 240;
+const MAX_DEPTH = 6;
+const trimDescription = (value) => {
+    if (typeof value !== 'string' || value.trim() === '') {
+        return undefined;
+    }
+    const flat = value.replace(/\s+/g, ' ').trim();
+    return flat.length > MAX_DESCRIPTION ? `${flat.slice(0, MAX_DESCRIPTION)}…` : flat;
+};
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const normalizeSchema = (node, components, depth = 0, refStack = []) => {
+    if (!isRecord(node)) {
+        return {};
+    }
+    const ref = node['$ref'];
+    if (typeof ref === 'string') {
+        const name = ref.split('/').pop() ?? '';
+        if (refStack.includes(name)) {
+            return { type: 'object', description: `(recursive ${name}, omitted)` };
+        }
+        const target = components[name];
+        if (target === undefined) {
+            return { type: 'object', description: `(unresolved ${name})` };
+        }
+        return normalizeSchema(target, components, depth, [...refStack, name]);
+    }
+    for (const key of ['allOf', 'oneOf', 'anyOf']) {
+        const variants = node[key];
+        if (Array.isArray(variants) && variants.length > 0) {
+            const merged = normalizeSchema(variants[0], components, depth, refStack);
+            const description = trimDescription(node['description']);
+            return description ? { ...merged, description } : merged;
+        }
+    }
+    const out = {};
+    const rawType = node['type'];
+    if (typeof rawType === 'string') {
+        if (VALID_TYPES.has(rawType)) {
+            out.type = rawType;
+        }
+        else {
+            const mapped = TYPE_MAP[rawType];
+            if (mapped) {
+                out.type = mapped.type;
+                if (mapped.format) {
+                    out.format = mapped.format;
+                }
+                if (mapped.items) {
+                    out.items = mapped.items;
+                }
+            }
+            else if (rawType.startsWith('Record<')) {
+                out.type = 'object';
+            }
+            out['x-source-type'] = rawType;
+            out['x-loose'] = true;
+        }
+    }
+    const format = node['format'];
+    if (typeof format === 'string' && !out.format) {
+        out.format = format;
+    }
+    const description = trimDescription(node['description']);
+    if (description) {
+        out.description = description;
+    }
+    if (node['example'] !== undefined) {
+        out.example = node['example'];
+    }
+    if (Array.isArray(node['enum'])) {
+        out.enum = node['enum'];
+    }
+    if (depth >= MAX_DEPTH) {
+        out['x-truncated'] = true;
+        return out;
+    }
+    if (node['items'] !== undefined) {
+        out.items = normalizeSchema(node['items'], components, depth + 1, refStack);
+        if (!out.type) {
+            out.type = 'array';
+        }
+    }
+    const properties = node['properties'];
+    if (isRecord(properties)) {
+        out.type = out.type ?? 'object';
+        out.properties = {};
+        for (const [key, value] of Object.entries(properties)) {
+            out.properties[key] = normalizeSchema(value, components, depth + 1, refStack);
+        }
+    }
+    const required = node['required'];
+    if (Array.isArray(required) && required.every((r) => typeof r === 'string')) {
+        out.required = required;
+    }
+    return out;
+};
+const MAX_SCHEMA_BYTES = 6_144;
+export const capSchema = (schema) => {
+    if (Buffer.byteLength(JSON.stringify(schema), 'utf8') <= MAX_SCHEMA_BYTES) {
+        return schema;
+    }
+    if (!schema.properties) {
+        return { ...schema, 'x-truncated': true };
+    }
+    const shallow = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+        shallow[key] = {
+            ...(value.type ? { type: value.type } : {}),
+            ...(value.format ? { format: value.format } : {}),
+            ...(value.description ? { description: value.description } : {}),
+            ...(value.example !== undefined ? { example: value.example } : {}),
+            ...(value['x-loose'] ? { 'x-loose': true } : {}),
+            ...(value.properties || value.items ? { 'x-truncated': true } : {}),
+        };
+    }
+    return { ...schema, properties: shallow, 'x-truncated': true };
+};

package/dist/api/policy.d.ts

@@ -1,7 +1,6 @@
 import type { AllowLevel } from '../config/config.js';
 import type { AdminIdentity } from './auth.js';
 import type { Operation } from './types.js';
-/** Результат проверки политики перед выполнением операции. */
 export type PolicyDecision = {
     kind: 'allow';
 } | {
@@ -11,42 +10,20 @@ export type PolicyDecision = {
     kind: 'needsConfirm';
     reason: string;
 };
-/**
- * Одноразовые токены подтверждения для необратимых операций.
- * Токен привязан к хэшу (opId + аргументы), поэтому подтверждение одного удаления
- * нельзя переиспользовать для другого — иначе двухшаговость была бы декоративной.
- */
 export declare class ConfirmStore {
     private readonly issued;
     private static hash;
     issue(opId: string, args: unknown, now?: number): string;
-    /**
-     * Проверяет токен, не гася его.
-     * Нужна, чтобы отказ по другой причине (нет права, не тот уровень allow)
-     * не сжигал подтверждение, которое человек уже дал.
-     */
     verify(token: string, opId: string, args: unknown, now?: number): boolean;
-    /** Проверяет и немедленно гасит токен. Повторное использование невозможно. */
     consume(token: string, opId: string, args: unknown, now?: number): boolean;
     private sweep;
 }
-/**
- * Проверяет только уровень `--allow`.
- * Вынесено отдельно, чтобы вызывающий мог отказать до аутентификации:
- * обещание «no request was sent» не должно нарушаться самим логином.
- */
 export declare const checkLevel: (operation: Operation, allow: AllowLevel) => Extract<PolicyDecision, {
     kind: "deny";
 }> | undefined;
-/**
- * Решает, можно ли выполнить операцию.
- * Порядок проверок значим: уровень доступа — до прав, права — до подтверждения,
- * чтобы read-only сервер вообще не выдавал токенов подтверждения.
- */
 export declare const decide: (params: {
     operation: Operation;
     allow: AllowLevel;
     identity?: AdminIdentity;
     confirmValid: boolean;
 }) => PolicyDecision;
-//# sourceMappingURL=policy.d.ts.map