channel-worker 1.0.0

package/bin/cli.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.channel-worker');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function parseArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      const val = args[i + 1] && !args[i + 1].startsWith('--') ? args[i + 1] : true;
+      result[key] = val;
+      if (val !== true) i++;
+    } else if (!result._cmd) {
+      result._cmd = args[i];
+    }
+  }
+  return result;
+}
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  }
+  return {};
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+const args = parseArgs(process.argv.slice(2));
+const cmd = args._cmd || 'start';
+
+if (cmd === 'init') {
+  const config = {
+    worker_id: args.id || `worker-${os.hostname()}`,
+    api_url: args.api || 'http://localhost:3001',
+    max_concurrent: parseInt(args.concurrent || '2', 10),
+    nst_api_key: args['nst-key'] || '',
+    extension_path: args.extension || '',
+  };
+  saveConfig(config);
+  console.log(`[channel-worker] Config saved to ${CONFIG_FILE}`);
+  console.log(JSON.stringify(config, null, 2));
+  console.log('\nRun: channel-worker start');
+  process.exit(0);
+}
+
+if (cmd === 'start') {
+  // Merge CLI args over saved config
+  const saved = loadConfig();
+  const config = {
+    worker_id: args.id || saved.worker_id || `worker-${os.hostname()}`,
+    api_url: args.api || saved.api_url || 'http://localhost:3001',
+    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 || '',
+    verbose: !!args.verbose,
+  };
+
+  if (!config.worker_id) {
+    console.error('[channel-worker] Error: --id required. Run: channel-worker init --id <name> --api <url>');
+    process.exit(1);
+  }
+
+  // Save merged config for next time
+  saveConfig(config);
+
+  const { Daemon } = require('../lib/daemon');
+  const daemon = new Daemon(config);
+  daemon.start();
+
+} else if (cmd === 'config') {
+  const config = loadConfig();
+  console.log(JSON.stringify(config, null, 2));
+
+} else {
+  console.log(`
+channel-worker — Channel Manager worker daemon
+
+Commands:
+  init     Configure worker (saves to ~/.channel-worker/config.json)
+  start    Start the daemon
+  config   Show current config
+
+Options:
+  --id <name>        Worker ID (unique name)
+  --api <url>        Dashboard API URL (http://host:3001)
+  --concurrent <n>   Max concurrent browser instances (default: 2)
+  --nst-key <key>    Nstbrowser API key
+  --extension <path> Path to content-creator extension
+  --verbose          Enable verbose logging
+
+Examples:
+  channel-worker init --id win-worker --api http://192.168.1.52:3001
+  channel-worker start
+  channel-worker start --id win-worker --api http://192.168.1.52:3001
+  `);
+}

package/lib/api-client.js

@@ -0,0 +1,64 @@
+class ApiClient {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+  }
+
+  async request(method, path, body = null) {
+    const url = `${this.baseUrl}${path}`;
+    const options = {
+      method,
+      headers: { 'Content-Type': 'application/json' },
+    };
+    if (body) options.body = JSON.stringify(body);
+
+    const res = await fetch(url, options);
+    const json = await res.json();
+
+    if (!json.success) {
+      throw new Error(json.message || `API error ${res.status}`);
+    }
+    return json.data;
+  }
+
+  // Worker
+  async register(workerData) {
+    return this.request('POST', '/workers/register', workerData);
+  }
+
+  async heartbeat(workerId) {
+    return this.request('POST', '/workers/heartbeat', { worker_id: workerId });
+  }
+
+  // Jobs
+  async getNextJob(workerId) {
+    return this.request('GET', `/jobs/next?worker_id=${workerId}`);
+  }
+
+  async claimJob(jobId, workerId) {
+    return this.request('PUT', `/jobs/${jobId}`, {
+      status: 'running',
+      worker_id: workerId,
+    });
+  }
+
+  async updateJob(jobId, data) {
+    return this.request('PUT', `/jobs/${jobId}`, data);
+  }
+
+  // Channel info
+  async getChannel(channelId) {
+    return this.request('GET', `/channels/${channelId}`);
+  }
+
+  async getMasterChannel(masterId) {
+    return this.request('GET', `/masters/${masterId}`);
+  }
+
+  // Settings
+  async getSetting(key) {
+    const data = await this.request('GET', `/settings/${key}`);
+    return data?.value;
+  }
+}
+
+module.exports = { ApiClient };

package/lib/daemon.js

