@okostream/mcp 0.12.1 → 0.12.3

package/dist/onboarding.js

@@ -1,122 +0,0 @@
-// Канонический адрес платформы. Живёт здесь, потому что onboarding — базовый
-// модуль без зависимостей: его импортируют и сервер, и инструменты, и гиды.
-// Домен нужен MCP-клиенту как ссылка для организатора, поэтому адреса
-// собираются из одного места, а не пишутся заново в каждом инструменте.
-export const APP_ORIGIN = "https://okostream.app";
-export const OKO_ONBOARDING_URLS = {
-    website: APP_ORIGIN,
-    signIn: `${APP_ORIGIN}/auth?redirect=/app/mcp`,
-    installCenter: `${APP_ORIGIN}/app/mcp`,
-};
-export const OKO_PRODUCT_INFO = {
-    name: "OKO Stream",
-    summary: "OKO Stream is a webinar operations platform. It adds an event page, configurable audience blocks, chat, analytics, forms, and integrations around an organizer-supplied video player.",
-    videoBoundary: "OKO does not host or start the underlying video stream. Organizers provide a YouTube, iframe, or other player URL.",
-    accountRequirement: "An active OKO organizer account is required to access webinar data or perform actions.",
-    accessModel: "Organizer access is currently provided by invitation. An invitation is required before a new organizer can create an API key.",
-};
-export const OKO_CONNECTION_STATUSES = [
-    "connected",
-    "not_configured",
-    "invalid_key",
-    "update_required",
-    "rate_limited",
-    "unavailable",
-];
-function nextSteps(status, minimumVersion) {
-    switch (status) {
-        case "connected":
-            return [{
-                    id: "continue",
-                    label: "Continue with the requested OKO workflow.",
-                }];
-        case "not_configured":
-            return [
-                {
-                    id: "obtain_access",
-                    label: "Obtain an OKO organizer invitation if you do not already have active organizer access.",
-                    url: OKO_ONBOARDING_URLS.website,
-                },
-                {
-                    id: "create_key",
-                    label: "Sign in to the OKO MCP install center and create a scoped API key.",
-                    url: OKO_ONBOARDING_URLS.installCenter,
-                },
-                {
-                    id: "configure_client",
-                    label: "Set OKO_API_KEY in the MCP client configuration, then restart or reconnect the server.",
-                },
-            ];
-        case "invalid_key":
-            return [
-                {
-                    id: "replace_key",
-                    label: "Create a fresh scoped key in the OKO MCP install center and replace OKO_API_KEY.",
-                    url: OKO_ONBOARDING_URLS.installCenter,
-                },
-                {
-                    id: "restart_client",
-                    label: "Restart or reconnect the MCP server after updating the key.",
-                },
-            ];
-        case "update_required":
-            return [
-                {
-                    id: "update_package",
-                    label: `Update to @okostream/mcp@latest${minimumVersion ? ` (minimum ${minimumVersion})` : ""}.`,
-                    command: "npx -y @okostream/mcp@latest",
-                },
-                {
-                    id: "restart_client",
-                    label: "Restart or reconnect the MCP server after updating.",
-                },
-            ];
-        case "rate_limited":
-            return [{
-                    id: "retry_later",
-                    label: "Wait one minute, then reconnect the MCP server.",
-                }];
-        case "unavailable":
-            return [{
-                    id: "retry",
-                    label: "Check network access to OKO Stream, then reconnect the MCP server.",
-                }];
-    }
-}
-export function buildConnectionStatus(status, options = {}) {
-    const connected = status === "connected";
-    const errorCode = connected
-        ? null
-        : status === "update_required"
-            ? "CLIENT_UPGRADE_REQUIRED"
-            : status === "rate_limited"
-                ? "RATE_LIMITED"
-                : status === "unavailable"
-                    ? "SERVICE_UNAVAILABLE"
-                    : "AUTH_REQUIRED";
-    const message = connected
-        ? "OKO MCP is connected to an active organizer account."
-        : status === "not_configured"
-            ? "OKO MCP is installed, but OKO_API_KEY is not configured."
-            : status === "invalid_key"
-                ? "OKO MCP is installed, but the configured API key is invalid or revoked."
-                : status === "update_required"
-                    ? "This OKO MCP client version is no longer supported."
-                    : status === "rate_limited"
-                        ? "OKO temporarily rate-limited the connection attempt."
-                        : "OKO MCP could not verify the organizer connection.";
-    return {
-        connected,
-        status,
-        errorCode,
-        message,
-        product: OKO_PRODUCT_INFO,
-        organizerAccountRequired: true,
-        credentialConfigured: status !== "not_configured",
-        links: OKO_ONBOARDING_URLS,
-        nextSteps: nextSteps(status, options.minimumVersion),
-        ...(options.minimumVersion ? { minimumVersion: options.minimumVersion } : {}),
-        ...(options.uid ? { uid: options.uid } : {}),
-        ...(options.scopes ? { scopes: options.scopes } : {}),
-    };
-}

