@powerfm/libretime-mcp 0.1.0 → 0.1.3

package/dist/stdio/client.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { createRequire } from 'module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@powerfm/libretime-mcp",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "private": false,
   "type": "module",
   "description": "MCP server for LibreTime radio station — connect Claude to your broadcast schedule, media library, and analytics",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nelsonra/libretime-mcp.git"
+    "url": "git+https://github.com/nelsonra/libretime-mcp.git"
   },
   "bin": {
-    "libretime-mcp": "dist/stdio/admin.js"
+    "libretime-mcp": "dist/stdio/admin.js",
+    "libretime-mcp-client": "dist/stdio/client.js"
   },
   "files": [
     "dist/",
@@ -20,7 +21,11 @@
     "dev:admin": "tsx --env-file=.env watch src/stdio/admin.ts",
     "dev:client-http": "tsx --env-file=.env watch src/http/client.ts",
     "dev:admin-http": "tsx --env-file=.env watch src/http/admin.ts",
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
+    "prepublishOnly": "npm run build",
+    "publish:patch": "npm version patch && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
     "start:client": "node --env-file=.env dist/stdio/client.js",
     "start:admin": "node --env-file=.env dist/stdio/admin.js",
     "start:client-http": "node --env-file=.env dist/http/client.js",

package/dist/index.js

@@ -1,48 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-import { libreGet } from './libretime.js';
-// ---- MCP Server ----------------------------------------------------------
-const server = new McpServer({
-    name: 'libretime-mcp',
-    version: '0.1.0',
-});
-// Tool: get_shows
-server.registerTool('get_shows', {
-    description: 'List all shows registered in LibreTime. Returns each show\'s id, name, description, and genre.'
-}, async () => {
-    const shows = await libreGet('/api/v2/shows');
-    const trimmed = shows.map(({ id, name, description, genre, url }) => ({ id, name, description, genre, url }));
-    return {
-        content: [{ type: 'text', text: JSON.stringify(trimmed) }],
-    };
-});
-// Tool: get_schedule
-server.registerTool('get_schedule', {
-    description: 'Get the broadcast schedule for a date range. Use starts_after and starts_before to filter by date (ISO 8601 format, e.g. 2024-06-01T00:00:00Z).',
-    inputSchema: {
-        starts_after: z.string().describe('Return items starting after this datetime (ISO 8601)'),
-        starts_before: z.string().describe('Return items starting before this datetime (ISO 8601)'),
-    }
-}, async ({ starts_after, starts_before }) => {
-    const params = {};
-    if (starts_after)
-        params.starts_after = starts_after;
-    if (starts_before)
-        params.starts_before = starts_before;
-    const schedule = await libreGet('/api/v2/schedule', params);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(schedule) }],
-    };
-});
-// Tool: get_stream_state
-server.registerTool('get_stream_state', { description: 'Check whether the PowerFM station is currently broadcasting live.' }, async () => {
-    const state = await libreGet('/api/v2/stream/state');
-    return {
-        content: [{ type: 'text', text: JSON.stringify(state) }],
-    };
-});
-// ---- Start ---------------------------------------------------------------
-const transport = new StdioServerTransport();
-await server.connect(transport);
-console.error('LibreTime MCP server running');

package/dist/tools/admin/delete_file.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { libreDelete } from '../../libretime.js';
-import { toolText } from '../../tool-response.js';
-export function register(server) {
-    server.registerTool('delete_file', {
-        description: 'Delete a file from the LibreTime media library by its ID.',
-        inputSchema: {
-            file_id: z.number().describe('ID of the file to delete'),
-        },
-    }, async ({ file_id }) => {
-        await libreDelete(`/api/v2/files/${file_id}`);
-        return toolText({ success: true, deleted_id: file_id });
-    });
-}

package/dist/tools/admin/search_files.js

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { libreGet } from '../../libretime.js';
-import { toolText } from '../../tool-response.js';
-import { LibreFileSchema } from './types.js';
-export function register(server) {
-    server.registerTool('search_files', {
-        description: 'Search the LibreTime media library. Optionally filter by genre. Returns file id, name, track title, artist, album, length, and mime type.',
-        inputSchema: {
-            genre: z.string().optional().describe('Filter files by genre'),
-        },
-    }, async ({ genre }) => {
-        const params = {};
-        if (genre)
-            params.genre = genre;
-        const raw = await libreGet('/api/v2/files', params);
-        const files = z.array(LibreFileSchema).parse(raw);
-        const trimmed = files.map(({ id, name, track_title, artist_name, album_title, genre, length, mime, import_status, created_at, last_played_at }) => ({
-            id, name, track_title, artist_name, album_title, genre, length, mime, import_status, created_at, last_played_at,
-        }));
-        return toolText(trimmed);
-    });
-}

