Merge pull request #420 from DialmasterOrg/fix/405-new-channel-wont-add

Work-in-progress possible fix

Author: dialmaster

docs/CONFIG.md

@@ -406,6 +406,7 @@ The old `discordWebhookUrl` and `notificationService` fields are automatically r
 - **Default**: `""` (empty)
 - **Description**: HTTP/HTTPS proxy for downloads
 - **Format**: `"http://proxy:port"` or `"socks5://proxy:port"`
+- **Note**: The proxy is used by yt-dlp for all YouTube requests (downloads, metadata, thumbnails). Some operations like thumbnail downloads and RSS feed checks first attempt a direct HTTP request with a 15-second timeout before falling back to yt-dlp. SOCKS5 proxy users may notice brief delays (~15 seconds) during these fallbacks when adding or refreshing channels, but the operations will complete successfully via yt-dlp.
 
 ### Use External Temporary Directory
 - **Config Key**: `useTmpForDownloads`

docs/TROUBLESHOOTING.md

@@ -439,6 +439,18 @@ YouTube is blocking your downloads.
 **NOTE**: In some cases YouTube may temporarily blacklist your IP address if too many requests were happening from your IP. You may just need to wait in order to download again. You can manually test downloading a video from YouTube to rule out Youtarr-specific issues by downloading yt-dlp and attempting to manually download a single video.
 
 
+## Slow Channel Operations with Proxy
+
+### Adding or Refreshing Channels Takes ~15 Seconds
+
+**Problem**: Adding a new channel or refreshing channel metadata takes around 15 seconds longer than expected.
+
+**Cause**: Youtarr first attempts direct HTTP requests for thumbnails and RSS feeds. When you're using a SOCKS5 or HTTP proxy, these direct requests cannot reach YouTube and must wait for a 15-second timeout before falling back to yt-dlp, which correctly uses your configured proxy.
+
+**Solution**: This is expected behavior and no action is needed. The operations will complete successfully after the brief timeout. If operations are taking significantly longer than 15-20 seconds, verify your proxy is correctly configured in **Configuration > Advanced Settings**.
+
+---
+
 ## Plex Integration Issues
 
 ### Videos Not Showing in Plex

server/modules/__tests__/channelModule.test.js

@@ -1,6 +1,7 @@
 /* eslint-env jest */
 
 const { Op } = require('sequelize');
+const realHttps = require('https');
 
 jest.mock('fs');
 jest.mock('child_process');
@@ -2500,6 +2501,41 @@ describe('ChannelModule', () => {
           autoDownloadEnabledTabs: 'video,short'
         });
       });