package/dist/scopes.js

@@ -1,22 +0,0 @@
-// Generated by scripts/generateMcpContract.mjs from mcp/public-contract.json.
-export const MCP_SCOPES = [
-    "events:read",
-    "events:write",
-    "events:delete",
-    "setup:write",
-    "analytics:read",
-    "analytics:write",
-    "live:control",
-    "chat:write",
-    "chat:moderate",
-    "telegram:write",
-    "workspace:read",
-    "workspace:write",
-    "leads:read"
-];
-const SCOPE_SET = new Set(MCP_SCOPES);
-export function sanitizeScopes(scopes) {
-    if (!Array.isArray(scopes))
-        return [];
-    return scopes.filter((scope) => typeof scope === "string" && SCOPE_SET.has(scope));
-}

package/dist/sessionRepair.js

@@ -1,37 +0,0 @@
-export function summarizeSessionRepair(input) {
-    const fixed = !input.verificationError
-        && input.firestorePointer === null
-        && input.rtdbPointer === null;
-    const fulfilled = new Set(input.attempts
-        .filter((attempt) => attempt.status === "fulfilled")
-        .map((attempt) => attempt.path));
-    const cleared = [
-        ...(input.firestorePointer === null ? ["events.activeAnalyticsSessionId"] : []),
-        ...(input.rtdbPointer === null ? ["ctrl/activeSessionId"] : []),
-        ...(input.sessionId && fulfilled.has(`activeSessions/${input.sessionId}`)
-            ? [`activeSessions/${input.sessionId}`]
-            : []),
-        ...(input.sessionId
-            && input.deleteRtdbSessionData
-            && fulfilled.has(`events/${input.eventId}/sessions/${input.sessionId}`)
-            ? [`events/${input.eventId}/sessions/${input.sessionId}`]
-            : []),
-    ];
-    const warnings = input.attempts
-        .filter((attempt) => attempt.status === "rejected")
-        .map((attempt) => `${attempt.path}: ${attempt.error || "cleanup failed"}`);
-    if (input.verificationError) {
-        warnings.push(`postcondition verification: ${input.verificationError}`);
-    }
-    return {
-        eventId: input.eventId,
-        sessionId: input.sessionId,
-        fixed,
-        cleared,
-        warnings,
-        remainingPointers: {
-            firestore: input.firestorePointer,
-            rtdb: input.rtdbPointer,
-        },
-    };
-}

package/dist/telegramChannelSchema.js

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export const telegramChannelSchema = z.object({
-    chatId: z.number().int(),
-    title: z.string().max(200).optional(),
-    username: z.string().max(120).nullable().optional(),
-}).strict();
-export const canonicalTelegramChannelSchema = telegramChannelSchema.extend({
-    workspaceIds: z.array(z.string()).max(50),
-    owned: z.boolean(),
-    subscriberCount: z.number().int().nonnegative().nullable().optional(),
-    health: z.enum(["connected", "needs_attention", "unknown"]).optional(),
-    healthCheckedAt: z.number().int().nonnegative().nullable().optional(),
-}).strict();

package/dist/tools/account.js

