channel-worker 1.2.0 → 1.3.1

package/bin/cli.js

@@ -6,6 +6,10 @@ const os = require('os');
 
 const CONFIG_DIR = path.join(os.homedir(), '.channel-worker');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_API_URL = 'https://api.channel.tunasm.art';
+const DEFAULT_EXT_PATH = process.platform === 'win32'
+  ? 'C:\\agents\\channel-manager-ext'
+  : path.join(os.homedir(), 'channel-manager-ext');
 
 function parseArgs(args) {
   const result = {};
@@ -40,9 +44,9 @@ const cmd = args._cmd || 'start';
 if (cmd === 'pair') {
   // Pair with dashboard using one-time code
   const code = args.code;
-  const apiUrl = args.api || 'https://api.channel.tunasm.art';
+  const apiUrl = args.api || DEFAULT_API_URL;
   const nstKey = args['nst-key'] || '';
-  const extensionPath = args.extension || '';
+  const extensionPath = args.extension || DEFAULT_EXT_PATH;
   const maxConcurrent = parseInt(args.concurrent || '2', 10);
 
   if (!code) {
@@ -91,10 +95,10 @@ if (cmd === 'pair') {
 } else if (cmd === 'init') {
   const config = {
     worker_id: args.id || `worker-${os.hostname()}`,
-    api_url: args.api || 'http://localhost:3001',
+    api_url: args.api || DEFAULT_API_URL,
     max_concurrent: parseInt(args.concurrent || '2', 10),
     nst_api_key: args['nst-key'] || '',
-    extension_path: args.extension || '',
+    extension_path: args.extension || DEFAULT_EXT_PATH,
     worker_token: args.token || '',
   };
   saveConfig(config);
@@ -108,10 +112,10 @@ if (cmd === 'pair') {
   const saved = loadConfig();
   const config = {
     worker_id: args.id || saved.worker_id || `worker-${os.hostname()}`,
-    api_url: args.api || saved.api_url || 'https://api.channel.tunasm.art',
+    api_url: args.api || saved.api_url || DEFAULT_API_URL,
     max_concurrent: parseInt(args.concurrent || saved.max_concurrent || '2', 10),
     nst_api_key: args['nst-key'] || saved.nst_api_key || '',
-    extension_path: args.extension || saved.extension_path || '',
+    extension_path: args.extension || saved.extension_path || DEFAULT_EXT_PATH,
     worker_token: args.token || saved.worker_token || '',
     verbose: !!args.verbose,
   };

package/lib/api-client.js

@@ -62,12 +62,32 @@ class ApiClient {
 
   // Commands
   async getNextCommand(workerId) {
-    return this.request('GET', `/workers/commands?worker_id=${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';
+    return this.request('GET', `/workers/commands?worker_id=${workerId}&types=${encodeURIComponent(workerTypes)}`);
   }
 
   async updateCommand(commandId, data) {
     return this.request('PUT', `/workers/commands/${commandId}`, data);
   }
+
+  // Extension download
+  async getExtensionVersion() {
+    const data = await this.request('GET', '/extension-download/version');
+    return data.version;
+  }
+
+  async downloadExtension(destPath) {
+    const url = `${this.baseUrl}/extension-download/zip`;
+    const res = await fetch(url, {
+      headers: { 'x-worker-token': this.workerToken },
+    });
+    if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+
+    const fs = require('fs');
+    const buffer = Buffer.from(await res.arrayBuffer());
+    fs.writeFileSync(destPath, buffer);
+    return destPath;
+  }
 }
 
 module.exports = { ApiClient };

package/lib/command-poller.js

@@ -1,4 +1,5 @@
 const { NstManager } = require('./nst-manager');
+const { checkAndUpdateExtension } = require('./extension-updater');
 
 class CommandPoller {
   constructor(api, config) {
@@ -64,6 +65,9 @@ class CommandPoller {
         case 'type_text':
           await this.handleTypeText(command);
           break;
+        case 'update_extension':
+          await this.handleUpdateExtension(command);
+          break;
         default:
           // Other commands (scan_facebook_pages, etc.) handled by extension
           console.log(`[commands] Skipping ${command.type} — handled by extension`);
@@ -827,6 +831,25 @@ class CommandPoller {
     await this.api.updateCommand(command._id, { status: 'done' });
   }
 
+  async handleUpdateExtension(command) {
+    console.log('[commands] Updating extension...');
+    try {
+      if (!this.config.extension_path) {
+        throw new Error('No extension_path configured');
+      }
+      const result = await checkAndUpdateExtension(this.api, this.config.extension_path);
+      if (result.updated) {
+        console.log(`[commands] Extension updated: ${result.from || 'none'} → ${result.to}`);
+      } else {
+        console.log(`[commands] Extension already up to date (v${result.local})`);
+      }
+      await this.api.updateCommand(command._id, { status: 'done', result });
+    } catch (err) {
+      console.error(`[commands] Extension update failed: ${err.message}`);
+      await this.api.updateCommand(command._id, { status: 'failed', error: err.message });
+    }
+  }
+
   async handleVerifyLogins(command) {
     const { profile_id, channel_id } = command.payload || {};
     console.log(`[commands] Verifying logins for profile: ${profile_id}`);

package/lib/daemon.js

@@ -3,6 +3,7 @@ const { Heartbeat } = require('./heartbeat');
 const { JobPoller } = require('./job-poller');
 const { CommandPoller } = require('./command-poller');
 const { UpdateChecker, getLocalVersion } = require('./updater');
+const { checkAndUpdateExtension } = require('./extension-updater');
 
 class Daemon {
   constructor(config) {
@@ -34,6 +35,20 @@ class Daemon {
         max_concurrent: this.config.max_concurrent,
       });
       console.log('[daemon] Registered with dashboard ✓');
+
+      // Auto-update extension on startup
+      if (this.config.extension_path) {
+        try {
+          const result = await checkAndUpdateExtension(this.api, this.config.extension_path);
+          if (result.updated) {
+            console.log(`[daemon] Extension updated: ${result.from || 'none'} → ${result.to}`);
+          } else {
+            console.log(`[daemon] Extension up to date (v${result.local})`);
+          }
+        } catch (err) {
+          console.warn(`[daemon] Extension update check failed: ${err.message}`);
+        }
+      }
     } catch (err) {
       console.error(`[daemon] Failed to register: ${err.message}`);
       console.error('[daemon] Is the dashboard API running? Retrying in 10s...');

package/lib/extension-updater.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+function getLocalExtensionVersion(extensionPath) {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(extensionPath, 'manifest.json'), 'utf8'));
+    return manifest.version || null;
+  } catch {
+    return null;
+  }
+}
+
+function isNewer(remote, local) {
+  const r = remote.split('.').map(Number);
+  const l = local.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((r[i] || 0) > (l[i] || 0)) return true;
+    if ((r[i] || 0) < (l[i] || 0)) return false;
+  }
+  return false;
+}
+
+async function checkAndUpdateExtension(api, extensionPath) {
+  const local = getLocalExtensionVersion(extensionPath);
+  const remote = await api.getExtensionVersion();
+
+  if (local && !isNewer(remote, local)) {
+    return { updated: false, local, remote };
+  }
+
+  console.log(`[ext-updater] ${local ? `Update available: ${local} → ${remote}` : `Downloading extension v${remote}...`}`);
+
+  // Download to temp
+  const tmpArchive = path.join(os.tmpdir(), `channel-manager-ext-${Date.now()}.tar.gz`);
+  const tmpExtract = path.join(os.tmpdir(), `channel-manager-ext-new-${Date.now()}`);
+
+  try {
+    await api.downloadExtension(tmpArchive);
+
+    // Extract
+    fs.mkdirSync(tmpExtract, { recursive: true });
+    execSync(`tar -xzf "${tmpArchive}" -C "${tmpExtract}"`, { timeout: 30000 });
+
+    // tar extracts into a subfolder named "channel-manager-ext"
+    const extracted = path.join(tmpExtract, 'channel-manager-ext');
+    const sourceDir = fs.existsSync(extracted) ? extracted : tmpExtract;
+
+    // Replace existing extension dir
+    if (fs.existsSync(extensionPath)) {
+      fs.rmSync(extensionPath, { recursive: true, force: true });
+    }
+    fs.mkdirSync(extensionPath, { recursive: true });
+
+    // Copy files
+    const files = fs.readdirSync(sourceDir);
+    for (const f of files) {
+      const src = path.join(sourceDir, f);
+      const dest = path.join(extensionPath, f);
+      const stat = fs.statSync(src);
+      if (stat.isFile()) {
+        fs.copyFileSync(src, dest);
+      } else if (stat.isDirectory()) {
+        fs.cpSync(src, dest, { recursive: true });
+      }
+    }
+
+    console.log(`[ext-updater] Extension updated to v${remote}`);
+    return { updated: true, from: local, to: remote };
+  } finally {
+    // Cleanup temp files
+    try { fs.unlinkSync(tmpArchive); } catch {}
+    try { fs.rmSync(tmpExtract, { recursive: true, force: true }); } catch {}
+  }
+}
+
+module.exports = { checkAndUpdateExtension, getLocalExtensionVersion };

package/package.json

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