channel-worker 1.5.1 → 1.6.0

package/lib/api-client.js

@@ -65,7 +65,7 @@ class ApiClient {
 
   // Commands
   async getNextCommand(workerId) {
-    const workerTypes = 'launch_profile,close_profile,save_file,set_thumbnail,set_tags,set_file_input,click_and_upload,type_text,verify_logins,update_extension,sync_youtube_stats';
+    const workerTypes = 'launch_profile,close_profile,save_file,set_thumbnail,set_tags,set_file_input,click_and_upload,type_text,verify_logins,update_extension,sync_youtube_stats,restart_worker';
     return this.request('GET', `/workers/commands?worker_id=${workerId}&types=${encodeURIComponent(workerTypes)}`);
   }
 

package/lib/command-poller.js

@@ -72,6 +72,9 @@ class CommandPoller {
         case 'sync_youtube_stats':
           await this.handleSyncYoutubeStats(command);
           break;
+        case 'restart_worker':
+          await this.handleRestartWorker(command);
+          break;
         default:
           // Other commands (scan_facebook_pages, etc.) handled by extension
           console.log(`[commands] Skipping ${command.type} — handled by extension`);
@@ -861,6 +864,40 @@ class CommandPoller {
     await this.api.updateCommand(command._id, { status: 'done' });
   }
 
+  async handleRestartWorker(command) {
+    console.log('[commands] Restart worker requested — spawning new process and exiting...');
+    try {
+      await this.api.updateCommand(command._id, {
+        status: 'done',
+        result: { message: 'Worker restarting', restarted_at: new Date().toISOString() },
+      });
+    } catch {}
+
+    // Spawn a new daemon process, then exit current one
+    const { spawn } = require('child_process');
+    const path = require('path');
+    const fs = require('fs');
+    const os = require('os');
+    const cliPath = path.resolve(__dirname, '../bin/cli.js');
+    const configDir = path.join(os.homedir(), '.channel-worker');
+    const logFile = path.join(configDir, 'daemon.log');
+    const logFd = fs.openSync(logFile, 'a');
+
+    const child = spawn(process.execPath, [cliPath, 'start', '--_daemon'], {
+      detached: true,
+      stdio: ['ignore', logFd, logFd],
+      cwd: os.homedir(),
+    });
+    child.unref();
+
+    // Update PID file
+    const pidFile = path.join(configDir, 'daemon.pid');
+    fs.writeFileSync(pidFile, String(child.pid));
+    console.log(`[commands] New daemon spawned (PID: ${child.pid}), exiting current process...`);
+
+    process.exit(0);
+  }
+
   async handleSyncYoutubeStats(command) {
     const { channel_id } = command.payload || {};
     console.log(`[commands] Syncing YouTube stats for channel: ${channel_id}`);

package/lib/daemon.js

@@ -13,6 +13,7 @@ class Daemon {
     this.poller = new JobPoller(this.api, config);
     this.commandPoller = new CommandPoller(this.api, config);
     this.updateChecker = new UpdateChecker(5 * 60 * 1000); // check every 5min
+    this.extCheckTimer = null;
   }
 
   async start() {
@@ -71,6 +72,22 @@ class Daemon {
     // Start auto-update checker
     this.updateChecker.start();
     console.log('[daemon] Auto-update checker started (every 5min)');
+
+    // Start extension auto-update checker (every 5min)
+    if (this.config.extension_path) {
+      this.extCheckTimer = setInterval(async () => {
+        try {
+          const result = await checkAndUpdateExtension(this.api, this.config.extension_path);
+          if (result.updated) {
+            console.log(`[daemon] Extension auto-updated: ${result.from || 'none'} → ${result.to}`);
+          }
+        } catch (err) {
+          // silent — don't spam logs on failure
+        }
+      }, 5 * 60 * 1000);
+      console.log('[daemon] Extension auto-update checker started (every 5min)');
+    }
+
     console.log('[daemon] Waiting for jobs & commands...\n');
 
     // Graceful shutdown
@@ -80,6 +97,7 @@ class Daemon {
       this.poller.stop();
       this.commandPoller.stop();
       this.updateChecker.stop();
+      if (this.extCheckTimer) clearInterval(this.extCheckTimer);
 
       // Mark offline
       try {

package/lib/stats-syncer.js

@@ -82,10 +82,9 @@ class StatsSyncer {
 
       ws.on('open', async () => {
         try {
-          // Get a page target
           const targets = await send('Target.getTargets');
           const pages = targets.targetInfos.filter(t => t.type === 'page');
-          let targetId = pages.length > 0 ? pages[0].targetId : (await send('Target.createTarget', { url: 'about:blank' })).targetId;
+          const targetId = pages.length > 0 ? pages[0].targetId : (await send('Target.createTarget', { url: 'about:blank' })).targetId;
 
           const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true });
           const s = (method, params = {}) => send(method, params, sessionId);
@@ -93,286 +92,221 @@ class StatsSyncer {
           await s('Page.enable');
           await s('Runtime.enable');
 
-          // Step 1: Go to YouTube Studio — it auto-redirects to the correct channel
+          let stats = { subscribers: 0, total_views: 0, video_count: 0 };
+
+          // Step 1: Go to YouTube Studio → auto-redirects to correct channel
           console.log('[stats] Navigating to YouTube Studio...');
           await s('Page.navigate', { url: 'https://studio.youtube.com' });
           await this.waitForLoad(s);
-          await this.sleep(6000); // SPA needs time to render
+          await this.sleep(5000);
 
-          // Log current URL for debugging
+          // Get channel ID from URL
           const urlResult = await s('Runtime.evaluate', { expression: 'window.location.href', returnByValue: true });
-          console.log(`[stats] Current URL: ${urlResult?.result?.value}`);
-
-          // Step 2: Try to extract stats
-          let stats = { subscribers: 0, total_views: 0, video_count: 0 };
-
-          // Method A: Dump all visible text and parse (most reliable for YouTube Studio)
-          const dumpResult = await s('Runtime.evaluate', {
-            expression: `
-              (function() {
-                const result = { subscribers: 0, total_views: 0, video_count: 0, debug: '' };
-                const text = document.body?.innerText || '';
-                result.debug = text.substring(0, 500);
-
-                // YouTube Studio shows "X subscribers" in the dashboard
-                // Format varies: "123 subscribers", "1.2K subscribers", "0 subscribers"
-                const subPatterns = [
-                  /Current subscribers\\n([\\d,\\.]+[KMB]?)/i,
-                  /([\\d,\\.]+[KMB]?)\\s*subscriber/i,
-                  /Subscribers?\\n([\\d,\\.]+[KMB]?)/i,
-                ];
-                for (const p of subPatterns) {
-                  const m = text.match(p);
-                  if (m) { result.subscribers = parseNum(m[1]); break; }
-                }
+          const studioUrl = urlResult?.result?.value || '';
+          console.log(`[stats] Studio URL: ${studioUrl}`);
 
-                // Views pattern
-                const viewPatterns = [
-                  /([\\d,\\.]+[KMB]?)\\s*views?\\b/i,
-                  /Views?\\n([\\d,\\.]+[KMB]?)/i,
-                ];
-                for (const p of viewPatterns) {
-                  const m = text.match(p);
-                  if (m) { result.total_views = parseNum(m[1]); break; }
-                }
+          const channelIdMatch = studioUrl.match(/channel\/(UC[\w-]+)/);
+          const channelId = channelIdMatch ? channelIdMatch[1] : null;
 
-                function parseNum(str) {
-                  if (!str) return 0;
-                  str = str.replace(/,/g, '').trim();
-                  const m = str.match(/([\\d\\.]+)\\s*([KMB])/i);
-                  if (m) {
-                    const n = parseFloat(m[1]);
-                    const s = m[2].toUpperCase();
-                    if (s === 'K') return Math.round(n * 1000);
-                    if (s === 'M') return Math.round(n * 1000000);
-                    if (s === 'B') return Math.round(n * 1000000000);
-                  }
-                  return parseInt(str, 10) || 0;
-                }
+          if (!channelId) {
+            // Try ytcfg
+            const cfgResult = await s('Runtime.evaluate', {
+              expression: '(window.ytcfg && window.ytcfg.get) ? window.ytcfg.get("CHANNEL_ID") : ""',
+              returnByValue: true,
+            });
+            console.log(`[stats] ytcfg CHANNEL_ID: ${cfgResult?.result?.value}`);
+          }
 
-                return JSON.stringify(result);
-              })()
-            `,
+          const cid = channelId || (await s('Runtime.evaluate', {
+            expression: '(window.ytcfg && window.ytcfg.get) ? window.ytcfg.get("CHANNEL_ID") : ""',
             returnByValue: true,
-          });
-
-          try {
-            const parsed = JSON.parse(dumpResult?.result?.value || '{}');
-            console.log(`[stats] Studio text dump (first 200): ${(parsed.debug || '').substring(0, 200)}`);
-            if (parsed.subscribers) stats.subscribers = parsed.subscribers;
-            if (parsed.total_views) stats.total_views = parsed.total_views;
-          } catch {}
-
-          // Method B: Use YouTube's internal youtubei API (works from studio.youtube.com origin)
-          console.log('[stats] Trying YouTube internal API...');
-          const apiResult = await s('Runtime.evaluate', {
-            expression: `
-              (async function() {
-                try {
-                  // Get SAPISIDHASH for auth (YouTube uses this for internal API calls)
-                  function getSapisidHash(origin) {
-                    const cookies = document.cookie.split(';').reduce((acc, c) => {
-                      const [k, v] = c.trim().split('=');
-                      acc[k] = v;
-                      return acc;
-                    }, {});
-                    const sapisid = cookies['SAPISID'] || cookies['__Secure-3PAPISID'];
-                    if (!sapisid) return null;
-                    const timestamp = Math.floor(Date.now() / 1000);
-                    // Can't compute SHA1 in plain JS easily, but we can use the session cookies directly
-                    return null;
-                  }
+          }))?.result?.value;
+
+          // Step 2: Navigate to Studio Analytics page (English URL works regardless of UI language)
+          if (cid) {
+            const analyticsUrl = `https://studio.youtube.com/channel/${cid}/analytics/tab-overview/period-default`;
+            console.log(`[stats] Navigating to analytics: ${analyticsUrl}`);
+            await s('Page.navigate', { url: analyticsUrl });
+            await this.waitForLoad(s);
+            await this.sleep(6000);
+
+            // Scrape analytics page — look for numbers regardless of language
+            const analyticsResult = await s('Runtime.evaluate', {
+              expression: `
+                (function() {
+                  var result = { subscribers: 0, total_views: 0, video_count: 0, debug_text: '' };
+                  var text = document.body ? document.body.innerText : '';
+                  result.debug_text = text.substring(0, 800);
+
+                  // YouTube Studio Analytics shows metric cards with labels and numbers
+                  // The layout is: Label (in any language) followed by a number
+                  // We look for large numbers near subscriber/view keywords in ANY language
+
+                  // Strategy: find all metric-like elements by looking for number patterns
+                  // Studio analytics typically shows: Views, Watch time, Subscribers
+                  // in cards with the number prominently displayed
+
+                  // Try to find subscriber-related numbers
+                  // Multi-language patterns: subscribers, người đăng ký, abonnés, Abonnenten, etc.
+                  var subKeywords = /subscri|đăng ký|abonn|подписч|구독/i;
+                  var viewKeywords = /views?|lượt xem|vues?|aufrufe|просмотр|조회/i;
+
+                  var lines = text.split('\\n').map(function(l) { return l.trim(); }).filter(function(l) { return l.length > 0; });
+
+                  for (var i = 0; i < lines.length; i++) {
+                    var line = lines[i];
+                    var nextLine = lines[i + 1] || '';
+                    var prevLine = lines[i - 1] || '';
+
+                    // Check if this line or adjacent lines contain keywords
+                    if (subKeywords.test(line) || subKeywords.test(prevLine)) {
+                      // Look for a number in this line or nearby
+                      var numInLine = extractNumber(line);
+                      var numInNext = extractNumber(nextLine);
+                      if (numInLine > 0 && result.subscribers === 0) result.subscribers = numInLine;
+                      else if (numInNext > 0 && result.subscribers === 0) result.subscribers = numInNext;
+                    }
 
-                  // Method 1: Use the ytcfg data that Studio loads
-                  if (window.ytcfg && window.ytcfg.get) {
-                    const channelId = window.ytcfg.get('CHANNEL_ID');
-                    if (channelId) {
-                      // Try fetching channel data from YouTube Data API v3 (internal, no key needed from same origin)
-                      const r = await fetch('https://www.youtube.com/youtubei/v1/browse?prettyPrint=false', {
-                        method: 'POST',
-                        headers: {
-                          'Content-Type': 'application/json',
-                          'X-Origin': 'https://www.youtube.com',
-                        },
-                        credentials: 'include',
-                        body: JSON.stringify({
-                          browseId: channelId,
-                          context: {
-                            client: {
-                              clientName: 'WEB',
-                              clientVersion: '2.20240101.00.00',
-                            },
-                          },
-                        }),
-                      });
-                      if (r.ok) {
-                        const d = await r.json();
-                        // Extract from header
-                        const header = d?.header?.c4TabbedHeaderRenderer || {};
-                        const subText = header?.subscriberCountText?.simpleText || '';
-                        const meta = d?.metadata?.channelMetadataRenderer || {};
-
-                        return JSON.stringify({
-                          source: 'youtubei_browse',
-                          channelId,
-                          subscribers_text: subText,
-                        });
-                      }
+                    if (viewKeywords.test(line) || viewKeywords.test(prevLine)) {
+                      var numInLine2 = extractNumber(line);
+                      var numInNext2 = extractNumber(nextLine);
+                      if (numInLine2 > 0 && result.total_views === 0) result.total_views = numInLine2;
+                      else if (numInNext2 > 0 && result.total_views === 0) result.total_views = numInNext2;
                     }
                   }
 
-                  // Method 2: Parse ytcfg directly for channel info
-                  if (window.ytcfg && window.ytcfg.data_) {
-                    return JSON.stringify({
-                      source: 'ytcfg',
-                      keys: Object.keys(window.ytcfg.data_).filter(k =>
-                        k.toLowerCase().includes('channel') || k.toLowerCase().includes('subscriber')
-                      ),
-                    });
+                  // Also try: Current subscribers count shown in Studio sidebar
+                  // Pattern: "Current subscribers\\n123" or "Người đăng ký hiện tại\\n123"
+                  var currentSubMatch = text.match(/(?:current subscribers|người đăng ký hiện tại|subscriber|đăng ký)[\\s\\n]*([\\d,\\.]+[KMB]?)/i);
+                  if (currentSubMatch && result.subscribers === 0) {
+                    result.subscribers = parseHumanNum(currentSubMatch[1]);
                   }
 
-                  return JSON.stringify({ source: 'none' });
-                } catch (e) {
-                  return JSON.stringify({ error: e.message });
-                }
-              })()
-            `,
-            awaitPromise: true,
-            returnByValue: true,
-          });
-
-          try {
-            const apiData = JSON.parse(apiResult?.result?.value || '{}');
-            console.log(`[stats] Internal API result: ${JSON.stringify(apiData).substring(0, 300)}`);
-          } catch {}
-
-          // Method C: Navigate to channel page to get video count via ytInitialData
-          if (stats.video_count === 0) {
-            console.log('[stats] Getting video count from channel page...');
+                  function extractNumber(str) {
+                    if (!str) return 0;
+                    // Match standalone numbers like "1,234" or "5.2K" or "123"
+                    var m = str.match(/^([\\d,\\.]+[KMB]?)$/i) || str.match(/\\b([\\d,\\.]+[KMB]?)\\b/);
+                    if (m) return parseHumanNum(m[1]);
+                    return 0;
+                  }
 
-            // Get the channel URL from Studio
-            const channelUrlResult = await s('Runtime.evaluate', {
-              expression: `
-                (function() {
-                  // Try to find channel URL/ID from Studio page
-                  const url = window.location.href;
-                  const m = url.match(/channel\\/(UC[\\w-]+)/);
-                  if (m) return 'https://www.youtube.com/channel/' + m[1] + '/videos';
-
-                  // Try ytcfg
-                  if (window.ytcfg && window.ytcfg.get) {
-                    const cid = window.ytcfg.get('CHANNEL_ID');
-                    if (cid) return 'https://www.youtube.com/channel/' + cid + '/videos';
+                  function parseHumanNum(str) {
+                    if (!str) return 0;
+                    str = str.replace(/,/g, '').trim();
+                    var m = str.match(/([\\d\\.]+)\\s*([KMB])/i);
+                    if (m) {
+                      var n = parseFloat(m[1]);
+                      var s = m[2].toUpperCase();
+                      if (s === 'K') return Math.round(n * 1000);
+                      if (s === 'M') return Math.round(n * 1000000);
+                      if (s === 'B') return Math.round(n * 1000000000);
+                    }
+                    return parseInt(str, 10) || 0;
                   }
 
-                  // Fallback: go to own channel
-                  return 'https://www.youtube.com/@me';
+                  return JSON.stringify(result);
                 })()
               `,
               returnByValue: true,
             });
 
-            const channelUrl = channelUrlResult?.result?.value;
-            if (channelUrl) {
-              console.log(`[stats] Navigating to: ${channelUrl}`);
-              await s('Page.navigate', { url: channelUrl });
-              await this.waitForLoad(s);
-              await this.sleep(4000);
-
-              const ytResult = await s('Runtime.evaluate', {
-                expression: `
-                  (function() {
-                    const result = { subscribers: 0, total_views: 0, video_count: 0 };
-                    try {
-                      const data = window.ytInitialData;
-                      if (!data) return JSON.stringify({ error: 'no ytInitialData' });
-
-                      // Subscriber count from header
-                      const header = data?.header?.c4TabbedHeaderRenderer
-                        || data?.header?.pageHeaderRenderer?.content?.pageHeaderViewModel;
-                      if (header) {
-                        // c4TabbedHeaderRenderer path
-                        const subText = header?.subscriberCountText?.simpleText || '';
-                        if (subText) {
-                          const m = subText.match(/([\\d,\\.]+[KMB]?)/);
-                          if (m) result.subscribers = parseNum(m[1]);
-                        }
-                        // pageHeaderViewModel path
-                        const metadata = header?.metadata?.contentMetadataViewModel?.metadataRows;
-                        if (metadata) {
-                          for (const row of metadata) {
-                            for (const part of (row?.metadataParts || [])) {
-                              const t = part?.text?.content || '';
-                              if (t.includes('subscriber')) {
-                                const m = t.match(/([\\d,\\.]+[KMB]?)/);
-                                if (m) result.subscribers = parseNum(m[1]);
-                              }
-                              if (t.includes('video')) {
-                                const m = t.match(/([\\d,\\.]+)/);
-                                if (m) result.video_count = parseInt(m[1].replace(/,/g, ''), 10);
-                              }
-                            }
-                          }
-                        }
-                      }
+            try {
+              var parsed = JSON.parse(analyticsResult?.result?.value || '{}');
+              console.log('[stats] Analytics debug text (first 300):', (parsed.debug_text || '').substring(0, 300));
+              if (parsed.subscribers > 0) stats.subscribers = parsed.subscribers;
+              if (parsed.total_views > 0) stats.total_views = parsed.total_views;
+            } catch {}
+          }
 
-                      // Video count from tabs
-                      const tabs = data?.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
-                      for (const tab of tabs) {
-                        const tabData = tab?.tabRenderer;
-                        if (tabData?.title === 'Videos') {
-                          // Sometimes the tab content has total count
-                          const content = tabData?.content;
-                          const grid = content?.richGridRenderer || content?.sectionListRenderer;
-                          // Check for video items count
-                        }
-                      }
+          // Step 3: Get video count + subscriber from channel page via ytInitialData
+          var channelPageUrl = cid
+            ? 'https://www.youtube.com/channel/' + cid
+            : 'https://www.youtube.com/@me';
 
-                      // Total views from about tab data or metadata
-                      const aboutData = data?.metadata?.channelMetadataRenderer;
-                      if (aboutData) {
-                        // metadata doesn't have view count directly, but try
-                      }
+          console.log('[stats] Navigating to channel page:', channelPageUrl);
+          await s('Page.navigate', { url: channelPageUrl });
+          await this.waitForLoad(s);
+          await this.sleep(4000);
 
-                      // Try to get view count from about page data
-                      const microformat = data?.microformat?.microformatDataRenderer;
-                      if (microformat) {
-                        // Some data here
+          var ytResult = await s('Runtime.evaluate', {
+            expression: `
+              (function() {
+                var result = { subscribers: 0, total_views: 0, video_count: 0 };
+                try {
+                  var data = window.ytInitialData;
+                  if (!data) return JSON.stringify({ error: 'no ytInitialData' });
+
+                  // Try pageHeaderRenderer (new layout)
+                  var pageHeader = data.header && data.header.pageHeaderRenderer;
+                  if (pageHeader) {
+                    var content = pageHeader.content && pageHeader.content.pageHeaderViewModel;
+                    if (content && content.metadata && content.metadata.contentMetadataViewModel) {
+                      var rows = content.metadata.contentMetadataViewModel.metadataRows || [];
+                      for (var r = 0; r < rows.length; r++) {
+                        var parts = rows[r].metadataParts || [];
+                        for (var p = 0; p < parts.length; p++) {
+                          var t = (parts[p].text && parts[p].text.content) || '';
+                          // subscriber text like "123 subscribers" or "0 người đăng ký"
+                          if (/subscri|đăng ký/i.test(t)) {
+                            var m = t.match(/([\\d,\\.]+[KMB]?)/);
+                            if (m) result.subscribers = parseN(m[1]);
+                          }
+                          // video count like "1 video" or "15 video"
+                          if (/video/i.test(t)) {
+                            var m2 = t.match(/([\\d,]+)/);
+                            if (m2) result.video_count = parseInt(m2[1].replace(/,/g, ''), 10);
+                          }
+                        }
                       }
-
-                    } catch (e) {
-                      return JSON.stringify({ error: e.message });
                     }
+                  }
 
-                    function parseNum(str) {
-                      if (!str) return 0;
-                      str = str.replace(/,/g, '').trim();
-                      const m = str.match(/([\\d\\.]+)\\s*([KMB])/i);
-                      if (m) {
-                        const n = parseFloat(m[1]);
-                        const s = m[2].toUpperCase();
-                        if (s === 'K') return Math.round(n * 1000);
-                        if (s === 'M') return Math.round(n * 1000000);
-                        if (s === 'B') return Math.round(n * 1000000000);
-                      }
-                      return parseInt(str, 10) || 0;
+                  // Try c4TabbedHeaderRenderer (old layout)
+                  var c4Header = data.header && data.header.c4TabbedHeaderRenderer;
+                  if (c4Header) {
+                    var subText = c4Header.subscriberCountText && c4Header.subscriberCountText.simpleText || '';
+                    if (subText) {
+                      var m3 = subText.match(/([\\d,\\.]+[KMB]?)/);
+                      if (m3 && result.subscribers === 0) result.subscribers = parseN(m3[1]);
+                    }
+                    if (c4Header.videosCountText) {
+                      var vText = c4Header.videosCountText.runs ? c4Header.videosCountText.runs.map(function(r){return r.text}).join('') : (c4Header.videosCountText.simpleText || '');
+                      var m4 = vText.match(/([\\d,]+)/);
+                      if (m4) result.video_count = parseInt(m4[1].replace(/,/g, ''), 10);
                     }
+                  }
 
-                    return JSON.stringify(result);
-                  })()
-                `,
-                returnByValue: true,
-              });
-
-              try {
-                const ytData = JSON.parse(ytResult?.result?.value || '{}');
-                console.log(`[stats] ytInitialData result: ${JSON.stringify(ytData)}`);
-                if (ytData.subscribers > 0 && stats.subscribers === 0) stats.subscribers = ytData.subscribers;
-                if (ytData.video_count > 0) stats.video_count = ytData.video_count;
-                if (ytData.total_views > 0 && stats.total_views === 0) stats.total_views = ytData.total_views;
-              } catch {}
-            }
-          }
+                } catch (e) {
+                  return JSON.stringify({ error: e.message });
+                }
+
+                function parseN(str) {
+                  if (!str) return 0;
+                  str = str.replace(/,/g, '').trim();
+                  var m = str.match(/([\\d\\.]+)\\s*([KMB])/i);
+                  if (m) {
+                    var n = parseFloat(m[1]);
+                    var s = m[2].toUpperCase();
+                    if (s === 'K') return Math.round(n * 1000);
+                    if (s === 'M') return Math.round(n * 1000000);
+                    if (s === 'B') return Math.round(n * 1000000000);
+                  }
+                  return parseInt(str, 10) || 0;
+                }
+
+                return JSON.stringify(result);
+              })()
+            `,
+            returnByValue: true,
+          });
+
+          try {
+            var ytData = JSON.parse(ytResult?.result?.value || '{}');
+            console.log('[stats] ytInitialData result:', JSON.stringify(ytData));
+            if (ytData.subscribers > 0 && stats.subscribers === 0) stats.subscribers = ytData.subscribers;
+            if (ytData.video_count > 0) stats.video_count = ytData.video_count;
+            if (ytData.total_views > 0 && stats.total_views === 0) stats.total_views = ytData.total_views;
+          } catch {}
 
           clearTimeout(timeout);
           ws.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "channel-worker",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {