vibo-mcp 1.0.0

package/dist/tools/playlists.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { textResult, toolAnnotations, schemaConfirm } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { GET_PLAYLISTS, GET_PLAYLIST_SONGS, EXPORT_EVENT_TO_SPOTIFY, EXPORT_EVENT_TO_APPLE_MUSIC, } from '../gql.js';
+import { limitSchema, skipSchema, pagination, previewResult } from './shared.js';
+const sourceSchema = z
+    .enum(['spotify', 'appleMusic'])
+    .describe('Streaming source — must be connected to your Vibo account.');
+export function registerPlaylistTools(server) {
+    server.registerTool('vibo_get_playlists', {
+        description: "List your playlists from a connected streaming service (Spotify or Apple Music) so you can import songs from them. Requires that source to be connected (see vibo_get_me).",
+        annotations: toolAnnotations({ title: 'List connected playlists', readOnly: true }),
+        inputSchema: {
+            source: sourceSchema,
+            q: z.string().optional().describe('Filter playlists by name.'),
+            limit: limitSchema,
+            skip: skipSchema,
+        },
+    }, async ({ source, q, limit, skip }) => {
+        const data = await client.gql(GET_PLAYLISTS, {
+            source,
+            pagination: pagination(limit, skip),
+            ...(q ? { filter: { q } } : {}),
+        });
+        return textResult(data.getPlaylists);
+    });
+    server.registerTool('vibo_get_playlist_songs', {
+        description: 'List the tracks in one of your connected-service playlists.',
+        annotations: toolAnnotations({ title: 'Get playlist tracks', readOnly: true }),
+        inputSchema: {
+            playlistId: z.string().describe('Playlist id from vibo_get_playlists.'),
+            source: sourceSchema,
+            limit: limitSchema,
+            skip: skipSchema,
+        },
+    }, async ({ playlistId, source, limit, skip }) => {
+        const data = await client.gql(GET_PLAYLIST_SONGS, {
+            playlistId,
+            source,
+            pagination: pagination(limit, skip),
+        });
+        return textResult(data.getPlaylistSongs);
+    });
+    server.registerTool('vibo_export_event_to_spotify', {
+        description: "Export an event's song selections to a new Spotify playlist (Spotify must be connected). Returns the playlist URL plus how many tracks exported / failed. Confirm-gated.",
+        annotations: toolAnnotations({ title: 'Export event to Spotify', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionIds: z.array(z.string()).min(1).describe('Section ids to include (from vibo_list_sections).'),
+            title: z.string().optional().describe('Playlist title (defaults to the event title).'),
+            onlyFlagged: z.boolean().optional().describe('Export only flagged/do-not-play songs (rarely needed).'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, sectionIds, title, onlyFlagged, confirm }) => {
+        const variables = { eventId, sectionIds };
+        if (title !== undefined)
+            variables.title = title;
+        if (onlyFlagged !== undefined)
+            variables.filter = { isFlagged: onlyFlagged };
+        if (!confirm)
+            return previewResult('exportEventToSpotify', variables);
+        const data = await client.gql(EXPORT_EVENT_TO_SPOTIFY, variables);
+        return textResult(data.exportEventToSpotify);
+    });
+    server.registerTool('vibo_export_event_to_apple_music', {
+        description: "Export an event's song selections to a new Apple Music playlist (Apple Music must be connected). Returns the playlist URL plus how many tracks exported / failed. Confirm-gated.",
+        annotations: toolAnnotations({ title: 'Export event to Apple Music', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionIds: z.array(z.string()).min(1).describe('Section ids to include (from vibo_list_sections).'),
+            title: z.string().optional().describe('Playlist title (defaults to the event title).'),
+            onlyFlagged: z.boolean().optional().describe('Export only flagged/do-not-play songs (rarely needed).'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, sectionIds, title, onlyFlagged, confirm }) => {
+        const variables = { eventId, sectionIds };
+        if (title !== undefined)
+            variables.title = title;
+        if (onlyFlagged !== undefined)
+            variables.filter = { isFlagged: onlyFlagged };
+        if (!confirm)
+            return previewResult('exportEventToAppleMusic', variables);
+        const data = await client.gql(EXPORT_EVENT_TO_APPLE_MUSIC, variables);
+        return textResult(data.exportEventToAppleMusic);
+    });
+}

package/dist/tools/profile.js

@@ -0,0 +1,19 @@
+import { textResult, toolAnnotations } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { GET_ME } from '../gql.js';
+export function registerProfileTools(server) {
+    server.registerTool('vibo_get_me', {
+        description: "Get the signed-in Vibo user's profile (id, name, email, phone, locale, and whether Spotify/Apple Music are connected). Use the returned _id to recognize your own songs/contacts.",
+        annotations: toolAnnotations({ title: 'Get my Vibo profile', readOnly: true }),
+    }, async () => {
+        const data = await client.gql(GET_ME);
+        return textResult(data.me);
+    });
+    server.registerTool('vibo_healthcheck', {
+        description: 'Verify connectivity and authentication to the Vibo API by fetching the current user. Returns ok:true with your account id when credentials work.',
+        annotations: toolAnnotations({ title: 'Vibo healthcheck', readOnly: true }),
+    }, async () => {
+        const data = await client.gql(GET_ME);
+        return textResult({ ok: true, userId: data.me._id, email: data.me.email });
+    });
+}

package/dist/tools/questions.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { textResult, toolAnnotations, schemaConfirm, McpToolError } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { LIST_SECTION_QUESTIONS, ANSWER_SECTION_QUESTION } from '../gql.js';
+import { previewResult } from './shared.js';
+export function registerQuestionTools(server) {
+    server.registerTool('vibo_list_section_questions', {
+        description: "List the DJ's planning questions for a section, with each question's type (text/radio/checkbox/select/link/header), available options, whether it's answered, the current answer, and overall progress. Use the question _id (and option _ids) with vibo_answer_question.",
+        annotations: toolAnnotations({ title: 'List Vibo section questions', readOnly: true }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionId: z.string().describe('Section id (from vibo_list_sections).'),
+        },
+    }, async ({ eventId, sectionId }) => {
+        const data = await client.gql(LIST_SECTION_QUESTIONS, {
+            eventId,
+            sectionId,
+        });
+        return textResult(data.getEventSectionQuestionsV2);
+    });
+    server.registerTool('vibo_answer_question', {
+        description: "Answer a section planning question. Provide exactly the field matching the question's type: `text` for a text question, `selectedOptions` (array of option _ids from vibo_list_section_questions) for radio/checkbox/select, or `link` (array of URLs) for a link question. Use `otherOptionTitle` with the question's \"other\" option. Confirm-gated.",
+        annotations: toolAnnotations({ title: 'Answer Vibo question', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionId: z.string().describe('Section id.'),
+            questionId: z.string().describe('Question _id (from vibo_list_section_questions).'),
+            text: z.string().optional().describe('Answer for a text question.'),
+            selectedOptions: z
+                .array(z.string())
+                .optional()
+                .describe('Option _ids to select, for radio/checkbox/select questions.'),
+            link: z.array(z.string()).optional().describe('URL(s), for a link question.'),
+            otherOptionTitle: z
+                .string()
+                .optional()
+                .describe('Free-text value when selecting the question\'s "other" option.'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, sectionId, questionId, text, selectedOptions, link, otherOptionTitle, confirm }) => {
+        // Require at least one PRIMARY answer field. otherOptionTitle is only a
+        // modifier for selectedOptions — on its own it is not a valid answer.
+        if (text === undefined && selectedOptions === undefined && link === undefined) {
+            throw new McpToolError('Provide an answer: text, selectedOptions, or link.', {
+                hint: "Match the question's type — text → `text`, radio/checkbox/select → `selectedOptions`, link → `link`.",
+            });
+        }
+        const answer = {};
+        if (text !== undefined)
+            answer.text = text;
+        if (selectedOptions !== undefined)
+            answer.selectedOptions = selectedOptions;
+        if (link !== undefined)
+            answer.link = link;
+        if (otherOptionTitle !== undefined)
+            answer.otherOptionTitle = otherOptionTitle;
+        const payload = { answer };
+        if (!confirm)
+            return previewResult('answerEventSectionQuestionV2', { eventId, sectionId, questionId, payload });
+        const data = await client.gql(ANSWER_SECTION_QUESTION, {
+            eventId,
+            sectionId,
+            questionId,
+            payload,
+        });
+        return textResult(data.answerEventSectionQuestionV2);
+    });
+}

package/dist/tools/sections.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { textResult, toolAnnotations } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { LIST_SECTIONS } from '../gql.js';
+export function registerSectionTools(server) {
+    server.registerTool('vibo_list_sections', {
+        description: "List an event's timeline sections (e.g. Ceremony, First Dance, Dinner, Dancing) with each section's id, name, scheduled time, note, song count and progress. Use a section _id with vibo_get_section_songs / vibo_add_song_to_section.",
+        annotations: toolAnnotations({ title: 'List Vibo event sections', readOnly: true }),
+        inputSchema: {
+            eventId: z.string().describe('Event id (from vibo_list_events).'),
+        },
+    }, async ({ eventId }) => {
+        const data = await client.gql(LIST_SECTIONS, { eventId });
+        return textResult(data.sections);
+    });
+}

package/dist/tools/shared.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { textResult } from '@chrischall/mcp-utils';
+/** Pagination knobs shared by the list tools (maps to Vibo's PaginationInput). */
+export const limitSchema = z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .optional()
+    .describe('Max items to return (default 20).');
+export const skipSchema = z
+    .number()
+    .int()
+    .min(0)
+    .optional()
+    .describe('Number of items to skip, for paging (default 0).');
+/** Build a Vibo PaginationInput from optional limit/skip with sane defaults. */
+export function pagination(limit, skip) {
+    return { skip: skip ?? 0, limit: limit ?? 20 };
+}
+/**
+ * Dry-run response for a confirm-gated write. Returned WITHOUT making any
+ * network call when `confirm` is not `true`, so the caller can see exactly what
+ * would be sent before committing.
+ */
+export function previewResult(action, willSend) {
+    return textResult({
+        preview: true,
+        action,
+        willSend,
+        note: 'No changes were made. Re-run with confirm: true to execute.',
+    });
+}

package/dist/tools/songs.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import { textResult, toolAnnotations, schemaConfirm } from '@chrischall/mcp-utils';
+import { client } from '../client.js';
+import { GET_SECTION_SONGS, SEARCH_SONGS, ADD_SONG_TO_SECTION, TOGGLE_LIKE } from '../gql.js';
+import { limitSchema, skipSchema, pagination, previewResult } from './shared.js';
+export function registerSongTools(server) {
+    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.",
+        annotations: toolAnnotations({ title: 'Get Vibo section songs', readOnly: true }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionId: z.string().describe('Section id (from vibo_list_sections).'),
+            q: z.string().optional().describe('Filter songs by text.'),
+            isMustPlay: z.boolean().optional(),
+            isFlagged: z.boolean().optional().describe('Filter to do-not-play / flagged songs.'),
+            sortField: z.enum(['likesCount', 'createdAt', 'title']).optional(),
+            sortDirection: z.enum(['asc', 'desc']).optional(),
+            limit: limitSchema,
+            skip: skipSchema,
+        },
+    }, async ({ eventId, sectionId, q, isMustPlay, isFlagged, sortField, sortDirection, limit, skip }) => {
+        const filter = {};
+        if (q !== undefined)
+            filter.q = q;
+        if (isMustPlay !== undefined)
+            filter.isMustPlay = isMustPlay;
+        if (isFlagged !== undefined)
+            filter.isFlagged = isFlagged;
+        const variables = {
+            eventId,
+            sectionId,
+            pagination: pagination(limit, skip),
+            ...(Object.keys(filter).length ? { filter } : {}),
+            ...(sortField ? { sort: { field: sortField, direction: sortDirection ?? 'desc' } } : {}),
+        };
+        const data = await client.gql(GET_SECTION_SONGS, variables);
+        return textResult(data.getSectionSongs);
+    });
+    server.registerTool('vibo_search_songs', {
+        description: "Search for songs to add to a section. source 'searchField' (default) searches Vibo's catalog; 'spotify' searches your connected Spotify. Returns songUrl/viboSongId/title/artist to pass to vibo_add_song_to_section.",
+        annotations: toolAnnotations({ title: 'Search Vibo songs', readOnly: true }),
+        inputSchema: {
+            eventId: z.string().describe('Event id (search is scoped to an event/section).'),
+            sectionId: z.string().describe('Section id the search is for.'),
+            query: z.string().describe('Song or artist to search for.'),
+            source: z.enum(['searchField', 'spotify']).optional().describe("Search source (default 'searchField')."),
+            limit: z.number().int().min(1).max(50).optional().describe('Max results (default 20).'),
+        },
+    }, async ({ eventId, sectionId, query, source, limit }) => {
+        const data = await client.gql(SEARCH_SONGS, {
+            eventId,
+            sectionId,
+            filter: { q: query, source: source ?? 'searchField' },
+            limit: limit ?? 20,
+        });
+        return textResult(data.getSongs);
+    });
+    server.registerTool('vibo_add_song_to_section', {
+        description: 'Add a song to a section. Pass a song from vibo_search_songs (songUrl is required; include viboSongId/title/artist when known). Confirm-gated.',
+        annotations: toolAnnotations({ title: 'Add song to Vibo section', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionId: z.string().describe('Section id to add the song to.'),
+            songUrl: z.string().describe('The song URL from vibo_search_songs (required).'),
+            viboSongId: z.string().optional().describe("The song's viboSongId from search, when available."),
+            title: z.string().optional(),
+            artist: z.string().optional(),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, sectionId, songUrl, viboSongId, title, artist, confirm }) => {
+        const song = { songUrl };
+        if (viboSongId !== undefined)
+            song.viboSongId = viboSongId;
+        if (title !== undefined)
+            song.title = title;
+        if (artist !== undefined)
+            song.artist = artist;
+        const payload = { song };
+        if (!confirm)
+            return previewResult('addSongToSection', { eventId, sectionId, payload });
+        const data = await client.gql(ADD_SONG_TO_SECTION, {
+            eventId,
+            sectionId,
+            payload,
+        });
+        return textResult(data.addSongToSection);
+    });
+    server.registerTool('vibo_toggle_song_like', {
+        description: 'Like or unlike a song in a section. Confirm-gated.',
+        annotations: toolAnnotations({ title: 'Like/unlike Vibo song', readOnly: false }),
+        inputSchema: {
+            eventId: z.string().describe('Event id.'),
+            sectionId: z.string().describe('Section id.'),
+            songId: z.string().describe('Song _id (from vibo_get_section_songs).'),
+            liked: z.boolean().describe('true to like, false to unlike.'),
+            confirm: schemaConfirm,
+        },
+    }, async ({ eventId, sectionId, songId, liked, confirm }) => {
+        if (!confirm)
+            return previewResult('toggleLike', { eventId, sectionId, songId, liked });
+        const data = await client.gql(TOGGLE_LIKE, {
+            eventId,
+            sectionId,
+            songId,
+            liked,
+        });
+        return textResult(data.toggleLike);
+    });
+}

package/dist/version.js

@@ -0,0 +1,5 @@
+// Single source of truth for the package version. release-please bumps the
+// 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 = '1.0.0'; // x-release-please-version

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "vibo-mcp",
+  "version": "1.0.0",
+  "mcpName": "io.github.chrischall/vibo-mcp",
+  "description": "Vibo (vibodj.com) MCP server for Claude — host/couple event music planning. Developed and maintained by AI (Claude Code).",
+  "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chrischall/vibo-mcp.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "ai",
+    "vibo",
+    "vibodj",
+    "wedding",
+    "dj",
+    "event-planning",
+    "playlist",
+    "music",
+    "spotify",
+    "apple-music"
+  ],
+  "type": "module",
+  "bin": {
+    "vibo-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    ".claude-plugin",
+    "SKILL.md",
+    ".mcp.json",
+    "server.json"
+  ],
+  "scripts": {
+    "build": "tsc && npm run bundle",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --external:dotenv --outfile=dist/bundle.js",
+    "dev": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@chrischall/mcp-utils": "^0.10.4",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^17.4.0",
+    "zod": "^4.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@vitest/coverage-v8": "^4.1.2",
+    "esbuild": "^0.28.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}

package/server.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.chrischall/vibo-mcp",
+  "description": "Vibo (vibodj.com) MCP — plan event music: events, timeline, song requests, playlist export",
+  "repository": {
+    "url": "https://github.com/chrischall/vibo-mcp",
+    "source": "github"
+  },
+  "version": "1.0.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "vibo-mcp",
+      "version": "1.0.0",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "VIBO_EMAIL",
+          "description": "Vibo account email (or use VIBO_ACCESS_TOKEN for SSO accounts)",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": false
+        },
+        {
+          "name": "VIBO_PASSWORD",
+          "description": "Vibo account password",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": true
+        },
+        {
+          "name": "VIBO_ACCESS_TOKEN",
+          "description": "Captured x-token from a signed-in web.vibodj.com session (SSO alternative)",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": true
+        },
+        {
+          "name": "VIBO_REFRESH_TOKEN",
+          "description": "Matching x-refresh-token so the session can renew",
+          "isRequired": false,
+          "format": "string",
+          "isSecret": true
+        }
+      ]
+    }
+  ]
+}