@okostream/mcp 0.11.1 → 0.11.2

package/dist/tools/telegram.js

@@ -0,0 +1,279 @@
+// Каналы Telegram и анонсы событий.
+//
+// Публикация — внешнее действие, которое нельзя отозвать, поэтому требует
+// явного confirm. Число подписчиков и состояние бота отдаёт CF40 с
+// десятиминутным кешем; при сбое Telegram она возвращает null и признак
+// «неизвестно», а не выдуманное число.
+import { z } from "zod";
+import { requireConfirm, safeString, serialize, textResult } from "../utils.js";
+import { authed, eventUrl } from "./context.js";
+import { cursorField, destructiveTool, eventIdField, limitField, readOnlyTool, TELEGRAM_POST_STATUSES, telegramChannelsOutputSchema, telegramPostsOutputSchema, toolDescription, unknownRecordSchema, writeTool } from "./schemas.js";
+import { addDoc, collection, deleteDoc, doc, getDoc, getDocs, limit, orderBy, query, serverTimestamp, startAfter, Timestamp, where } from "firebase/firestore";
+import { canonicalTelegramChannelSchema, telegramChannelSchema } from "../telegramChannelSchema.js";
+import { cursorMeta, parseTimestampCursor, pickPage, timestampCursorFrom } from "./formatting.js";
+import { firestore, functions } from "../firebase.js";
+import { httpsCallable } from "firebase/functions";
+import { readEvent } from "./eventAccess.js";
+export function registerTelegramTools(server) {
+    server.registerTool("oko_create_telegram_link", {
+        title: "Link personal Telegram",
+        description: toolDescription({
+            summary: "Create a short-lived Telegram deep link that binds the organizer's personal Telegram identity to OKO.",
+            args: [],
+            returns: "@OKOStreamBot link and expiry in seconds.",
+            examples: ["Open the returned link in the organizer's Telegram account before claiming a channel."],
+            notes: ["The link expires in 15 minutes and can be used only once. Opening it is a user action outside MCP."],
+        }),
+        inputSchema: {},
+        outputSchema: z.object({ url: z.string().url(), expiresIn: z.number().int().positive() }).passthrough(),
+        annotations: writeTool,
+    }, async () => {
+        await authed(["telegram:write"]);
+        const createLink = httpsCallable(functions, "createTelegramLink");
+        return textResult((await createLink({})).data);
+    });
+    server.registerTool("oko_list_telegram_channels", {
+        title: "List Telegram channels",
+        description: toolDescription({
+            summary: "List Telegram channels available to the authenticated organizer.",
+            args: [
+                "eventId: optional event; when provided, include channels explicitly shared to that event's workspace.",
+                "includeWorkspaceChannels: deprecated compatibility field; eventId is required to resolve workspace sharing safely.",
+            ],
+            returns: "canonical channels with identity, workspace sharing, ownership, subscriber count, and connection health.",
+            examples: ["Use before oko_publish_telegram_post so the user can choose a channel by title instead of numeric id."],
+        }),
+        inputSchema: {
+            eventId: eventIdField.optional().describe("Optional event used to include channels shared to its workspace."),
+            includeWorkspaceChannels: z.boolean().optional().describe("Deprecated; retained for client compatibility."),
+        },
+        outputSchema: telegramChannelsOutputSchema,
+        annotations: readOnlyTool,
+    }, async ({ eventId }) => {
+        await authed(["telegram:write"]);
+        const listChannels = httpsCallable(functions, "listTelegramChannels");
+        const result = await listChannels(eventId ? { eventId } : {});
+        const parsed = z.array(canonicalTelegramChannelSchema).safeParse(result.data.channels);
+        if (!parsed.success)
+            throw new Error("OKO listTelegramChannels returned an invalid channel payload.");
+        const channels = parsed.data.sort((a, b) => (a.title ?? "").localeCompare(b.title ?? ""));
+        return textResult({ channels, count: channels.length });
+    });
+    server.registerTool("oko_claim_telegram_channel", {
+        title: "Claim Telegram channel",
+        description: toolDescription({
+            summary: "Claim a pending Telegram channel using the code sent by OKO bot.",
+            args: [
+                "claimCode: code posted by the bot after it was added to a channel.",
+                "workspaceIds: optional owned workspaces to expose this channel to after claim.",
+                "confirm: must be true.",
+            ],
+            returns: "claimed channel and workspace ids updated.",
+            examples: ["Link personal Telegram first, add @OKOStreamBot as channel administrator, copy the claim code, then call this tool."],
+            notes: ["The linked personal Telegram user must be a channel administrator. Workspace sharing is server-validated."],
+        }),
+        inputSchema: {
+            claimCode: z.string().min(4).max(32).describe("Telegram channel claim code."),
+            workspaceIds: z.array(z.string().min(1)).max(20).default([]).describe("Optional workspace ids to attach the channel to."),
+            confirm: z.boolean().optional().describe("Required true to claim and attach the channel."),
+        },
+        outputSchema: z.object({ channel: unknownRecordSchema, workspaceIdsUpdated: z.array(z.string()) }).passthrough(),
+        annotations: writeTool,
+    }, async ({ claimCode, workspaceIds, confirm }) => {
+        await authed(["telegram:write"]);
+        requireConfirm(confirm, "oko_claim_telegram_channel", { workspaceIds: workspaceIds.join(",") });
+        const claimChannel = httpsCallable(functions, "claimTelegramChannel");
+        const result = await claimChannel({ code: claimCode.trim().toUpperCase() });
+        const data = serialize(result.data);
+        const channelRaw = data.channel && typeof data.channel === "object" ? data.channel : {};
+        const parsed = telegramChannelSchema.safeParse(channelRaw);
+        if (!parsed.success)
+            throw new Error("OKO claimTelegramChannel returned an invalid channel payload.");
+        if (workspaceIds.length > 0) {
+            const setWorkspaces = httpsCallable(functions, "setTelegramChannelWorkspaces");
+            await setWorkspaces({ channelId: parsed.data.chatId, workspaceIds });
+        }
+        return textResult({ ...data, channel: parsed.data, workspaceIdsUpdated: workspaceIds });
+    });
+    server.registerTool("oko_set_telegram_channel_workspaces", {
+        title: "Share Telegram channel to workspaces",
+        description: toolDescription({
+            summary: "Replace the owned Telegram channel's explicit OKO workspace sharing list.",
+            args: ["channelId: owned Telegram channel id.", "workspaceIds: complete replacement list, up to 50.", "confirm: must be true."],
+            returns: "channel id and the applied workspace ids.",
+            examples: ["Use an empty workspaceIds list to make the channel private to its owner again."],
+            notes: ["This replaces, rather than appends to, the current sharing list. Every workspace must be owned by the organizer."],
+        }),
+        inputSchema: {
+            channelId: z.number().int().describe("Owned Telegram channel id."),
+            workspaceIds: z.array(z.string().min(1).max(128)).max(50).describe("Complete replacement workspace sharing list."),
+            confirm: z.boolean().optional().describe("Required true to change workspace sharing."),
+        },
+        outputSchema: z.object({ success: z.boolean(), channelId: z.number().int(), workspaceIds: z.array(z.string()) }).passthrough(),
+        annotations: writeTool,
+    }, async ({ channelId, workspaceIds, confirm }) => {
+        await authed(["telegram:write"]);
+        requireConfirm(confirm, "oko_set_telegram_channel_workspaces", { channelId, workspaceIds: workspaceIds.join(",") });
+        const setWorkspaces = httpsCallable(functions, "setTelegramChannelWorkspaces");
+        return textResult((await setWorkspaces({ channelId, workspaceIds })).data);
+    });
+    server.registerTool("oko_disconnect_telegram_channel", {
+        title: "Disconnect Telegram channel",
+        description: toolDescription({
+            summary: "Disconnect an owned Telegram channel from OKO and clear all workspace sharing.",
+            args: ["channelId: owned Telegram channel id.", "confirm: must be true."],
+            returns: "disconnected channel id.",
+            examples: ["Use only after showing the exact channel selected from oko_list_telegram_channels."],
+            notes: ["Existing sent Telegram messages are not deleted. The channel must be claimed again before future publication."],
+        }),
+        inputSchema: {
+            channelId: z.number().int().describe("Owned Telegram channel id."),
+            confirm: z.boolean().optional().describe("Required true to disconnect the channel."),
+        },
+        outputSchema: z.object({ success: z.boolean(), channelId: z.number().int() }).passthrough(),
+        annotations: destructiveTool,
+    }, async ({ channelId, confirm }) => {
+        await authed(["telegram:write"]);
+        requireConfirm(confirm, "oko_disconnect_telegram_channel", { channelId });
+        const disconnect = httpsCallable(functions, "disconnectTelegramChannel");
+        return textResult((await disconnect({ channelId })).data);
+    });
+    server.registerTool("oko_list_telegram_posts", {
+        title: "List Telegram posts",
+        description: toolDescription({
+            summary: "List Telegram notification posts for an event.",
+            args: [
+                "eventId: event whose Telegram posts to list.",
+                "status: optional client-side status filter.",
+                "limit: max posts, default 30, max 100.",
+                "cursor: createdAt cursor returned by previous page.",
+            ],
+            returns: "posts plus cursor pagination metadata.",
+            examples: ["Use to review scheduled/sent/failed Telegram posts before canceling or cloning."],
+        }),
+        inputSchema: {
+            eventId: eventIdField,
+            status: z.enum(TELEGRAM_POST_STATUSES).optional().describe("Optional post status filter."),
+            limit: limitField(),
+            cursor: cursorField,
+        },
+        outputSchema: telegramPostsOutputSchema,
+        annotations: readOnlyTool,
+    }, async ({ eventId, status, limit: max, cursor }) => {
+        const { uid } = await authed(["telegram:write"]);
+        await readEvent(eventId, uid, "notify");
+        const constraints = [
+            where("eventId", "==", eventId),
+            orderBy("createdAt", "desc"),
+            limit(max + 1),
+        ];
+        if (cursor)
+            constraints.splice(2, 0, startAfter(parseTimestampCursor(cursor)));
+        const snap = await getDocs(query(collection(firestore, "telegramPosts"), ...constraints));
+        const { page, hasMore } = pickPage(snap.docs, max);
+        let posts = page.map((item) => ({ id: item.id, ...serialize(item.data()) }));
+        if (status)
+            posts = posts.filter((post) => post.status === status);
+        const nextCursor = hasMore ? timestampCursorFrom(page.at(-1)?.data().createdAt) : null;
+        return textResult({ posts, ...cursorMeta(posts.length, max, hasMore, nextCursor) });
+    });
+    server.registerTool("oko_cancel_telegram_post", {
+        title: "Cancel Telegram post",
+        description: toolDescription({
+            summary: "Delete a draft/scheduled/failed Telegram post record before it is sent.",
+            args: ["postId: telegramPosts document id.", "confirm: must be true."],
+            returns: "postId, eventId, status, and canceled=true.",
+            examples: ["Use for scheduled posts that should not be sent."],
+            notes: ["Already sent Telegram messages cannot be unsent through OKO; this tool refuses status=sent."],
+        }),
+        inputSchema: { postId: z.string().min(1), confirm: z.boolean().optional().describe("Required true for cancellation.") },
+        outputSchema: z.object({ postId: z.string(), canceled: z.boolean() }).passthrough(),
+        annotations: destructiveTool,
+    }, async ({ postId, confirm }) => {
+        const { uid } = await authed(["telegram:write"]);
+        const postRef = doc(firestore, "telegramPosts", postId);
+        const postSnap = await getDoc(postRef);
+        if (!postSnap.exists())
+            throw new Error("Telegram post not found.");
+        const post = postSnap.data();
+        if (typeof post.eventId !== "string")
+            throw new Error("Telegram post has no valid event.");
+        await readEvent(post.eventId, uid, "notify");
+        if (!["draft", "pending", "scheduled", "failed"].includes(safeString(post.status))) {
+            throw new Error("Only draft, pending, scheduled, or failed Telegram posts can be canceled. A sent or delivery-unknown post must be reviewed manually.");
+        }
+        requireConfirm(confirm, "oko_cancel_telegram_post", { postId, eventId: post.eventId, status: post.status, caption: post.caption });
+        await deleteDoc(postRef);
+        return textResult({ postId, eventId: post.eventId, status: post.status, canceled: true });
+    });
+    server.registerTool("oko_publish_telegram_post", {
+        title: "Publish Telegram post",
+        description: toolDescription({
+            summary: "Create and optionally send or schedule a Telegram post for an OKO event.",
+            args: [
+                "eventId: event used for access checks and default button URL.",
+                "channelId: Telegram channel id configured for the organizer.",
+                "caption: post caption, max 4096 chars.",
+                "scheduleAt: optional ISO datetime; omitted means immediate send.",
+                "confirm: must be true for both immediate and scheduled publication.",
+            ],
+            returns: "postId, scheduled flag, and sent flag.",
+            examples: ["Use scheduleAt for scheduled posts; for immediate send, show the exact channel/caption and ask for confirmation."],
+            notes: ["External side effect: immediate sends can publish to real Telegram channels."],
+        }),
+        inputSchema: {
+            eventId: eventIdField,
+            channelId: z.number().int().describe("Telegram channel id."),
+            caption: z.string().min(1).max(4096).describe("Telegram post caption."),
+            imageUrl: z.string().nullable().optional().describe("Optional image URL."),
+            buttonLabel: z.string().max(64).nullable().optional().describe("Optional inline button label."),
+            buttonUrl: z.string().max(1000).nullable().optional().describe("Optional inline button URL; defaults to event URL when buttonLabel is set."),
+            scheduleAt: z.string().datetime().nullable().optional().describe("Optional ISO datetime for scheduled send."),
+            confirm: z.boolean().optional().describe("Required true to create the external Telegram side effect."),
+        },
+        outputSchema: z.object({ postId: z.string(), scheduled: z.boolean(), sent: z.boolean() }).passthrough(),
+        annotations: writeTool,
+    }, async (args) => {
+        const { uid } = await authed(["telegram:write"]);
+        await readEvent(args.eventId, uid, "notify");
+        const listChannels = httpsCallable(functions, "listTelegramChannels");
+        const availableResult = await listChannels({ eventId: args.eventId });
+        const available = z.array(canonicalTelegramChannelSchema).safeParse(availableResult.data.channels);
+        if (!available.success)
+            throw new Error("OKO listTelegramChannels returned an invalid channel payload.");
+        const channel = available.data.find((item) => item.chatId === args.channelId);
+        if (!channel)
+            throw new Error("Telegram channel is not available for this event. List channels with this eventId and choose a returned channel.");
+        const scheduled = !!args.scheduleAt;
+        requireConfirm(args.confirm, "oko_publish_telegram_post", {
+            eventId: args.eventId,
+            channelId: args.channelId,
+            channelTitle: channel.title ?? "",
+            caption: args.caption,
+            scheduleAt: args.scheduleAt ?? null,
+        });
+        const postData = {
+            eventId: args.eventId,
+            ownerId: uid,
+            ownerEmail: "",
+            channelId: args.channelId,
+            channelKey: String(args.channelId),
+            caption: args.caption.trim(),
+            imageUrl: args.imageUrl?.trim() || null,
+            buttons: args.buttonLabel?.trim() ? [{ label: args.buttonLabel.trim(), url: args.buttonUrl?.trim() || eventUrl(args.eventId) }] : [],
+            status: scheduled ? "scheduled" : "draft",
+            scheduledAt: args.scheduleAt ? Timestamp.fromDate(new Date(args.scheduleAt)) : null,
+            sentAt: null,
+            telegramMessageId: null,
+            error: null,
+            createdAt: serverTimestamp(),
+            updatedAt: serverTimestamp(),
+        };
+        const postRef = await addDoc(collection(firestore, "telegramPosts"), postData);
+        if (!scheduled) {
+            const sendPost = httpsCallable(functions, "sendTelegramPost");
+            await sendPost({ postId: postRef.id });
+        }
+        return textResult({ postId: postRef.id, scheduled, sent: !scheduled });
+    });
+}

