@clawbow/synology-mcp-audiostation 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+// Configuration
+const SYNOLOGY_URL = process.env.SYNOLOGY_URL || '';
+const SYNOLOGY_USERNAME = process.env.SYNOLOGY_USERNAME || '';
+const SYNOLOGY_PASSWORD = process.env.SYNOLOGY_PASSWORD || '';
+if (!SYNOLOGY_URL || !SYNOLOGY_USERNAME || !SYNOLOGY_PASSWORD) {
+    console.error('Erreur: Variables d\'environnement requises:\n' +
+        '  SYNOLOGY_URL (ex: https://nas.example.com:5001)\n' +
+        '  SYNOLOGY_USERNAME\n' +
+        '  SYNOLOGY_PASSWORD');
+    process.exit(1);
+}
+// Client Synology Audio Station
+class AudioStationClient {
+    baseUrl;
+    username;
+    password;
+    sid = null;
+    constructor(config) {
+        this.baseUrl = config.url.replace(/\/$/, '');
+        this.username = config.username;
+        this.password = config.password;
+    }
+    async login() {
+        const url = `${this.baseUrl}/webapi/auth.cgi`;
+        const response = await axios.get(url, {
+            params: {
+                api: 'SYNO.API.Auth',
+                version: 3,
+                method: 'login',
+                account: this.username,
+                passwd: this.password,
+                session: 'audiostation',
+                format: 'cookie',
+            },
+        });
+        if (response.data.success) {
+            this.sid = response.data.data.sid;
+        }
+        else {
+            throw new Error(`Login failed: ${response.data.error?.code || 'Unknown'}`);
+        }
+    }
+    async ensureAuth() {
+        if (!this.sid) {
+            await this.login();
+        }
+    }
+    async apiCall(api, version, method, params = {}) {
+        await this.ensureAuth();
+        const url = `${this.baseUrl}/webapi/entry.cgi`;
+        const response = await axios.get(url, {
+            params: {
+                api,
+                version,
+                method,
+                _sid: this.sid,
+                ...params,
+            },
+        });
+        return response.data;
+    }
+    async listartists(args) {
+        const params = {};
+        if (args.limit)
+            params.limit = args.limit;
+        return await this.apiCall('SYNO.AudioStation.Artist', 1, 'list', params);
+    }
+    async listalbums(args) {
+        const params = {};
+        if (args.artist)
+            params.artist = args.artist;
+        if (args.limit)
+            params.limit = args.limit;
+        return await this.apiCall('SYNO.AudioStation.Album', 1, 'list', params);
+    }
+    async listsongs(args) {
+        const params = {};
+        if (args.album)
+            params.album = args.album;
+        if (args.limit)
+            params.limit = args.limit;
+        return await this.apiCall('SYNO.AudioStation.Song', 1, 'list', params);
+    }
+    async listplaylists(args = {}) {
+        return await this.apiCall('SYNO.AudioStation.Playlist', 1, 'list');
+    }
+    async createplaylist(args) {
+        const params = { name: args.name };
+        if (args.songs)
+            params.songs = args.songs.join(',');
+        return await this.apiCall('SYNO.AudioStation.Playlist', 1, 'create', params);
+    }
+    async updateplaylist(args) {
+        const params = { id: args.id };
+        if (args.name)
+            params.name = args.name;
+        if (args.songs)
+            params.songs = args.songs.join(',');
+        return await this.apiCall('SYNO.AudioStation.Playlist', 1, 'update', params);
+    }
+    async deleteplaylist(args) {
+        return await this.apiCall('SYNO.AudioStation.Playlist', 1, 'delete', { id: args.id });
+    }
+    async addtoplaylist(args) {
+        return await this.apiCall('SYNO.AudioStation.Playlist', 1, 'add_song', { playlist_id: args.playlist_id, songs: args.songs.join(',') });
+    }
+    async removefromplaylist(args) {
+        return await this.apiCall('SYNO.AudioStation.Playlist', 1, 'delete_song', { playlist_id: args.playlist_id, songs: args.songs.join(',') });
+    }
+    async searchmusic(args) {
+        const params = { keyword: args.query };
+        if (args.type)
+            params.type = args.type;
+        return await this.apiCall('SYNO.AudioStation.Search', 1, 'list', params);
+    }
+    async customaudiocall(args) {
+        return await this.apiCall(args.endpoint, 1, args.method.toLowerCase(), args.body || {});
+    }
+}
+// Définition des outils MCP
+const TOOLS = [
+    {
+        name: 'list_artists',
+        description: 'List artists',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "number",
+                    "description": "Max results"
+                }
+            }
+        },
+    },
+    {
+        name: 'list_albums',
+        description: 'List albums',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "artist": {
+                    "type": "string",
+                    "description": "Filter by artist"
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "Max results"
+                }
+            }
+        },
+    },
+    {
+        name: 'list_songs',
+        description: 'List songs',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "album": {
+                    "type": "string",
+                    "description": "Filter by album"
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "Max results"
+                }
+            }
+        },
+    },
+    {
+        name: 'list_playlists',
+        description: 'List playlists',
+        inputSchema: {
+            "type": "object",
+            "properties": {}
+        },
+    },
+    {
+        name: 'create_playlist',
+        description: 'Create playlist',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Playlist name"
+                },
+                "songs": {
+                    "type": "string",
+                    "description": "Song IDs"
+                }
+            },
+            "required": [
+                "name"
+            ]
+        },
+    },
+    {
+        name: 'update_playlist',
+        description: 'Update playlist',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "string",
+                    "description": "Playlist ID"
+                },
+                "name": {
+                    "type": "string",
+                    "description": "New name"
+                },
+                "songs": {
+                    "type": "string",
+                    "description": "Song IDs"
+                }
+            },
+            "required": [
+                "id"
+            ]
+        },
+    },
+    {
+        name: 'delete_playlist',
+        description: 'Delete playlist',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "string",
+                    "description": "Playlist ID"
+                }
+            },
+            "required": [
+                "id"
+            ]
+        },
+    },
+    {
+        name: 'add_to_playlist',
+        description: 'Add songs to playlist',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "playlist_id": {
+                    "type": "string",
+                    "description": "Playlist ID"
+                },
+                "songs": {
+                    "type": "string",
+                    "description": "Song IDs to add"
+                }
+            },
+            "required": [
+                "playlist_id",
+                "songs"
+            ]
+        },
+    },
+    {
+        name: 'remove_from_playlist',
+        description: 'Remove songs from playlist',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "playlist_id": {
+                    "type": "string",
+                    "description": "Playlist ID"
+                },
+                "songs": {
+                    "type": "string",
+                    "description": "Song IDs to remove"
+                }
+            },
+            "required": [
+                "playlist_id",
+                "songs"
+            ]
+        },
+    },
+    {
+        name: 'search_music',
+        description: 'Search music',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Search query"
+                },
+                "type": {
+                    "type": "string",
+                    "description": "Search type (artist/album/song)"
+                }
+            },
+            "required": [
+                "query"
+            ]
+        },
+    },
+    {
+        name: 'custom_audio_call',
+        description: 'Custom API call',
+        inputSchema: {
+            "type": "object",
+            "properties": {
+                "method": {
+                    "type": "string",
+                    "description": "HTTP method"
+                },
+                "endpoint": {
+                    "type": "string",
+                    "description": "API endpoint"
+                },
+                "body": {
+                    "type": "object",
+                    "description": "Request body"
+                }
+            },
+            "required": [
+                "method",
+                "endpoint"
+            ]
+        },
+    },
+];
+// Initialisation
+const client = new AudioStationClient({
+    url: SYNOLOGY_URL,
+    username: SYNOLOGY_USERNAME,
+    password: SYNOLOGY_PASSWORD,
+});
+const server = new Server({ name: 'synology-mcp-audiostation', version: '0.1.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case 'list_artists': return await client.listartists(args);
+            case 'list_albums': return await client.listalbums(args);
+            case 'list_songs': return await client.listsongs(args);
+            case 'list_playlists': return await client.listplaylists(args);
+            case 'create_playlist': return await client.createplaylist(args);
+            case 'update_playlist': return await client.updateplaylist(args);
+            case 'delete_playlist': return await client.deleteplaylist(args);
+            case 'add_to_playlist': return await client.addtoplaylist(args);
+            case 'remove_from_playlist': return await client.removefromplaylist(args);
+            case 'search_music': return await client.searchmusic(args);
+            case 'custom_audio_call': return await client.customaudiocall(args);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Synology Audio Station MCP server running on stdio');
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@clawbow/synology-mcp-audiostation",
+  "version": "0.1.1",
+  "description": "MCP server for Synology Audio Station - Audio Station management via Model Context Protocol",
+  "type": "module",
+  "bin": {
+    "synology-mcp-audiostation": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "synology",
+    "audiostation",
+    "dsm",
+    "model-context-protocol"
+  ],
+  "author": "Bob (@clawbow)",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}