plex-mcp 0.0.2 → 0.0.4

package/TODO.md

@@ -0,0 +1,252 @@
+# Plex MCP Server - TODO List
+
+## Unimplemented Plex API Features
+
+### Critical Missing APIs (High Priority)
+
+#### Session Management
+- [ ] **get_active_sessions** - List current "Now Playing" sessions
+  - Endpoint: `/status/sessions`
+  - Returns: Active playback sessions with user, client, media info
+- [ ] **get_transcode_sessions** - List active transcoding operations
+  - Endpoint: `/transcode/sessions`
+  - Returns: Transcoding progress, quality settings, resource usage
+- [ ] **terminate_session** - Stop/kill active playback sessions
+  - Endpoint: `/status/sessions/terminate`
+  - Action: Force stop sessions by session ID
+
+#### Playback Control
+- [ ] **control_playback** - Control playback (play/pause/stop/seek)
+  - Endpoint: `/player/playback/{command}`
+  - Commands: play, pause, stop, stepForward, stepBack, seekTo
+- [ ] **start_playback** - Initiate playback on specific clients
+  - Endpoint: `/player/playback/playMedia`
+  - Parameters: media key, client ID, resume offset
+- [ ] **remote_control** - Advanced remote control operations
+  - Endpoint: `/player/navigation/{command}`
+  - Commands: moveUp, moveDown, select, back, home
+
+#### Client & Device Management
+- [ ] **get_clients** - List available Plex clients/players
+  - Endpoint: `/clients`
+  - Returns: Client names, IDs, capabilities, online status
+- [ ] **get_devices** - List all registered devices
+  - Endpoint: `/devices`
+  - Returns: Device info, last seen, platform details
+- [ ] **get_servers** - List available Plex servers
+  - Endpoint: `/servers`
+  - Returns: Server list for multi-server setups
+
+### Server Administration (Medium Priority)
+
+#### Server Info & Management
+- [ ] **get_server_info** - Server capabilities and status
+  - Endpoint: `/`
+  - Returns: Version, capabilities, transcoder info, platform
+- [ ] **get_server_preferences** - Server configuration settings
+  - Endpoint: `/:/prefs`
+  - Returns: All server preferences and settings
+- [ ] **scan_library** - Trigger library content scan
+  - Endpoint: `/library/sections/{id}/refresh`
+  - Action: Force library scan for new content
+- [ ] **refresh_metadata** - Force metadata refresh for items
+  - Endpoint: `/library/metadata/{id}/refresh`
+  - Action: Re-download metadata, artwork, etc.
+
+#### User Management
+- [ ] **get_users** - List server users and accounts
+  - Endpoint: `/accounts`
+  - Returns: User list, permissions, sharing status
+- [ ] **get_user_activity** - User-specific activity logs
+  - Endpoint: `/status/sessions/history/all?accountID={id}`
+  - Returns: Per-user watch history and statistics
+
+### Content Discovery & Recommendations (Medium Priority)
+
+#### Advanced Discovery
+- [ ] **get_content_hubs** - Plex's recommendation engine
+  - Endpoint: `/hubs`
+  - Returns: Curated content recommendations, trending
+- [ ] **get_discover_content** - Discover new content across libraries
+  - Endpoint: `/library/sections/all?discover=1`
+  - Returns: Cross-library content discovery
+- [ ] **get_trending** - Trending content on Plex platform
+  - Endpoint: `/hubs/trending`
+  - Returns: Popular content across Plex network
+
+#### Metadata Enhancement
+- [ ] **get_genres** - Available genres across libraries
+  - Endpoint: `/library/sections/{id}/genre`
+  - Returns: Genre list with item counts
+- [ ] **get_years** - Available years across libraries
+  - Endpoint: `/library/sections/{id}/year`
+  - Returns: Year list with item counts
+- [ ] **get_studios** - Available studios/networks
+  - Endpoint: `/library/sections/{id}/studio`
+  - Returns: Studio/network list with item counts
+- [ ] **get_directors** - Available directors/actors
+  - Endpoint: `/library/sections/{id}/director`
+  - Returns: People list with filmography counts
+
+### Media Management (Medium Priority)
+
+#### Watch Status Management
+- [ ] **mark_watched** - Mark items as watched
+  - Endpoint: `/:/scrobble?key={id}&identifier=com.plexapp.plugins.library`
+  - Action: Set watch status, update play count
+- [ ] **mark_unwatched** - Mark items as unwatched
+  - Endpoint: `/:/unscrobble?key={id}&identifier=com.plexapp.plugins.library`
+  - Action: Remove watch status, reset play count
+- [ ] **set_rating** - Rate content (stars/thumbs)
+  - Endpoint: `/:/rate?key={id}&rating={rating}&identifier=com.plexapp.plugins.library`
+  - Action: Set user rating for content
+
+#### Library Maintenance
+- [ ] **optimize_library** - Database optimization operations
+  - Endpoint: `/library/optimize`
+  - Action: Clean up database, optimize indexes
+- [ ] **empty_trash** - Empty library trash/deleted items
+  - Endpoint: `/library/sections/{id}/emptyTrash`
+  - Action: Permanently delete trashed items
+- [ ] **update_library** - Update library metadata
+  - Endpoint: `/library/sections/{id}/update`
+  - Action: Update library without full scan
+
+### Advanced Features (Low Priority)
+
+#### Transcoding Management
+- [ ] **get_transcoding_settings** - Transcoding preferences
+  - Endpoint: `/:/prefs?group=transcoder`
+  - Returns: Quality settings, codec preferences
+- [ ] **optimize_content** - Content optimization for devices
+  - Endpoint: `/library/metadata/{id}/optimize`
+  - Action: Pre-transcode content for specific devices
+
+#### Sync & Download
+- [ ] **get_sync_items** - Sync queue and downloaded items
+  - Endpoint: `/sync/items`
+  - Returns: Sync status, download queue
+- [ ] **download_media** - Download content for offline viewing
+  - Endpoint: `/sync/items`
+  - Action: Queue content for download/sync
+
+#### Webhooks & Events
+- [ ] **get_webhooks** - List configured webhooks
+  - Endpoint: `/:/webhooks`
+  - Returns: Webhook URLs and trigger events
+- [ ] **listen_events** - Real-time event streaming
+  - Endpoint: `/:/events` (WebSocket/SSE)
+  - Returns: Live server events, playback updates
+
+## Missing Test Coverage
+
+### Unit Tests
+- [ ] **Session management handlers** - Tests for new session control APIs
+- [ ] **Playback control handlers** - Tests for media control functionality
+- [ ] **Client management handlers** - Tests for device/client discovery
+- [ ] **Server admin handlers** - Tests for administrative functions
+- [ ] **User management handlers** - Tests for multi-user functionality
+- [ ] **Content discovery handlers** - Tests for recommendation features
+- [ ] **Watch status handlers** - Tests for marking watched/unwatched
+- [ ] **Library management handlers** - Tests for scan/refresh operations
+
+### Integration Tests
+- [ ] **Multi-library operations** - Cross-library search and discovery
+- [ ] **Playlist management with new content** - Advanced playlist operations
+- [ ] **User permission scenarios** - Multi-user access control
+- [ ] **Server configuration changes** - Settings modification testing
+- [ ] **Transcoding workflow** - End-to-end transcoding scenarios
+- [ ] **Sync/download workflows** - Offline content management
+
+### Mock Data Enhancement
+- [ ] **Session data mocks** - Active session responses
+- [ ] **Client data mocks** - Available client/device responses
+- [ ] **Server info mocks** - Server capabilities and status
+- [ ] **User data mocks** - Multi-user account responses
+- [ ] **Transcoding mocks** - Transcoding session responses
+- [ ] **Webhook mocks** - Event and webhook responses
+
+## E2E Tests to Add
+
+### Real Server Integration
+- [ ] **Live session monitoring** - Connect to real server, monitor active sessions
+  - Test with actual playback sessions
+  - Verify session data accuracy
+  - Test session termination
+- [ ] **Live playback control** - Control actual Plex clients
+  - Test play/pause/stop commands
+  - Test seek functionality
+  - Test client discovery and selection
+- [ ] **Live library management** - Real library operations
+  - Test library scanning
+  - Test metadata refresh
+  - Test library optimization
+- [ ] **Live user scenarios** - Multi-user testing
+  - Test shared library access
+  - Test user-specific history
+  - Test permission boundaries
+
+### Cross-Platform Testing
+- [ ] **Multiple client types** - Test with various Plex clients
+  - Desktop app, mobile app, web player
+  - Smart TV apps, streaming devices
+  - Verify control compatibility
+- [ ] **Multiple server versions** - Test against different Plex server versions
+  - Latest stable, previous versions
+  - PlexPass vs free features
+  - API compatibility testing
+
+### Network Scenarios
+- [ ] **SSL/TLS configurations** - Various security setups
+  - Self-signed certificates
+  - Valid SSL certificates
+  - Mixed HTTP/HTTPS environments
+- [ ] **Remote access testing** - Plex relay and direct connections
+  - Remote server access via Plex.tv
+  - Direct IP connections
+  - VPN/tunnel scenarios
+- [ ] **Performance testing** - Large library scenarios
+  - Libraries with 10k+ items
+  - Multiple concurrent operations
+  - Memory and CPU usage monitoring
+
+## Code Quality & Architecture
+
+### Error Handling Improvements
+- [ ] **Granular error types** - Specific error classes for different failure modes
+- [ ] **Retry mechanisms** - Automatic retry for transient failures
+- [ ] **Circuit breaker pattern** - Fail-fast for consistently failing operations
+- [ ] **Rate limiting** - Respect Plex server rate limits
+
+### Performance Optimizations
+- [ ] **Response caching** - Cache frequently accessed data
+- [ ] **Batch operations** - Combine multiple API calls when possible
+- [ ] **Streaming responses** - Handle large datasets efficiently
+- [ ] **Connection pooling** - Reuse HTTP connections
+
+### Documentation
+- [ ] **API reference docs** - Complete documentation for all tools
+- [ ] **Usage examples** - Real-world scenarios and code examples
+- [ ] **Troubleshooting guide** - Common issues and solutions
+- [ ] **Performance tuning** - Optimization recommendations
+
+### Security Enhancements
+- [ ] **Token validation** - Verify Plex token format and permissions
+- [ ] **SSL certificate validation** - Proper certificate handling
+- [ ] **Input sanitization** - Validate all user inputs
+- [ ] **Audit logging** - Log all administrative operations
+
+## Development Infrastructure
+
+### CI/CD Improvements
+- [ ] **Automated testing** - Run full test suite on every commit
+- [ ] **Code coverage tracking** - Monitor and improve test coverage
+- [ ] **Performance benchmarks** - Track performance regressions
+- [ ] **Security scanning** - Automated vulnerability detection
+
+### Development Tools
+- [ ] **Mock Plex server** - Local development server for testing
+- [ ] **Test data generator** - Generate realistic test datasets
+- [ ] **Performance profiler** - Identify bottlenecks and optimize
+- [ ] **Documentation generator** - Auto-generate API docs from code
+