package/dist/tools/admin/update_file_metadata.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { librePatch } from '../../libretime.js';
-import { toolText } from '../../tool-response.js';
-import { LibreFileSchema } from './types.js';
-export function register(server) {
-    server.registerTool('update_file_metadata', {
-        description: 'Update metadata for a file already in the LibreTime library (track title, artist, album, genre).',
-        inputSchema: {
-            file_id: z.number().describe('ID of the file to update'),
-            track_title: z.string().optional().describe('Track title'),
-            artist_name: z.string().optional().describe('Artist name'),
-            album_title: z.string().optional().describe('Album title'),
-            genre: z.string().optional().describe('Genre'),
-        },
-    }, async ({ file_id, track_title, artist_name, album_title, genre }) => {
-        const body = {};
-        if (track_title !== undefined)
-            body.track_title = track_title;
-        if (artist_name !== undefined)
-            body.artist_name = artist_name;
-        if (album_title !== undefined)
-            body.album_title = album_title;
-        if (genre !== undefined)
-            body.genre = genre;
-        const raw = await librePatch(`/api/v2/files/${file_id}`, body);
-        const result = LibreFileSchema.parse(raw);
-        return toolText(result);
-    });
-}

package/dist/tools/admin/upload_file.js

@@ -1,50 +0,0 @@
-import { z } from 'zod';
-import { libreUpload } from '../../libretime.js';
-import { toolText } from '../../tool-response.js';
-import { LibreFileSchema } from './types.js';
-export function register(server) {
-    server.registerTool('upload_file', {
-        description: 'Upload an audio file to the LibreTime media library from a URL. If no URL is provided, returns an action signal so the client can trigger a local file upload workflow. Optionally provide metadata such as track title, artist, album, and genre.',
-        inputSchema: {
-            url: z.string().optional().describe('Publicly accessible URL of the audio file to upload'),
-            track_title: z.string().optional().describe('Track title'),
-            artist_name: z.string().optional().describe('Artist name'),
-            album_title: z.string().optional().describe('Album title'),
-            genre: z.string().optional().describe('Genre'),
-        },
-    }, async ({ url, track_title, artist_name, album_title, genre }) => {
-        if (!url) {
-            return toolText({ status: 'upload_required', action: 'file_upload' });
-        }
-        let fileResponse;
-        try {
-            fileResponse = await fetch(url);
-            if (!fileResponse.ok) {
-                return toolText({ status: 'error', reason: `Could not fetch file: ${fileResponse.status} ${fileResponse.statusText}` });
-            }
-        }
-        catch (err) {
-            return toolText({ status: 'error', reason: `Failed to reach URL: ${err instanceof Error ? err.message : String(err)}` });
-        }
-        const fileName = url.split('/').pop()?.split('?')[0] || 'upload';
-        const blob = await fileResponse.blob();
-        const formData = new FormData();
-        formData.append('file', blob, fileName);
-        if (track_title)
-            formData.append('track_title', track_title);
-        if (artist_name)
-            formData.append('artist_name', artist_name);
-        if (album_title)
-            formData.append('album_title', album_title);
-        if (genre)
-            formData.append('genre', genre);
-        try {
-            const raw = await libreUpload('/api/v2/files', formData);
-            const file = LibreFileSchema.parse(raw);
-            return toolText({ status: 'success', file });
-        }
-        catch (err) {
-            return toolText({ status: 'error', reason: `LibreTime upload failed: ${err instanceof Error ? err.message : String(err)}` });
-        }
-    });
-}

package/dist/tools/admin.js

