@powerfm/libretime-mcp 0.1.0

package/README.md

@@ -0,0 +1,143 @@
+# libretime-mcp
+
+A [Model Context Protocol](https://modelcontextprotocol.io) server that connects Claude (or any MCP-compatible AI client) to a [LibreTime](https://libretime.org) radio station via its REST API. Ask Claude to check your schedule, manage files, pull listener stats, and more — directly from your station.
+
+## Servers
+
+Two access levels, each available in stdio and HTTP flavors:
+
+| Entry point | Transport | Tools |
+|---|---|---|
+| `src/stdio/client.ts` | stdio | Shows, schedule, stream state (read-only) |
+| `src/stdio/admin.ts` | stdio | All client tools + analytics + file/user management |
+| `src/http/client.ts` | HTTP :3001 | Same as client, over the network |
+| `src/http/admin.ts` | HTTP :3000 | Same as admin, over the network |
+
+Use **stdio** for Claude Desktop. Use **HTTP** for server-to-server integrations (e.g. an AI agent or backend service calling over the network).
+
+## Tools
+
+Tools are organised into subdirectories under `src/tools/` — one file per tool.
+
+| Tool | Server | Description |
+|---|---|---|
+| `get_shows` | both | List shows |
+| `get_schedule` | both | Fetch the broadcast schedule |
+| `get_stream_state` | both | Current stream/on-air state |
+| `get_listener_counts` | admin | Listener stats by mount point |
+| `get_playout_history` | admin | Recent playout history with file metadata |
+| `search_files` | admin | Search the media library |
+| `upload_file` | admin | Upload an audio file |
+| `update_file_metadata` | admin | Edit metadata for a file |
+| `delete_file` | admin | Delete a file from the library |
+| `get_users` | admin | List station users |
+| `get_hosts` | admin | List show hosts with enriched user details |
+
+## Setup
+
+```bash
+npm install @powerfm/libretime-mcp
+```
+
+Or run without installing:
+
+```bash
+npx @powerfm/libretime-mcp
+```
+
+If you're working from source:
+
+```bash
+npm install
+```
+
+Copy and fill in your environment variables:
+
+```bash
+# LibreTime instance (required for all servers)
+LIBRETIME_URL=https://your-libretime-instance.example.com
+LIBRETIME_USER=your_api_username
+LIBRETIME_PASS=your_api_password
+
+# Required for HTTP servers only
+MCP_API_KEY=your_secret_api_key
+MCP_PORT=3000   # optional, defaults to 3000 (admin) / 3001 (client)
+```
+
+Generate a random API key:
+
+```bash
+npm run generate:key
+```
+
+## Commands
+
+```bash
+# Development (tsx watch — restarts on save)
+npm run dev:client          # read-only stdio server
+npm run dev:admin           # full-access stdio server
+npm run dev:client-http     # read-only HTTP server (port 3001)
+npm run dev:admin-http      # full-access HTTP server (port 3000)
+
+# Build TypeScript → dist/
+npm run build
+
+# Run built output
+npm run start:client
+npm run start:admin
+npm run start:client-http
+npm run start:admin-http
+
+# Tests
+npm test
+```
+
+## Using with Claude Desktop (stdio)
+
+Claude Desktop spawns the server as a subprocess and manages its lifecycle — nothing extra to run.
+
+Add to your `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "libretime": {
+      "command": "npx",
+      "args": ["tsx", "/absolute/path/to/libretime-mcp/src/stdio/admin.ts"],
+      "env": {
+        "LIBRETIME_URL": "https://your-instance.example.com",
+        "LIBRETIME_USER": "user",
+        "LIBRETIME_PASS": "pass"
+      }
+    }
+  }
+}
+```
+
+`npx tsx` resolves from the project's local `node_modules` — no global install needed as long as you've run `npm install` first.
+
+Or point at the built output (`npm run build` first):
+
+```json
+"command": "node",
+"args": ["/absolute/path/to/libretime-mcp/dist/stdio/admin.js"]
+```
+
+## Using the HTTP Server (server-to-server)
+
+The HTTP servers are designed for network clients — e.g. an AI agent or backend service calling LibreTime tools over the network. Claude Desktop does not support HTTP MCP servers directly; use stdio above for Desktop.
+
+Start the server:
+
+```bash
+npm run start:admin-http   # full access, port 3000
+npm run start:client-http  # read-only, port 3001
+```
+
+All requests must go to `POST /mcp` with the API key header:
+
+```
+Authorization: Bearer <MCP_API_KEY>
+```
+
+Requests without a valid key receive `401 Unauthorized`.

package/dist/env.js

@@ -0,0 +1,9 @@
+// This module must be the first import in any entry point that needs .env loaded.
+// ES module imports are hoisted and evaluated before any code runs, so we can't
+// call process.loadEnvFile() inline and have it take effect before other imports.
+// Importing this file first ensures .env is loaded before any other module reads env vars.
+try {
+    process.loadEnvFile();
+}
+catch { }
+export {};

package/dist/http/admin.js

@@ -0,0 +1,43 @@
+// HTTP MCP server — full admin access (shows + analytics + file/user management).
+// Exposes POST /mcp using MCP Streamable HTTP transport.
+// Requires Authorization: Bearer <MCP_API_KEY> on every request.
+// Intended for network clients (e.g. powerfm-agent). For Claude Desktop use stdio/admin.ts.
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+const { version } = createRequire(import.meta.url)('../../package.json');
+import { register as registerShows } from '../tools/shows/index.js';
+import { register as registerAnalytics } from '../tools/analytics/index.js';
+import { register as registerAdmin } from '../tools/admin/index.js';
+const PORT = parseInt(process.env.MCP_PORT ?? '3000', 10);
+const API_KEY = process.env.MCP_API_KEY;
+if (!API_KEY) {
+    console.error('ERROR: MCP_API_KEY environment variable is required');
+    process.exit(1);
+}
+const app = createMcpExpressApp({ host: '0.0.0.0' });
+// Simple API key middleware — checks Authorization: Bearer <key>
+app.use('/mcp', (req, res, next) => {
+    const auth = req.headers['authorization'];
+    if (!auth || auth !== `Bearer ${API_KEY}`) {
+        res.status(401).json({ error: 'Unauthorized' });
+        return;
+    }
+    next();
+});
+// Stateless transport — a fresh McpServer per request keeps things simple
+// and avoids session management complexity for now
+app.post('/mcp', async (req, res) => {
+    const server = new McpServer({ name: 'libretime-mcp-admin', version });
+    registerShows(server);
+    registerAnalytics(server);
+    registerAdmin(server);
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+});
+app.listen(PORT, '0.0.0.0', () => {
+    console.error(`LibreTime MCP admin HTTP server listening on port ${PORT}`);
+    console.error('Endpoint: POST /mcp  (Authorization: Bearer <MCP_API_KEY>)');
+});

package/dist/http/client.js

@@ -0,0 +1,39 @@
+// HTTP MCP server — read-only access (shows, schedule, stream state only).
+// Exposes POST /mcp using MCP Streamable HTTP transport.
+// Requires Authorization: Bearer <MCP_API_KEY> on every request.
+// Intended for network clients. For Claude Desktop use stdio/client.ts.
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+import { register as registerShows } from '../tools/shows/index.js';
+const { version } = createRequire(import.meta.url)('../../package.json');
+const PORT = parseInt(process.env.MCP_PORT ?? '3001', 10);
+const API_KEY = process.env.MCP_API_KEY;
+if (!API_KEY) {
+    console.error('ERROR: MCP_API_KEY environment variable is required');
+    process.exit(1);
+}
+const app = createMcpExpressApp({ host: '0.0.0.0' });
+// Simple API key middleware — checks Authorization: Bearer <key>
+app.use('/mcp', (req, res, next) => {
+    const auth = req.headers['authorization'];
+    if (!auth || auth !== `Bearer ${API_KEY}`) {
+        res.status(401).json({ error: 'Unauthorized' });
+        return;
+    }
+    next();
+});
+// Stateless transport — a fresh McpServer per request keeps things simple
+// and avoids session management complexity for now
+app.post('/mcp', async (req, res) => {
+    const server = new McpServer({ name: 'libretime-mcp-client', version });
+    registerShows(server);
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+});
+app.listen(PORT, '0.0.0.0', () => {
+    console.error(`LibreTime MCP client HTTP server listening on port ${PORT}`);
+    console.error('Endpoint: POST /mcp  (Authorization: Bearer <MCP_API_KEY>)');
+});

package/dist/index.js

@@ -0,0 +1,48 @@
+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/libretime.js

@@ -0,0 +1,103 @@
+const BASE_URL = process.env.LIBRETIME_URL ?? '';
+const USER = process.env.LIBRETIME_USER ?? '';
+const PASS = process.env.LIBRETIME_PASS ?? '';
+// Basic Auth header value, base64-encoded as the HTTP spec requires
+const authHeader = 'Basic ' + Buffer.from(`${USER}:${PASS}`).toString('base64');
+/**
+ * Make an authenticated GET request to the LibreTime API.
+ * Returns the parsed JSON response as unknown — callers are responsible for validation.
+ */
+export async function libreGet(path, params) {
+    const url = new URL(path, BASE_URL);
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, value);
+        }
+    }
+    const response = await fetch(url.toString(), {
+        headers: {
+            Authorization: authHeader,
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`LibreTime API error: ${response.status} ${response.statusText} — ${url.toString()}`);
+    }
+    return response.json();
+}
+/**
+ * Make an authenticated POST request to the LibreTime API with a JSON body.
+ * Returns the parsed JSON response as unknown — callers are responsible for validation.
+ */
+export async function librePost(path, body) {
+    const url = new URL(path, BASE_URL);
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            Authorization: authHeader,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(`LibreTime API error: ${response.status} ${response.statusText} — ${url.toString()}`);
+    }
+    return response.json();
+}
+/**
+ * Make an authenticated multipart POST request to the LibreTime API.
+ * Used for file uploads. Returns the parsed JSON response as unknown.
+ */
+export async function libreUpload(path, formData) {
+    const url = new URL(path, BASE_URL);
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            Authorization: authHeader,
+            Accept: 'application/json',
+            // Note: do NOT set Content-Type here — fetch sets it automatically
+            // with the correct multipart boundary when given a FormData body
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        throw new Error(`LibreTime API error: ${response.status} ${response.statusText} — ${url.toString()}`);
+    }
+    return response.json();
+}
+/**
+ * Make an authenticated PATCH request to the LibreTime API with a JSON body.
+ * Returns the parsed JSON response as unknown — callers are responsible for validation.
+ */
+export async function librePatch(path, body) {
+    const url = new URL(path, BASE_URL);
+    const response = await fetch(url.toString(), {
+        method: 'PATCH',
+        headers: {
+            Authorization: authHeader,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(`LibreTime API error: ${response.status} ${response.statusText} — ${url.toString()}`);
+    }
+    return response.json();
+}
+/**
+ * Make an authenticated DELETE request to the LibreTime API.
+ */
+export async function libreDelete(path) {
+    const url = new URL(path, BASE_URL);
+    const response = await fetch(url.toString(), {
+        method: 'DELETE',
+        headers: {
+            Authorization: authHeader,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`LibreTime API error: ${response.status} ${response.statusText} — ${url.toString()}`);
+    }
+}

package/dist/stdio/admin.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { register as registerShows } from '../tools/shows/index.js';
+import { register as registerAnalytics } from '../tools/analytics/index.js';
+import { register as registerAdmin } from '../tools/admin/index.js';
+import { register as registerFiles } from '../tools/files/index.js';
+const { version } = createRequire(import.meta.url)('../../package.json');
+const server = new McpServer({
+    name: 'libretime-mcp-admin',
+    version,
+});
+registerShows(server);
+registerAnalytics(server);
+registerAdmin(server);
+registerFiles(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('LibreTime MCP admin server running (shows + analytics + admin)');

package/dist/stdio/client.js

@@ -0,0 +1,13 @@
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { register as registerShows } from '../tools/shows/index.js';
+const { version } = createRequire(import.meta.url)('../../package.json');
+const server = new McpServer({
+    name: 'libretime-mcp-client',
+    version,
+});
+registerShows(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('LibreTime MCP client server running (read-only: shows)');

package/dist/tool-response.js

@@ -0,0 +1,7 @@
+/**
+ * Wraps any JSON-serialisable value in the MCP text content response shape.
+ * Use this in every tool handler instead of writing the structure inline.
+ */
+export const toolText = (data) => ({
+    content: [{ type: 'text', text: JSON.stringify(data) }],
+});

package/dist/tools/admin/delete_file.js

@@ -0,0 +1,14 @@
+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/get_hosts.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ShowHostSchema, UserSchema } from './types.js';
+export function register(server) {
+    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 [rawHosts, rawUsers] = await Promise.all([
+            libreGet('/api/v2/show-hosts'),
+            libreGet('/api/v2/users'),
+        ]);
+        const hosts = z.array(ShowHostSchema).parse(rawHosts);
+        const users = z.array(UserSchema).parse(rawUsers);
+        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 toolText(enriched);
+    });
+}

package/dist/tools/admin/get_users.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { UserSchema } from './types.js';
+export function register(server) {
+    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 raw = await libreGet('/api/v2/users');
+        const users = z.array(UserSchema).parse(raw);
+        const trimmed = users.map(({ id, username, first_name, last_name, email, type }) => ({
+            id, username, first_name, last_name, email, role: type,
+        }));
+        return toolText(trimmed);
+    });
+}

