vibo-mcp 2.2.2 → 2.3.0

package/dist/client.js

@@ -1,3 +1,4 @@
+import { createHash } from 'crypto';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { loadDotenvSafely, readEnvVar, McpToolError, SessionNotAuthenticatedError, truncateErrorMessage, withAmbientCancellation, } from '@chrischall/mcp-utils';
@@ -38,8 +39,18 @@ const REFRESH = `
   }
 `;
 // 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']);
+// missing session — these should trigger a token refresh + replay. FORBIDDEN
+// is deliberately NOT here: it is a permission denial (a guest removing a
+// user, a section whose host-edit permission is off), and refreshing cannot
+// fix it — see PERMISSION_ERROR_CODES.
+const AUTH_ERROR_CODES = new Set(['UNAUTHORIZED', 'UNAUTHENTICATED']);
+// Codes for "you are signed in, but not allowed to do this".
+const PERMISSION_ERROR_CODES = new Set(['FORBIDDEN']);
+// Message fallback, consulted ONLY for an error that carries no code. Vibo's
+// expired-session text is "Not authorized. Try to log in"; the patterns are
+// anchored on session/token wording so an unrelated message that merely
+// mentions "login" or "JWT" is not mistaken for an expired session.
+const AUTH_MESSAGE_PATTERN = /not authoriz|unauthoriz|unauthenticated|invalid token|token (has )?expired|expired token|jwt (expired|malformed)|try to log ?in/i;
 /**
  * The signal every Vibo request is made with: our timeout, and the caller's
  * cancellation if there is one (mcp-utils `cancel`).
@@ -59,6 +70,39 @@ const AUTH_ERROR_CODES = new Set(['UNAUTHORIZED', 'UNAUTHENTICATED', 'FORBIDDEN'
 function requestSignal() {
     return withAmbientCancellation(AbortSignal.timeout(REQUEST_TIMEOUT_MS));
 }
+/** Whether a GraphQL document is a mutation (a write with side effects). */
+function isMutation(query) {
+    return /^\s*(?:#[^\n]*\n\s*)*mutation\b/.test(query);
+}
+/**
+ * The error for a request that never produced a response (timeout, dropped
+ * connection, caller abort). For a READ that is safely retryable. For a WRITE
+ * the outcome is unknown — Vibo may already have committed it — and a blind
+ * retry repeats the side effect (a second round of invitation emails, a
+ * second exported playlist, a duplicate comment or import); the confirmation
+ * gate cannot stop that, because a fresh preview earns a fresh approval and
+ * token. So a write says so, and asks for a state check first.
+ */
+function transportError(what, err, isWrite) {
+    const reason = err instanceof Error && err.name === 'TimeoutError' ? 'timed out' : 'failed';
+    if (isWrite) {
+        return new McpToolError(`${what} ${SERVICE} ${reason} — the change may already have been applied (outcome is unknown).`, {
+            hint: 'Do not repeat this write blindly — check the current state before retrying: e.g. ' +
+                'vibo_list_event_users after inviting, vibo_get_section_songs after adding, importing or commenting ' +
+                'on songs, the Spotify/Apple Music account after an export. Retry only if the change is not there.',
+            cause: err,
+        });
+    }
+    return new McpToolError(`${what} ${SERVICE} ${reason}.`, {
+        hint: 'The Vibo API may be unreachable — check your connection and retry.',
+        cause: err,
+    });
+}
+/** One-way fingerprint of a configured token, so session.json never holds a
+ *  second copy of the pasted secret just to record where a session came from. */
+function tokenLineage(token) {
+    return createHash('sha256').update(token).digest('hex').slice(0, 32);
+}
 export class ViboClient {
     apiUrl;
     email;
@@ -67,6 +111,9 @@ export class ViboClient {
     configError = null;
     accessToken;
     refreshTokenValue;
+    // Which configured token pair the current tokens descend from (see
+    // ViboSession.lineage); stamped on every persisted rotation.
+    sessionLineage = null;
     // The constructor is PURE — it does no filesystem / homedir / async-I/O /
     // random op — so it is safe to run at Worker global scope (where the
     // module-level `export const client` singleton below is constructed). The
@@ -105,6 +152,21 @@ export class ViboClient {
             if (saved) {
                 this.accessToken = saved.accessToken;
                 this.refreshTokenValue = saved.refreshToken;
+                this.sessionLineage = saved.lineage ?? null;
+            }
+        }
+        else if (this.accessToken && !haveLogin) {
+            // A configured (pasted) token pair. Vibo rotates the refresh token on
+            // every refresh, so after the first refresh the pasted pair is dead and
+            // only the persisted rotated pair works. Resume from it when it descends
+            // from THIS configured pair; a newly pasted pair (different lineage) or a
+            // browser capture (no lineage) never shadows the configured tokens.
+            const lineage = tokenLineage(this.refreshTokenValue ?? this.accessToken);
+            this.sessionLineage = lineage;
+            const saved = loadSession();
+            if (saved?.lineage === lineage) {
+                this.accessToken = saved.accessToken;
+                this.refreshTokenValue = saved.refreshToken;
             }
         }
         const haveToken = Boolean(this.accessToken);
@@ -125,6 +187,7 @@ export class ViboClient {
     setTokens(accessToken, refreshToken) {
         this.accessToken = accessToken;
         this.refreshTokenValue = refreshToken;
+        this.sessionLineage = null; // a browser capture descends from no configured pair
         this.configError = null;
     }
     /** True when operating purely from a token (no email/password) — refreshed
@@ -195,11 +258,8 @@ export class ViboClient {
             });
         }
         catch (err) {
-            const reason = err instanceof Error && err.name === 'TimeoutError' ? 'timed out' : 'failed';
-            throw new McpToolError(`Upload to ${SERVICE} ${reason}.`, {
-                hint: 'The Vibo API may be unreachable — check your connection and retry.',
-                cause: err,
-            });
+            // An upload is always a write (the multipart path only carries mutations).
+            throw transportError('Upload to', err, true);
         }
         let body;
         try {
@@ -254,7 +314,11 @@ export class ViboClient {
                             // Persist the rotated pair so a captured/pasted session survives
                             // a restart (no email/password to re-login with).
                             if (this.tokenOnlyMode) {
-                                saveSession({ accessToken: this.accessToken, refreshToken: this.refreshTokenValue });
+                                saveSession({
+                                    accessToken: this.accessToken,
+                                    refreshToken: this.refreshTokenValue,
+                                    ...(this.sessionLineage ? { lineage: this.sessionLineage } : {}),
+                                });
                             }
                             return this.accessToken;
                         }
@@ -288,11 +352,9 @@ export class ViboClient {
             });
         }
         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,
-            });
+            // signIn / refreshToken are mutations too, but repeating them is harmless.
+            const isWrite = query !== SIGN_IN && query !== REFRESH && isMutation(query);
+            throw transportError('Request to', err, isWrite);
         }
         let body;
         try {
@@ -303,21 +365,34 @@ export class ViboClient {
         }
         return { status: response.status, body };
     }
+    /** An expired / missing session — the only case a refresh + replay can fix. */
     isAuthError(status, errors) {
-        if (status === 401 || status === 403)
+        if (status === 401)
             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 ?? '');
+            const code = e.code ?? e.extensions?.code;
+            if (code)
+                return AUTH_ERROR_CODES.has(code);
+            return AUTH_MESSAGE_PATTERN.test(e.message ?? '');
         });
     }
+    /** Signed in, but not allowed to do this (HTTP 403 / FORBIDDEN). */
+    isPermissionError(status, errors) {
+        if (status === 403)
+            return true;
+        return (errors ?? []).some((e) => PERMISSION_ERROR_CODES.has(e.code ?? e.extensions?.code ?? ''));
+    }
     unwrap(status, body) {
+        if (this.isPermissionError(status, body.errors)) {
+            const detail = body.errors?.map((e) => e.message).filter(Boolean).join('; ');
+            throw new McpToolError(`You don't have permission to do this in this ${SERVICE} event${detail ? `: ${truncateErrorMessage(detail)}` : '.'}`, {
+                hint: 'This is a permission denial, not an expired session — signing in again will not help. ' +
+                    'Your role in the event (e.g. guest vs. host) or the DJ\'s section settings do not allow this change; ' +
+                    'ask the event host or DJ.',
+            });
+        }
         if (body.errors?.length) {
             if (this.isAuthError(status, body.errors)) {
                 throw new SessionNotAuthenticatedError(SERVICE, SIGN_IN_HOST);

package/dist/session-store.js

@@ -20,6 +20,7 @@ export function loadSession() {
             return {
                 accessToken: rec.accessToken,
                 refreshToken: typeof rec.refreshToken === 'string' ? rec.refreshToken : null,
+                ...(typeof rec.lineage === 'string' && rec.lineage ? { lineage: rec.lineage } : {}),
             };
         }
         return null;
@@ -34,6 +35,7 @@ export function saveSession(session) {
         key: SESSION_KEY,
         accessToken: session.accessToken,
         refreshToken: session.refreshToken ?? null,
+        ...(session.lineage ? { lineage: session.lineage } : {}),
     });
 }
 /** Remove any persisted session. */

package/dist/tools/collaboration.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { minifiedResult, schemaConfirm, toolAnnotations } from '@chrischall/mcp-utils';
+import { minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { LIST_EVENT_USERS, INVITE_USERS, CHANGE_USER_ROLE, REMOVE_USER } from '../gql.js';
-import { limitSchema, skipSchema, pagination, previewResult } from './shared.js';
+import { limitSchema, skipSchema, pagination, confirmWrite, CONFIRM_NOTE } from './shared.js';
 import { viewArg, viewResponse } from '../view.js';
 export function registerCollaborationTools(server, client) {
     server.registerTool('vibo_list_event_users', {
@@ -41,50 +41,74 @@ export function registerCollaborationTools(server, client) {
         });
     });
     server.registerTool('vibo_invite_users', {
-        description: 'Invite people to an event by email (as host or guest). Confirm-gated.',
+        description: 'Invite people to an event by email (as host or guest). ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Invite Vibo event users', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             type: z.enum(['host', 'guest']).describe('Invite as host or guest.'),
             text: z.string().describe('Personal message included in the invite.'),
             emails: z.array(z.string().email()).min(1).describe('Email addresses to invite.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, type, text, emails, confirm }) => {
+    }, async ({ eventId, type, text, emails, confirmToken }, ctx) => {
         const variables = { eventId, type, text, emails };
-        if (!confirm)
-            return previewResult('inviteUserViaEmail', variables);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_invite_users',
+            mutation: 'inviteUserViaEmail',
+            message: 'Review and confirm sending these invitations:',
+            confirmToken,
+            target: eventId,
+            willSend: variables,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(INVITE_USERS, variables);
         return minifiedResult(data.inviteUserViaEmail);
     });
     server.registerTool('vibo_change_user_role', {
-        description: "Change an event member's role between host and guest. Confirm-gated.",
+        description: "Change an event member's role between host and guest. " + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Change Vibo user role', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             userId: z.string().describe('Id of the member to update.'),
             type: z.enum(['host', 'guest']).describe('New role for the member.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, userId, type, confirm }) => {
+    }, async ({ eventId, userId, type, confirmToken }, ctx) => {
         const variables = { eventId, userId, type };
-        if (!confirm)
-            return previewResult('changeUserTypeInEvent', variables);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_change_user_role',
+            mutation: 'changeUserTypeInEvent',
+            message: 'Review and confirm this role change:',
+            confirmToken,
+            target: userId,
+            willSend: variables,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(CHANGE_USER_ROLE, variables);
         return minifiedResult(data.changeUserTypeInEvent);
     });
     server.registerTool('vibo_remove_user', {
-        description: 'Remove a member from an event. Confirm-gated.',
+        description: 'Remove a member from an event. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Remove Vibo event user', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             userId: z.string().describe('Id of the member to remove.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, userId, confirm }) => {
+    }, async ({ eventId, userId, confirmToken }, ctx) => {
         const variables = { eventId, userId };
-        if (!confirm)
-            return previewResult('removeUserFromEvent', variables);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_remove_user',
+            mutation: 'removeUserFromEvent',
+            message: 'Review and confirm removing this member from the event:',
+            confirmToken,
+            target: userId,
+            willSend: variables,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(REMOVE_USER, variables);
         return minifiedResult(data.removeUserFromEvent);
     });

package/dist/tools/comments.js

@@ -1,71 +1,103 @@
 import { z } from 'zod';
-import { minifiedResult, schemaConfirm, toolAnnotations } from '@chrischall/mcp-utils';
+import { minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { CREATE_SONG_COMMENT, DELETE_SONG_COMMENT, CREATE_SECTION_COMMENT, DELETE_SECTION_COMMENT, } from '../gql.js';
-import { previewResult } from './shared.js';
+import { confirmWrite, CONFIRM_NOTE } from './shared.js';
 export function registerCommentTools(server, client) {
     server.registerTool('vibo_comment_on_song', {
-        description: 'Leave a comment / note for the DJ on a specific song. Confirm-gated.',
+        description: 'Leave a comment / note for the DJ on a specific song. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Comment on Vibo song', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             sectionId: z.string().describe('Section id.'),
             songId: z.string().describe('Song _id (from vibo_get_section_songs).'),
             message: z.string().describe('The comment text.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, sectionId, songId, message, confirm }) => {
+    }, async ({ eventId, sectionId, songId, message, confirmToken }, ctx) => {
         const vars = { eventId, sectionId, songId, payload: { message } };
-        if (!confirm)
-            return previewResult('createSongComment', vars);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_comment_on_song',
+            mutation: 'createSongComment',
+            message: 'Review and confirm this song comment:',
+            confirmToken,
+            target: songId,
+            willSend: vars,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(CREATE_SONG_COMMENT, vars);
         return minifiedResult(data.createSongComment);
     });
     server.registerTool('vibo_delete_song_comment', {
-        description: 'Delete a comment on a song. Confirm-gated.',
+        description: 'Delete a comment on a song. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Delete Vibo song comment', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             sectionId: z.string().describe('Section id.'),
             songId: z.string().describe('Song _id (from vibo_get_section_songs).'),
             commentId: z.string().describe('Comment _id to delete.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, sectionId, songId, commentId, confirm }) => {
+    }, async ({ eventId, sectionId, songId, commentId, confirmToken }, ctx) => {
         const vars = { eventId, sectionId, songId, commentId };
-        if (!confirm)
-            return previewResult('deleteSongComment', vars);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_delete_song_comment',
+            mutation: 'deleteSongComment',
+            message: 'Review and confirm deleting this song comment:',
+            confirmToken,
+            target: commentId,
+            willSend: vars,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(DELETE_SONG_COMMENT, vars);
         return minifiedResult(data.deleteSongComment);
     });
     server.registerTool('vibo_comment_on_section', {
-        description: 'Leave a comment on a timeline section. Confirm-gated.',
+        description: 'Leave a comment on a timeline section. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Comment on Vibo section', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             sectionId: z.string().describe('Section id (from vibo_list_sections).'),
             message: z.string().describe('The comment text.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, sectionId, message, confirm }) => {
+    }, async ({ eventId, sectionId, message, confirmToken }, ctx) => {
         const vars = { eventId, sectionId, payload: { message } };
-        if (!confirm)
-            return previewResult('createSectionComment', vars);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_comment_on_section',
+            mutation: 'createSectionComment',
+            message: 'Review and confirm this section comment:',
+            confirmToken,
+            target: sectionId,
+            willSend: vars,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(CREATE_SECTION_COMMENT, vars);
         return minifiedResult(data.createSectionComment);
     });
     server.registerTool('vibo_delete_section_comment', {
-        description: 'Delete a comment on a timeline section. Confirm-gated.',
+        description: 'Delete a comment on a timeline section. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Delete Vibo section comment', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
             sectionId: z.string().describe('Section id (from vibo_list_sections).'),
             commentId: z.string().describe('Comment _id to delete.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, sectionId, commentId, confirm }) => {
+    }, async ({ eventId, sectionId, commentId, confirmToken }, ctx) => {
         const vars = { eventId, sectionId, commentId };
-        if (!confirm)
-            return previewResult('deleteSectionComment', vars);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_delete_section_comment',
+            mutation: 'deleteSectionComment',
+            message: 'Review and confirm deleting this section comment:',
+            confirmToken,
+            target: commentId,
+            willSend: vars,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(DELETE_SECTION_COMMENT, vars);
         return minifiedResult(data.deleteSectionComment);
     });

package/dist/tools/events.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { McpToolError, minifiedResult, schemaConfirm, toolAnnotations } from '@chrischall/mcp-utils';
+import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 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';
+import { limitSchema, skipSchema, pagination, confirmWrite, CONFIRM_NOTE } from './shared.js';
 export function registerEventTools(server, client) {
     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.",
@@ -32,19 +32,26 @@ export function registerEventTools(server, client) {
         return minifiedResult(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.",
+        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_NOTE,
         annotations: toolAnnotations({ title: 'Join Vibo event', readOnly: false, destructive: false }),
         inputSchema: z.object({
             link: z
                 .string()
                 .describe('The full event share URL (vibodj.app.link/... or web.vibodj.com/...) or the bare join hash.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ link, confirm }) => {
+    }, async ({ link, confirmToken }, ctx) => {
         const isUrl = /^https?:\/\//i.test(link);
-        if (!confirm) {
-            return previewResult('joinEvent', isUrl ? { deepLink: link } : { hash: link });
-        }
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_join_event',
+            mutation: 'joinEvent',
+            message: 'Review and confirm joining this event:',
+            confirmToken,
+            target: link,
+            willSend: isUrl ? { deepLink: link } : { hash: link },
+        });
+        if (gate)
+            return gate;
         if (isUrl) {
             const data = await client.gql(JOIN_EVENT_BY_DEEP_LINK, {
                 deepLink: link,
@@ -55,20 +62,28 @@ export function registerEventTools(server, client) {
         return minifiedResult({ joined: true, eventId: data.joinEventByHash._id });
     });
     server.registerTool('vibo_leave_event', {
-        description: 'Leave an event you previously joined. Confirm-gated.',
+        description: 'Leave an event you previously joined. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Leave Vibo event', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id to leave.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, confirm }) => {
-        if (!confirm)
-            return previewResult('leaveEvent', { eventId });
+    }, async ({ eventId, confirmToken }, ctx) => {
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_leave_event',
+            mutation: 'leaveEvent',
+            message: 'Review and confirm leaving this event:',
+            confirmToken,
+            target: eventId,
+            willSend: { eventId },
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(LEAVE_EVENT, { eventId });
         return minifiedResult({ 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.',
+        description: 'Add a contact (host or guest) to an event with their name/email/phone. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Add Vibo event contact', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -78,9 +93,9 @@ export function registerEventTools(server, client) {
             lastName: z.string().optional(),
             phoneCode: z.string().optional().describe('Country calling code, e.g. "1".'),
             phoneNumber: z.string().optional(),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, role, email, firstName, lastName, phoneCode, phoneNumber, confirm }) => {
+    }, async ({ eventId, role, email, firstName, lastName, phoneCode, phoneNumber, confirmToken }, ctx) => {
         const payload = { role, email };
         if (firstName !== undefined)
             payload.firstName = firstName;
@@ -95,8 +110,16 @@ export function registerEventTools(server, client) {
                 hint: 'Pass phoneCode (e.g. "1") alongside phoneNumber.',
             });
         }
-        if (!confirm)
-            return previewResult('createEventContact', { eventId, payload });
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_create_event_contact',
+            mutation: 'createEventContact',
+            message: 'Review and confirm adding this event contact:',
+            confirmToken,
+            target: eventId,
+            willSend: { eventId, payload },
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(CREATE_EVENT_CONTACT, { eventId, payload });
         return minifiedResult(data.createEventContact);
     });

package/dist/tools/imports.js

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { minifiedResult, schemaConfirm, toolAnnotations } from '@chrischall/mcp-utils';
+import { minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { IMPORT_PLAYLIST_TO_SECTION } from '../gql.js';
-import { previewResult } from './shared.js';
+import { confirmWrite, CONFIRM_NOTE } from './shared.js';
 export function registerImportTools(server, client) {
     server.registerTool('vibo_import_playlist_to_section', {
-        description: 'Import selected tracks from a connected Spotify/Apple Music playlist into a section. Returns counts of added/existing/ignored. Confirm-gated.',
+        description: 'Import selected tracks from a connected Spotify/Apple Music playlist into a section. Returns counts of added/existing/ignored. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Import playlist to section', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -18,9 +18,9 @@ export function registerImportTools(server, client) {
                 .min(1)
                 .describe('Track ids (from vibo_get_playlist_songs) to import.'),
             tracksToIgnore: z.array(z.string()).optional().describe('Track ids to skip.'),
-            confirm: schemaConfirm,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ eventId, sectionId, source, playlistId, tracksToAdd, tracksToIgnore, confirm }) => {
+    }, async ({ eventId, sectionId, source, playlistId, tracksToAdd, tracksToIgnore, confirmToken }, ctx) => {
         const vars = {
             eventId,
             sectionId,
@@ -29,8 +29,16 @@ export function registerImportTools(server, client) {
             tracksToAdd,
             tracksToIgnore: tracksToIgnore ?? [],
         };
-        if (!confirm)
-            return previewResult('importPlaylistToSectionWeb', vars);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_import_playlist_to_section',
+            mutation: 'importPlaylistToSectionWeb',
+            message: 'Review and confirm this playlist import:',
+            confirmToken,
+            target: sectionId,
+            willSend: vars,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(IMPORT_PLAYLIST_TO_SECTION, vars);
         return minifiedResult(data.importPlaylistToSectionWeb);
     });

package/dist/tools/notifications.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { McpToolError, minifiedResult, schemaConfirm, toolAnnotations } from '@chrischall/mcp-utils';
+import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { GET_NOTIFICATIONS, GET_NOTIFICATIONS_COUNT, MARK_AS_READ } from '../gql.js';
-import { limitSchema, skipSchema, pagination, previewResult } from './shared.js';
+import { limitSchema, skipSchema, pagination, confirmWrite, CONFIRM_NOTE } from './shared.js';
 import { viewArg, viewResponse } from '../view.js';
 export function registerNotificationTools(server, client) {
     server.registerTool('vibo_list_notifications', {
@@ -26,14 +26,14 @@ export function registerNotificationTools(server, client) {
         return minifiedResult(data.getNotificationsCount);
     });
     server.registerTool('vibo_mark_notifications_read', {
-        description: 'Mark notifications as read — pass specific notificationIds, or readAll:true to clear everything. Confirm-gated.',
+        description: 'Mark notifications as read — pass specific notificationIds, or readAll:true to clear everything. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Mark notifications read', readOnly: false, destructive: false }),
         inputSchema: z.object({
             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,
+            confirmToken: confirmTokenParam,
         }),
-    }, async ({ notificationIds, readAll, confirm }) => {
+    }, async ({ notificationIds, readAll, confirmToken }, ctx) => {
         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.',
@@ -44,8 +44,16 @@ export function registerNotificationTools(server, client) {
             variables.notificationIds = notificationIds;
         if (readAll)
             variables.readAll = true;
-        if (!confirm)
-            return previewResult('markAsRead', variables);
+        const gate = await confirmWrite(ctx, {
+            tool: 'vibo_mark_notifications_read',
+            mutation: 'markAsRead',
+            message: 'Review and confirm marking these notifications read:',
+            confirmToken,
+            target: '',
+            willSend: variables,
+        });
+        if (gate)
+            return gate;
         const data = await client.gql(MARK_AS_READ, variables);
         return minifiedResult({ marked: true, result: data.markAsRead });
     });