@@ -0,0 +1,84 @@
+const { ApiClient } = require('./api-client');
+const { Heartbeat } = require('./heartbeat');
+const { JobPoller } = require('./job-poller');
+const os = require('os');
+
+class Daemon {
+  constructor(config) {
+    this.config = config;
+    this.api = new ApiClient(config.api_url);
+    this.heartbeat = new Heartbeat(this.api, config.worker_id);
+    this.poller = new JobPoller(this.api, config);
+  }
+
+  async start() {
+    console.log(`
+╔══════════════════════════════════════╗
+║       channel-worker v1.0.0          ║
+╠══════════════════════════════════════╣
+║  Worker ID:  ${this.config.worker_id.padEnd(22)}║
+║  API URL:    ${this.config.api_url.padEnd(22)}║
+║  Concurrent: ${String(this.config.max_concurrent).padEnd(22)}║
+╚══════════════════════════════════════╝
+`);
+
+    // Register with dashboard
+    try {
+      await this.api.register({
+        worker_id: this.config.worker_id,
+        name: this.config.worker_id,
+        ip_address: this.getLocalIP(),
+        max_concurrent: this.config.max_concurrent,
+      });
+      console.log('[daemon] Registered with dashboard ✓');
+    } catch (err) {
+      console.error(`[daemon] Failed to register: ${err.message}`);
+      console.error('[daemon] Is the dashboard API running? Retrying in 10s...');
+      setTimeout(() => this.start(), 10000);
+      return;
+    }
+
+    // Start heartbeat
+    this.heartbeat.start();
+    console.log('[daemon] Heartbeat started (every 30s)');
+
+    // Start job polling
+    this.poller.start();
+    console.log('[daemon] Job poller started (every 5s)');
+    console.log('[daemon] Waiting for jobs...\n');
+
+    // Graceful shutdown
+    const shutdown = async () => {
+      console.log('\n[daemon] Shutting down...');
+      this.heartbeat.stop();
+      this.poller.stop();
+
+      // Mark offline
+      try {
+        await this.api.request('PUT', `/workers/${this.config.worker_id}`, {
+          status: 'offline',
+        });
+      } catch { /* ignore */ }
+
+      console.log('[daemon] Goodbye.');
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+  }
+
+  getLocalIP() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const iface of interfaces[name]) {
+        if (iface.family === 'IPv4' && !iface.internal) {
+          return iface.address;
+        }
+      }
+    }
+    return '127.0.0.1';
+  }
+}
+
+module.exports = { Daemon };

package/lib/heartbeat.js

