vibo-mcp 1.0.0

package/dist/client.js

@@ -0,0 +1,219 @@
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { loadDotenvSafely, readEnvVar, McpToolError, SessionNotAuthenticatedError, truncateErrorMessage, } from '@chrischall/mcp-utils';
+// Load .env for local dev; silently skip if dotenv is unavailable (e.g. the
+// mcpb bundle, which externalizes dotenv). `override: false` means a
+// host-provided env var always wins over .env.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+await loadDotenvSafely({ path: join(__dirname, '..', '.env'), override: false });
+const DEFAULT_API_URL = 'https://api.vibodj.com/v2/graphql';
+const SERVICE = 'Vibo';
+const SIGN_IN_HOST = 'https://web.vibodj.com';
+const REQUEST_TIMEOUT_MS = 30_000;
+/** `signIn` exchanges email + password for an access/refresh token pair. */
+const SIGN_IN = `
+  mutation signIn($email: String!, $password: String!) {
+    signIn(email: $email, password: $password) {
+      accessToken
+      refreshToken
+    }
+  }
+`;
+/** `refreshToken` mints a fresh access token from a still-valid refresh token. */
+const REFRESH = `
+  mutation refreshToken($refreshToken: String!) {
+    refreshToken(refreshToken: $refreshToken) {
+      accessToken
+      refreshToken
+    }
+  }
+`;
+// Error codes Vibo (and conventional GraphQL servers) use for an expired /
+// missing session — these should trigger a token refresh + replay.
+const AUTH_ERROR_CODES = new Set(['UNAUTHORIZED', 'UNAUTHENTICATED', 'FORBIDDEN']);
+/**
+ * Thin GraphQL client for the Vibo consumer API.
+ *
+ * Vibo authenticates with custom `x-token` / `x-refresh-token` headers (not
+ * `Authorization: Bearer`), so this is a hand-written client rather than
+ * `createApiClient`. Two credential paths are supported:
+ *
+ *   - VIBO_EMAIL + VIBO_PASSWORD  → server-side `signIn` mutation (preferred)
+ *   - VIBO_ACCESS_TOKEN [+ VIBO_REFRESH_TOKEN] → use a captured token directly
+ *     (for accounts that only sign in via Apple/Google/Facebook SSO)
+ *
+ * The config error is deferred: the constructor never throws, so the server
+ * still boots and answers the host's install-time `tools/list` probe when no
+ * credentials are set. The error surfaces on the first tool call.
+ */
+export class ViboClient {
+    apiUrl;
+    email;
+    password;
+    configError;
+    accessToken;
+    refreshTokenValue;
+    // Single-flight guards so concurrent tool calls never race two logins /
+    // refreshes against each other (à la mcp-utils' TokenManager).
+    loginInFlight = null;
+    reauthInFlight = null;
+    constructor() {
+        this.apiUrl = readEnvVar('VIBO_API_URL') ?? DEFAULT_API_URL;
+        const email = readEnvVar('VIBO_EMAIL');
+        const password = readEnvVar('VIBO_PASSWORD');
+        const accessToken = readEnvVar('VIBO_ACCESS_TOKEN');
+        const refreshToken = readEnvVar('VIBO_REFRESH_TOKEN');
+        this.email = email ?? null;
+        this.password = password ?? null;
+        this.accessToken = accessToken ?? null;
+        this.refreshTokenValue = refreshToken ?? null;
+        const haveLogin = Boolean(email && password);
+        const haveToken = Boolean(accessToken);
+        if (!haveLogin && !haveToken) {
+            this.configError = new McpToolError('Vibo credentials are not configured.', {
+                hint: 'Set VIBO_EMAIL and VIBO_PASSWORD (recommended), or paste a captured ' +
+                    'VIBO_ACCESS_TOKEN (+ VIBO_REFRESH_TOKEN) if your account uses Apple/Google/Facebook sign-in.',
+            });
+        }
+        else {
+            this.configError = null;
+        }
+    }
+    /** Run a GraphQL operation, transparently authenticating + retrying once on token expiry. */
+    async gql(query, variables = {}) {
+        if (this.configError)
+            throw this.configError;
+        const token = await this.ensureAccessToken();
+        let res = await this.post(query, variables, token);
+        if (this.isAuthError(res.status, res.body.errors)) {
+            // Token expired/invalid — re-authenticate once and replay exactly once.
+            const fresh = await this.reauthenticate();
+            res = await this.post(query, variables, fresh);
+        }
+        return this.unwrap(res.status, res.body);
+    }
+    /** Returns the current access token, performing a first login if we only have email/password. */
+    async ensureAccessToken() {
+        if (this.accessToken)
+            return this.accessToken;
+        return this.login();
+    }
+    /** Single-flight email/password login. */
+    login() {
+        if (this.loginInFlight)
+            return this.loginInFlight;
+        if (!this.email || !this.password) {
+            // Only a (now-rejected) token was supplied and there's nothing to log in with.
+            throw new SessionNotAuthenticatedError(SERVICE, SIGN_IN_HOST);
+        }
+        this.loginInFlight = (async () => {
+            const res = await this.post(SIGN_IN, { email: this.email, password: this.password }, null);
+            const data = this.unwrap(res.status, res.body);
+            if (!data.signIn?.accessToken) {
+                throw new SessionNotAuthenticatedError(SERVICE, SIGN_IN_HOST);
+            }
+            this.accessToken = data.signIn.accessToken;
+            this.refreshTokenValue = data.signIn.refreshToken;
+            return this.accessToken;
+        })().finally(() => {
+            this.loginInFlight = null;
+        });
+        return this.loginInFlight;
+    }
+    /** Single-flight re-auth: try a refresh-token grant first, fall back to a fresh login. */
+    reauthenticate() {
+        if (this.reauthInFlight)
+            return this.reauthInFlight;
+        this.reauthInFlight = (async () => {
+            if (this.refreshTokenValue) {
+                try {
+                    const res = await this.post(REFRESH, { refreshToken: this.refreshTokenValue }, null);
+                    if (!this.isAuthError(res.status, res.body.errors)) {
+                        const data = this.unwrap(res.status, res.body);
+                        if (data.refreshToken?.accessToken) {
+                            this.accessToken = data.refreshToken.accessToken;
+                            this.refreshTokenValue = data.refreshToken.refreshToken;
+                            return this.accessToken;
+                        }
+                    }
+                }
+                catch {
+                    // fall through to a full login
+                }
+            }
+            if (this.email && this.password) {
+                this.accessToken = null;
+                return this.login();
+            }
+            throw new SessionNotAuthenticatedError(SERVICE, SIGN_IN_HOST);
+        })().finally(() => {
+            this.reauthInFlight = null;
+        });
+        return this.reauthInFlight;
+    }
+    async post(query, variables, token) {
+        const headers = { 'content-type': 'application/json' };
+        if (token)
+            headers['x-token'] = token;
+        let response;
+        try {
+            response = await fetch(this.apiUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ query, variables }),
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (err) {
+            const reason = err instanceof Error && err.name === 'TimeoutError' ? 'timed out' : 'failed';
+            throw new McpToolError(`Request to ${SERVICE} ${reason}.`, {
+                hint: 'The Vibo API may be unreachable — check your connection and retry.',
+                cause: err,
+            });
+        }
+        let body;
+        try {
+            body = (await response.json());
+        }
+        catch {
+            body = {};
+        }
+        return { status: response.status, body };
+    }
+    isAuthError(status, errors) {
+        if (status === 401 || status === 403)
+            return true;
+        if (!errors?.length)
+            return false;
+        return errors.some((e) => {
+            const code = e.code ?? e.extensions?.code ?? '';
+            if (AUTH_ERROR_CODES.has(code))
+                return true;
+            // Message fallback for servers that omit a code. Vibo's text is
+            // "Not authorized. Try to log in".
+            return /not authoriz|unauthor|unauthenticated|invalid token|token expired|expired token|jwt|log ?in/i.test(e.message ?? '');
+        });
+    }
+    unwrap(status, body) {
+        if (body.errors?.length) {
+            if (this.isAuthError(status, body.errors)) {
+                throw new SessionNotAuthenticatedError(SERVICE, SIGN_IN_HOST);
+            }
+            const message = body.errors.map((e) => e.message ?? 'Unknown error').join('; ');
+            throw new McpToolError(`${SERVICE} API error: ${truncateErrorMessage(message)}`);
+        }
+        if (status >= 400) {
+            throw new McpToolError(`${SERVICE} API returned HTTP ${status}.`);
+        }
+        if (body.data === undefined) {
+            throw new McpToolError(`${SERVICE} API returned an empty response.`);
+        }
+        return body.data;
+    }
+}
+/**
+ * Module-level singleton shared by every tool module. Constructed here (not in
+ * index.ts) so the deferred-config-error pattern holds: the server boots and
+ * answers the install-time tools/list probe even when credentials are absent.
+ */
+export const client = new ViboClient();