@@ -1,77 +0,0 @@
-// Состояние подключения, личность организатора и его профиль.
-//
-// oko_connection_status намеренно работает БЕЗ ключа: сервер должен уметь
-// объяснить, что он не настроен, а не падать при старте. Остальные два
-// требуют живой авторизации.
-import { z } from "zod";
-import { serialize, textResult } from "../utils.js";
-import { authed } from "./context.js";
-import { connectionStatusOutputSchema, idempotentWriteTool, profileDisplayNameSchema, profileOutputSchema, readOnlyTool, timezoneSchema, toolDescription } from "./schemas.js";
-import { currentScopes, getConnectionStatus } from "../auth.js";
-import { doc, getDoc, serverTimestamp, setDoc } from "firebase/firestore";
-import { firestore } from "../firebase.js";
-export function registerAccountTools(server) {
-    server.registerTool("oko_connection_status", {
-        title: "Check OKO connection",
-        description: toolDescription({
-            summary: "Check whether this MCP process is connected to an active OKO organizer account.",
-            returns: "A factual connection status, product boundary, and setup links. This tool works without OKO_API_KEY and never changes data.",
-            examples: [
-                "Use when an OKO request is made and the organizer connection state is unknown.",
-                "Use after installing the package without a key to explain the exact next setup step.",
-            ],
-            notes: ["This tool does not create accounts, invitations, or API keys."],
-        }),
-        outputSchema: connectionStatusOutputSchema,
-        annotations: readOnlyTool,
-    }, async () => textResult(await getConnectionStatus()));
-    server.registerTool("oko_whoami", {
-        title: "Who am I",
-        description: toolDescription({
-            summary: "Return the authenticated OKO organizer uid and granted MCP scopes.",
-            returns: "uid plus the exact scopes granted by OKO API key exchange. Use this before write workflows to check permissions.",
-            examples: ['Use when starting a session: call first, then choose tools allowed by "scopes".'],
-        }),
-        outputSchema: {
-            uid: z.string(),
-            scopes: z.array(z.string()),
-        },
-        annotations: readOnlyTool,
-    }, async () => {
-        const auth = await authed([]);
-        return textResult({ uid: auth.uid, scopes: currentScopes() });
-    });
-    server.registerTool("oko_update_profile", {
-        title: "Update profile",
-        description: toolDescription({
-            summary: "Update the authenticated organizer profile fields used by OKO UI.",
-            args: [
-                "displayName: optional display name, max 40 chars; null clears it.",
-                "timezone: optional IANA timezone such as Europe/Moscow or UTC.",
-            ],
-            returns: "uid, updated field names, and the resulting profile snapshot.",
-            examples: ["Use when the organizer asks to change their visible OKO name or timezone."],
-            notes: ["Edits the organizer profile that owns this key. Requires workspace:write: the key holder is not necessarily the organizer, so a read-only key must not rewrite the owner's name, avatar or timezone."],
-        }),
-        inputSchema: {
-            displayName: profileDisplayNameSchema.optional().describe("Display name, max 40 chars. Null clears it."),
-            timezone: timezoneSchema.optional().describe("IANA timezone, for example Europe/Moscow or UTC."),
-        },
-        outputSchema: profileOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ displayName, timezone }) => {
-        const { uid } = await authed(["workspace:write"]);
-        const patch = { updatedAt: serverTimestamp() };
-        if (displayName !== undefined)
-            patch.displayName = displayName?.trim() || null;
-        if (timezone !== undefined)
-            patch.timezone = timezone.trim();
-        const updated = Object.keys(patch).filter((key) => key !== "updatedAt");
-        if (updated.length === 0)
-            throw new Error("Provide displayName and/or timezone.");
-        const profileRef = doc(firestore, "userProfiles", uid);
-        await setDoc(profileRef, patch, { merge: true });
-        const profileSnap = await getDoc(profileRef);
-        return textResult({ uid, updated, profile: profileSnap.exists() ? serialize(profileSnap.data()) : {} });
-    });
-}

package/dist/tools/audit.js