+
+      test('should fallback to videos tab when all RSS checks fail', async () => {
+        const mockChannel = {
+          ...mockChannelData,
+          available_tabs: null, // Not yet populated
+          auto_download_enabled_tabs: null
+        };
+        Channel.findOne.mockResolvedValue(mockChannel);
+        Channel.update.mockResolvedValue([1]);
+
+        // Mock fetch to always reject (simulating network timeout/failure)
+        const originalFetch = global.fetch;
+        global.fetch = jest.fn().mockRejectedValue(new Error('Network timeout'));
+
+        try {
+          const result = await ChannelModule.detectAndSaveChannelTabs('UC123');
+
+          // Should fallback to videos tab
+          expect(result).toEqual({
+            availableTabs: ['videos'],
+            autoDownloadEnabledTabs: 'video'
+          });
+
+          // Should save the fallback to the database
+          expect(Channel.update).toHaveBeenCalledWith(
+            expect.objectContaining({
+              available_tabs: 'videos',
+              auto_download_enabled_tabs: 'video'
+            }),
+            expect.anything()
+          );
+        } finally {
+          global.fetch = originalFetch;
+        }
+      });
     });
 
     describe('buildRssFeedUrl', () => {
@@ -2534,7 +2570,7 @@ describe('ChannelModule', () => {
           expect(exists).toBe(true);
           expect(global.fetch).toHaveBeenCalledWith(
             'https://www.youtube.com/feeds/videos.xml?playlist_id=UULF123',
-            { method: 'GET' }
+            expect.objectContaining({ method: 'GET', signal: expect.any(AbortSignal) })
           );
         } finally {
           global.fetch = originalFetch;
@@ -2969,4 +3005,95 @@ describe('ChannelModule', () => {
       expect(ChannelModule.resizeChannelThumbnail).toHaveBeenCalledWith(channelId);
     });
   });
+
+  describe('downloadChannelThumbnailFromUrl', () => {
+    let fsExtra;
+    let mockWriteStream;
+    let mockRequest;
+    let mockResponse;
+    let originalGet;
+    let originalCreateWriteStream;
+
+    beforeEach(() => {
+      originalGet = realHttps.get;
+      fsExtra = require('fs-extra');
+      originalCreateWriteStream = fsExtra.createWriteStream;
+
+      mockWriteStream = {
+        on: jest.fn(),
+        close: jest.fn(),
+      };
+      fsExtra.createWriteStream = jest.fn().mockReturnValue(mockWriteStream);
+
+      mockRequest = {
+        on: jest.fn().mockReturnThis(),
+        destroy: jest.fn(),
+      };
+
+      mockResponse = {
+        statusCode: 200,
+        pipe: jest.fn(),
+        headers: {},
+      };
+    });
+
+    afterEach(() => {
+      realHttps.get = originalGet;
+      fsExtra.createWriteStream = originalCreateWriteStream;
+    });
+
+    test('should pass timeout option to protocol.get', async () => {
+      realHttps.get = jest.fn((url, opts, cb) => {
+        cb(mockResponse);
+        const finishCb = mockWriteStream.on.mock.calls.find(c => c[0] === 'finish')[1];
+        finishCb();
+        return mockRequest;
+      });
+
+      await ChannelModule.downloadChannelThumbnailFromUrl('https://example.com/thumb.jpg', 'UC123');
+
+      expect(realHttps.get).toHaveBeenCalledWith(
+        'https://example.com/thumb.jpg',
+        expect.objectContaining({ timeout: 15000 }),
+        expect.any(Function)
+      );
+    });
+
+    test('should reject and clean up partial file on timeout', async () => {
+      fsExtra.existsSync = jest.fn().mockReturnValue(true);
+      fsExtra.unlinkSync = jest.fn();
+
+      realHttps.get = jest.fn(() => {
+        return mockRequest;
+      });
+
+      const promise = ChannelModule.downloadChannelThumbnailFromUrl('https://example.com/thumb.jpg', 'UC123');
+
+      const timeoutHandler = mockRequest.on.mock.calls.find(c => c[0] === 'timeout')[1];
+      timeoutHandler();
+
+      await expect(promise).rejects.toThrow('Thumbnail download timed out');
+      expect(mockRequest.destroy).toHaveBeenCalled();
+      expect(mockWriteStream.close).toHaveBeenCalled();
+      expect(fsExtra.unlinkSync).toHaveBeenCalled();
+    });
+
+    test('should reject on network error and clean up', async () => {
+      fsExtra.existsSync = jest.fn().mockReturnValue(true);
+      fsExtra.unlinkSync = jest.fn();
+
+      realHttps.get = jest.fn(() => {
+        return mockRequest;
+      });
+
+      const promise = ChannelModule.downloadChannelThumbnailFromUrl('https://example.com/thumb.jpg', 'UC123');
+
+      const errorHandler = mockRequest.on.mock.calls.find(c => c[0] === 'error')[1];
+      errorHandler(new Error('ECONNREFUSED'));
+
+      await expect(promise).rejects.toThrow('ECONNREFUSED');
+      expect(mockWriteStream.close).toHaveBeenCalled();
+      expect(fsExtra.unlinkSync).toHaveBeenCalled();
+    });
+  });
 });

server/modules/channelModule.js

@@ -641,7 +641,7 @@ class ChannelModule {
       const protocol = thumbnailUrl.startsWith('https') ? https : http;
       const file = fs.createWriteStream(imagePath);
 
-      protocol.get(thumbnailUrl, (response) => {
+      const req = protocol.get(thumbnailUrl, { timeout: 15000 }, (response) => {
         // Handle redirects
         if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
           file.close();
@@ -663,7 +663,18 @@ class ChannelModule {
           logger.debug({ channelId, imagePath }, 'Channel thumbnail downloaded via HTTP');
           resolve();
         });
-      }).on('error', (err) => {
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        file.close();
+        if (fs.existsSync(imagePath)) {
+          fs.unlinkSync(imagePath);
+        }
+        reject(new Error('Thumbnail download timed out'));
+      });
+
+      req.on('error', (err) => {
         file.close();
         if (fs.existsSync(imagePath)) {
           fs.unlinkSync(imagePath);
@@ -1838,12 +1849,15 @@ class ChannelModule {
     const rssUrl = this.buildRssFeedUrl(channelId, tabType);
 
     try {
-      const response = await fetch(rssUrl, { method: 'GET' });
+      const response = await fetch(rssUrl, {
+        method: 'GET',
+        signal: AbortSignal.timeout(10000), // 10 second timeout
+      });
       // Any non-404 response means the tab exists
       // (YouTube returns 404 for non-existent playlist feeds)
       return response.status !== 404;
     } catch (error) {
-      // Network error - assume tab doesn't exist
+      // Network error or timeout - assume tab doesn't exist
       logger.debug({ channelId, tabType, error: error.message }, 'RSS feed check failed');
       return false;
     }
@@ -1897,10 +1911,17 @@ class ChannelModule {
         })
       );
 
-      const availableTabs = tabChecks
+      let availableTabs = tabChecks
         .filter(result => result.exists)
         .map(result => result.tabType);
 
+      // Fallback: if all RSS checks failed (e.g., network timeout), assume "videos" tab exists
+      // This prevents channels from being added with no tabs, which would make them unusable
+      if (availableTabs.length === 0) {
+        logger.warn({ channelId }, 'All RSS tab checks failed, defaulting to videos tab');
+        availableTabs = [TAB_TYPES.VIDEOS];
+      }
+
       // Determine smart default for auto_download_enabled_tabs
       let autoDownloadEnabledTabs = 'video';
       if (!availableTabs.includes(TAB_TYPES.VIDEOS) && availableTabs.length > 0) {