@@ -1,153 +0,0 @@
-import { z } from 'zod';
-import { libreGet, librePatch, libreDelete, libreUpload } from '../libretime.js';
-export function register(server) {
-    // ---- Files ---------------------------------------------------------------
-    server.registerTool('search_files', {
-        description: 'Search the LibreTime media library. Optionally filter by genre. Returns file id, name, track title, artist, album, length, and mime type.',
-        inputSchema: {
-            genre: z.string().optional().describe('Filter files by genre'),
-        },
-    }, async ({ genre }) => {
-        const params = {};
-        if (genre)
-            params.genre = genre;
-        const files = await libreGet('/api/v2/files', params);
-        const trimmed = files.map(({ id, name, track_title, artist_name, album_title, genre, length, mime, import_status, created_at, last_played_at }) => ({
-            id, name, track_title, artist_name, album_title, genre, length, mime, import_status, created_at, last_played_at,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(trimmed) }] };
-    });
-    server.registerTool('upload_file', {
-        description: 'Upload an audio file to the LibreTime media library from a URL. If no URL is provided, returns an action signal so the client can trigger a local file upload workflow. Optionally provide metadata such as track title, artist, album, and genre.',
-        inputSchema: {
-            url: z.string().optional().describe('Publicly accessible URL of the audio file to upload'),
-            track_title: z.string().optional().describe('Track title'),
-            artist_name: z.string().optional().describe('Artist name'),
-            album_title: z.string().optional().describe('Album title'),
-            genre: z.string().optional().describe('Genre'),
-        },
-    }, async ({ url, track_title, artist_name, album_title, genre }) => {
-        // No URL — signal the client to trigger the local file upload workflow
-        if (!url) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({ status: 'upload_required', action: 'file_upload' }),
-                    }],
-            };
-        }
-        // Fetch the file from the provided URL
-        let fileResponse;
-        try {
-            fileResponse = await fetch(url);
-            if (!fileResponse.ok) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({ status: 'error', reason: `Could not fetch file: ${fileResponse.status} ${fileResponse.statusText}` }),
-                        }],
-                };
-            }
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({ status: 'error', reason: `Failed to reach URL: ${err instanceof Error ? err.message : String(err)}` }),
-                    }],
-            };
-        }
-        // Derive filename from URL, fall back to 'upload'
-        const fileName = url.split('/').pop()?.split('?')[0] || 'upload';
-        const blob = await fileResponse.blob();
-        const formData = new FormData();
-        formData.append('file', blob, fileName);
-        if (track_title)
-            formData.append('track_title', track_title);
-        if (artist_name)
-            formData.append('artist_name', artist_name);
-        if (album_title)
-            formData.append('album_title', album_title);
-        if (genre)
-            formData.append('genre', genre);
-        try {
-            const result = await libreUpload('/api/v2/files', formData);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({ status: 'success', file: result }),
-                    }],
-            };
-        }
-        catch (err) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({ status: 'error', reason: `LibreTime upload failed: ${err instanceof Error ? err.message : String(err)}` }),
-                    }],
-            };
-        }
-    });
-    server.registerTool('update_file_metadata', {
-        description: 'Update metadata for a file already in the LibreTime library (track title, artist, album, genre).',
-        inputSchema: {
-            file_id: z.number().describe('ID of the file to update'),
-            track_title: z.string().optional().describe('Track title'),
-            artist_name: z.string().optional().describe('Artist name'),
-            album_title: z.string().optional().describe('Album title'),
-            genre: z.string().optional().describe('Genre'),
-        },
-    }, async ({ file_id, track_title, artist_name, album_title, genre }) => {
-        const body = {};
-        if (track_title !== undefined)
-            body.track_title = track_title;
-        if (artist_name !== undefined)
-            body.artist_name = artist_name;
-        if (album_title !== undefined)
-            body.album_title = album_title;
-        if (genre !== undefined)
-            body.genre = genre;
-        const result = await librePatch(`/api/v2/files/${file_id}`, body);
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    server.registerTool('delete_file', {
-        description: 'Delete a file from the LibreTime media library by its ID.',
-        inputSchema: {
-            file_id: z.number().describe('ID of the file to delete'),
-        },
-    }, async ({ file_id }) => {
-        await libreDelete(`/api/v2/files/${file_id}`);
-        return { content: [{ type: 'text', text: JSON.stringify({ success: true, deleted_id: file_id }) }] };
-    });
-    // ---- Users ---------------------------------------------------------------
-    server.registerTool('get_users', {
-        description: 'List all LibreTime users (presenters and admins). Returns id, username, name, email, and role. Roles: G = Guest, H = Host, P = Manager, A = Admin.',
-    }, async () => {
-        const users = await libreGet('/api/v2/users');
-        const trimmed = users.map(({ id, username, first_name, last_name, email, type }) => ({
-            id, username, first_name, last_name, email, role: type,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(trimmed) }] };
-    });
-    // ---- Show Hosts ----------------------------------------------------------
-    server.registerTool('get_hosts', {
-        description: 'Get all show-to-host assignments. Enriches each entry with user details so you can see which presenter hosts which show by name.',
-    }, async () => {
-        const [hosts, users] = await Promise.all([
-            libreGet('/api/v2/show-hosts'),
-            libreGet('/api/v2/users'),
-        ]);
-        const userMap = new Map(users.map((u) => [u.id, u]));
-        const enriched = hosts.map(({ id, show, user }) => {
-            const u = userMap.get(user);
-            return {
-                id,
-                show_id: show,
-                user_id: user,
-                username: u?.username ?? null,
-                name: u ? `${u.first_name} ${u.last_name}`.trim() : null,
-            };
-        });
-        return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
-    });
-}

package/dist/tools/analytics.js

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { libreGet } from '../libretime.js';
-export function register(server) {
-    server.registerTool('get_listener_counts', {
-        description: 'Get listener count history for PowerFM streams. Returns counts per mount point (stream URL) with timestamps. Useful for understanding peak listening times and audience size.',
-    }, async () => {
-        const [counts, mounts] = await Promise.all([
-            libreGet('/api/v2/listener-counts'),
-            libreGet('/api/v2/mount-names'),
-        ]);
-        const mountMap = new Map(mounts.map((m) => [m.id, m.mount_name]));
-        const enriched = counts.map(({ id, listener_count, timestamp, mount_name }) => ({
-            id,
-            listener_count,
-            timestamp,
-            mount: mountMap.get(mount_name) ?? `mount_${mount_name}`,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
-    });
-    server.registerTool('get_playout_history', {
-        description: 'Get the history of tracks that have played on PowerFM. Enriches each entry with track title and artist from the file library. Use starts and ends to filter by time range (ISO 8601).',
-        inputSchema: {
-            starts: z.string().optional().describe('Return history entries starting after this datetime (ISO 8601)'),
-            ends: z.string().optional().describe('Return history entries ending before this datetime (ISO 8601)'),
-        },
-    }, async ({ starts, ends }) => {
-        const params = {};
-        if (starts)
-            params.starts = starts;
-        if (ends)
-            params.ends = ends;
-        const history = await libreGet('/api/v2/playout-history', params);
-        // Collect unique file IDs to enrich in parallel
-        const fileIds = [...new Set(history.map((h) => h.file).filter((id) => id !== null))];
-        const files = await Promise.all(fileIds.map((id) => libreGet(`/api/v2/files/${id}`)));
-        const fileMap = new Map(files.map((f) => [f.id, f]));
-        const enriched = history.map(({ id, starts, ends, file, instance }) => {
-            const meta = file !== null ? fileMap.get(file) : undefined;
-            return {
-                id,
-                starts,
-                ends,
-                instance,
-                track_title: meta?.track_title ?? null,
-                artist_name: meta?.artist_name ?? null,
-                album_title: meta?.album_title ?? null,
-                genre: meta?.genre ?? null,
-                length: meta?.length ?? null,
-            };
-        });
-        return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
-    });
-}

package/dist/tools/shows.js

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import { libreGet } from '../libretime.js';
-export function register(server) {
-    server.registerTool('get_shows', {
-        description: "List all shows registered in LibreTime. Returns each show's id, name, description, and genre.",
-    }, async () => {
-        const shows = await libreGet('/api/v2/shows');
-        const trimmed = shows.map(({ id, name, description, genre, url }) => ({ id, name, description, genre, url }));
-        return { content: [{ type: 'text', text: JSON.stringify(trimmed) }] };
-    });
-    server.registerTool('get_schedule', {
-        description: 'Get the broadcast schedule for a date range. Use starts_after and starts_before to filter by date (ISO 8601 format, e.g. 2024-06-01T00:00:00Z).',
-        inputSchema: {
-            starts_after: z.string().describe('Return items starting after this datetime (ISO 8601)'),
-            starts_before: z.string().describe('Return items starting before this datetime (ISO 8601)'),
-        },
-    }, async ({ starts_after, starts_before }) => {
-        const params = {};
-        if (starts_after)
-            params.starts_after = starts_after;
-        if (starts_before)
-            params.starts_before = starts_before;
-        const schedule = await libreGet('/api/v2/schedule', params);
-        return { content: [{ type: 'text', text: JSON.stringify(schedule) }] };
-    });
-    server.registerTool('get_stream_state', { description: 'Check whether the PowerFM station is currently broadcasting live.' }, async () => {
-        const state = await libreGet('/api/v2/stream/state');
-        return { content: [{ type: 'text', text: JSON.stringify(state) }] };
-    });
-}