package/dist/tools/admin/index.js

@@ -0,0 +1,6 @@
+import { register as registerGetUsers } from './get_users.js';
+import { register as registerGetHosts } from './get_hosts.js';
+export function register(server) {
+    registerGetUsers(server);
+    registerGetHosts(server);
+}

package/dist/tools/admin/search_files.js

@@ -0,0 +1,22 @@
+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/types.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const UserSchema = z.object({
+    id: z.number(),
+    username: z.string(),
+    first_name: z.string(),
+    last_name: z.string(),
+    email: z.string(),
+    type: z.string(),
+});
+export const ShowHostSchema = z.object({
+    id: z.number(),
+    show: z.number(),
+    user: z.number(),
+});

package/dist/tools/admin/update_file_metadata.js

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,153 @@
+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/get_listener_counts.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ListenerCountSchema, MountNameSchema } from './types.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 [rawCounts, rawMounts] = await Promise.all([
+            libreGet('/api/v2/listener-counts'),
+            libreGet('/api/v2/mount-names'),
+        ]);
+        const counts = z.array(ListenerCountSchema).parse(rawCounts);
+        const mounts = z.array(MountNameSchema).parse(rawMounts);
+        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 toolText(enriched);
+    });
+}

package/dist/tools/analytics/get_playout_history.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { PlayoutHistorySchema, FileMetadataSchema } from './types.js';
+export function register(server) {
+    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 rawHistory = await libreGet('/api/v2/playout-history', params);
+        const history = z.array(PlayoutHistorySchema).parse(rawHistory);
+        // Collect unique file IDs then fetch metadata in parallel
+        const fileIds = [...new Set(history.map((h) => h.file).filter((id) => id !== null))];
+        const rawFiles = await Promise.all(fileIds.map((id) => libreGet(`/api/v2/files/${id}`)));
+        const files = rawFiles.map((f) => FileMetadataSchema.parse(f));
+        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 toolText(enriched);
+    });
+}