@@ -0,0 +1,30 @@
+class Heartbeat {
+  constructor(api, workerId, intervalMs = 30000) {
+    this.api = api;
+    this.workerId = workerId;
+    this.intervalMs = intervalMs;
+    this.timer = null;
+  }
+
+  start() {
+    this.send(); // immediate first heartbeat
+    this.timer = setInterval(() => this.send(), this.intervalMs);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async send() {
+    try {
+      await this.api.heartbeat(this.workerId);
+    } catch (err) {
+      console.error(`[heartbeat] Failed: ${err.message}`);
+    }
+  }
+}
+
+module.exports = { Heartbeat };

package/lib/job-executor.js

@@ -0,0 +1,122 @@
+class JobExecutor {
+  constructor(api, config) {
+    this.api = api;
+    this.config = config;
+  }
+
+  async execute(job) {
+    const jobId = job._id;
+    console.log(`[executor] Starting job ${jobId} — ${job.flow_type} for channel ${job.channel_id}`);
+
+    try {
+      // 1. Get channel + master info
+      await this.updateStatus(jobId, 'sourcing');
+      const channel = await this.api.getChannel(job.channel_id);
+      const master = await this.api.getMasterChannel(channel.master_id);
+      const brandKit = master.brand_kit || {};
+
+      console.log(`[executor] Channel: ${channel.name} | Master: ${master.name} | Profile: ${channel.nst_profile_id}`);
+
+      // 2. Launch Nstbrowser profile
+      if (channel.nst_profile_id) {
+        await this.updateStatus(jobId, 'rendering', { progress: 10 });
+        await this.launchProfile(channel.nst_profile_id);
+      }
+
+      // 3. Execute based on flow type
+      switch (job.flow_type) {
+        case 'clone':
+          await this.executeClone(jobId, job, channel, brandKit);
+          break;
+        case 'generate':
+          await this.executeGenerate(jobId, job, channel, brandKit);
+          break;
+        case 'repurpose':
+          await this.executeRepurpose(jobId, job, channel, brandKit);
+          break;
+        default:
+          throw new Error(`Unknown flow type: ${job.flow_type}`);
+      }
+
+      // 4. Post-process
+      await this.updateStatus(jobId, 'post_processing', { progress: 80 });
+      // FFmpeg captions, trim, etc — TODO
+
+      // 5. Publish to platforms
+      await this.updateStatus(jobId, 'publishing', { progress: 90 });
+      // YouTube/TikTok/FB upload — TODO
+
+      // 6. Done
+      await this.updateStatus(jobId, 'published', { progress: 100 });
+      console.log(`[executor] Job ${jobId} completed successfully`);
+
+    } catch (err) {
+      console.error(`[executor] Job ${jobId} failed: ${err.message}`);
+      await this.api.updateJob(jobId, {
+        status: 'failed',
+        error_message: err.message,
+      });
+    }
+  }
+
+  async executeClone(jobId, job, channel, brandKit) {
+    // Step 1: Download source video
+    await this.updateStatus(jobId, 'sourcing', { progress: 20 });
+    console.log(`[executor:clone] Source: ${job.source_url}`);
+    // TODO: yt-dlp download
+
+    // Step 2: Transcribe
+    await this.updateStatus(jobId, 'scripting', { progress: 40 });
+    // TODO: Whisper/Groq transcribe
+
+    // Step 3: Rewrite script with brand voice
+    console.log(`[executor:clone] Rewriting with brand voice: ${brandKit.voice?.personality || 'default'}`);
+    // TODO: Claude API rewrite
+
+    // Step 4: Render new video
+    await this.updateStatus(jobId, 'rendering', { progress: 60 });
+    // TODO: Veo3 via extension auto-pilot OR Hailuo API
+  }
+
+  async executeGenerate(jobId, job, channel, brandKit) {
+    // Step 1: Generate script
+    await this.updateStatus(jobId, 'scripting', { progress: 30 });
+    console.log(`[executor:generate] Generating script for: ${job.caption || 'topic from planner'}`);
+    // TODO: Claude API generate
+
+    // Step 2: Render video
+    await this.updateStatus(jobId, 'rendering', { progress: 60 });
+    // TODO: Veo3 via extension OR Hailuo API
+  }
+
+  async executeRepurpose(jobId, job, channel, brandKit) {
+    // Step 1: Download long-form video
+    await this.updateStatus(jobId, 'sourcing', { progress: 20 });
+    // TODO: yt-dlp download
+
+    // Step 2: Extract clips
+    await this.updateStatus(jobId, 'rendering', { progress: 50 });
+    // TODO: Jiang-Clips or FunClip
+
+    // Step 3: Add captions
+    await this.updateStatus(jobId, 'post_processing', { progress: 70 });
+    // TODO: FFmpeg captions
+  }
+
+  async launchProfile(profileId) {
+    // TODO: Nstbrowser SDK launch profile
+    console.log(`[executor] Launching Nstbrowser profile: ${profileId}`);
+    // const { wsEndpoint } = await nstApi.launchProfile(profileId);
+    // return wsEndpoint;
+  }
+
+  async updateStatus(jobId, status, extra = {}) {
+    const update = { status, ...extra };
+    if (extra.progress) {
+      update.metadata = { progress: extra.progress };
+    }
+    await this.api.updateJob(jobId, update);
+  }
+}
+
+module.exports = { JobExecutor };

package/lib/job-poller.js

@@ -0,0 +1,63 @@
+const { JobExecutor } = require('./job-executor');
+
+class JobPoller {
+  constructor(api, config) {
+    this.api = api;
+    this.config = config;
+    this.executor = new JobExecutor(api, config);
+    this.running = new Set(); // job IDs currently executing
+    this.timer = null;
+    this.pollIntervalMs = 5000;
+  }
+
+  start() {
+    console.log(`[poller] Started — max concurrent: ${this.config.max_concurrent}`);
+    this.poll(); // immediate first poll
+    this.timer = setInterval(() => this.poll(), this.pollIntervalMs);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  get availableSlots() {
+    return this.config.max_concurrent - this.running.size;
+  }
+
+  async poll() {
+    if (this.availableSlots <= 0) return;
+
+    try {
+      const job = await this.api.getNextJob(this.config.worker_id);
+      if (!job) return; // no jobs in queue
+
+      const jobId = job._id;
+      if (this.running.has(jobId)) return; // already running
+
+      // Claim the job
+      await this.api.claimJob(jobId, this.config.worker_id);
+      this.running.add(jobId);
+
+      console.log(`[poller] Claimed job ${jobId} (${this.running.size}/${this.config.max_concurrent} slots used)`);
+
+      // Execute in background — don't await
+      this.executor.execute(job)
+        .finally(() => {
+          this.running.delete(jobId);
+          console.log(`[poller] Slot freed (${this.running.size}/${this.config.max_concurrent})`);
+          // Immediately try to pick next job
+          if (this.availableSlots > 0) this.poll();
+        });
+
+    } catch (err) {
+      if (this.config.verbose) {
+        console.error(`[poller] Poll error: ${err.message}`);
+      }
+    }
+  }
+}
+
+module.exports = { JobPoller };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "channel-worker",
+  "version": "1.0.0",
+  "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
+  "main": "lib/daemon.js",
+  "bin": {
+    "channel-worker": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js start",
+    "dev": "node bin/cli.js start --verbose"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}