package/dist/tools/workspaceAccess.js

@@ -0,0 +1,55 @@
+// Кто и что может: пространства организатора, права участников, роль в чате.
+//
+// Права нормализуются к девяти известным булевым ключам — неизвестное поле
+// в приглашении не должно превращаться в способность. Роль в чате читается
+// из серверного зеркала (его пишут CF7/CF18), а не выводится клиентом.
+import { randomBytes } from "node:crypto";
+import { collection, doc, getDoc, getDocs, query, where } from "firebase/firestore";
+import { get, ref } from "firebase/database";
+import { chatRtdb, firestore } from "../firebase.js";
+import { WORKSPACE_PERMISSION_KEYS } from "./schemas.js";
+import { serialize } from "../utils.js";
+export async function readWorkspaceForOwner(workspaceId, uid) {
+    const snap = await getDoc(doc(firestore, "workspaces", workspaceId));
+    if (!snap.exists())
+        throw new Error("Workspace not found.");
+    const data = snap.data();
+    if (data.ownerId !== uid)
+        throw new Error("Only the workspace owner can manage this workspace.");
+    return data;
+}
+export function normalizeWorkspacePermissions(value) {
+    const out = {};
+    for (const key of WORKSPACE_PERMISSION_KEYS) {
+        if (value[key] === true)
+            out[key] = true;
+        else if (value[key] === false)
+            out[key] = false;
+    }
+    return out;
+}
+export function randomInviteCode() {
+    return randomBytes(8).toString("hex").toUpperCase();
+}
+export async function listVisibleWorkspaces(uid, includeShared) {
+    const out = [];
+    const ownedSnap = await getDocs(query(collection(firestore, "workspaces"), where("ownerId", "==", uid)));
+    ownedSnap.forEach((item) => out.push({ id: item.id, ...serialize(item.data()), isOwner: true }));
+    if (includeShared) {
+        const profileSnap = await getDoc(doc(firestore, "userProfiles", uid));
+        const sharedIds = (profileSnap.data()?.sharedWorkspaceIds ?? []);
+        for (const workspaceId of sharedIds) {
+            if (out.some((row) => row.id === workspaceId))
+                continue;
+            const wsSnap = await getDoc(doc(firestore, "workspaces", workspaceId));
+            const shareSnap = await getDoc(doc(firestore, "workspaces", workspaceId, "shares", uid));
+            if (wsSnap.exists())
+                out.push({ id: workspaceId, ...serialize(wsSnap.data()), isOwner: false, permissions: serialize(shareSnap.data()?.permissions ?? {}) });
+        }
+    }
+    return out;
+}
+export async function getChatRole(eventId, uid) {
+    const snap = await get(ref(chatRtdb, `settings/${eventId}/roles/${uid}`));
+    return typeof snap.val() === "string" ? snap.val() : "viewer";
+}