@@ -1,44 +0,0 @@
-// Серверный аудит записывающих инструментов MCP.
-//
-// Наружу уходят только ключи из разрешённого списка и только в усечённом
-// виде: аргументы инструментов могут содержать текст организатора, а аудит —
-// это журнал действий, не копия данных. Отказ самого аудита никогда не роняет
-// инструмент: журнал важен, но не важнее операции, которую он описывает.
-import { httpsCallable } from "firebase/functions";
-import { functions } from "../firebase.js";
-export const MCP_AUDIT_TARGET_KEYS = new Set([
-    "eventId", "workspaceId", "targetWorkspaceId", "sessionId", "postId",
-    "messageId", "leadId", "participantUid", "uid", "channelId", "cardId", "imageId",
-]);
-export function auditTargets(args) {
-    if (!args || typeof args !== "object" || Array.isArray(args))
-        return {};
-    const targets = {};
-    for (const [key, value] of Object.entries(args)) {
-        if (!MCP_AUDIT_TARGET_KEYS.has(key))
-            continue;
-        if (typeof value === "string")
-            targets[key] = value.slice(0, 160);
-        else if (typeof value === "number" || typeof value === "boolean" || value === null)
-            targets[key] = value;
-    }
-    return targets;
-}
-export async function recordToolAudit(toolName, outcome, args, startedAt, error) {
-    try {
-        const audit = httpsCallable(functions, "recordMcpToolAudit");
-        const errorCode = error && typeof error === "object" && "code" in error
-            ? String(error.code ?? "error")
-            : error instanceof Error ? error.name : null;
-        await audit({
-            toolName,
-            outcome,
-            targets: auditTargets(args),
-            durationMs: Date.now() - startedAt,
-            errorCode,
-        });
-    }
-    catch (auditError) {
-        console.error(`[oko-mcp] audit failed for ${toolName}:`, auditError instanceof Error ? auditError.message : String(auditError));
-    }
-}

package/dist/tools/chat.js

