plex-mcp 0.0.2 → 0.1.0

package/README.md

@@ -32,9 +32,9 @@ A Model Context Protocol (MCP) server for searching Plex media libraries using C
 
 ## Claude Desktop Configuration
 
-### Option 1: Using npx (Recommended)
+### Option 1: Production (Using npx - Recommended)
 
-Add this configuration to your Claude Desktop settings:
+Add this configuration to your Claude Desktop settings for the stable published version:
 
 ```json
 {
@@ -51,14 +51,14 @@ Add this configuration to your Claude Desktop settings:
 }
 ```
 
-### Option 2: Local development
+### Option 2: Development (Local)
 
-For local development, add this configuration:
+For development with your local code changes, add this configuration:
 
 ```json
 {
   "mcpServers": {
-    "plex": {
+    "plex-dev": {
       "command": "node",
       "args": ["/path/to/your/plex-mcp/index.js"],
       "env": {
@@ -72,6 +72,33 @@ For local development, add this configuration:
 
 Replace `/path/to/your/plex-mcp/` with the actual path to this project directory.
 
+### Running Both Versions
+
+You can configure both versions simultaneously by using different server names (`plex` and `plex-dev`):
+
+```json
+{
+  "mcpServers": {
+    "plex": {
+      "command": "npx",
+      "args": ["plex-mcp"],
+      "env": {
+        "PLEX_URL": "http://your-plex-server:32400",
+        "PLEX_TOKEN": "your_plex_token"
+      }
+    },
+    "plex-dev": {
+      "command": "node",
+      "args": ["/path/to/your/plex-mcp/index.js"],
+      "env": {
+        "PLEX_URL": "http://your-plex-server:32400",
+        "PLEX_TOKEN": "your_plex_token"
+      }
+    }
+  }
+}
+```
+
 **Configuration Steps:**
 1. Open Claude Desktop settings (Cmd/Ctrl + ,)
 2. Navigate to the "MCP Servers" tab

package/TODO.md

@@ -0,0 +1,272 @@
+# Plex MCP Server - TODO List
+
+## Recent Completions
+
+### ✅ Completed Items
+- **Plex Item ID Investigation** - Identified correct field usage for playlist operations
+  - Confirmed `ratingKey` is the primary identifier for all playlist operations
+  - Documented ID field relationships (`ratingKey`, `key`, `machineIdentifier`)
+  - Found URI format conversion pattern for server operations
+- **Playlist Operation Parameter Analysis** - Verified correct API parameter formats
+  - Confirmed `item_keys` array expects `ratingKey` values from search results
+  - Documented URI conversion: `ratingKey` → `server://localhost/com.plexapp.plugins.library/library/metadata/{key}`
+- **Live Playlist Test Implementation** - Created comprehensive E2E test sequence
+  - Added playlist creation test with dynamic item search
+  - Added playlist item addition test with multiple items
+  - Added playlist browsing verification test
+  - Tests extract `ratingKey` from search results using `**ID: (\d+)**` pattern
+- **Browse Playlist Bug Fix** - Fixed empty results issue in `handleBrowsePlaylist`
+  - Added missing pagination parameters (`X-Plex-Container-Start`, `X-Plex-Container-Size`)
+  - Added fallback to `/playlists/{id}/items` endpoint when main endpoint returns empty
+  - Added `leafCount` check to detect playlists that should have items
+
+## 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.",
@@ -429,6 +456,10 @@ class PlexMCPServer {
               required: ["playlist_id", "item_keys"],
             },
           },
