vibo-mcp 2.3.0 → 2.4.0

package/dist/tools/song-management.js

@@ -1,10 +1,19 @@
 import { z } from 'zod';
 import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { REMOVE_SECTION_SONGS, UPDATE_SECTION_SONGS, MOVE_SECTION_SONGS, REORDER_SONGS } from '../gql.js';
+import { planMoves } from '../reorder.js';
 import { confirmWrite, CONFIRM_NOTE } from './shared.js';
+import { fetchSections, fetchEventPermissions, fetchSectionSongs, findSection, assertSongsInSection, isHost, } from './lookups.js';
+/**
+ * Vibo's song-comment limit, measured live: 90 is stored, 91 is refused with
+ * "Comment should be less then 90 characters". Counted in UTF-16 units (an
+ * emoji is 2), which is what String#length gives.
+ */
+export const SONG_COMMENT_MAX = 90;
 export function registerSongManagementTools(server, client) {
     server.registerTool('vibo_remove_song_from_section', {
-        description: 'Remove one or more songs from a section. ' + CONFIRM_NOTE,
+        description: 'Remove one or more songs from a section. Every id is checked against the section first; if any is not ' +
+            'there, nothing is sent and the missing ids are listed. ' + CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Remove songs from Vibo section', readOnly: false, destructive: true }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -16,6 +25,10 @@ export function registerSongManagementTools(server, client) {
             confirmToken: confirmTokenParam,
         }),
     }, async ({ eventId, sectionId, songIds, confirmToken }, ctx) => {
+        // Vibo answers success:true for ids that aren't in the section and removes
+        // nothing, so check them ourselves before asking the user to confirm.
+        const songs = await fetchSectionSongs(client, eventId, sectionId);
+        assertSongsInSection(songIds, songs);
         const vars = { eventId, sectionId, songIds };
         const gate = await confirmWrite(ctx, {
             tool: 'vibo_remove_song_from_section',
@@ -24,6 +37,12 @@ export function registerSongManagementTools(server, client) {
             confirmToken,
             target: sectionId,
             willSend: vars,
+            context: {
+                songs: songIds.map((id) => {
+                    const s = songs.find((x) => x._id === id);
+                    return `${s.title ?? '?'} — ${s.artist ?? '?'}`;
+                }),
+            },
         });
         if (gate)
             return gate;
@@ -31,7 +50,9 @@ export function registerSongManagementTools(server, client) {
         return minifiedResult(data.removeSectionSongsV2);
     });
     server.registerTool('vibo_update_song', {
-        description: 'Update songs in a section: mark must-play, flag as do-not-play, and/or set a comment. Provide at least one field. ' + CONFIRM_NOTE,
+        description: 'Update songs in a section: mark must-play, flag as do-not-play, and/or set a comment. Provide at least one field. ' +
+            `A comment can be at most ${SONG_COMMENT_MAX} characters (Vibo's limit; emoji count double; checked before anything is sent). ` +
+            CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Update Vibo section songs', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -42,7 +63,7 @@ export function registerSongManagementTools(server, client) {
                 .describe('Song _ids from vibo_get_section_songs.'),
             isMustPlay: z.boolean().optional(),
             isFlagged: z.boolean().optional().describe('mark do-not-play / flagged'),
-            comment: z.string().optional(),
+            comment: z.string().optional().describe(`Comment for the DJ, at most ${SONG_COMMENT_MAX} characters.`),
             confirmToken: confirmTokenParam,
         }),
     }, async ({ eventId, sectionId, songIds, isMustPlay, isFlagged, comment, confirmToken }, ctx) => {
@@ -58,6 +79,9 @@ export function registerSongManagementTools(server, client) {
                 hint: 'Pass isMustPlay, isFlagged, and/or comment to update the songs.',
             });
         }
