channel-worker 1.0.0 → 1.0.2

package/lib/api-client.js

@@ -59,6 +59,15 @@ class ApiClient {
     const data = await this.request('GET', `/settings/${key}`);
     return data?.value;
   }
+
+  // Commands
+  async getNextCommand(workerId) {
+    return this.request('GET', `/workers/commands?worker_id=${workerId}`);
+  }
+
+  async updateCommand(commandId, data) {
+    return this.request('PUT', `/workers/commands/${commandId}`, data);
+  }
 }
 
 module.exports = { ApiClient };

package/lib/command-poller.js

@@ -0,0 +1,109 @@
+const { NstManager } = require('./nst-manager');
+
+class CommandPoller {
+  constructor(api, config) {
+    this.api = api;
+    this.config = config;
+    this.timer = null;
+    this.pollIntervalMs = 3000;
+    this.nst = null;
+
+    // Init Nstbrowser if API key available
+    if (config.nst_api_key) {
+      try {
+        this.nst = new NstManager(config.nst_api_key);
+        console.log('[commands] Nstbrowser SDK initialized');
+      } catch (err) {
+        console.warn(`[commands] Nstbrowser SDK not available: ${err.message}`);
+      }
+    }
+  }
+
+  start() {
+    console.log('[commands] Polling for commands (every 3s)');
+    this.poll();
+    this.timer = setInterval(() => this.poll(), this.pollIntervalMs);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async poll() {
+    try {
+      const command = await this.api.getNextCommand(this.config.worker_id);
+      if (!command) return;
+
+      console.log(`[commands] Received: ${command.type} (${command._id})`);
+
+      switch (command.type) {
+        case 'launch_profile':
+          await this.handleLaunchProfile(command);
+          break;
+        case 'close_profile':
+          await this.handleCloseProfile(command);
+          break;
+        case 'verify_logins':
+          await this.handleVerifyLogins(command);
+          break;
+        default:
+          console.warn(`[commands] Unknown command type: ${command.type}`);
+          await this.api.updateCommand(command._id, { status: 'failed', error: 'Unknown command type' });
+      }
+    } catch (err) {
+      if (this.config.verbose) {
+        console.error(`[commands] Poll error: ${err.message}`);
+      }
+    }
+  }
+
+  async handleLaunchProfile(command) {
+    const { profile_id } = command.payload || {};
+    console.log(`[commands] Launching Nstbrowser profile: ${profile_id}`);
+
+    try {
+      if (!this.nst) {
+        // No Nstbrowser SDK — try to get API key from dashboard settings
+        const apiKey = await this.api.getSetting('nst_api_key');
+        if (apiKey) {
+          this.nst = new NstManager(apiKey);
+        } else {
+          throw new Error('Nstbrowser API key not configured. Set it in Dashboard → Settings.');
+        }
+      }
+
+      const result = await this.nst.launchProfile(profile_id);
+      console.log(`[commands] Profile ${profile_id} launched — user can now login via RDP`);
+
+      await this.api.updateCommand(command._id, {
+        status: 'done',
+        result: { profile_id: result.profileId, launched_at: new Date().toISOString() },
+      });
+    } catch (err) {
+      console.error(`[commands] Failed to launch profile: ${err.message}`);
+      await this.api.updateCommand(command._id, {
+        status: 'failed',
+        error: err.message,
+      });
+    }
+  }
+
+  async handleCloseProfile(command) {
+    const { profile_id } = command.payload || {};
+    console.log(`[commands] Closing profile: ${profile_id}`);
+    // TODO: close Nstbrowser profile
+    await this.api.updateCommand(command._id, { status: 'done' });
+  }
+
+  async handleVerifyLogins(command) {
+    const { profile_id, channel_id } = command.payload || {};
+    console.log(`[commands] Verifying logins for profile: ${profile_id}`);
+    // TODO: launch headless, check cookies for Google/Facebook/TikTok
+    await this.api.updateCommand(command._id, { status: 'done' });
+  }
+}
+
+module.exports = { CommandPoller };

package/lib/daemon.js

@@ -1,6 +1,7 @@
 const { ApiClient } = require('./api-client');
 const { Heartbeat } = require('./heartbeat');
 const { JobPoller } = require('./job-poller');
+const { CommandPoller } = require('./command-poller');
 const os = require('os');
 
 class Daemon {
@@ -9,6 +10,7 @@ class Daemon {
     this.api = new ApiClient(config.api_url);
     this.heartbeat = new Heartbeat(this.api, config.worker_id);
     this.poller = new JobPoller(this.api, config);
+    this.commandPoller = new CommandPoller(this.api, config);
   }
 
   async start() {
@@ -45,13 +47,18 @@ class Daemon {
     // Start job polling
     this.poller.start();
     console.log('[daemon] Job poller started (every 5s)');
-    console.log('[daemon] Waiting for jobs...\n');
+
+    // Start command polling
+    this.commandPoller.start();
+    console.log('[daemon] Command poller started (every 3s)');
+    console.log('[daemon] Waiting for jobs & commands...\n');
 
     // Graceful shutdown
     const shutdown = async () => {
       console.log('\n[daemon] Shutting down...');
       this.heartbeat.stop();
       this.poller.stop();
+      this.commandPoller.stop();
 
       // Mark offline
       try {

package/lib/nst-manager.js

@@ -0,0 +1,119 @@
+let NstBrowserV2;
+try {
+  NstBrowserV2 = require('nstbrowser-sdk-node').NstBrowserV2;
+} catch {
+  // SDK not installed — will fail gracefully
+}
+
+class NstManager {
+  constructor(apiKey, options = {}) {
+    if (!NstBrowserV2) {
+      throw new Error('nstbrowser-sdk-node not installed. Run: npm install -g nstbrowser-sdk-node');
+    }
+    this.client = new NstBrowserV2(apiKey, {
+      timeout: options.timeout || 60000,
+      apiAddress: options.apiAddress || 'http://localhost:8848/api/v2',
+    });
+  }
+
+  // Check if profile exists by name, return profileId
+  async findProfile(name) {
+    try {
+      const res = await this.client.profiles().getProfiles({ keyword: name });
+      const profiles = res?.data?.list || res?.data || [];
+      const match = profiles.find(p => p.name === name);
+      return match?.profileId || match?.id || null;
+    } catch (err) {
+      console.error(`[nst] Error finding profile "${name}":`, err.message);
+      return null;
+    }
+  }
+
+  // Create profile if not exists, return profileId
+  async ensureProfile(name) {
+    // Check existing
+    let profileId = await this.findProfile(name);
+    if (profileId) {
+      console.log(`[nst] Profile "${name}" exists: ${profileId}`);
+      return profileId;
+    }
+
+    // Create new
+    console.log(`[nst] Creating profile "${name}"...`);
+    const res = await this.client.profiles().createProfile({
+      name,
+      platform: 'Windows',
+      kernelMilestone: '132',
+      fingerprint: {
+        flags: {
+          audio: 'Noise',
+          canvas: 'Noise',
+          fonts: 'Masked',
+          gpu: 'Allow',
+          webgl: 'Noise',
+        },
+        hardwareConcurrency: 8,
+        deviceMemory: 8,
+      },
+    });
+
+    profileId = res?.data?.profileId || res?.data?.id;
+    if (!profileId) throw new Error('Failed to create profile — no ID returned');
+
+    console.log(`[nst] Profile "${name}" created: ${profileId}`);
+    return profileId;
+  }
+
+  // Launch browser for profile (visible, not headless)
+  async launchProfile(profileIdOrName) {
+    // If it looks like a name (not UUID), find/create by name
+    let profileId = profileIdOrName;
+    if (!this.isUUID(profileIdOrName)) {
+      profileId = await this.ensureProfile(profileIdOrName);
+    }
+
+    console.log(`[nst] Starting browser for profile: ${profileId}`);
+    const res = await this.client.browsers().startBrowser(profileId);
+    console.log(`[nst] Browser started`);
+    return { profileId, response: res };
+  }
+
+  // Launch and get CDP WebSocket URL (for automation)
+  async connectProfile(profileIdOrName) {
+    let profileId = profileIdOrName;
+    if (!this.isUUID(profileIdOrName)) {
+      profileId = await this.ensureProfile(profileIdOrName);
+    }
+
+    console.log(`[nst] Connecting to profile: ${profileId}`);
+    const res = await this.client.cdpEndpoints().connectBrowser(profileId, {
+      headless: false,
+      autoClose: false,
+    });
+
+    const wsEndpoint = res?.data?.webSocketDebuggerUrl;
+    if (!wsEndpoint) throw new Error('No WebSocket endpoint returned');
+
+    console.log(`[nst] Connected — WS: ${wsEndpoint}`);
+    return { profileId, wsEndpoint };
+  }
+
+  // Stop browser for profile
+  async stopProfile(profileIdOrName) {
+    let profileId = profileIdOrName;
+    if (!this.isUUID(profileIdOrName)) {
+      profileId = await this.findProfile(profileIdOrName);
+      if (!profileId) return;
+    }
+
+    console.log(`[nst] Stopping browser for profile: ${profileId}`);
+    await this.client.browsers().stopBrowser(profileId);
+    console.log(`[nst] Browser stopped`);
+  }
+
+  isUUID(str) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+  }
+}
+
+module.exports = { NstManager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "channel-worker",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {
@@ -15,7 +15,8 @@
     "dev": "node bin/cli.js start --verbose"
   },
   "dependencies": {
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "nstbrowser-sdk-node": "^0.1.1"
   },
   "engines": {
     "node": ">=18"