package/dist/gql.js

@@ -0,0 +1,210 @@
+// All GraphQL operation documents for the Vibo consumer API, in one place so
+// the wire surface is reviewable independently of the tool wiring. Field
+// selections were built from live schema introspection of api.vibodj.com — see
+// docs/VIBO-API.md. Tool modules import these and call client.gql(DOC, vars).
+const SONG_LINKS = `links { spotify appleMusic youtube tidal soundcloud deezer }`;
+const THUMBS = `thumbnails { s180x180 original }`;
+const LOCATION = `location { name lat lng }`;
+// ---- Profile ----------------------------------------------------------------
+export const GET_ME = `
+  query getMe {
+    me {
+      _id firstName lastName email phoneCode phoneNumber country lang
+      imageUrl role loginType spotifyConnected appleMusicConnected
+      ${LOCATION}
+    }
+  }
+`;
+// ---- Events -----------------------------------------------------------------
+const EVENT_LIST_ITEM = `
+  _id title status type date timezone role isPast isLocked playlistSize
+  usersCount hostsCount guestsCount sectionsWithSongs sectionsWithSongsTotal
+  sectionsWithSongsProgress questionsCount answeredQuestionsCount isPro
+  ${LOCATION}
+`;
+export const LIST_UPCOMING_EVENTS = `
+  query getUpcomingEvents($filter: EventsFilterInput, $pagination: PaginationInput, $sort: SortInput) {
+    upcomingEvents(filter: $filter, pagination: $pagination, sort: $sort) {
+      events { ${EVENT_LIST_ITEM} }
+      next { skip limit }
+      totalCount
+    }
+  }
+`;
+export const LIST_HISTORY_EVENTS = `
+  query getHistoryEvents($filter: EventsFilterInput, $pagination: PaginationInput, $sort: SortInput) {
+    historyEvents(filter: $filter, pagination: $pagination, sort: $sort) {
+      events { ${EVENT_LIST_ITEM} }
+      next { skip limit }
+      totalCount
+    }
+  }
+`;
+export const GET_EVENT = `
+  query getEvent($eventId: ID!) {
+    event(eventId: $eventId) {
+      _id title status type date timezone arrivalTime startTime endTime
+      role isPast isLocked lockDate note hostsCount guestsCount usersCount
+      playlistSize sectionsCount sectionsWithSongs sectionsWithSongsTotal
+      sectionsWithSongsProgress questionsCount answeredQuestionsCount
+      dontPlayVisibility hostDeepLink guestDeepLink isPro firstSectionId
+      ${LOCATION}
+    }
+  }
+`;
+export const JOIN_EVENT_BY_DEEP_LINK = `
+  mutation joinEventViaDeepLink($deepLink: String!) {
+    joinEventViaDeepLink(deepLink: $deepLink) { _id }
+  }
+`;
+export const JOIN_EVENT_BY_HASH = `
+  mutation joinEventByHash($hash: String!) {
+    joinEventByHash(hash: $hash) { _id }
+  }
+`;
+export const LEAVE_EVENT = `
+  mutation leaveEvent($eventId: ID!) {
+    leaveEvent(eventId: $eventId)
+  }
+`;
+export const CREATE_EVENT_CONTACT = `
+  mutation createEventContact($eventId: ID!, $payload: CreateContactInput!) {
+    createEventContact(eventId: $eventId, payload: $payload) {
+      _id role email firstName lastName phoneCode phoneNumber
+    }
+  }
+`;
+// ---- Sections (timeline) ----------------------------------------------------
+export const LIST_SECTIONS = `
+  query sections($eventId: ID!, $filter: SectionsFilterInput) {
+    sections(eventId: $eventId, filter: $filter) {
+      _id name time note description type
+      hasNote hasComments hasSongs hasQuestions
+      songsCount songsInfo questionsCount answeredCount songIdeasCount
+      visibility progress totalProgress
+      coverSong { artist title }
+    }
+  }
+`;
+// ---- Songs ------------------------------------------------------------------
+export const GET_SECTION_SONGS = `
+  query getSectionSongs($eventId: ID!, $sectionId: ID!, $filter: SectionSongsFilter, $pagination: PaginationInput, $sort: SongsSortInput) {
+    getSectionSongs(eventId: $eventId, sectionId: $sectionId, filter: $filter, pagination: $pagination, sort: $sort) {
+      songs {
+        _id viboSongId artist title isMustPlay isFlagged comment
+        likedByMe likesCount commentsCount isAddedByMe canRemove createdAt
+        creator { _id firstName lastName }
+        ${THUMBS}
+        ${SONG_LINKS}
+      }
+      next { skip limit }
+      totalCount
+    }
+  }
+`;
+export const SEARCH_SONGS = `
+  query getSongs($eventId: ID!, $sectionId: ID!, $filter: SongsFilter!, $limit: Int!) {
+    getSongs(eventId: $eventId, sectionId: $sectionId, filter: $filter, limit: $limit) {
+      sectionSongId viboSongId songUrl title artist isInSection isDontPlay
+      ${THUMBS}
+      ${SONG_LINKS}
+    }
+  }
+`;
+export const ADD_SONG_TO_SECTION = `
+  mutation addSongToSection($eventId: ID!, $sectionId: ID!, $payload: AddSongToSectionInput!) {
+    addSongToSection(eventId: $eventId, sectionId: $sectionId, payload: $payload) {
+      added songId totalCount sectionsWithSongs sectionsWithSongsTotal
+      sectionsWithSongsProgress totalProgress songsInfo
+    }
+  }
+`;
+export const TOGGLE_LIKE = `
+  mutation toggleLike($eventId: ID!, $sectionId: ID!, $songId: ID!, $liked: Boolean!) {
+    toggleLike(eventId: $eventId, sectionId: $sectionId, songId: $songId, liked: $liked) { liked }
+  }
+`;
+// ---- Playlists (connected Spotify / Apple Music) ----------------------------
+export const GET_PLAYLISTS = `
+  query getPlaylists($source: MusicImportSource!, $pagination: PaginationInput, $filter: PlaylistsFilter) {
+    getPlaylists(source: $source, pagination: $pagination, filter: $filter) {
+      playlists { id name total images { url width height } }
+      total
+      next { skip limit }
+    }
+  }
+`;
+export const GET_PLAYLIST_SONGS = `
+  query getPlaylistSongs($playlistId: ID!, $source: MusicImportSource!, $pagination: PaginationInput) {
+    getPlaylistSongs(playlistId: $playlistId, source: $source, pagination: $pagination) {
+      tracks { id title artist songUrl images { url width height } }
+      total
+      next { skip limit }
+    }
+  }
+`;
+export const EXPORT_EVENT_TO_SPOTIFY = `
+  mutation exportEventToSpotify($eventId: ID!, $sectionIds: [ID!]!, $sort: SongsSortInput, $filter: ExportEventFilter, $title: String) {
+    exportEventToSpotify(eventId: $eventId, sectionIds: $sectionIds, sort: $sort, filter: $filter, title: $title) {
+      playlistUrl exportedCount title
+      failedToExport { text viboSongId sectionId }
+    }
+  }
+`;
+export const EXPORT_EVENT_TO_APPLE_MUSIC = `
+  mutation exportEventToAppleMusic($eventId: ID!, $sectionIds: [ID!]!, $sort: SongsSortInput, $filter: ExportEventFilter, $title: String) {
+    exportEventToAppleMusic(eventId: $eventId, sectionIds: $sectionIds, sort: $sort, filter: $filter, title: $title) {
+      playlistUrl exportedCount title
+      failedToExport { text viboSongId sectionId }
+    }
+  }
+`;
+// ---- Notifications ----------------------------------------------------------
+export const GET_NOTIFICATIONS = `
+  query getNotifications($pagination: PaginationInput) {
+    getNotifications(pagination: $pagination) {
+      notifications {
+        _id imageUrl header body isRead notificationType createdAt
+        metadata { eventId sectionId questionId }
+      }
+      next { skip limit }
+      totalCount
+    }
+  }
+`;
+export const GET_NOTIFICATIONS_COUNT = `
+  query getNotificationsCount {
+    getNotificationsCount { total }
+  }
+`;
+export const MARK_AS_READ = `
+  mutation markAsRead($notificationIds: [ID!], $readAll: Boolean) {
+    markAsRead(notificationIds: $notificationIds, readAll: $readAll)
+  }
+`;
+// ---- Section questions (the DJ's planning questions) ------------------------
+export const LIST_SECTION_QUESTIONS = `
+  query getEventSectionQuestionsV2($eventId: ID!, $sectionId: ID!) {
+    getEventSectionQuestionsV2(eventId: $eventId, sectionId: $sectionId) {
+      progress
+      questions {
+        _id
+        isAnswered
+        settings { type hasOther optionImagesEnabled notifyMe }
+        question {
+          title
+          options { _id title isOther }
+        }
+        answer { text selectedOptions link }
+      }
+    }
+  }
+`;
+export const ANSWER_SECTION_QUESTION = `
+  mutation answerEventSectionQuestionV2($eventId: ID!, $sectionId: ID!, $questionId: ID!, $payload: AnswerQuestionV2Input!) {
+    answerEventSectionQuestionV2(eventId: $eventId, sectionId: $sectionId, questionId: $questionId, payload: $payload) {
+      progress
+      question { _id isAnswered answer { text selectedOptions link } }
+    }
+  }
+`;