+        if (comment !== undefined && comment.length > SONG_COMMENT_MAX) {
+            throw new McpToolError(`Comment is ${comment.length} characters; Vibo allows at most ${SONG_COMMENT_MAX}. Nothing was sent.`, { hint: `Shorten it to ${SONG_COMMENT_MAX} characters or fewer, or put the longer text in a section note.` });
+        }
         const vars = { eventId, sectionId, songIds, payload };
         const gate = await confirmWrite(ctx, {
             tool: 'vibo_update_song',
@@ -101,7 +125,12 @@ export function registerSongManagementTools(server, client) {
         return minifiedResult(data.moveSectionSongsV2);
     });
     server.registerTool('vibo_reorder_songs', {
-        description: 'Reorder songs within a section. ' + CONFIRM_NOTE,
+        description: 'Reorder songs within a section: move sourceSongIds (in the given order) to directly after targetSongId, ' +
+            'or to the top when it is omitted. Checks the ids against the section and, for a host, that the DJ allows ' +
+            "hosts to order this section's songs. That setting is OFF for every section a host creates and only the " +
+            'DJ can turn it on, so a host usually cannot reorder songs in sections they added. Sends one ' +
+            'reorderSongsBatch call per song that actually moves. ' +
+            CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Reorder Vibo section songs', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -109,26 +138,57 @@ export function registerSongManagementTools(server, client) {
             sourceSongIds: z
                 .array(z.string())
                 .min(1)
-                .describe('Song _ids from vibo_get_section_songs.'),
+                .describe('Song _ids from vibo_get_section_songs, in the order they should end up.'),
             targetSongId: z
                 .string()
                 .optional()
-                .describe('place the moved songs after this song _id; omit for start'),
+                .describe('place the moved songs directly after this song _id; omit for the top'),
             confirmToken: confirmTokenParam,
         }),
     }, async ({ eventId, sectionId, sourceSongIds, targetSongId, confirmToken }, ctx) => {
-        const vars = { eventId, sectionId, sourceSongIds, targetSongId: targetSongId ?? null };
+        if (new Set(sourceSongIds).size !== sourceSongIds.length) {
+            throw new McpToolError('sourceSongIds contains a duplicate.', { hint: 'List each song once.' });
+        }
+        if (targetSongId !== undefined && sourceSongIds.includes(targetSongId)) {
+            throw new McpToolError('targetSongId is also one of the songs being moved.', {
+                hint: 'Pick a target outside sourceSongIds.',
+            });
+        }
+        const [perms, sections, songs] = await Promise.all([
+            fetchEventPermissions(client, eventId),
+            fetchSections(client, eventId),
+            fetchSectionSongs(client, eventId, sectionId),
+        ]);
+        const section = findSection(sections, sectionId);
+        // Vibo refuses a host's reorder with "Action is not allowed for user" when
+        // the section's "hosts can order songs" is off — which it is for every
+        // section a host creates (measured live; a host's attempt to turn it on
+        // is accepted and ignored). The web app hides drag handles there too.
+        if (isHost(perms) && section.settings?.canHostsOrderSongs === false) {
+            throw new McpToolError(`The DJ has turned off host song ordering for "${section.name}", so Vibo refuses reorders from hosts there. Nothing was sent.`, {
+                hint: "It's the section's canHostsOrderSongs setting. Vibo turns it off for sections a host creates, and only the DJ " +
+                    'can turn it on (a host update is ignored). Ask the DJ, or leave a comment on the song instead.',
+            });
+        }
+        assertSongsInSection([...sourceSongIds, ...(targetSongId ? [targetSongId] : [])], songs);
+        const { moves } = planMoves(songs.map((s) => s._id), sourceSongIds, targetSongId ?? null);
+        if (moves.length === 0) {
+            return minifiedResult({ changed: false, message: 'Those songs are already in that order.' });
+        }
+        const calls = moves.map((m) => ({ sourceSongIds: [m.source], targetSongId: m.target }));
         const gate = await confirmWrite(ctx, {
             tool: 'vibo_reorder_songs',
             mutation: 'reorderSongsBatch',
             message: 'Review and confirm this reorder:',
             confirmToken,
             target: sectionId,
-            willSend: vars,
+            willSend: { eventId, sectionId, calls },
         });
         if (gate)
             return gate;
-        const data = await client.gql(REORDER_SONGS, vars);
-        return minifiedResult(data.reorderSongsBatch);
+        for (const c of calls) {
+            await client.gql(REORDER_SONGS, { eventId, sectionId, ...c });
+        }
+        return minifiedResult({ changed: true, callsSent: calls.length });
     });
 }