@@ -1,221 +0,0 @@
-// Чат события и модерация.
-//
-// Сообщения живут в отдельной базе (okostreamcore-chat), а не в основной RTDB.
-// Отправка — один атомарный корневой update, который пишет сообщение и метку
-// частоты вместе: разделить их значит открыть обход медленного режима.
-// Инвариант стережёт protocol.test.
-import { z } from "zod";
-import { requireConfirm, serialize, textResult } from "../utils.js";
-import { authed } from "./context.js";
-import { basicEventOutputSchema, chatOutputSchema, cursorField, destructiveTool, eventIdField, idempotentWriteTool, limitField, readOnlyTool, toolDescription, writeTool } from "./schemas.js";
-import { chatRtdb, rtdb } from "../firebase.js";
-import { cursorMeta, pickPage } from "./formatting.js";
-import { endBefore, get, limitToLast, orderByKey, push, query as dbQuery, ref, remove, runTransaction, serverTimestamp as rtdbServerTimestamp, set, update } from "firebase/database";
-import { getChatRole } from "./workspaceAccess.js";
-import { readEvent } from "./eventAccess.js";
-export function registerChatTools(server) {
-    server.registerTool("oko_list_recent_chat", {
-        title: "List recent chat",
-        description: toolDescription({
-            summary: "Read recent chat messages from chat RTDB with cursor pagination.",
-            args: [
-                "eventId: event chat to inspect.",
-                "limit: max messages to return, default 50, max 100.",
-                "cursor: message id returned as nextCursor by the previous page to read older messages.",
-            ],
-            returns: "messages array sorted newest-first plus count, limit, hasMore/has_more, nextCursor/next_cursor.",
-            examples: ["Use limit=20 first; if hasMore is true, call again with cursor=nextCursor for older chat."],
-        }),
-        inputSchema: { eventId: eventIdField, limit: limitField(100, 50), cursor: cursorField },
-        outputSchema: chatOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, limit: max, cursor }) => {
-        const { uid } = await authed(["analytics:read"]);
-        await readEvent(eventId, uid, "read");
-        const constraints = cursor
-            ? [orderByKey(), endBefore(cursor), limitToLast(max + 1)]
-            : [orderByKey(), limitToLast(max + 1)];
-        const snap = await get(dbQuery(ref(chatRtdb, `messages/${eventId}`), ...constraints));
-        // 🔴 Побайтовое сравнение, а не `localeCompare`. RTDB упорядочивает
-        // push-ключи по кодам символов, а `localeCompare` учитывает локаль и
-        // сортирует регистр наоборот: push-ключи содержат и цифры, и обе
-        // раскладки букв, поэтому порядок расходился с серверным. Курсор брался
-        // не тот, и страницы повторялись или пропускались.
-        const entries = Object.entries((snap.val() ?? {}))
-            .sort(([a], [b]) => (a < b ? 1 : a > b ? -1 : 0));
-        const { page, hasMore } = pickPage(entries, max);
-        const messages = page.map(([id, message]) => ({ id, ...serialize(message) }));
-        const nextCursor = hasMore ? messages.at(-1)?.id ?? null : null;
-        return textResult({ messages, ...cursorMeta(messages.length, max, hasMore, nextCursor) });
-    });
-    server.registerTool("oko_send_chat_message", {
-        title: "Send chat message",
-        description: toolDescription({
-            summary: "Send a chat message as the authenticated organizer/moderator.",
-            args: ["eventId: target event chat.", "text: message text, max 500 chars.", "name: display name, default OKO MCP.", "confirm: must be true."],
-            returns: "eventId, new messageId, and sent=true.",
-            examples: ["Use for organizer announcements in chat after user confirms the exact text."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            text: z.string().min(1).max(500).describe("Message text."),
-            name: z.string().min(1).max(24).default("OKO MCP").describe("Display name."),
-            confirm: z.boolean().optional().describe("Required true to post to live chat."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, text, name, confirm }) => {
-        const { uid } = await authed(["chat:write"]);
-        await readEvent(eventId, uid, "read");
-        requireConfirm(confirm, "oko_send_chat_message", { eventId, name, text });
-        const role = await getChatRole(eventId, uid);
-        const msgRef = push(ref(chatRtdb, `messages/${eventId}`));
-        if (!msgRef.key)
-            throw new Error("Could not allocate chat message id");
-        const timestamp = rtdbServerTimestamp();
-        // 🔴 Форма сообщения обязана совпадать с `prepareChatMessage`
-        // (`web/src/lib/chatMessages.ts`) — единственным контрактом записи чата
-        // по Pattern 26. Импортировать его сюда нельзя: MCP отдельный пакет, у
-        // него нет доступа к web. Поэтому копия, и она УЖЕ разошлась: без `trim`
-        // сообщение из одних пробелов проходило и публиковалось всем зрителям, а
-        // имя уходило без обрезки до 24 символов.
-        const messageText = text.trim();
-        if (!messageText)
-            throw new Error("Chat message text cannot be empty or whitespace only.");
-        const messageName = name.trim().slice(0, 24) || "Organizer";
-        await update(ref(chatRtdb), {
-            [`messages/${eventId}/${msgRef.key}`]: { text: messageText, uid, name: messageName, role, ts: timestamp },
-            [`rate_limits/${eventId}/${uid}`]: { ts: timestamp, messageId: msgRef.key },
-        });
-        await runTransaction(ref(rtdb, `events/${eventId}/agg/chatMessages`), (n) => (n ?? 0) + 1)
-            .catch(() => undefined);
-        return textResult({ eventId, messageId: msgRef.key, sent: true });
-    });
-    server.registerTool("oko_delete_chat_message", {
-        title: "Delete chat message",
-        description: toolDescription({
-            summary: "Soft-delete a chat message through moderation metadata.",
-            args: ["eventId: target event.", "messageId: chat RTDB message id.", "confirm: must be true."],
-            returns: "eventId, messageId, and deleted=true.",
-            examples: ["Use only after showing the message text/id and receiving explicit confirmation."],
-        }),
-        inputSchema: { eventId: eventIdField, messageId: z.string().min(1).describe("Chat RTDB message id."), confirm: z.boolean().optional().describe("Required true for deletion.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, messageId, confirm }) => {
-        const { uid } = await authed(["chat:moderate"]);
-        await readEvent(eventId, uid, "moderate");
-        requireConfirm(confirm, "oko_delete_chat_message", { eventId, messageId });
-        await set(ref(chatRtdb, `mod/deleted/${eventId}/${messageId}`), { deletedAt: rtdbServerTimestamp(), ts: Date.now(), by: uid });
-        return textResult({ eventId, messageId, deleted: true });
-    });
-    server.registerTool("oko_mute_user", {
-        title: "Mute chat user",
-        description: toolDescription({
-            summary: "Mute a chat user for a bounded time window.",
-            args: ["eventId: target event.", "uid: Firebase uid to mute.", "minutes: mute duration, 1-1440, default 5.", "confirm: must be true."],
-            returns: "eventId, targetUid, and mutedMinutes.",
-            examples: ["Use after reading chat messages and confirming the exact uid with the user."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to mute."), minutes: z.number().int().min(1).max(1440).default(5).describe("Mute duration in minutes."), confirm: z.boolean().optional().describe("Required true for mute.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, uid: targetUid, minutes, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_mute_user", { eventId, targetUid, minutes });
-        await set(ref(chatRtdb, `mutes/${eventId}/${targetUid}`), { until: Date.now() + minutes * 60_000, by: actor.uid, reason: "manual" });
-        return textResult({ eventId, targetUid, mutedMinutes: minutes });
-    });
-    server.registerTool("oko_ban_user", {
-        title: "Ban chat user",
-        description: toolDescription({
-            summary: "Ban a chat user and soft-delete up to 500 recent messages from that uid.",
-            args: ["eventId: target event.", "uid: Firebase uid to ban.", "confirm: must be true."],
-            returns: "eventId, targetUid, banned=true, and deletedMessages count.",
-            examples: ["Use only after explicit user confirmation; prefer mute for temporary moderation."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to ban."), confirm: z.boolean().optional().describe("Required true for ban.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, uid: targetUid, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_ban_user", { eventId, targetUid });
-        await set(ref(chatRtdb, `bans/${eventId}/${targetUid}`), true);
-        const messagesSnap = await get(dbQuery(ref(chatRtdb, `messages/${eventId}`), limitToLast(500)));
-        const messages = (messagesSnap.val() ?? {});
-        const deletes = {};
-        for (const [messageId, message] of Object.entries(messages)) {
-            if (message.uid === targetUid)
-                deletes[`mod/deleted/${eventId}/${messageId}`] = { deletedAt: rtdbServerTimestamp(), ts: Date.now(), by: actor.uid, reason: "ban" };
-        }
-        if (Object.keys(deletes).length > 0)
-            await update(ref(chatRtdb), deletes);
-        return textResult({ eventId, targetUid, banned: true, deletedMessages: Object.keys(deletes).length });
-    });
-    server.registerTool("oko_unmute_user", {
-        title: "Unmute chat user",
-        description: toolDescription({
-            summary: "Remove a chat mute for a user.",
-            args: ["eventId: target event.", "uid: Firebase uid to unmute.", "confirm: must be true."],
-            returns: "eventId, targetUid, and unmuted=true.",
-            examples: ["Use when a user was muted by mistake or the organizer wants to restore chat access."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to unmute."), confirm: z.boolean().optional().describe("Required true for unmute.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, uid: targetUid, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_unmute_user", { eventId, targetUid });
-        await remove(ref(chatRtdb, `mutes/${eventId}/${targetUid}`));
-        return textResult({ eventId, targetUid, unmuted: true });
-    });
-    server.registerTool("oko_unban_user", {
-        title: "Unban chat user",
-        description: toolDescription({
-            summary: "Remove a chat ban for a user.",
-            args: ["eventId: target event.", "uid: Firebase uid to unban.", "confirm: must be true."],
-            returns: "eventId, targetUid, and unbanned=true.",
-            examples: ["Use when a user was banned by mistake or the organizer wants to restore event chat access."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to unban."), confirm: z.boolean().optional().describe("Required true for unban.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, uid: targetUid, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_unban_user", { eventId, targetUid });
-        await remove(ref(chatRtdb, `bans/${eventId}/${targetUid}`));
-        return textResult({ eventId, targetUid, unbanned: true });
-    });
-    server.registerTool("oko_set_chat_settings", {
-        title: "Set chat settings",
-        description: toolDescription({
-            summary: "Set slow mode and automod settings for an event chat.",
-            args: ["eventId: target event.", "slowModeMs: optional slow mode delay, 0-60000 ms.", "automodEnabled: optional automod toggle.", "confirm: must be true."],
-            returns: "eventId and updated RTDB setting paths.",
-            examples: ["Use slowModeMs=5000 to slow busy chats; use automodEnabled=false as an emergency kill switch."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            slowModeMs: z.number().int().min(0).max(60000).optional().describe("Slow mode delay in milliseconds."),
-            automodEnabled: z.boolean().optional().describe("Enable or disable chat automoderation."),
-            confirm: z.boolean().optional().describe("Required true to change live chat settings."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, slowModeMs, automodEnabled, confirm }) => {
-        const { uid } = await authed(["chat:moderate"]);
-        await readEvent(eventId, uid, "moderate");
-        requireConfirm(confirm, "oko_set_chat_settings", { eventId, slowModeMs: slowModeMs ?? null, automodEnabled: automodEnabled ?? null });
-        const patch = {};
-        if (slowModeMs !== undefined)
-            patch[`settings/${eventId}/slowModeMs`] = slowModeMs;
-        if (automodEnabled !== undefined)
-            patch[`settings/${eventId}/automodEnabled`] = automodEnabled;
-        await update(ref(chatRtdb), patch);
-        return textResult({ eventId, updated: Object.keys(patch) });
-    });
-}

package/dist/tools/context.js

@@ -1,40 +0,0 @@
-// Общий контекст инструментов: авторизация вызова, публичные адреса
-// платформы и мелкие приведения типов.
-//
-// `authed` — единственная точка, через которую инструмент получает права.
-// Права принадлежат организатору, а ключ лишь предъявляет их: разбор области
-// доступа и синтетической личности живёт в `auth.ts`, здесь только вызов.
-import { randomUUID } from "node:crypto";
-import { ensureAuth } from "../auth.js";
-import { APP_ORIGIN } from "../onboarding.js";
-export function randomId() {
-    return randomUUID();
-}
-export async function authed(scopes) {
-    return ensureAuth(scopes);
-}
-export function eventUrl(eventId) {
-    return `${APP_ORIGIN}/event/${eventId}`;
-}
-export function setupUrl(eventId) {
-    return `${APP_ORIGIN}/setup/${eventId}`;
-}
-export function analyticsUrl(eventId) {
-    return `${APP_ORIGIN}/analytics/${eventId}`;
-}
-export function sessionReportUrl(eventId, sessionId) {
-    return `${analyticsUrl(eventId)}/report/${sessionId}`;
-}
-export function inviteUrl(code) {
-    return `${APP_ORIGIN}/invite/${code}`;
-}
-export function eventLinks(eventId) {
-    return {
-        url: eventUrl(eventId),
-        setupUrl: setupUrl(eventId),
-        analyticsUrl: analyticsUrl(eventId),
-    };
-}
-export function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}

package/dist/tools/eventAccess.js

@@ -1,65 +0,0 @@
-// Контур прав MCP на конкретное событие.
-//
-// Источник истины — grant `eventAccess/{uid}/grants/{eventId}`, который
-// поддерживают CF7 и CF18. Legacy-путь по массивам события остаётся только
-// на случай, когда правила отказали в чтении grants: отличить отказ доступа
-// от сетевого сбоя обязательно, иначе первый молча превращается во второй.
-//
-// Сторож инварианта — `test/event-access-index.test.mjs`.
-import { doc, getDoc } from "firebase/firestore";
-import { firestore } from "../firebase.js";
-import { asRecord } from "./context.js";
-export const EVENT_ACCESS_FIELD_BY_MODE = {
-    read: "accessibleBy",
-    edit: "editors",
-    delete: "deleters",
-    live: "liveControllers",
-    session: "sessionManagers",
-    analytics: "analyticsViewers",
-    report: "reportDownloaders",
-    moderate: "chatModerators",
-    notify: "notificationSenders",
-};
-export function grantAllowsMode(data, mode) {
-    const field = EVENT_ACCESS_FIELD_BY_MODE[mode];
-    return asRecord(data.capabilities)[field] === true;
-}
-export function legacyEventAllowsMode(data, uid, mode) {
-    if (data.ownerId === uid)
-        return true;
-    const fields = mode === "read"
-        ? ["accessibleBy", "editors"]
-        : [EVENT_ACCESS_FIELD_BY_MODE[mode]];
-    return fields.some((field) => (Array.isArray(data[field]) && data[field].includes(uid)));
-}
-export function isFirestorePermissionDenied(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const code = error.code;
-    return code === "permission-denied"
-        || code === "firestore/permission-denied"
-        || code === "PERMISSION_DENIED";
-}
-export async function readEvent(eventId, uid, mode = "read") {
-    const [snap, grant] = await Promise.all([
-        getDoc(doc(firestore, "events", eventId)),
-        getDoc(doc(firestore, "eventAccess", uid, "grants", eventId)).catch((error) => {
-            if (!isFirestorePermissionDenied(error))
-                throw error;
-            return null;
-        }),
-    ]);
-    if (!snap.exists())
-        throw new Error("Event not found.");
-    const data = snap.data();
-    const allowed = grant === null
-        ? legacyEventAllowsMode(data, uid, mode)
-        : data.ownerId === uid || (grant.exists() && grantAllowsMode(grant.data(), mode));
-    if (!allowed) {
-        throw new Error(`Event does not grant ${mode} access to this organizer.`);
-    }
-    if (data.trashedAt && mode !== "read" && mode !== "delete") {
-        throw new Error("Event is in trash. Restore it before making changes or live actions.");
-    }
-    return data;
-}