package/dist/tools/workspaces.js

@@ -0,0 +1,292 @@
+// Рабочие пространства: состав, права участников и приглашения.
+//
+// Девять способностей выдаются точечно; их разносит по событиям CF18, а не
+// клиент. Личное пространство имеет id, равный uid владельца, — искать его
+// отдельным запросом не нужно.
+//
+// oko_create_workspace_invite до 01.09 лежал в конце файла, оторванным от
+// своей группы; при разборе возвращён к остальным инструментам приглашений.
+import { z } from "zod";
+import { requireConfirm, safeString, serialize, textResult } from "../utils.js";
+import { authed, inviteUrl } from "./context.js";
+import { destructiveTool, idempotentWriteTool, MAX_WORKSPACE_INVITE_CODE_LENGTH, MAX_WORKSPACE_NAME_LENGTH, readOnlyTool, toolDescription, unknownRecordSchema, updateOutputSchema, workspaceAccessOutputSchema, workspacePermissionsSchema, workspacesOutputSchema, writeTool } from "./schemas.js";
+import { addDoc, collection, deleteDoc, doc, getDoc, getDocs, limit, query, serverTimestamp, setDoc, updateDoc, where } from "firebase/firestore";
+import { firestore, functions } from "../firebase.js";
+import { httpsCallable } from "firebase/functions";
+import { listVisibleWorkspaces, normalizeWorkspacePermissions, randomInviteCode, readWorkspaceForOwner } from "./workspaceAccess.js";
+export function registerWorkspaceTools(server) {
+    server.registerTool("oko_list_workspaces", {
+        title: "List workspaces",
+        description: toolDescription({
+            summary: "List OKO workspaces visible to the authenticated organizer.",
+            args: ["includeShared: include workspaces shared with this organizer, default true."],
+            returns: "workspaces array with id, ownership flag, and permissions for shared workspaces, plus count.",
+            examples: ["Use before oko_create_webinar when the user wants to create a webinar in a shared workspace."],
+        }),
+        inputSchema: { includeShared: z.boolean().default(true).describe("Include workspaces shared with this organizer.") },
+        outputSchema: workspacesOutputSchema,
+        annotations: readOnlyTool,
+    }, async ({ includeShared }) => {
+        const { uid } = await authed(["workspace:read"]);
+        const out = await listVisibleWorkspaces(uid, includeShared);
+        return textResult({ workspaces: out, count: out.length });
+    });
+    server.registerTool("oko_create_workspace", {
+        title: "Create workspace",
+        description: toolDescription({
+            summary: "Create a shared OKO workspace owned by the authenticated organizer.",
+            args: ["name: workspace display name."],
+            returns: "workspaceId, name, and created=true.",
+            examples: ["Use when the organizer wants to create a new team/workspace for events."],
+        }),
+        inputSchema: { name: z.string().min(1).max(MAX_WORKSPACE_NAME_LENGTH).describe("Workspace name.") },
+        outputSchema: z.object({ workspaceId: z.string(), created: z.boolean() }).passthrough(),
+        annotations: writeTool,
+    }, async ({ name }) => {
+        const { uid } = await authed(["workspace:write"]);
+        const workspaceRef = await addDoc(collection(firestore, "workspaces"), {
+            name: name.trim(),
+            ownerId: uid,
+            personal: false,
+            createdAt: serverTimestamp(),
+        });
+        return textResult({ workspaceId: workspaceRef.id, name: name.trim(), created: true });
+    });
+    server.registerTool("oko_update_workspace", {
+        title: "Update workspace",
+        description: toolDescription({
+            summary: "Rename a workspace owned by the authenticated organizer.",
+            args: ["workspaceId: workspace to update.", "name: new workspace display name."],
+            returns: "workspaceId and updated fields.",
+            examples: ["Use for workspace rename requests."],
+        }),
+        inputSchema: { workspaceId: z.string().min(1), name: z.string().min(1).max(MAX_WORKSPACE_NAME_LENGTH).describe("New workspace name.") },
+        outputSchema: updateOutputSchema,
+        annotations: idempotentWriteTool,
+    }, async ({ workspaceId, name }) => {
+        const { uid } = await authed(["workspace:write"]);
+        await readWorkspaceForOwner(workspaceId, uid);
+        await updateDoc(doc(firestore, "workspaces", workspaceId), { name: name.trim() });
+        return textResult({ workspaceId, updated: ["name"] });
+    });
+    server.registerTool("oko_delete_workspace", {
+        title: "Delete workspace",
+        description: toolDescription({
+            summary: "Delete an empty non-personal workspace owned by the authenticated organizer.",
+            args: ["workspaceId: workspace to delete.", "confirm: must be true."],
+            returns: "workspaceId and deleted=true.",
+            examples: ["Use after listing workspace access and confirming the workspace is empty."],
+            notes: ["Personal workspaces cannot be deleted. This tool refuses to delete workspaces that still contain events; move/delete events first."],
+        }),
+        inputSchema: { workspaceId: z.string().min(1), confirm: z.boolean().optional().describe("Required true for workspace deletion.") },
+        outputSchema: z.object({ workspaceId: z.string(), deleted: z.boolean() }).passthrough(),
+        annotations: destructiveTool,
+    }, async ({ workspaceId, confirm }) => {
+        const { uid } = await authed(["workspace:write"]);
+        const workspace = await readWorkspaceForOwner(workspaceId, uid);
+        requireConfirm(confirm, "oko_delete_workspace", { workspaceId, name: workspace.name, personal: workspace.personal });
+        if (workspace.personal === true)
+            throw new Error("Personal workspace cannot be deleted.");
+        const eventsSnap = await getDocs(query(collection(firestore, "events"), where("workspaceId", "==", workspaceId), limit(1)));
+        if (!eventsSnap.empty)
+            throw new Error("Workspace still has events. Move or delete its events before deleting the workspace.");
+        await deleteDoc(doc(firestore, "workspaces", workspaceId));
+        return textResult({ workspaceId, deleted: true });
+    });
+    server.registerTool("oko_list_workspace_access", {
+        title: "List workspace access",
+        description: toolDescription({
+            summary: "List workspace members/shares and pending invites.",
+            args: ["workspaceId: workspace owned by the authenticated organizer."],
+            returns: "workspace document, members array, invites array.",
+            examples: ["Use before changing permissions, removing a member, or revoking an invite."],
+        }),
+        inputSchema: { workspaceId: z.string().min(1) },
+        outputSchema: workspaceAccessOutputSchema,
+        annotations: readOnlyTool,
+    }, async ({ workspaceId }) => {
+        const { uid } = await authed(["workspace:read"]);
+        const workspace = await readWorkspaceForOwner(workspaceId, uid);
+        const [sharesSnap, invitesSnap] = await Promise.all([
+            getDocs(collection(firestore, "workspaces", workspaceId, "shares")),
+            getDocs(query(collection(firestore, "workspaceInvites"), where("workspaceId", "==", workspaceId))),
+        ]);
+        const members = [];
+        for (const share of sharesSnap.docs) {
+            // Правила разрешают читать чужой профиль только владельцу платформы,
+            // поэтому на любом рабочем пространстве с участниками это чтение
+            // заканчивается отказом. Без обработки инструмент падал целиком вместо
+            // того, чтобы вернуть состав команды без необязательных профилей.
+            const profile = await getDoc(doc(firestore, "userProfiles", share.id))
+                .then((snap) => (snap.exists() ? serialize(snap.data()) : null))
+                .catch(() => null);
+            members.push({
+                uid: share.id,
+                ...serialize(share.data()),
+                profile,
+            });
+        }
+        const invites = invitesSnap.docs.map((invite) => ({ code: invite.id, ...serialize(invite.data()) }));
+        return textResult({ workspaceId, workspace: { id: workspaceId, ...serialize(workspace) }, members, invites });
+    });
+    server.registerTool("oko_update_workspace_member", {
+        title: "Update workspace member",
+        description: toolDescription({
+            summary: "Create or update a workspace share/member permissions document.",
+            args: ["workspaceId: workspace owned by the organizer.", "uid: member uid.", "permissions: 9 workspace permission booleans.", "confirm: must be true."],
+            returns: "workspaceId, uid, and updated=true.",
+            examples: ["Use to change an existing member's permissions, or direct-add a known uid."],
+            notes: ["Changing a share materializes lightweight event grants and updates RTDB workspace/chat mirrors."],
+        }),
+        inputSchema: {
+            workspaceId: z.string().min(1),
+            uid: z.string().min(1).describe("Member Firebase uid."),
+            email: z.string().email().optional().describe("Optional member email cache."),
+            comment: z.string().max(500).default(""),
+            permissions: workspacePermissionsSchema,
+            confirm: z.boolean().optional().describe("Required true for share updates."),
+        },
+        outputSchema: updateOutputSchema,
+        annotations: writeTool,
+    }, async (args) => {
+        const { uid } = await authed(["workspace:write"]);
+        const workspace = await readWorkspaceForOwner(args.workspaceId, uid);
+        requireConfirm(args.confirm, "oko_update_workspace_member", { workspaceId: args.workspaceId, workspaceName: workspace.name, targetUid: args.uid, permissions: args.permissions });
+        await setDoc(doc(firestore, "workspaces", args.workspaceId, "shares", args.uid), {
+            email: args.email ?? "",
+            comment: args.comment.trim(),
+            permissions: normalizeWorkspacePermissions(args.permissions),
+            sharedAt: serverTimestamp(),
+            sharedBy: uid,
+        }, { merge: true });
+        return textResult({ workspaceId: args.workspaceId, uid: args.uid, updated: true });
+    });
+    server.registerTool("oko_remove_workspace_member", {
+        title: "Remove workspace member",
+        description: toolDescription({
+            summary: "Remove a member/share from a workspace.",
+            args: ["workspaceId: workspace owned by the organizer.", "uid: member uid.", "confirm: must be true."],
+            returns: "workspaceId, uid, removed=true.",
+            examples: ["Use after listing workspace access and confirming the exact uid."],
+            notes: ["Removing a share revokes its event grants and RTDB workspace/chat mirrors."],
+        }),
+        inputSchema: { workspaceId: z.string().min(1), uid: z.string().min(1), confirm: z.boolean().optional().describe("Required true for member removal.") },
+        outputSchema: z.object({ workspaceId: z.string(), uid: z.string(), removed: z.boolean() }).passthrough(),
+        annotations: destructiveTool,
+    }, async ({ workspaceId, uid: targetUid, confirm }) => {
+        const { uid } = await authed(["workspace:write"]);
+        const workspace = await readWorkspaceForOwner(workspaceId, uid);
+        requireConfirm(confirm, "oko_remove_workspace_member", { workspaceId, workspaceName: workspace.name, targetUid });
+        await deleteDoc(doc(firestore, "workspaces", workspaceId, "shares", targetUid));
+        return textResult({ workspaceId, uid: targetUid, removed: true });
+    });
+    server.registerTool("oko_list_workspace_invites", {
+        title: "List workspace invites",
+        description: toolDescription({
+            summary: "List workspace invite links for a workspace owned by the organizer.",
+            args: ["workspaceId: workspace owned by the organizer."],
+            returns: "invites array with code, claim status, permissions, and inviteUrl.",
+            examples: ["Use before revoking or sharing an invite code."],
+        }),
+        inputSchema: { workspaceId: z.string().min(1) },
+        outputSchema: z.object({ workspaceId: z.string(), invites: z.array(unknownRecordSchema), count: z.number().int().nonnegative() }).passthrough(),
+        annotations: readOnlyTool,
+    }, async ({ workspaceId }) => {
+        const { uid } = await authed(["workspace:read"]);
+        await readWorkspaceForOwner(workspaceId, uid);
+        const snap = await getDocs(query(collection(firestore, "workspaceInvites"), where("workspaceId", "==", workspaceId)));
+        const invites = snap.docs.map((invite) => ({ code: invite.id, ...serialize(invite.data()), inviteUrl: inviteUrl(invite.id) }));
+        return textResult({ workspaceId, invites, count: invites.length });
+    });
+    server.registerTool("oko_revoke_workspace_invite", {
+        title: "Revoke workspace invite",
+        description: toolDescription({
+            summary: "Delete a pending workspace invite code.",
+            args: ["code: invite code.", "confirm: must be true."],
+            returns: "code and revoked=true.",
+            examples: ["Use after confirming the exact invite code."],
+        }),
+        inputSchema: { code: z.string().min(4).max(MAX_WORKSPACE_INVITE_CODE_LENGTH), confirm: z.boolean().optional().describe("Required true for invite revocation.") },
+        outputSchema: z.object({ code: z.string(), revoked: z.boolean() }).passthrough(),
+        annotations: destructiveTool,
+    }, async ({ code, confirm }) => {
+        const { uid } = await authed(["workspace:write"]);
+        const normalizedCode = code.trim().toUpperCase();
+        const inviteSnap = await getDoc(doc(firestore, "workspaceInvites", normalizedCode));
+        if (!inviteSnap.exists())
+            throw new Error("Workspace invite not found.");
+        const invite = inviteSnap.data();
+        if (invite.createdBy !== uid)
+            throw new Error("Only the invite creator/workspace owner can revoke this invite.");
+        requireConfirm(confirm, "oko_revoke_workspace_invite", { code: normalizedCode, workspaceId: invite.workspaceId, claimed: invite.claimed });
+        await deleteDoc(doc(firestore, "workspaceInvites", normalizedCode));
+        return textResult({ code: normalizedCode, revoked: true });
+    });
+    server.registerTool("oko_claim_workspace_invite", {
+        title: "Claim workspace invite",
+        description: toolDescription({
+            summary: "Accept a workspace invite code for the authenticated organizer.",
+            args: ["code: invite code from /invite/{code}.", "confirm: must be true."],
+            returns: "success plus workspace id/name returned by OKO CF19.",
+            examples: ["Use when the organizer wants to join a workspace from an invite code."],
+        }),
+        inputSchema: {
+            code: z.string().min(4).max(MAX_WORKSPACE_INVITE_CODE_LENGTH),
+            confirm: z.boolean().optional().describe("Required true to join the workspace."),
+        },
+        outputSchema: z.object({
+            success: z.boolean(),
+            workspace: z.object({ id: z.string(), name: z.string() }).passthrough(),
+        }).passthrough(),
+        annotations: writeTool,
+    }, async ({ code, confirm }) => {
+        await authed(["workspace:write"]);
+        requireConfirm(confirm, "oko_claim_workspace_invite", { code: code.trim().toUpperCase() });
+        const claimInvite = httpsCallable(functions, "claimWorkspaceInvite");
+        const result = await claimInvite({ code: code.trim().toUpperCase() });
+        return textResult({ ...serialize(result.data) });
+    });
+    server.registerTool("oko_create_workspace_invite", {
+        title: "Create workspace invite",
+        description: toolDescription({
+            summary: "Create a workspace invite for a known OKO workspace.",
+            args: [
+                "workspaceId: workspace owned by the authenticated organizer.",
+                "code: optional invite code, 4-64 chars; omitted means generated.",
+                "email: optional intended recipient email.",
+                "permissions: optional whitelist of workspace permission booleans.",
+                "confirm: must be true.",
+            ],
+            returns: "workspaceId, invite code, inviteUrl, and created=true.",
+            examples: ["Use only after confirming the recipient and permission set with the workspace owner."],
+        }),
+        inputSchema: {
+            workspaceId: z.string().min(1),
+            code: z.string().min(4).max(MAX_WORKSPACE_INVITE_CODE_LENGTH).optional(),
+            email: z.string().email().optional(),
+            comment: z.string().max(500).default(""),
+            permissions: workspacePermissionsSchema,
+            confirm: z.boolean().optional(),
+        },
+        outputSchema: z.object({ workspaceId: z.string(), code: z.string(), inviteUrl: z.string().url(), created: z.boolean() }).passthrough(),
+        annotations: writeTool,
+    }, async (args) => {
+        const { uid } = await authed(["workspace:write"]);
+        const workspace = await readWorkspaceForOwner(args.workspaceId, uid);
+        requireConfirm(args.confirm, "oko_create_workspace_invite", { workspaceId: args.workspaceId, code: args.code, email: args.email });
+        const code = (args.code?.trim() || randomInviteCode()).toUpperCase();
+        const url = inviteUrl(code);
+        await setDoc(doc(firestore, "workspaceInvites", code), {
+            workspaceId: args.workspaceId,
+            workspaceName: safeString(workspace.name, "Workspace"),
+            email: args.email ?? "",
+            comment: args.comment,
+            permissions: normalizeWorkspacePermissions(args.permissions),
+            createdBy: uid,
+            createdAt: serverTimestamp(),
+            claimed: false,
+            claimedBy: null,
+        });
+        return textResult({ workspaceId: args.workspaceId, code, inviteUrl: url, created: true });
+    });
+}