package/dist/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { runMcp } from '@chrischall/mcp-utils';
+import { VERSION } from './version.js';
+import { registerProfileTools } from './tools/profile.js';
+import { registerEventTools } from './tools/events.js';
+import { registerSectionTools } from './tools/sections.js';
+import { registerSongTools } from './tools/songs.js';
+import { registerPlaylistTools } from './tools/playlists.js';
+import { registerNotificationTools } from './tools/notifications.js';
+import { registerQuestionTools } from './tools/questions.js';
+// The ViboClient is a module-level singleton (constructed in client.ts and
+// imported by each tool module) that defers its config error to the first
+// request. That preserves the deferred-config-error pattern: the server boots
+// and answers the host's install-time tools/list probe even when no Vibo
+// credentials are set — the error only surfaces on the first tool call.
+await runMcp({
+    name: 'vibo-mcp',
+    version: VERSION,
+    banner: '[vibo-mcp] This project was developed and is maintained by AI (Claude Code). Use at your own discretion.',
+    tools: [
+        registerProfileTools,
+        registerEventTools,
+        registerSectionTools,
+        registerSongTools,
+        registerPlaylistTools,
+        registerNotificationTools,
+        registerQuestionTools,
+    ],
+});

package/dist/tools/events.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { textResult, toolAnnotations, schemaConfirm, McpToolError } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { LIST_UPCOMING_EVENTS, LIST_HISTORY_EVENTS, GET_EVENT, JOIN_EVENT_BY_DEEP_LINK, JOIN_EVENT_BY_HASH, LEAVE_EVENT, CREATE_EVENT_CONTACT, } from '../gql.js';
+import { limitSchema, skipSchema, pagination, previewResult } from './shared.js';
+export function registerEventTools(server) {
+    server.registerTool('vibo_list_events', {
+        description: "List the events you're part of (as host or guest). Defaults to upcoming events; pass past:true for events that have already happened. Optionally filter by a search query.",
+        annotations: toolAnnotations({ title: 'List Vibo events', readOnly: true }),
+        inputSchema: {
+            past: z.boolean().optional().describe('Return past events instead of upcoming (default false).'),
+            q: z.string().optional().describe('Search events by title.'),
+            limit: limitSchema,
+            skip: skipSchema,
+        },
+    }, async ({ past, q, limit, skip }) => {
+        const variables = {
+            pagination: pagination(limit, skip),
+            ...(q ? { filter: { q } } : {}),
+        };
+        const doc = past ? LIST_HISTORY_EVENTS : LIST_UPCOMING_EVENTS;
+        const data = await client.gql(doc, variables);
+        return textResult(past ? data.historyEvents : data.upcomingEvents);
+    });
+    server.registerTool('vibo_get_event', {
+        description: 'Get full details for one event: title, date/timezone, location, your role, lock status, playlist size, and section/question progress. Use vibo_list_sections for the timeline.',
+        annotations: toolAnnotations({ title: 'Get Vibo event', readOnly: true }),
+        inputSchema: {
+            eventId: z.string().describe('Event id (the _id from vibo_list_events).'),
+        },
+    }, async ({ eventId }) => {
+        const data = await client.gql(GET_EVENT, { eventId });
+        return textResult(data.event);
+    });
+    server.registerTool('vibo_join_event', {
+        description: "Join an event you were invited to, via its share link or hash (e.g. a vibodj.app.link/... URL someone sent you). Returns the joined event's id. Confirm-gated.",
+        annotations: toolAnnotations({ title: 'Join Vibo event', readOnly: false }),
+        inputSchema: {
+            link: z
+                .string()
+                .describe('The full event share URL (vibodj.app.link/... or web.vibodj.com/...) or the bare join hash.'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ link, confirm }) => {
+        const isUrl = /^https?:\/\//i.test(link);
+        if (!confirm) {
+            return previewResult('joinEvent', isUrl ? { deepLink: link } : { hash: link });
+        }
+        if (isUrl) {
+            const data = await client.gql(JOIN_EVENT_BY_DEEP_LINK, {
+                deepLink: link,
+            });
+            return textResult({ joined: true, eventId: data.joinEventViaDeepLink._id });
+        }
+        const data = await client.gql(JOIN_EVENT_BY_HASH, { hash: link });
+        return textResult({ joined: true, eventId: data.joinEventByHash._id });
+    });
+    server.registerTool('vibo_leave_event', {
+        description: 'Leave an event you previously joined. Confirm-gated.',
+        annotations: toolAnnotations({ title: 'Leave Vibo event', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id to leave.'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, confirm }) => {
+        if (!confirm)
+            return previewResult('leaveEvent', { eventId });
+        const data = await client.gql(LEAVE_EVENT, { eventId });
+        return textResult({ left: true, eventId, result: data.leaveEvent });
+    });
+    server.registerTool('vibo_create_event_contact', {
+        description: 'Add a contact (host or guest) to an event with their name/email/phone. Confirm-gated.',
+        annotations: toolAnnotations({ title: 'Add Vibo event contact', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            role: z.enum(['host', 'guest']).describe("The contact's role in the event."),
+            email: z.string().email().describe('Contact email (required by Vibo).'),
+            firstName: z.string().optional(),
+            lastName: z.string().optional(),
+            phoneCode: z.string().optional().describe('Country calling code, e.g. "1".'),
+            phoneNumber: z.string().optional(),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, role, email, firstName, lastName, phoneCode, phoneNumber, confirm }) => {
+        const payload = { role, email };
+        if (firstName !== undefined)
+            payload.firstName = firstName;
+        if (lastName !== undefined)
+            payload.lastName = lastName;
+        if (phoneCode !== undefined)
+            payload.phoneCode = phoneCode;
+        if (phoneNumber !== undefined)
+            payload.phoneNumber = phoneNumber;
+        if (phoneNumber !== undefined && phoneCode === undefined) {
+            throw new McpToolError('phoneCode is required when phoneNumber is provided.', {
+                hint: 'Pass phoneCode (e.g. "1") alongside phoneNumber.',
+            });
+        }
+        if (!confirm)
+            return previewResult('createEventContact', { eventId, payload });
+        const data = await client.gql(CREATE_EVENT_CONTACT, { eventId, payload });
+        return textResult(data.createEventContact);
+    });
+}

package/dist/tools/notifications.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { textResult, toolAnnotations, schemaConfirm, McpToolError } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { GET_NOTIFICATIONS, GET_NOTIFICATIONS_COUNT, MARK_AS_READ } from '../gql.js';
+import { limitSchema, skipSchema, pagination, previewResult } from './shared.js';
+export function registerNotificationTools(server) {
+    server.registerTool('vibo_list_notifications', {
+        description: 'List your Vibo notifications (song additions, comments, DJ updates, etc.) with read state and linked event/section ids.',
+        annotations: toolAnnotations({ title: 'List Vibo notifications', readOnly: true }),
+        inputSchema: {
+            limit: limitSchema,
+            skip: skipSchema,
+        },
+    }, async ({ limit, skip }) => {
+        const data = await client.gql(GET_NOTIFICATIONS, {
+            pagination: pagination(limit, skip),
+        });
+        return textResult(data.getNotifications);
+    });
+    server.registerTool('vibo_get_notifications_count', {
+        description: 'Get the count of unread Vibo notifications.',
+        annotations: toolAnnotations({ title: 'Unread notification count', readOnly: true }),
+    }, async () => {
+        const data = await client.gql(GET_NOTIFICATIONS_COUNT);
+        return textResult(data.getNotificationsCount);
+    });
+    server.registerTool('vibo_mark_notifications_read', {
+        description: 'Mark notifications as read — pass specific notificationIds, or readAll:true to clear everything. Confirm-gated.',
+        annotations: toolAnnotations({ title: 'Mark notifications read', readOnly: false }),
+        inputSchema: {
+            notificationIds: z.array(z.string()).optional().describe('Specific notification ids to mark read.'),
+            readAll: z.boolean().optional().describe('Mark every notification as read.'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ notificationIds, readAll, confirm }) => {
+        if (!notificationIds?.length && !readAll) {
+            throw new McpToolError('Provide notificationIds or set readAll:true.', {
+                hint: 'Pass an array of notification ids, or readAll:true to clear all.',
+            });
+        }
+        const variables = {};
+        if (notificationIds?.length)
+            variables.notificationIds = notificationIds;
+        if (readAll)
+            variables.readAll = true;
+        if (!confirm)
+            return previewResult('markAsRead', variables);
+        const data = await client.gql(MARK_AS_READ, variables);
+        return textResult({ marked: true, result: data.markAsRead });
+    });
+}