package/dist/tools/songs.js

@@ -1,9 +1,17 @@
 import { z } from 'zod';
-import { minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
+import { McpToolError, minifiedResult, confirmTokenParam, toolAnnotations } from '@chrischall/mcp-utils';
 import { viewArg, viewResponse } from '../view.js';
 import { GET_SECTION_SONGS, SEARCH_SONGS, ADD_SONG_TO_SECTION, TOGGLE_LIKE } from '../gql.js';
 import { annotateSearchResults } from '../song-search.js';
 import { limitSchema, skipSchema, pagination, confirmWrite, CONFIRM_NOTE } from './shared.js';
+import { fetchSectionSongs } from './lookups.js';
+/**
+ * Waits before each post-add re-read. Vibo's re-reads can be briefly stale
+ * (CLAUDE.md, "Write-verification re-reads can be cached"), so one miss is not
+ * proof; three spread over ~2s is. Exported so tests can zero them.
+ */
+export const addVerifyDelaysMs = [0, 700, 1500];
+const sleep = (ms) => (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve());
 export function registerSongTools(server, client) {
     server.registerTool('vibo_get_section_songs', {
         description: "List the songs requested in a section, with who added each, like counts, must-play / do-not-play flags, comments, and streaming links. Sort by likesCount, createdAt, or title.",
@@ -95,7 +103,9 @@ export function registerSongTools(server, client) {
             'include viboSongId/title/artist when known). Before adding, check that result\'s ' +
             '`quality.confidence`: adding a `likely-not-original` result puts a cover, karaoke ' +
             'track or junk-metadata re-upload in front of a live DJ. If nothing looks original, ' +
-            'report the closest matches back rather than adding a best guess. ' + CONFIRM_NOTE,
+            'report the closest matches back rather than adding a best guess. After adding, re-reads the section and ' +
+            'reports an error if the song is not actually there (Vibo has answered added:true without adding). ' +
+            CONFIRM_NOTE,
         annotations: toolAnnotations({ title: 'Add song to Vibo section', readOnly: false, destructive: false }),
         inputSchema: z.object({
             eventId: z.string().describe('Event id.'),
@@ -130,7 +140,38 @@ export function registerSongTools(server, client) {
             sectionId,
             payload,
         });
-        return minifiedResult(data.addSongToSection);
+        const res = data.addSongToSection ?? {};
+        if (res.added === false) {
+            throw new McpToolError('Vibo did not add the song (added: false).', {
+                hint: 'It may already be in this section, be on the do-not-play list, or the section may be full. ' +
+                    'Check with vibo_get_section_songs.',
+            });
+        }
+        // Don't trust added:true alone — confirm the song is really in the section.
+        // With no id to match on, say so rather than claim a failure: a false
+        // "NOT added" invites a retry that would add the song twice.
+        if (!res.songId && !viboSongId) {
+            return minifiedResult({
+                ...res,
+                verified: false,
+                note: 'Vibo returned no songId and no viboSongId was passed, so the add could not be checked by re-reading. Check with vibo_get_section_songs before retrying.',
+            });
+        }
+        const isOurs = (s) => (!!res.songId && s._id === res.songId) || (!!viboSongId && s.viboSongId === viboSongId);
+        let found;
+        for (const delay of addVerifyDelaysMs) {
+            await sleep(delay);
+            found = (await fetchSectionSongs(client, eventId, sectionId)).find(isOurs);
+            if (found)
+                break;
+        }
+        if (!found) {
+            throw new McpToolError('Vibo answered added:true, but the song is not in the section when re-read, so it was NOT added.', {
+                hint: 'Retry once; if it still fails, add it in the Vibo app. Details: ' +
+                    JSON.stringify({ songId: res.songId ?? null, viboSongId: viboSongId ?? null, totalCount: res.totalCount }),
+            });
+        }
+        return minifiedResult({ ...res, verified: true, song: found });
     });
     server.registerTool('vibo_toggle_song_like', {
         description: 'Like or unlike a song in a section. ' + CONFIRM_NOTE,

package/dist/version.js

@@ -2,4 +2,4 @@
 // literal on the line carrying the release marker; every manifest and the MCP
 // server banner import VERSION from here, so there is exactly one place to keep
 // in sync (and one release-please extra-files entry).
-export const VERSION = '2.3.0'; // x-release-please-version
+export const VERSION = '2.4.0'; // x-release-please-version

package/dist/view.js

@@ -18,13 +18,26 @@ import { minifiedResult, resolveView, stripMediaUrls, viewParam } from '@chrisch
  * When a real payload can be captured, a field projection belongs here beside
  * this one and will save considerably more. Until then this is the honest
  * ceiling, and this docblock says so rather than implying a shape was checked.
+ *
+ * One exception: `vibo_list_event_users` projects its members to
+ * `{_id, firstName, lastName, role}` on compact, because its document's field
+ * list is fixed by the query and the dropped `email` is third-party PII
+ * (fleet-audit #1136). See `membersForView` in `tools/collaboration.ts`.
  */
 export const VIBO_VIEWS = ['compact', 'full'];
 const NOTE = 'compact strips image/avatar URLs from the response; "full" returns Vibo\'s payload untouched. ' +
     'No field projection: this server has no verified record of which Vibo fields matter, and inventing ' +
     'one would risk dropping a field a caller needs.';
+const EVENT_USERS_NOTE = 'compact (default) returns each member as {_id, firstName, lastName, role} only — no email addresses or ' +
+    'avatar URLs; "full" returns Vibo\'s payload untouched, emails included. This document\'s field list is ' +
+    'fixed by its query, so the projection cannot drop an unknown field.';
 /** The `view` parameter every read tool in this server takes. */
 export const viewArg = () => viewParam(VIBO_VIEWS, { note: NOTE });
+/**
+ * `vibo_list_event_users`' `view` parameter — the one exception to NOTE's
+ * "no field projection" (see the docblock above), so its schema says so.
+ */
+export const eventUsersViewArg = () => viewParam(VIBO_VIEWS, { note: EVENT_USERS_NOTE });
 /**
  * Answer in the requested rung.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibo-mcp",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "mcpName": "io.github.chrischall/vibo-mcp",
   "description": "Vibo (vibodj.com) MCP server for Claude — host/couple event music planning & management. Developed and maintained by AI (Claude Code).",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -46,8 +46,8 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^2.6.0",
-    "@fetchproxy/bootstrap": "^3.2.0",
+    "@chrischall/mcp-utils": "^2.8.0",
+    "@fetchproxy/bootstrap": "^3.4.1",
     "@modelcontextprotocol/server": "^2.0.0",
     "dotenv": "^18.0.1",
     "zod": "^4.6.5"

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/vibo-mcp",
     "source": "github"
   },
-  "version": "2.3.0",
+  "version": "2.4.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "vibo-mcp",
-      "version": "2.3.0",
+      "version": "2.4.0",
       "transport": {
         "type": "stdio"
       },

package/skills/vibo-mcp/SKILL.md

@@ -40,7 +40,9 @@ Pick one:
 - **Captured token (for Apple/Google/Facebook accounts):** set
   `VIBO_ACCESS_TOKEN` (and `VIBO_REFRESH_TOKEN`) with values captured from a
   signed-in `web.vibodj.com` session — no password needed.
-- **Browser capture (SSO, automatic):** with the fetchproxy browser extension
+- **Browser capture (SSO, automatic):** with the ContextMint Bridge browser extension
+  (https://github.com/nullnet-app/contextmint-bridge/releases — the fetchproxy
+  extension renamed, same maintainer, public source; Chrome only for now)
   installed and yourself signed into https://web.vibodj.com, run
   `vibo_capture_session` once — it grabs the token from your tab (approve the
   pair code), saves it to `~/.vibo-mcp/session.json`, and reuses it thereafter.
@@ -76,8 +78,10 @@ fresh preview and token to re-approve), and a reused one as `TOKEN_REUSED`.
 `MCP_CONFIRM_MODE` (`ask-user` default / `auto` / `refuse`) controls this flow.
 
 - `vibo_add_song_to_section` — add a searched song to a section.
-- `vibo_remove_song_from_section` / `vibo_move_song` / `vibo_reorder_songs`.
-- `vibo_update_song` — mark must-play / do-not-play, or set a comment.
+- `vibo_remove_song_from_section` — every id is checked against the section first; unknown ids are listed and nothing is sent.
+- `vibo_move_song` / `vibo_reorder_songs` — reorder places `sourceSongIds` directly after `targetSongId` (omit it for the top). A host needs the section's "hosts can order songs" setting on — Vibo turns it off for sections a host creates, and only the DJ can turn it on.
+- `vibo_update_song` — mark must-play / do-not-play, or set a comment (at most 90 characters; an emoji counts as 2).
+- `vibo_add_song_to_section` re-reads the section after adding and errors if the song isn't actually there.
 - `vibo_toggle_song_like` — like/unlike a song.
 - `vibo_comment_on_song` / `vibo_comment_on_section` (+ delete) — leave the DJ notes.
 - `vibo_import_playlist_to_section` — pull tracks from a connected Spotify/Apple playlist.
@@ -86,6 +90,9 @@ fresh preview and token to re-approve), and a reused one as `TOKEN_REUSED`.
 - `vibo_create_event_contact` — add a host/guest contact.
 - `vibo_invite_users` / `vibo_change_user_role` / `vibo_remove_user` — manage who's on the event.
 - `vibo_update_section` — edit a section's name, time, or note.
+- `vibo_create_section` — add a section (name ≤ 45 characters; `visibility` host/public; optional time and note — Vibo drops a host's description) and place it with `afterSectionId` or `position`. Returns the new `_id`.
+- `vibo_delete_section` — delete a section; the preview shows its name, song count and answered questions. `dontPlay`/`headline` sections need `force: true`.
+- `vibo_reorder_sections` — move sections to directly after `targetSectionId` (omit for the start).
 - `vibo_answer_question` — answer a planning question (text / option ids / link / image+file uploads).
 - `vibo_set_profile_photo` — set your profile photo from a local image in the upload directory (`VIBO_UPLOAD_DIR`, default `~/Downloads/vibo-mcp`).
 - `vibo_capture_session` — capture your login from a signed-in browser tab (SSO accounts).
@@ -94,7 +101,7 @@ fresh preview and token to re-approve), and a reused one as `TOKEN_REUSED`.
 
 ## Response shape (`view`)
 
-**Six of this server's 39 tools take `view: "compact" | "full"`**, and on every
+**Six of this server's 42 tools take `view: "compact" | "full"`**, and on every
 one of them **`compact` is the DEFAULT**. You get the slim rung without asking.
 
 They are exactly the six reads whose GraphQL document asks Vibo for media:
@@ -104,7 +111,7 @@ They are exactly the six reads whose GraphQL document asks Vibo for media:
 | `vibo_search_songs` | `thumbnails { s180x180 original }` per track |
 | `vibo_get_section_songs` | `thumbnails { s180x180 original }` per song |
 | `vibo_list_song_ideas_songs` | `thumbnails { s180x180 original }` per song |
-| `vibo_list_event_users` | `imageUrl` per person (both exits — merged and filtered) |
+| `vibo_list_event_users` | `email` + `imageUrl` per person — projected to `_id`/`firstName`/`lastName`/`role` on both exits (merged and filtered); `view: "full"` for emails |
 | `vibo_list_notifications` | `imageUrl` per notification |
 | `vibo_get_me` | `imageUrl` |
 
@@ -117,6 +124,11 @@ writes no field list, because this repo holds no captured Vibo payload to
 derive one from honestly; instead it removes keys whose value is a picture,
 which is subtractive and so cannot drop a field nobody knew about.
 
+The one exception is `vibo_list_event_users`: its query fixes the member field
+list, so compact projects each member to `_id`/`firstName`/`lastName`/`role`
+and keeps other people's email addresses out of the default answer (fleet-audit
+#1136). Ask for `view: "full"` only when an email is actually needed.
+
 What compact does **not** touch is the point of these tools: `songUrl`, the
 `links` block (`spotify` / `youtube` / `appleMusic`) and the `quality` verdict
 all survive. A streaming link is this server's product, not decoration —