package/index.js

@@ -25,6 +25,14 @@ class PlexMCPServer {
     this.setupToolHandlers();
   }
 
+  getHttpsAgent() {
+    const verifySSL = process.env.PLEX_VERIFY_SSL !== 'false';
+    return new (require('https').Agent)({
+      rejectUnauthorized: verifySSL,
+      minVersion: 'TLSv1.2'
+    });
+  }
+
   setupToolHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
@@ -380,6 +388,25 @@ class PlexMCPServer {
               required: [],
             },
           },
+          {
+            name: "browse_playlist",
+            description: "Browse and view the contents of a specific playlist with full track metadata",
+            inputSchema: {
+              type: "object",
+              properties: {
+                playlist_id: {
+                  type: "string",
+                  description: "The ID of the playlist to browse",
+                },
+                limit: {
+                  type: "number",
+                  description: "Maximum number of items to return (default: 50)",
+                  default: 50,
+                },
+              },
+              required: ["playlist_id"],
+            },
+          },
           {
             name: "create_playlist",
             description: "Create a new playlist on the Plex server. Note: Non-smart playlists require an initial item (item_key parameter) to be created successfully.",
@@ -611,6 +638,8 @@ class PlexMCPServer {
           return await this.handleOnDeck(request.params.arguments);
         case "list_playlists":
           return await this.handleListPlaylists(request.params.arguments);
+        case "browse_playlist":
+          return await this.handleBrowsePlaylist(request.params.arguments);
         case "create_playlist":
           return await this.handleCreatePlaylist(request.params.arguments);
         case "add_to_playlist":
@@ -690,10 +719,7 @@ class PlexMCPServer {
 
       const response = await axios.get(searchUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       let results = this.parseSearchResults(response.data);
@@ -786,6 +812,12 @@ class PlexMCPServer {
       contentRating: item.contentRating,
       Media: item.Media,
       key: item.key,
+      ratingKey: item.ratingKey, // Critical: the unique identifier for playlist operations
+      // Additional hierarchical info for music tracks
+      parentTitle: item.parentTitle, // Album name
+      grandparentTitle: item.grandparentTitle, // Artist name
+      parentRatingKey: item.parentRatingKey, // Album ID
+      grandparentRatingKey: item.grandparentRatingKey, // Artist ID
       // Additional metadata for basic filters
       studio: item.studio,
       genres: item.Genre ? item.Genre.map(g => g.tag) : [],
@@ -807,8 +839,24 @@ class PlexMCPServer {
         formatted += ` - ${item.type}`;
       }
       
+      // Add artist/album info for music tracks
+      if (item.grandparentTitle && item.parentTitle) {
+        formatted += `\n   Artist: ${item.grandparentTitle} | Album: ${item.parentTitle}`;
+      } else if (item.parentTitle) {
+        formatted += `\n   Album/Show: ${item.parentTitle}`;
+      }
+      
       if (item.rating) {
-        formatted += ` - Rating: ${item.rating}`;
+        formatted += `\n   Rating: ${item.rating}`;
+      }
+      
+      if (item.duration) {
+        formatted += `\n   Duration: ${this.formatDuration(item.duration)}`;
+      }
+      
+      // CRITICAL: Show the ratingKey for playlist operations
+      if (item.ratingKey) {
+        formatted += `\n   **ID: ${item.ratingKey}** (use this for playlists)`;
       }
       
       if (item.summary) {
@@ -819,6 +867,21 @@ class PlexMCPServer {
     }).join('\n\n');
   }
 
+  formatDuration(milliseconds) {
+    if (!milliseconds || milliseconds === 0) return 'Unknown';
+    
+    const seconds = Math.floor(milliseconds / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    
+    if (hours > 0) {
+      const remainingMinutes = minutes % 60;
+      return `${hours}h ${remainingMinutes}m`;
+    } else {
+      return `${minutes}m`;
+    }
+  }
+
   async handleBrowseLibraries(args) {
     try {
       const plexUrl = process.env.PLEX_URL || 'http://localhost:32400';
@@ -835,10 +898,7 @@ class PlexMCPServer {
 
       const response = await axios.get(librariesUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const libraries = this.parseLibraries(response.data);
@@ -965,10 +1025,7 @@ class PlexMCPServer {
 
       const response = await axios.get(libraryUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       let results = this.parseLibraryContent(response.data);
@@ -1090,10 +1147,7 @@ class PlexMCPServer {
 
       const response = await axios.get(recentUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const results = this.parseLibraryContent(response.data);
@@ -1191,10 +1245,7 @@ class PlexMCPServer {
 
       const response = await axios.get(historyUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const results = this.parseWatchHistory(response.data);
@@ -1314,10 +1365,7 @@ class PlexMCPServer {
 
       const response = await axios.get(onDeckUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const results = this.parseOnDeck(response.data);
@@ -1423,10 +1471,7 @@ class PlexMCPServer {
 
       const response = await axios.get(playlistsUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const playlists = this.parsePlaylists(response.data);
@@ -1456,6 +1501,120 @@ class PlexMCPServer {
     }
   }
 
+  async handleBrowsePlaylist(args) {
+    const { playlist_id, limit = 50 } = args;
+    
+    try {
+      const plexUrl = process.env.PLEX_URL || 'http://localhost:32400';
+      const plexToken = process.env.PLEX_TOKEN;
+      
+      if (!plexToken) {
+        throw new Error('PLEX_TOKEN environment variable is required');
+      }
+
+      // First get playlist info
+      const playlistUrl = `${plexUrl}/playlists/${playlist_id}`;
+      const response = await axios.get(playlistUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const playlistData = response.data.MediaContainer;
+      if (!playlistData || !playlistData.Metadata || playlistData.Metadata.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Playlist with ID ${playlist_id} not found or is empty`,
+            },
+          ],
+        };
+      }
+
+      const playlist = playlistData.Metadata[0];
+      const items = playlistData.Metadata[0].Metadata || [];
+      
+      // Limit results if specified
+      const limitedItems = limit ? items.slice(0, limit) : items;
+      
+      let resultText = `**${playlist.title}**`;
+      if (playlist.smart) {
+        resultText += ` (Smart Playlist)`;
+      }
+      resultText += `\n`;
+      if (playlist.summary) {
+        resultText += `${playlist.summary}\n`;
+      }
+      resultText += `Duration: ${this.formatDuration(playlist.duration || 0)}\n`;
+      resultText += `Items: ${items.length}`;
+      if (limit && items.length > limit) {
+        resultText += ` (showing first ${limit})`;
+      }
+      resultText += `\n\n`;
+
+      if (limitedItems.length === 0) {
+        resultText += `This playlist is empty.`;
+      } else {
+        resultText += limitedItems.map((item, index) => {
+          let itemText = `${index + 1}. **${item.title}**`;
+          
+          // Add artist/album info for music
+          if (item.grandparentTitle && item.parentTitle) {
+            itemText += `\n   Artist: ${item.grandparentTitle}\n   Album: ${item.parentTitle}`;
+          } else if (item.parentTitle) {
+            itemText += `\n   Album/Show: ${item.parentTitle}`;
+          }
+          
+          // Add duration
+          if (item.duration) {
+            itemText += `\n   Duration: ${this.formatDuration(item.duration)}`;
+          }
+          
+          // Add rating key for identification
+          itemText += `\n   ID: ${item.ratingKey}`;
+          
+          // Add media type
+          const mediaType = this.getMediaTypeFromItem(item);
+          if (mediaType) {
+            itemText += `\n   Type: ${mediaType}`;
+          }
+          
+          return itemText;
+        }).join('\n\n');
+      }
+      
+      return {
+        content: [
+          {
+            type: "text",
+            text: resultText,
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error browsing playlist: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  getMediaTypeFromItem(item) {
+    if (item.type === 'track') return 'Music Track';
+    if (item.type === 'episode') return 'TV Episode';
+    if (item.type === 'movie') return 'Movie';
+    if (item.type === 'artist') return 'Artist';
+    if (item.type === 'album') return 'Album';
+    return item.type || 'Unknown';
+  }
+
   parsePlaylists(data) {
     if (!data.MediaContainer || !data.MediaContainer.Metadata) {
       return [];
@@ -1540,10 +1699,7 @@ class PlexMCPServer {
       // First get server info to get machine identifier
       const serverResponse = await axios.get(`${plexUrl}/`, {
         headers: { 'X-Plex-Token': plexToken },
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
 
       const machineIdentifier = serverResponse.data?.MediaContainer?.machineIdentifier;
@@ -1576,20 +1732,22 @@ class PlexMCPServer {
         headers: {
           'Content-Length': '0'
         },
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       // Get the created playlist info from the response
       const playlistData = response.data?.MediaContainer?.Metadata?.[0];
       
-      let resultText = `Successfully created ${smart ? 'smart ' : ''}playlist: **${title}**`;
+      let resultText = `✅ Successfully created ${smart ? 'smart ' : ''}playlist: **${title}**`;
       if (playlistData) {
-        resultText += `\n   Playlist ID: ${playlistData.ratingKey}`;
+        resultText += `\n   **Playlist ID: ${playlistData.ratingKey}** (use this ID for future operations)`;
         resultText += `\n   Type: ${type}`;
         if (smart) resultText += `\n   Smart Playlist: Yes`;
+        if (item_key && !smart) {
+          resultText += `\n   Initial item added: ${item_key}`;
+        }
+      } else {
+        resultText += `\n   ⚠️ Playlist created but details not available - check your playlists`;
       }
       
       return {
@@ -1636,6 +1794,21 @@ You can try creating the playlist manually in Plex and then use other MCP tools
         throw new Error('PLEX_TOKEN environment variable is required');
       }
 
+      // Get playlist info before adding items
+      const playlistUrl = `${plexUrl}/playlists/${playlist_id}`;
+      const beforeResponse = await axios.get(playlistUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const beforeData = beforeResponse.data.MediaContainer;
+      const beforeCount = (beforeData.Metadata && beforeData.Metadata[0] && beforeData.Metadata[0].Metadata) 
+        ? beforeData.Metadata[0].Metadata.length : 0;
+      const playlistTitle = beforeData.Metadata && beforeData.Metadata[0] 
+        ? beforeData.Metadata[0].title : `Playlist ${playlist_id}`;
+
       const addUrl = `${plexUrl}/playlists/${playlist_id}/items`;
       const params = {
         'X-Plex-Token': plexToken,
@@ -1644,13 +1817,39 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
       const response = await axios.put(addUrl, null, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      // Verify the addition by checking the playlist again
+      const afterResponse = await axios.get(playlistUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
       });
       
-      const resultText = `Successfully added ${item_keys.length} item(s) to playlist ${playlist_id}`;
+      const afterData = afterResponse.data.MediaContainer;
+      const afterCount = (afterData.Metadata && afterData.Metadata[0] && afterData.Metadata[0].Metadata) 
+        ? afterData.Metadata[0].Metadata.length : 0;
+      
+      const actualAdded = afterCount - beforeCount;
+      const attempted = item_keys.length;
+      
+      let resultText = `Playlist "${playlistTitle}" update:\n`;
+      resultText += `• Attempted to add: ${attempted} item(s)\n`;
+      resultText += `• Actually added: ${actualAdded} item(s)\n`;
+      resultText += `• Playlist size: ${beforeCount} → ${afterCount} items\n`;
+      
+      if (actualAdded === attempted) {
+        resultText += `✅ All items added successfully!`;
+      } else if (actualAdded > 0) {
+        resultText += `⚠️ Partial success: ${attempted - actualAdded} item(s) may have been duplicates or invalid`;
+      } else {
+        resultText += `❌ No items were added. This may indicate:\n`;
+        resultText += `  - Invalid item IDs (use ratingKey from search results)\n`;
+        resultText += `  - Items already exist in playlist\n`;
+        resultText += `  - Permission issues`;
+      }
       
       return {
         content: [
@@ -1684,6 +1883,21 @@ You can try creating the playlist manually in Plex and then use other MCP tools
         throw new Error('PLEX_TOKEN environment variable is required');
       }
 
+      // Get playlist info before removing items
+      const playlistUrl = `${plexUrl}/playlists/${playlist_id}`;
+      const beforeResponse = await axios.get(playlistUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const beforeData = beforeResponse.data.MediaContainer;
+      const beforeCount = (beforeData.Metadata && beforeData.Metadata[0] && beforeData.Metadata[0].Metadata) 
+        ? beforeData.Metadata[0].Metadata.length : 0;
+      const playlistTitle = beforeData.Metadata && beforeData.Metadata[0] 
+        ? beforeData.Metadata[0].title : `Playlist ${playlist_id}`;
+
       const removeUrl = `${plexUrl}/playlists/${playlist_id}/items`;
       const params = {
         'X-Plex-Token': plexToken,
@@ -1692,13 +1906,39 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
       const response = await axios.delete(removeUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      // Verify the removal by checking the playlist again
+      const afterResponse = await axios.get(playlistUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
       });
       
-      const resultText = `Successfully removed ${item_keys.length} item(s) from playlist ${playlist_id}`;
+      const afterData = afterResponse.data.MediaContainer;
+      const afterCount = (afterData.Metadata && afterData.Metadata[0] && afterData.Metadata[0].Metadata) 
+        ? afterData.Metadata[0].Metadata.length : 0;
+      
+      const actualRemoved = beforeCount - afterCount;
+      const attempted = item_keys.length;
+      
+      let resultText = `Playlist "${playlistTitle}" update:\n`;
+      resultText += `• Attempted to remove: ${attempted} item(s)\n`;
+      resultText += `• Actually removed: ${actualRemoved} item(s)\n`;
+      resultText += `• Playlist size: ${beforeCount} → ${afterCount} items\n`;
+      
+      if (actualRemoved === attempted) {
+        resultText += `✅ All items removed successfully!`;
+      } else if (actualRemoved > 0) {
+        resultText += `⚠️ Partial success: ${attempted - actualRemoved} item(s) were not found in the playlist`;
+      } else {
+        resultText += `❌ No items were removed. This may indicate:\n`;
+        resultText += `  - Invalid item IDs\n`;
+        resultText += `  - Items not present in playlist\n`;
+        resultText += `  - Permission issues`;
+      }
       
       return {
         content: [
@@ -1739,10 +1979,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
       const response = await axios.delete(deleteUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const resultText = `Successfully deleted playlist ${playlist_id}`;
@@ -1795,10 +2032,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
           const response = await axios.get(itemUrl, { 
             params,
-            httpsAgent: new (require('https').Agent)({
-              rejectUnauthorized: false,
-              minVersion: 'TLSv1.2'
-            })
+            httpsAgent: this.getHttpsAgent()
           });
           
           const item = response.data?.MediaContainer?.Metadata?.[0];
@@ -2242,10 +2476,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
       const response = await axios.get(collectionsUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const collections = this.parseCollections(response.data);
@@ -2296,10 +2527,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
       const response = await axios.get(collectionUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const results = this.parseLibraryContent(response.data);
@@ -2399,10 +2627,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
 
       const response = await axios.get(mediaUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const item = response.data?.MediaContainer?.Metadata?.[0];
@@ -2691,10 +2916,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
       // Get library information first
       const librariesResponse = await axios.get(`${plexUrl}/library/sections`, { 
         params: { 'X-Plex-Token': plexToken },
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const libraries = this.parseLibraries(librariesResponse.data);
@@ -2783,10 +3005,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
             'X-Plex-Container-Start': offset,
             'X-Plex-Container-Size': batchSize
           },
-          httpsAgent: new (require('https').Agent)({
-            rejectUnauthorized: false,
-            minVersion: 'TLSv1.2'
-          })
+          httpsAgent: this.getHttpsAgent()
         });
 
         const content = this.parseLibraryContent(contentResponse.data);
@@ -2827,10 +3046,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
             try {
               const mediaResponse = await axios.get(`${plexUrl}${item.key}`, { 
                 params: { 'X-Plex-Token': plexToken },
-                httpsAgent: new (require('https').Agent)({
-                  rejectUnauthorized: false,
-                  minVersion: 'TLSv1.2'
-                })
+                httpsAgent: this.getHttpsAgent()
               });
               
               const detailedItem = mediaResponse.data?.MediaContainer?.Metadata?.[0];
@@ -3059,10 +3275,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
       } else {
         const librariesResponse = await axios.get(`${plexUrl}/library/sections`, { 
           params: { 'X-Plex-Token': plexToken },
-          httpsAgent: new (require('https').Agent)({
-            rejectUnauthorized: false,
-            minVersion: 'TLSv1.2'
-          })
+          httpsAgent: this.getHttpsAgent()
         });
         
         const allLibraries = this.parseLibraries(librariesResponse.data);
@@ -3165,10 +3378,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
     try {
       const historyResponse = await axios.get(`${plexUrl}/status/sessions/history/all`, { 
         params: historyParams,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
       const history = this.parseWatchHistory(historyResponse.data);
@@ -3249,10 +3459,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
                 query: trackName,
                 type: 10 // Track type
               },
-              httpsAgent: new (require('https').Agent)({
-                rejectUnauthorized: false,
-                minVersion: 'TLSv1.2'
-              })
+              httpsAgent: this.getHttpsAgent()
             });
             
             const tracks = this.parseSearchResults(searchResponse.data);
@@ -3260,10 +3467,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
               if (track.key) {
                 const trackDetailResponse = await axios.get(`${plexUrl}${track.key}`, {
                   params: { 'X-Plex-Token': plexToken },
-                  httpsAgent: new (require('https').Agent)({
-                    rejectUnauthorized: false,
-                    minVersion: 'TLSv1.2'
-                  })
+                  httpsAgent: this.getHttpsAgent()
                 });
                 
                 const trackDetail = trackDetailResponse.data?.MediaContainer?.Metadata?.[0];
@@ -3308,10 +3512,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
                 'X-Plex-Container-Size': 10,
                 sort: 'addedAt:desc' // Recently added first
               },
-              httpsAgent: new (require('https').Agent)({
-                rejectUnauthorized: false,
-                minVersion: 'TLSv1.2'
-              })
+              httpsAgent: this.getHttpsAgent()
             });
             
             const tracks = this.parseLibraryContent(genreSearchResponse.data);
@@ -3342,10 +3543,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
                 query: artist,
                 type: 8 // Artist type
               },
-              httpsAgent: new (require('https').Agent)({
-                rejectUnauthorized: false,
-                minVersion: 'TLSv1.2'
-              })
+              httpsAgent: this.getHttpsAgent()
             });
             
             const artists = this.parseSearchResults(artistSearchResponse.data);
@@ -3353,10 +3551,7 @@ You can try creating the playlist manually in Plex and then use other MCP tools
               if (foundArtist.key) {
                 const artistDetailResponse = await axios.get(`${plexUrl}${foundArtist.key}`, {
                   params: { 'X-Plex-Token': plexToken },
-                  httpsAgent: new (require('https').Agent)({
-                    rejectUnauthorized: false,
-                    minVersion: 'TLSv1.2'
-                  })
+                  httpsAgent: this.getHttpsAgent()
                 });
                 
                 const artistTracks = this.parseLibraryContent(artistDetailResponse.data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plex-mcp",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A Model Context Protocol (MCP) server that enables Claude to query and manage Plex media libraries.",
   "main": "index.js",
   "bin": {
@@ -8,9 +8,11 @@
   },
   "scripts": {
     "start": "node index.js",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
+    "test": "jest --testPathIgnorePatterns=/tests/e2e/",
+    "test:e2e": "jest --testPathPattern=e2e",
+    "test:all": "jest",
+    "test:watch": "jest --watch --testPathIgnorePatterns=/tests/e2e/",
+    "test:coverage": "jest --coverage --testPathIgnorePatterns=/tests/e2e/",
     "prepublishOnly": "npm test",
     "version:patch": "npm version patch",
     "version:minor": "npm version minor",