Spaces:

AEUPH
/

NeuralOS-Hypervisor

Sleeping

App Files Files Community

AEUPH commited on Jan 23

Commit

8431283

verified ·

1 Parent(s): 94e1d62

Update Dockerfile

Browse files

Files changed (1) hide show

Dockerfile +544 -16

Dockerfile CHANGED Viewed

@@ -1,31 +1,559 @@
 FROM python:3.10-slim
 # Set working directory
 WORKDIR /app
-# Copy requirements and install
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-# Create a user to avoid running as root (HF requirement)
-RUN useradd -m -u 1000 user
-# Switch to user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
-# Copy the monolith to the container
-COPY --chown=user . .
-# --- DEBUGGING STEP ---
-# This will print the contents of /app to your build logs.
-# Check the logs to see where app.py actually is!
-RUN ls -R /app
-# ----------------------
-# Expose the standard Hugging Face port
-EXPOSE 7860
-# Launch the Monolith
 CMD ["python", "app.py"]

+# Use a lightweight Python base
 FROM python:3.10-slim
 # Set working directory
 WORKDIR /app
+# 1. Install System Dependencies
+# 'git' is often needed by Diffusers/Transformers to load models
+RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+# 2. Install Python Dependencies
+# We include 'accelerate' and 'transformers' which are required by 'diffusers'
+RUN pip install --no-cache-dir \
+    torch \
+    flask \
+    flask-sock \
+    diffusers \
+    transformers \
+    accelerate \
+    safetensors \
+    scipy
+# 3. Create a non-root user (Required for Hugging Face Spaces)
+RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH
+# 4. Write the Monolith Application to disk
+# We use 'COPY <<'EOF' app.py' to preserve all special characters, quotes, and backslashes exactly.
+COPY --chown=user <<'EOF' app.py
+import sys
+import os
+import subprocess
+import time
+# ============================================================================
+# 1. PORTABLE ENVIRONMENT SELF-CORRECTION (Legacy Support)
+# ============================================================================
+def ensure_portable_env():
+    """
+    Checks if a local 'py312' folder exists.
+    If yes, and we aren't running from it, RESTART script using that Python.
+    """
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    portable_python = os.path.join(base_dir, "py312", "python.exe")
+    if os.path.exists(portable_python):
+        current_exe = os.path.normpath(sys.executable).lower()
+        target_exe = os.path.normpath(portable_python).lower()
+        if current_exe != target_exe:
+            print(f"[*] SWITCHING TO PORTABLE KERNEL: {portable_python}")
+            args = [portable_python, __file__] + sys.argv[1:]
+            subprocess.call(args)
+            sys.exit(0)
+    else:
+        print(f"[*] Portable 'py312' not found. Using system Python: {sys.executable}")
+ensure_portable_env()
+# ============================================================================
+# 2. DEPENDENCY CHECK & IMPORTS
+# ============================================================================
+print(f"[*] NeuralOS Monolith Bootloader v9.2 (Running in: {sys.executable})")
+try:
+    import torch
+    from flask import Flask
+    from flask_sock import Sock
+    from diffusers import StableDiffusionPipeline, LCMScheduler, AutoencoderTiny
+    from PIL import Image, ImageDraw, ImageFont
+except ImportError as e:
+    print(f"\n[!] CRITICAL: Missing dependency: {e.name}")
+    sys.exit(1)
+# ============================================================================
+# 3. EMBEDDED GUI
+# ============================================================================
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>NeuralOS | Monolith</title>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=VT323&display=swap');
+        body {
+            background: #050505;
+            margin: 0;
+            overflow: hidden;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            font-family: 'VT323', monospace;
+        }
+        .monitor-case {
+            background: #1a1a1a;
+            padding: 20px;
+            border-radius: 20px;
+            box-shadow: 0 0 0 5px #222, 0 0 50px rgba(0,0,0,0.8), inset 0 0 20px rgba(0,0,0,0.5);
+            position: relative;
+        }
+        .screen-container {
+            width: 1024px;
+            height: 1024px;
+            position: relative;
+            background: #000;
+            overflow: hidden;
+            border-radius: 4px;
+        }
+        .crt-overlay {
+            position: absolute;
+            inset: 0;
+            background: linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%);
+            background-size: 100% 4px;
+            pointer-events: none;
+            z-index: 10;
+        }
+        .scanline {
+            width: 100%;
+            height: 100px;
+            z-index: 10;
+            background: linear-gradient(0deg, rgba(0,0,0,0) 0%, rgba(255, 255, 255, 0.04) 50%, rgba(0,0,0,0) 100%);
+            opacity: 0.1;
+            position: absolute;
+            bottom: 100%;
+            animation: scanline 10s linear infinite;
+            pointer-events: none;
+        }
+        @keyframes scanline { 0% { bottom: 100%; } 100% { bottom: -100px; } }
+        #display {
+            width: 100%;
+            height: 100%;
+            object-fit: contain;
+            image-rendering: pixelated;
+        }
+        .controls {
+            position: absolute;
+            bottom: -60px;
+            right: 20px;
+            display: flex;
+            gap: 10px;
+        }
+        .pwr-btn {
+            background: #333;
+            color: #0f0;
+            border: 2px solid #222;
+            padding: 10px 20px;
+            font-family: 'VT323';
+            cursor: pointer;
+            text-transform: uppercase;
+            box-shadow: 0 4px 0 #111;
+        }
+        .pwr-btn:active { transform: translateY(4px); box-shadow: none; }
+        .led {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: #111;
+            margin-top: 15px;
+            box-shadow: 0 0 2px #000;
+        }
+        .led.on { background: #0f0; box-shadow: 0 0 5px #0f0; }
+        .led.busy { background: #f00; box-shadow: 0 0 5px #f00; animation: blink 0.1s infinite; }
+        @keyframes blink { 0% { opacity: 0.5; } 100% { opacity: 1; } }
+    </style>
+</head>
+<body>
+    <div class="monitor-case">
+        <div class="screen-container">
+            <div class="crt-overlay"></div>
+            <div class="scanline"></div>
+            <img id="display" src="" alt="AWAITING NEURAL SIGNAL..." />
+        </div>
+        <div class="controls">
+            <div class="led on"></div>
+            <div id="hdd-led" class="led"></div>
+            <button class="pwr-btn" onclick="location.reload()">HARD RESET</button>
+        </div>
+    </div>
+    <script>
+        const display = document.getElementById('display');
+        const hddLed = document.getElementById('hdd-led');
+        let ws = null;
+        function connect() {
+            const proto = window.location.protocol === 'https:' ? 'wss' : 'ws';
+            ws = new WebSocket(`${proto}://${window.location.host}/kernel`);
+            ws.onmessage = (e) => {
+                const msg = JSON.parse(e.data);
+                if (msg.type === 'frame_update') {
+                    display.src = `data:image/jpeg;base64,${msg.data}`;
+                    hddLed.classList.add('busy');
+                    setTimeout(() => hddLed.classList.remove('busy'), 50);
+                }
+            };
+            ws.onclose = () => { setTimeout(connect, 3000); };
+        }
+        display.addEventListener('mousedown', (e) => {
+            if (!ws) return;
+            const rect = display.getBoundingClientRect();
+            const x = Math.floor(((e.clientX - rect.left) / rect.width) * 128);
+            const y = Math.floor(((e.clientY - rect.top) / rect.height) * 128);
+            ws.send(JSON.stringify({ type: 'click', x: x, y: y }));
+        });
+        document.addEventListener('keydown', (e) => {
+            if (!ws) return;
+            if (['Backspace', 'Tab', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(e.key)) {
+                e.preventDefault();
+            }
+            ws.send(JSON.stringify({ type: 'keydown', key: e.key }));
+        });
+        connect();
+    </script>
+</body>
+</html>
+"""
+# ============================================================================
+# 4. KERNEL & HARDWARE
+# ============================================================================
+from dataclasses import dataclass, field
+from typing import Dict, List
+import io
+import json
+import base64
+DRIVERS = {
+    "TITLE_BAR": torch.zeros((1, 4, 4, 32), dtype=torch.float16),
+    "CLOSE_BTN": torch.zeros((1, 4, 4, 4), dtype=torch.float16),
+    "TASKBAR": torch.zeros((1, 4, 6, 128), dtype=torch.float16),
+    "START_BTN": torch.zeros((1, 4, 6, 24), dtype=torch.float16),
+    "DESKTOP_BG": torch.zeros((1, 4, 128, 128), dtype=torch.float16),
+    "ICON_NOTEPAD": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
+    "ICON_CMD": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
+    "ICON_FOLDER": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
+    "ICON_GAME": torch.zeros((1, 4, 8, 8), dtype=torch.float16),
+}
+def init_drivers():
+    DRIVERS["TITLE_BAR"][:, 0, 0:1, :] = 2.0; DRIVERS["TITLE_BAR"][:, 1, :, :] = -1.0
+    DRIVERS["CLOSE_BTN"][:, 2, :, :] = 2.5
+    DRIVERS["TASKBAR"][:, 0, 0, :] = 1.2
+    DRIVERS["START_BTN"][:, 1, 1:5, 2:22] = 1.8
+    DRIVERS["DESKTOP_BG"][:, 1, 0:80, :] = 1.2; DRIVERS["DESKTOP_BG"][:, 2, 0:80, :] = 1.5
+    DRIVERS["DESKTOP_BG"][:, 1, 80:128, :] = 0.8
+    DRIVERS["ICON_NOTEPAD"][:, 0, :, :] = 1.5
+    DRIVERS["ICON_CMD"][:, 1, :, :] = -1.0
+    DRIVERS["ICON_GAME"][:, 0, 2:6, 2:6] = 2.0
+@dataclass
+class Application:
+    name: str
+    icon_dna: str
+    default_size: tuple
+    is_game: bool = False
+PROGRAMS = {
+    "notepad": Application("Notepad", "ICON_NOTEPAD", (48, 40)),
+    "cmd": Application("Terminal", "ICON_CMD", (56, 40)),
+    "explorer": Application("My Computer", "ICON_FOLDER", (72, 56)),
+    "doom": Application("NeuroDoom", "ICON_GAME", (64, 48), True)
+}
+@dataclass
+class Process:
+    pid: int
+    name: str
+    app_type: str
+    position: tuple
+    size: tuple
+    latent_state: torch.Tensor
+    text_buffer: List[str] = field(default_factory=list)
+    input_focus: bool = False
+    status: str = "running"
+    z_order: int = 0
+    meta: Dict = field(default_factory=dict)
+class OSKernel:
+    def __init__(self):
+        self.processes = {}
+        self.next_pid = 1000
+        self.focused_pid = None
+        self.system_state = "BOOT"
+        self.boot_log = []
+        self.desktop_latent = None
+        self.desktop_icons = []
+        self.start_menu_open = False
+        self.current_dir = "C:\\Users\\Admin"
+    def init_desktop(self):
+        self.desktop_latent = DRIVERS["DESKTOP_BG"].clone()
+        self.desktop_icons = [
+            {"app": "notepad", "x": 4, "y": 4},
+            {"app": "cmd", "x": 4, "y": 16},
+            {"app": "explorer", "x": 4, "y": 28},
+            {"app": "doom", "x": 4, "y": 40},
+        ]
+        self.system_state = "DESKTOP"
+    def spawn(self, app_type, x, y):
+        if app_type not in PROGRAMS: return
+        app = PROGRAMS[app_type]
+        pid = self.next_pid
+        self.next_pid += 1
+        buf = []
+        if app_type == "cmd":
+            buf = ["NEURAL OS [Version 9.2]", "(C) Monolith Corp", "", f"{self.current_dir}>"]
+        elif app_type == "notepad":
+            buf = ["_"]
+        elif app_type == "doom":
+            buf = ["[INIT] LOADING TEXTURES...", "[INIT] CONNECTING NEURAL NET..."]
+        self.processes[pid] = Process(
+            pid, app.name, app_type, (x, y), app.default_size,
+            torch.zeros((1, 4, app.default_size[1], app.default_size[0]), dtype=torch.float16),
+            buf, False, "running", pid, {"state": "menu"} if app.is_game else {}
+        )
+        self.focus(pid)
+        return pid
+    def focus(self, pid):
+        if pid in self.processes:
+            for p in self.processes.values(): p.input_focus = False
+            self.processes[pid].input_focus = True
+            self.processes[pid].z_order = max([p.z_order for p in self.processes.values()], default=0) + 1
+            self.focused_pid = pid
+    def kill(self, pid):
+        if pid in self.processes: del self.processes[pid]
+    def input(self, key):
+        if not self.focused_pid: return
+        proc = self.processes[self.focused_pid]
+        if proc.app_type == "cmd":
+            if key == "Enter":
+                cmd = proc.text_buffer[-1].split(">")[-1].strip()
+                proc.text_buffer.append("")
+                if cmd == "dir": proc.text_buffer.append("  <DIR> Documents")
+                elif cmd == "cls": proc.text_buffer = []
+                elif cmd == "exit": self.kill(proc.pid)
+                elif cmd.startswith("start "):
+                    target = cmd.split(" ")[1]
+                    if target in PROGRAMS:
+                        proc.meta["spawn_req"] = target
+                        proc.text_buffer.append(f"Starting {target}...")
+                else: proc.text_buffer.append("Unknown command")
+                proc.text_buffer.append(f"{self.current_dir}>")
+            elif key == "Backspace":
+                if ">" in proc.text_buffer[-1] and len(proc.text_buffer[-1].split(">")[-1]) > 0:
+                    proc.text_buffer[-1] = proc.text_buffer[-1][:-1]
+            elif len(key) == 1: proc.text_buffer[-1] += key
+        elif proc.app_type == "notepad":
+            if key == "Enter": proc.text_buffer.append("")
+            elif key == "Backspace":
+                if len(proc.text_buffer[-1]) > 0: proc.text_buffer[-1] = proc.text_buffer[-1][:-1]
+                elif len(proc.text_buffer) > 1: proc.text_buffer.pop()
+            elif len(key) == 1: proc.text_buffer[-1] += key
+        elif proc.app_type == "doom":
+            proc.meta["last_key"] = key
+            proc.meta["needs_update"] = True
+    def composite(self):
+        if self.system_state == "BOOT": return None
+        out = self.desktop_latent.clone()
+        for i in self.desktop_icons:
+            if PROGRAMS[i['app']].icon_dna in DRIVERS:
+                dna = DRIVERS[PROGRAMS[i['app']].icon_dna]
+                out[:, :, i['y']:i['y']+8, i['x']:i['x']+8] = dna
+        for p in sorted(self.processes.values(), key=lambda x: x.z_order):
+            x, y = p.position
+            w, h = p.size
+            if x+w <= 128 and y+h <= 128:
+                out[:, :, y:y+h, x:x+w] = p.latent_state
+        tb = DRIVERS["TASKBAR"].clone()
+        tb[:, :, :, 0:24] = DRIVERS["START_BTN"]
+        out[:, :, 122:128, :] = tb
+        return out
+# ============================================================================
+# 5. SERVER
+# ============================================================================
+app = Flask(__name__)
+sock = Sock(app)
+pipe = None
+kernel = OSKernel()
+def init_ai():
+    global pipe
+    print("[*] Loading Neural Graphics Pipeline...")
+    # AUTO-DETECT DEVICE
+    if torch.cuda.is_available():
+        device = "cuda"
+        dtype = torch.float16
+        print(f"[✓] CUDA Detected: {torch.cuda.get_device_name(0)}")
+    else:
+        device = "cpu"
+        dtype = torch.float32
+        print("[!] WARNING: CUDA Not Found. Running CPU Mode.")
+    try:
+        pipe = StableDiffusionPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5",
+            torch_dtype=dtype,
+            variant="fp16" if device=="cuda" else None
+        ).to(device)
+        if device == "cuda":
+            try:
+                pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
+                pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+                pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", torch_dtype=dtype).to(device)
+                print("[✓] Optimizations (LCM+TAE) Enabled")
+            except:
+                print("[!] Using Standard Scheduler")
+    except Exception as e:
+        print(f"[!] AI Init Error: {e}")
+def render_frame(k_obj):
+    latent_tensor = k_obj.composite()
+    if latent_tensor is not None:
+        with torch.no_grad():
+            latents = (1 / 0.18215) * latent_tensor.to(pipe.device)
+            if pipe.device.type == 'cpu': latents = latents.float()
+            img = pipe.vae.decode(latents).sample
+            img = (img / 2 + 0.5).clamp(0, 1).nan_to_num()
+            img = img.cpu().permute(0, 2, 3, 1).numpy()
+            pil_img = pipe.numpy_to_pil(img)[0]
+    else:
+        pil_img = Image.new('RGB', (128, 128), (0,0,0))
+    pil_img = pil_img.resize((1024, 1024), resample=Image.NEAREST)
+    draw = ImageDraw.Draw(pil_img)
+    font = ImageFont.load_default()
+    if k_obj.system_state == "BOOT":
+        y = 50
+        for log in k_obj.boot_log:
+            draw.text((50, y), log, fill=(0, 255, 0), font=font)
+            y += 20
+    scale = 8
+    for p in k_obj.processes.values():
+        wx, wy = p.position
+        cx = (wx * scale) + 10
+        cy = (wy * scale) + 30
+        draw.text(((wx*scale)+5, (wy*scale)+5), p.name, fill=(255,255,255), font=font)
+        if p.text_buffer:
+            for i, line in enumerate(p.text_buffer[-20:]):
+                col = (0, 255, 0) if p.app_type == "cmd" else (0,0,0)
+                if p.app_type == "doom": col = (255, 50, 50)
+                draw.text((cx, cy + (i*15)), line, fill=col, font=font)
+    buf = io.BytesIO()
+    pil_img.save(buf, format="JPEG", quality=85)
+    return base64.b64encode(buf.getvalue()).decode()
+@app.route('/')
+def index():
+    return HTML_TEMPLATE
+@sock.route('/kernel')
+def websocket_kernel(ws):
+    global kernel
+    if not pipe: init_ai()
+    init_drivers()
+    kernel = OSKernel()
+    boot_msgs = ["BIOS DATE 01/23/2026", "DETECTING NEURAL NET...", "LOADING VFS...", "BOOTING..."]
+    for msg in boot_msgs:
+        kernel.boot_log.append(msg)
+        ws.send(json.dumps({"type": "frame_update", "data": render_frame(kernel)}))
+        time.sleep(0.5)
+    kernel.init_desktop()
+    ws.send(json.dumps({"type": "frame_update", "data": render_frame(kernel)}))
+    while True:
+        try:
+            data = ws.receive()
+            if not data: break
+            msg = json.loads(data)
+            needs_update = False
+            if msg['type'] == 'click':
+                x, y = msg['x'], msg['y']
+                if y >= 122 and x < 24:
+                    kernel.start_menu_open = not kernel.start_menu_open
+                    needs_update = True
+                elif kernel.system_state == "DESKTOP":
+                    for i in kernel.desktop_icons:
+                        if i['x'] <= x < i['x']+8 and i['y'] <= y < i['y']+8:
+                            kernel.spawn(i['app'], 30, 20)
+                            needs_update = True
+                    for p in sorted(kernel.processes.values(), key=lambda z: z.z_order, reverse=True):
+                        px, py = p.position
+                        pw, ph = p.size
+                        if px <= x < px+pw and py <= y < py+ph:
+                            kernel.focus(p.pid)
+                            if py <= y < py+4 and px+pw-4 <= x < px+pw: kernel.kill(p.pid)
+                            needs_update = True
+                            break
+            elif msg['type'] == 'keydown':
+                kernel.input(msg['key'])
+                if kernel.focused_pid:
+                    p = kernel.processes[kernel.focused_pid]
+                    if "spawn_req" in p.meta:
+                        kernel.spawn(p.meta.pop("spawn_req"), 40, 40)
+                    if p.app_type == "doom" and p.meta.get("needs_update"):
+                        p.text_buffer.append(f"ACTION: {p.meta.get('last_key')}")
+                        p.meta["needs_update"] = False
+                needs_update = True
+            if needs_update:
+                ws.send(json.dumps({"type": "frame_update", "data": render_frame(kernel)}))
+        except Exception as e:
+            print(f"WS Error: {e}")
+            break
+if __name__ == "__main__":
+    print("="*50)
+    print("  NEURAL OS MONOLITH v9.2")
+    print("  http://0.0.0.0:7860")
+    print("="*50)
+    # Updated to port 7860 for Hugging Face
+    app.run(host="0.0.0.0", port=7860, threaded=True)
+EOF
+# 5. Launch the Monolith
+EXPOSE 7860
 CMD ["python", "app.py"]