+          // DISABLED: remove_from_playlist - PROBLEMATIC due to Plex API limitations
+          // This operation removes ALL instances of matching items, not just one
+          // Uncomment only after implementing safer removal patterns
+          /*
           {
             name: "remove_from_playlist",
             description: "Remove items from an existing playlist",
@@ -450,6 +481,7 @@ class PlexMCPServer {
               required: ["playlist_id", "item_keys"],
             },
           },
+          */
           {
             name: "delete_playlist",
             description: "Delete an existing playlist",
@@ -611,12 +643,15 @@ 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":
           return await this.handleAddToPlaylist(request.params.arguments);
-        case "remove_from_playlist":
-          return await this.handleRemoveFromPlaylist(request.params.arguments);
+        // DISABLED: remove_from_playlist - PROBLEMATIC operation
+        // case "remove_from_playlist":
+        //   return await this.handleRemoveFromPlaylist(request.params.arguments);
         case "delete_playlist":
           return await this.handleDeletePlaylist(request.params.arguments);
         case "get_watched_status":
@@ -690,10 +725,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 +818,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 +845,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 +873,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 +904,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 +1031,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 +1153,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 +1251,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 +1371,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 +1477,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 +1507,154 @@ 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,
+          'X-Plex-Container-Start': 0,
+          'X-Plex-Container-Size': limit || 50
+        },
+        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`,
+            },
+          ],
+        };
+      }
+
+      const playlist = playlistData.Metadata[0];
+      
+      // Try to get items from the current response first
+      let items = playlistData.Metadata[0].Metadata || [];
+      
+      // If no items found, try the /items endpoint specifically
+      if (items.length === 0 && playlist.leafCount && playlist.leafCount > 0) {
+        try {
+          const itemsUrl = `${plexUrl}/playlists/${playlist_id}/items`;
+          const itemsResponse = await axios.get(itemsUrl, { 
+            params: {
+              'X-Plex-Token': plexToken,
+              'X-Plex-Container-Start': 0,
+              'X-Plex-Container-Size': limit || 50
+            },
+            httpsAgent: this.getHttpsAgent()
+          });
+          
+          const itemsData = itemsResponse.data.MediaContainer;
+          if (itemsData && itemsData.Metadata) {
+            items = itemsData.Metadata;
+          }
+        } catch (itemsError) {
+          console.error(`Failed to fetch playlist items via /items endpoint: ${itemsError.message}`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error retrieving playlist items: ${itemsError.message}`,
+              },
+            ],
+          };
+        }
+      }
+      
+      // 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 appears to be empty or items could not be retrieved.`;
+      } 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 +1739,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 +1772,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 {
@@ -1628,6 +1826,17 @@ You can try creating the playlist manually in Plex and then use other MCP tools
   async handleAddToPlaylist(args) {
     const { playlist_id, item_keys } = args;
     
+    // Input validation
+    if (!playlist_id || typeof playlist_id !== 'string') {
+      throw new Error('Valid playlist_id is required');
+    }
+    if (!item_keys || !Array.isArray(item_keys) || item_keys.length === 0) {
+      throw new Error('item_keys must be a non-empty array');
+    }
+    if (item_keys.some(key => !key || typeof key !== 'string')) {
+      throw new Error('All item_keys must be non-empty strings');
+    }
+    
     try {
       const plexUrl = process.env.PLEX_URL || 'http://localhost:32400';
       const plexToken = process.env.PLEX_TOKEN;
@@ -1636,21 +1845,103 @@ 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 playlistInfoUrl = `${plexUrl}/playlists/${playlist_id}`;
+      const playlistItemsUrl = `${plexUrl}/playlists/${playlist_id}/items`;
+      
+      // Get playlist metadata (title, etc.)
+      const playlistInfoResponse = await axios.get(playlistInfoUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const playlistInfo = playlistInfoResponse.data.MediaContainer;
+      const playlistTitle = playlistInfo.Metadata && playlistInfo.Metadata[0] 
+        ? playlistInfo.Metadata[0].title : `Playlist ${playlist_id}`;
+      
+      // Get current playlist items count
+      let beforeCount = 0;
+      try {
+        const beforeResponse = await axios.get(playlistItemsUrl, { 
+          params: {
+            'X-Plex-Token': plexToken
+          },
+          httpsAgent: this.getHttpsAgent()
+        });
+        beforeCount = beforeResponse.data.MediaContainer?.totalSize || 0;
+      } catch (error) {
+        // If items endpoint fails, playlist might be empty
+        beforeCount = 0;
+      }
+
+      // Get server machine identifier for proper URI format
+      const serverResponse = await axios.get(`${plexUrl}/`, {
+        headers: { 'X-Plex-Token': plexToken },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const machineIdentifier = serverResponse.data?.MediaContainer?.machineIdentifier;
+      if (!machineIdentifier) {
+        throw new Error('Could not get server machine identifier');
+      }
+
       const addUrl = `${plexUrl}/playlists/${playlist_id}/items`;
       const params = {
         'X-Plex-Token': plexToken,
-        uri: item_keys.map(key => `server://localhost/com.plexapp.plugins.library/library/metadata/${key}`).join(',')
+        uri: item_keys.map(key => `server://${machineIdentifier}/com.plexapp.plugins.library/library/metadata/${key}`).join(',')
       };
 
       const response = await axios.put(addUrl, null, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
-      const resultText = `Successfully added ${item_keys.length} item(s) to playlist ${playlist_id}`;
+      // Check if the PUT request was successful based on HTTP status
+      const putSuccessful = response.status >= 200 && response.status < 300;
+      
+      // Small delay to allow Plex server to update
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      // Verify the addition by checking the playlist items again
+      let afterCount = 0;
+      try {
+        const afterResponse = await axios.get(playlistItemsUrl, { 
+          params: {
+            'X-Plex-Token': plexToken
+          },
+          httpsAgent: this.getHttpsAgent()
+        });
+        afterCount = afterResponse.data.MediaContainer?.totalSize || 0;
+      } catch (error) {
+        // If items endpoint fails, playlist might be empty
+        afterCount = 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 HTTP request was successful but count didn't change, 
+      // it's likely the items already exist or are duplicates
+      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 if (putSuccessful) {
+        resultText += `✅ API request successful! Items may already exist in playlist or were duplicates.\n`;
+        resultText += `ℹ️ This is normal behavior - Plex doesn't add duplicate items.`;
+      } 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: [
@@ -1661,11 +1952,27 @@ You can try creating the playlist manually in Plex and then use other MCP tools
         ],
       };
     } catch (error) {
+      // Enhanced error handling with specific error types
+      let errorMessage = `Error adding items to playlist: ${error.message}`;
+      
+      if (error.response) {
+        const status = error.response.status;
+        if (status === 404) {
+          errorMessage = `Playlist with ID ${playlist_id} not found`;
+        } else if (status === 401 || status === 403) {
+          errorMessage = `Permission denied: Check your Plex token and server access`;
+        } else if (status >= 500) {
+          errorMessage = `Plex server error (${status}): ${error.message}`;
+        }
+      } else if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+        errorMessage = `Cannot connect to Plex server: Check PLEX_URL configuration`;
+      }
+      
       return {
         content: [
           {
             type: "text",
-            text: `Error adding items to playlist: ${error.message}`,
+            text: errorMessage,
           },
         ],
         isError: true,
@@ -1673,9 +1980,24 @@ You can try creating the playlist manually in Plex and then use other MCP tools
     }
   }
 
+  // DISABLED METHOD - PROBLEMATIC OPERATION
+  // This method is currently disabled due to destructive Plex API behavior
+  // It removes ALL instances of matching items, not just one instance
+  // Use with extreme caution - consider implementing safer alternatives
   async handleRemoveFromPlaylist(args) {
     const { playlist_id, item_keys } = args;
     
+    // Input validation
+    if (!playlist_id || typeof playlist_id !== 'string') {
+      throw new Error('Valid playlist_id is required');
+    }
+    if (!item_keys || !Array.isArray(item_keys) || item_keys.length === 0) {
+      throw new Error('item_keys must be a non-empty array');
+    }
+    if (item_keys.some(key => !key || typeof key !== 'string')) {
+      throw new Error('All item_keys must be non-empty strings');
+    }
+    
     try {
       const plexUrl = process.env.PLEX_URL || 'http://localhost:32400';
       const plexToken = process.env.PLEX_TOKEN;
@@ -1684,21 +2006,141 @@ 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 playlistInfoUrl = `${plexUrl}/playlists/${playlist_id}`;
+      const playlistItemsUrl = `${plexUrl}/playlists/${playlist_id}/items`;
+      
+      // Get playlist metadata (title, etc.)
+      const playlistInfoResponse = await axios.get(playlistInfoUrl, { 
+        params: {
+          'X-Plex-Token': plexToken
+        },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const playlistInfo = playlistInfoResponse.data.MediaContainer;
+      const playlistTitle = playlistInfo.Metadata && playlistInfo.Metadata[0] 
+        ? playlistInfo.Metadata[0].title : `Playlist ${playlist_id}`;
+      
+      // Get current playlist items with their detailed information
+      let beforeCount = 0;
+      let playlistItems = [];
+      try {
+        const beforeResponse = await axios.get(playlistItemsUrl, { 
+          params: {
+            'X-Plex-Token': plexToken
+          },
+          httpsAgent: this.getHttpsAgent()
+        });
+        beforeCount = beforeResponse.data.MediaContainer?.totalSize || 0;
+        playlistItems = beforeResponse.data.MediaContainer?.Metadata || [];
+      } catch (error) {
+        // If items endpoint fails, playlist might be empty
+        beforeCount = 0;
+        playlistItems = [];
+      }
+
+      // Get server machine identifier for proper URI format
+      const serverResponse = await axios.get(`${plexUrl}/`, {
+        headers: { 'X-Plex-Token': plexToken },
+        httpsAgent: this.getHttpsAgent()
+      });
+      
+      const machineIdentifier = serverResponse.data?.MediaContainer?.machineIdentifier;
+      if (!machineIdentifier) {
+        throw new Error('Could not get server machine identifier');
+      }
+
+      // Find items to remove by matching ratingKeys to actual playlist positions
+      const itemsToRemove = [];
+      const itemKeysSet = new Set(item_keys);
+      
+      playlistItems.forEach((item, index) => {
+        if (itemKeysSet.has(item.ratingKey)) {
+          itemsToRemove.push({
+            ratingKey: item.ratingKey,
+            position: index,
+            title: item.title || 'Unknown'
+          });
+        }
+      });
+      
+      if (itemsToRemove.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No matching items found in playlist "${playlistTitle}".\\nSpecified items may not exist in this playlist.`,
+            },
+          ],
+        };
+      }
+      
+      // WARNING: Current Plex API behavior - this removes ALL instances of matching items
+      // This is a limitation of the Plex API - there's no way to remove just specific instances
       const removeUrl = `${plexUrl}/playlists/${playlist_id}/items`;
       const params = {
         'X-Plex-Token': plexToken,
-        uri: item_keys.map(key => `server://localhost/com.plexapp.plugins.library/library/metadata/${key}`).join(',')
+        uri: itemsToRemove.map(item => `server://${machineIdentifier}/com.plexapp.plugins.library/library/metadata/${item.ratingKey}`).join(',')
       };
 
       const response = await axios.delete(removeUrl, { 
         params,
-        httpsAgent: new (require('https').Agent)({
-          rejectUnauthorized: false,
-          minVersion: 'TLSv1.2'
-        })
+        httpsAgent: this.getHttpsAgent()
       });
       
-      const resultText = `Successfully removed ${item_keys.length} item(s) from playlist ${playlist_id}`;
+      // Check if the DELETE request was successful based on HTTP status
+      const deleteSuccessful = response.status >= 200 && response.status < 300;
+      
+      // Small delay to allow Plex server to update
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      // Verify the removal by checking the playlist items again
+      let afterCount = 0;
+      try {
+        const afterResponse = await axios.get(playlistItemsUrl, { 
+          params: {
+            'X-Plex-Token': plexToken
+          },
+          httpsAgent: this.getHttpsAgent()
+        });
+        afterCount = afterResponse.data.MediaContainer?.totalSize || 0;
+      } catch (error) {
+        // If items endpoint fails, playlist might be empty
+        afterCount = 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 += `• Found in playlist: ${itemsToRemove.length} item(s)\n`;
+      resultText += `• Actually removed: ${actualRemoved} item(s)\n`;
+      resultText += `• Playlist size: ${beforeCount} → ${afterCount} items\n\n`;
+      
+      // Add warning about Plex behavior
+      if (itemsToRemove.length > 0) {
+        resultText += `⚠️ **Important**: Plex removes ALL instances of matching items from playlists.\n`;
+        resultText += `If you had duplicate tracks, all copies were removed.\n\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 if (deleteSuccessful && itemsToRemove.length > 0) {
+        resultText += `✅ API request successful! Items were processed.\n`;
+        resultText += `ℹ️ If count didn't change, items may have already been removed previously.`;
+      } else if (deleteSuccessful) {
+        resultText += `✅ API request successful! Items may not have been in the playlist.\n`;
+        resultText += `ℹ️ This is normal behavior - Plex ignores requests to remove non-existent items.`;
+      } 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: [
@@ -1709,11 +2151,27 @@ You can try creating the playlist manually in Plex and then use other MCP tools
         ],
       };
     } catch (error) {
+      // Enhanced error handling with specific error types
+      let errorMessage = `Error removing items from playlist: ${error.message}`;
+      
+      if (error.response) {
+        const status = error.response.status;
+        if (status === 404) {
+          errorMessage = `Playlist with ID ${playlist_id} not found`;
+        } else if (status === 401 || status === 403) {
+          errorMessage = `Permission denied: Check your Plex token and server access`;
+        } else if (status >= 500) {
+          errorMessage = `Plex server error (${status}): ${error.message}`;
+        }
+      } else if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+        errorMessage = `Cannot connect to Plex server: Check PLEX_URL configuration`;
+      }
+      
       return {
         content: [
           {
             type: "text",
-            text: `Error removing items from playlist: ${error.message}`,
+            text: errorMessage,
           },
         ],
         isError: true,
@@ -1739,10 +2197,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 +2250,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 +2694,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 +2745,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 +2845,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 +3134,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 +3223,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 +3264,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 +3493,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 +3596,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 +3677,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 +3685,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 +3730,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 +3761,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 +3769,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.1.0",
   "description": "A Model Context Protocol (MCP) server that enables Claude to query and manage Plex media libraries.",
   "main": "index.js",
   "bin": {
@@ -8,9 +8,12 @@
   },
   "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:e2e:analysis": "jest --testPathPattern=e2e --testNamePattern=\"(Playlist Behavior Analysis|Critical Remove Bug Investigation|Multiple Item Addition Analysis)\"",
+    "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",