package/dist/tools/analytics/index.js

@@ -0,0 +1,6 @@
+import { register as registerGetListenerCounts } from './get_listener_counts.js';
+import { register as registerGetPlayoutHistory } from './get_playout_history.js';
+export function register(server) {
+    registerGetListenerCounts(server);
+    registerGetPlayoutHistory(server);
+}

package/dist/tools/analytics/types.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const ListenerCountSchema = z.object({
+    id: z.number(),
+    listener_count: z.number(),
+    timestamp: z.number(),
+    mount_name: z.number(),
+});
+export const MountNameSchema = z.object({
+    id: z.number(),
+    mount_name: z.string(),
+});
+export const PlayoutHistorySchema = z.object({
+    id: z.number(),
+    starts: z.string(),
+    ends: z.string().nullable(),
+    file: z.number().nullable(),
+    instance: z.number().nullable(),
+});
+export const FileMetadataSchema = z.object({
+    id: z.number(),
+    track_title: z.string().nullable(),
+    artist_name: z.string().nullable(),
+    album_title: z.string().nullable(),
+    genre: z.string().nullable(),
+    length: z.string().nullable(),
+});

package/dist/tools/analytics.js

@@ -0,0 +1,53 @@
+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/files/delete_file.js

@@ -0,0 +1,14 @@
+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/files/index.js

