@powerfm/libretime-mcp 0.1.8 → 0.3.0

package/dist/tools/files/upload_file_legacy.js

@@ -0,0 +1,160 @@
+// Active upload implementation — uses /rest/media (legacy LibreTime PHP endpoint).
+//
+// Background: /api/v2/files (DRF) creates a DB record but never writes to disk or queues
+// the analyzer. /rest/media is the only endpoint that triggers the full import workflow.
+// This file stays active until LibreTime wires the analyzer in the DRF endpoint.
+//
+// When that upstream fix lands, swap index.ts to import from upload_file.ts instead.
+// See upload_file.ts for the DRF implementation kept ready for that switch.
+import { z } from 'zod';
+import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE, } from '@modelcontextprotocol/ext-apps/server';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { libreGet, libreRestMedia } from '../../libretime.js';
+import { toolText } from '../../tool-response.js';
+import { LibreFileSchema, LibrarySchema } from './types.js';
+// When running via tsx (dev): __dirname is src/tools/files/ → walk up to project root, then into dist/
+// When running compiled:      __dirname is dist/tools/files/ → walk up two levels to dist/
+const HTML_PATH = import.meta.filename.endsWith('.ts')
+    ? path.join(import.meta.dirname, '../../../dist/apps/upload-file.html')
+    : path.join(import.meta.dirname, '../../apps/upload-file.html');
+const resourceUri = 'ui://libretime/upload-file.html';
+const metadataFields = {
+    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'),
+    library: z.number().optional().describe('Track type / library ID'),
+};
+const MIME_MAP = {
+    mp3: 'audio/mpeg',
+    flac: 'audio/flac',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    aac: 'audio/aac',
+    m4a: 'audio/mp4',
+    opus: 'audio/opus',
+};
+function inferMime(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+    return MIME_MAP[ext] ?? 'audio/mpeg';
+}
+function appendMetadata(formData, fields) {
+    if (fields.track_title)
+        formData.append('track_title', fields.track_title);
+    if (fields.artist_name)
+        formData.append('artist_name', fields.artist_name);
+    if (fields.album_title)
+        formData.append('album_title', fields.album_title);
+    if (fields.genre)
+        formData.append('genre', fields.genre);
+    if (fields.library)
+        formData.append('library', String(fields.library));
+}
+export function register(server, uploadUrl, uploadToken) {
+    registerAppTool(server, 'upload_file', {
+        description: 'Upload an audio file to the LibreTime media library. Provide a URL to fetch the file from, or a local file path when running in stdio mode. When neither is given, opens a file picker. Optionally pre-fill metadata such as track title, artist, album, and genre.',
+        inputSchema: {
+            url: z.string().optional().describe('Publicly accessible URL of the audio file to upload'),
+            file_path: z.string().optional().describe('Absolute path to a local audio file — use when running stdio mode'),
+            ...metadataFields,
+        },
+        _meta: { ui: { resourceUri } },
+    }, async ({ url, file_path, track_title, artist_name, album_title, genre, library }) => {
+        const meta = { track_title, artist_name, album_title, genre, library };
+        // Priority 1: local file path (stdio mode — server runs on the user's machine)
+        if (file_path) {
+            let fileBuffer;
+            try {
+                fileBuffer = await fs.readFile(file_path);
+            }
+            catch (err) {
+                return toolText({
+                    status: 'error',
+                    reason: `Could not read file: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+            const fileName = path.basename(file_path);
+            const mime = inferMime(file_path);
+            const formData = new FormData();
+            formData.append('file', new Blob([new Uint8Array(fileBuffer)], { type: mime }), fileName);
+            appendMetadata(formData, meta);
+            try {
+                const raw = await libreRestMedia(formData);
+                const parsed = LibreFileSchema.safeParse(raw);
+                return toolText({ status: 'success', file: parsed.success ? parsed.data : raw });
+            }
+            catch (err) {
+                return toolText({
+                    status: 'error',
+                    reason: `LibreTime upload failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        }
+        // Priority 2: remote URL — fetch then forward to LibreTime
+        if (url) {
+            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', new Blob([await blob.arrayBuffer()], { type: blob.type || inferMime(fileName) }), fileName);
+            appendMetadata(formData, meta);
+            try {
+                const raw = await libreRestMedia(formData);
+                const parsed = LibreFileSchema.safeParse(raw);
+                return toolText({ status: 'success', file: parsed.success ? parsed.data : raw });
+            }
+            catch (err) {
+                return toolText({
+                    status: 'error',
+                    reason: `LibreTime upload failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        }
+        // Priority 3: no input — hand off to the file picker UI
+        let libraries = [];
+        try {
+            const raw = await libreGet('/api/v2/libraries');
+            libraries = LibrarySchema.array().parse(raw);
+        }
+        catch {
+            // Non-fatal — UI will just show no dropdown
+        }
+        return toolText({
+            status: uploadUrl ? 'upload_ready' : 'upload_required',
+            upload_url: uploadUrl ?? null,
+            upload_token: uploadToken ?? null,
+            libraries,
+        });
+    });
+    registerAppResource(server, resourceUri, resourceUri, { mimeType: RESOURCE_MIME_TYPE }, async () => {
+        const html = await fs.readFile(HTML_PATH, 'utf-8');
+        return {
+            contents: [
+                {
+                    uri: resourceUri,
+                    mimeType: RESOURCE_MIME_TYPE,
+                    text: html,
+                    ...(uploadUrl && {
+                        _meta: { ui: { csp: { connectDomains: [uploadUrl] } } },
+                    }),
+                },
+            ],
+        };
+    });
+}

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "@powerfm/libretime-mcp",
-  "version": "0.1.8",
+  "version": "0.3.0",
   "private": false,
   "type": "module",
   "license": "GPL-3.0",
   "description": "MCP server for LibreTime radio station — connect Claude to your broadcast schedule, media library, and analytics",
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "libretime",
+    "radio",
+    "claude"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nelsonra/libretime-mcp.git"
@@ -24,9 +31,11 @@
     "dev:client": "tsx watch --env-file=.env src/stdio/client.ts",
     "dev:admin": "tsx watch --env-file=.env src/stdio/admin.ts",
     "dev:client-http": "tsx watch --env-file=.env src/http/client.ts",
-    "dev:admin-http": "tsx watch --env-file=.env src/http/admin.ts",
+    "dev:admin-http": "concurrently \"npm run watch:app\" \"tsx watch --env-file=.env src/http/admin.ts\"",
     "clean": "rm -rf dist",
-    "build": "npm run clean && tsc",
+    "build:app": "cross-env INPUT=apps/upload-file.html vite build",
+    "watch:app": "cross-env NODE_ENV=development INPUT=apps/upload-file.html vite build --watch",
+    "build": "npm run clean && npm run build:app && tsc",
     "prepublishOnly": "npm run build && npm test",
     "publish:patch": "npm version patch && npm publish --access public",
     "publish:minor": "npm version minor && npm publish --access public",
@@ -43,17 +52,31 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@modelcontextprotocol/ext-apps": "~1.3.2",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "cors": "~2.8.6",
     "express": "~5.2.1",
+    "express-rate-limit": "~8.3.2",
+    "helmet": "~8.1.0",
+    "morgan": "~1.10.1",
+    "react": "~19.2.4",
+    "react-dom": "~19.2.4",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/cors": "~2.8.19",
     "@types/express": "~5.0.6",
+    "@types/morgan": "~1.9.10",
     "@types/node": "^22.0.0",
+    "@types/react": "~19.2.14",
+    "@types/react-dom": "~19.2.3",
+    "@vitejs/plugin-react": "~6.0.1",
+    "concurrently": "~9.2.1",
+    "cross-env": "~10.1.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
+    "vite": "~8.0.3",
+    "vite-plugin-singlefile": "~2.3.2",
     "vitest": "~4.1.1"
   }
 }