@@ -0,0 +1,10 @@
+import { register as registerSearchFiles } from '../files/search_files.js';
+import { register as registerUploadFile } from '../files/upload_file.js';
+import { register as registerUpdateFileMetadata } from '../files/update_file_metadata.js';
+import { register as registerDeleteFile } from '../files/delete_file.js';
+export function register(server) {
+    registerSearchFiles(server);
+    registerUploadFile(server);
+    registerUpdateFileMetadata(server);
+    registerDeleteFile(server);
+}

package/dist/tools/files/search_files.js

@@ -0,0 +1,22 @@
+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/files/types.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const LibreFileSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    track_title: z.string().nullable(),
+    artist_name: z.string().nullable(),
+    album_title: z.string().nullable(),
+    genre: z.string().nullable(),
+    length: z.string().nullable(),
+    mime: z.string(),
+    import_status: z.number(),
+    created_at: z.string().nullable(),
+    last_played_at: z.string().nullable(),
+});

package/dist/tools/files/update_file_metadata.js

@@ -0,0 +1,29 @@
+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/files/upload_file.js

@@ -0,0 +1,50 @@
+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/shows/get_schedule.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ScheduleItemSchema } from './types.js';
+export function register(server) {
+    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 raw = await libreGet('/api/v2/schedule', params);
+        const schedule = z.array(ScheduleItemSchema).parse(raw);
+        return toolText(schedule);
+    });
+}

package/dist/tools/shows/get_shows.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { ShowSchema } from './types.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 raw = await libreGet('/api/v2/shows');
+        const shows = z.array(ShowSchema).parse(raw);
+        const trimmed = shows.map(({ id, name, description, genre, url }) => ({ id, name, description, genre, url }));
+        return toolText(trimmed);
+    });
+}

package/dist/tools/shows/get_stream_state.js

@@ -0,0 +1,10 @@
+import { libreGet } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { StreamStateSchema } from './types.js';
+export function register(server) {
+    server.registerTool('get_stream_state', { description: 'Check whether the PowerFM station is currently broadcasting live.' }, async () => {
+        const raw = await libreGet('/api/v2/stream/state');
+        const state = StreamStateSchema.parse(raw);
+        return toolText(state);
+    });
+}

package/dist/tools/shows/index.js

@@ -0,0 +1,8 @@
+import { register as registerGetShows } from './get_shows.js';
+import { register as registerGetSchedule } from './get_schedule.js';
+import { register as registerGetStreamState } from './get_stream_state.js';
+export function register(server) {
+    registerGetShows(server);
+    registerGetSchedule(server);
+    registerGetStreamState(server);
+}

package/dist/tools/shows/types.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const ShowSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    description: z.string(),
+    genre: z.string(),
+    url: z.string(),
+});
+export const ScheduleItemSchema = z.object({
+    id: z.number(),
+    starts: z.string(),
+    ends: z.string(),
+    show_id: z.number(),
+    show_name: z.string(),
+    broadcasted: z.number(),
+});
+export const StreamStateSchema = z.object({
+    source_enabled: z.boolean(),
+}).passthrough();

package/dist/tools/shows.js

@@ -0,0 +1,30 @@
+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) }] };
+    });
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@powerfm/libretime-mcp",
+  "version": "0.1.0",
+  "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"
+  },
+  "bin": {
+    "libretime-mcp": "dist/stdio/admin.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "dev:client": "tsx --env-file=.env watch src/stdio/client.ts",
+    "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",
+    "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",
+    "start:admin-http": "node --env-file=.env dist/http/admin.js",
+    "generate:key": "node -e \"console.log(require('crypto').randomBytes(32).toString('hex'))\"",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "express": "~5.2.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/express": "~5.0.6",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "~4.1.1"
+  }
+}