fix state error

.agent/memory/session.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
-  "session_id": "a709b623",
-  "started_at": "2026-04-07T22:15:07.430955+05:30",
+  "session_id": "ca245f40",
+  "started_at": "2026-04-08T00:02:12.484470+05:30",
   "workspace": "D:\\Code\\codeverse",
   "active_task_id": null,
   "active_agent": null,

auth.ts

@@ -5,6 +5,7 @@ import { client as db } from "@/lib/db";
 import { randomUUID } from "crypto";
 import type { Adapter, AdapterUser, AdapterAccount, AdapterSession, VerificationToken } from "@auth/core/adapters";
 import { JWT } from "next-auth/jwt";
+import { AUTH_CONFIG, ROUTES } from "@/constants";
 
 /**
  * 🛰️ CodeVerse Authentication Core
@@ -274,10 +275,10 @@ export const { handlers, auth, signIn, signOut } = NextAuth({
         async authorize(credentials) {
           if (credentials?.username === "dev" || credentials?.username === "guest") {
               return { 
-                id: "dev-user-id", 
-                name: "Developer Guest", 
-                email: "dev@codeverse.local", 
-                image: "https://github.com/identicons/dev.png",
+                id: AUTH_CONFIG.DEV_USER_ID, 
+                name: AUTH_CONFIG.DEV_USER_NAME, 
+                email: AUTH_CONFIG.DEV_USER_EMAIL, 
+                image: AUTH_CONFIG.DEV_AVATAR,
               };
           }
           return null;
@@ -285,7 +286,7 @@ export const { handlers, auth, signIn, signOut } = NextAuth({
       })
     ] : []),
   ],
-  session: { strategy: "jwt" },
+  session: { strategy: AUTH_CONFIG.SESSION_STRATEGY as "jwt" | "database" },
   callbacks: {
     async jwt({ token, user }) {
       if (user) {
@@ -303,7 +304,7 @@ export const { handlers, auth, signIn, signOut } = NextAuth({
     },
   },
   pages: {
-    signIn: "/login",
+    signIn: ROUTES.LOGIN,
   },
   debug: process.env.NODE_ENV === "development",
 });

dist/constants/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * 🛠️ CodeVerse Global Constants
+ * Centralized source of truth for all non-changeable text, configuration, and magic numbers.
+ * Adheres to Production-Grade Standards for consistency and maintainability.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROUTES = exports.UI_STRINGS = exports.INFRA_CONFIG = exports.AUTH_CONFIG = exports.APP_CONFIG = void 0;
+exports.APP_CONFIG = {
+    NAME: "CodeVerse",
+    VERSION: "1.0.0-stable",
+    DESCRIPTION: "The fully managed, agentic VS Code environment running securely in the browser.",
+    LOGO_SIZE: 40,
+    DEFAULT_LANGUAGE: "typescript",
+};
+exports.AUTH_CONFIG = {
+    DEV_USER_ID: "dev-user-id",
+    DEV_USER_NAME: "Developer Guest",
+    DEV_USER_EMAIL: "dev@codeverse.local",
+    DEV_AVATAR: "https://github.com/identicons/dev.png",
+    SESSION_STRATEGY: "jwt",
+};
+exports.INFRA_CONFIG = {
+    WORKSPACE_ROOT: process.env.WORKSPACE_ROOT || "/home/node/w",
+    TMPDIR: process.env.TMPDIR || "/tmp",
+    HF_HOME: process.env.HF_HOME || "/tmp/.cache/huggingface",
+    DEFAULT_PORT_START: 3001,
+    IDLE_TIMEOUT_MS: 30 * 60 * 1000, // 30 minutes
+    PERSISTENCE_INTERVAL_MS: 60 * 1000, // 1 minute
+};
+exports.UI_STRINGS = {
+    MAINTENANCE_TITLE: "Infrastructure Locked",
+    MAINTENANCE_MESSAGE: "CodeVerse is currently initializing hardware. Please wait while we secure your environment.",
+    LOGIN_TITLE: "CodeVerse Studio",
+    LOGIN_SUBTITLE: "The fully managed, agentic VS Code environment running securely in the browser.",
+    BYPASS_LABEL: "Bypass Login (Local Dev Only)",
+};
+exports.ROUTES = {
+    HOME: "/",
+    LOGIN: "/login",
+    API: {
+        AUTH: "/api/auth",
+        WORKSPACE: "/api/workspace",
+    }
+};

dist/lib/db/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = exports.client = void 0;
+const client_1 = require("@libsql/client");
+const url = process.env.TURSO_URL || "file:local.db";
+const authToken = process.env.TURSO_AUTH_TOKEN;
+/**
+ * 🛠️ LibSQL Client Singleton (Native Edition)
+ * Provides 100% stable, high-performance database access without Drizzle overhead.
+ * Optimized for sandboxed execution on Hugging Face Spaces.
+ */
+exports.client = (0, client_1.createClient)({
+    url,
+    authToken,
+});
+/**
+ * 🛡️ Database Client Export
+ * Used by authentication and action layers.
+ */
+exports.db = exports.client;
+// 🚀 Database lifecycle is managed by the server entrypoint to ensure proper synchronization.

dist/lib/db/schema.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawSchema = void 0;
+exports.initDb = initDb;
+exports.rawSchema = `
+CREATE TABLE IF NOT EXISTS users (
+  id TEXT PRIMARY KEY,
+  name TEXT,
+  email TEXT UNIQUE,
+  image TEXT,
+  github_username TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS accounts (
+  id TEXT PRIMARY KEY,
+  userId TEXT NOT NULL,
+  provider TEXT NOT NULL,
+  providerAccountId TEXT NOT NULL,
+  refresh_token TEXT,
+  access_token TEXT,
+  expires_at INTEGER,
+  token_type TEXT,
+  scope TEXT,
+  id_token TEXT,
+  session_state TEXT,
+  FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS workspaces (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  project_name TEXT NOT NULL,
+  container_id TEXT,
+  android_container_id TEXT,
+  status TEXT DEFAULT 'stopped',
+  port_mapping INTEGER,
+  android_port INTEGER,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS chat_history (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  tool_invocations TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+  FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS communities (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  description TEXT,
+  owner_id TEXT NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  sessionToken TEXT UNIQUE NOT NULL,
+  userId TEXT NOT NULL,
+  expires DATETIME NOT NULL,
+  FOREIGN KEY (userId) REFERENCES users(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS verification_tokens (
+  identifier TEXT NOT NULL,
+  token TEXT NOT NULL,
+  expires DATETIME NOT NULL,
+  PRIMARY KEY (identifier, token)
+);
+`;
+/**
+ * 🚀 Database Initialization Routine
+ * Hardened for Hugging Face Spaces: Ensures schema exists and dev user is seeded.
+ */
+async function initDb(client) {
+    // Use raw execution for robustness during cold start
+    await client.executeMultiple(exports.rawSchema);
+    // 🌱 SEEDING (Dev Only): Create a 'Developer Guest' user for the login bypass
+    if (process.env.NODE_ENV === "development" || process.env.NEXT_PUBLIC_NODE_ENV === "development") {
+        try {
+            await client.execute({
+                sql: "INSERT OR IGNORE INTO users (id, name, email, image) VALUES (?, ?, ?, ?)",
+                args: ["dev-user-id", "Developer Guest", "dev@codeverse.local", "https://github.com/identicons/dev.png"]
+            });
+            console.log("[SYSTEM] Dev Seeding: 'Developer Guest' user ready.");
+        }
+        catch (e) {
+            console.error("[SYSTEM] Dev Seeding failed:", e);
+        }
+    }
+}

dist/lib/docker/manager.js

@@ -0,0 +1,428 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerManager = exports.DockerManager = exports.pendingProvisioning = exports.provisioningBus = exports.nativeProcesses = void 0;
+exports.isNativeWorkspaceRunning = isNativeWorkspaceRunning;
+exports.getWorkspaceStatus = getWorkspaceStatus;
+exports.isDockerAvailable = isDockerAvailable;
+exports.stopNativeWorkspace = stopNativeWorkspace;
+exports.getNativeWorkspacePort = getNativeWorkspacePort;
+exports.getAndroidPort = getAndroidPort;
+exports.prewarmWorkspace = prewarmWorkspace;
+exports.startWorkspaceContainer = startWorkspaceContainer;
+exports.reconnectRunningWorkspaces = reconnectRunningWorkspaces;
+exports.stopWorkspaceContainer = stopWorkspaceContainer;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const dockerode_1 = __importDefault(require("dockerode"));
+const events_1 = require("events");
+const idx_engine_1 = require("../idx/idx-engine");
+const storage_1 = require("../hf/storage");
+/**
+ * Registry for native workspace processes (IDE instances running outside Docker)
+ * Map<workspaceId, { pid: number; port: number; process: WorkspaceProcess }>
+ */
+exports.nativeProcesses = new Map();
+/**
+ * Internal Provisioning Bus to multicast logs to concurrent clients.
+ */
+class ProvisioningBus extends events_1.EventEmitter {
+}
+exports.provisioningBus = new ProvisioningBus();
+/**
+ * Map to track active provisioning promises to prevent redundant creation loops.
+ */
+exports.pendingProvisioning = new Map();
+/**
+ * Checks if a native workspace is currently running.
+ * Supports fuzzy matching for reconnected sessions that might use a prefix key.
+ */
+function isNativeWorkspaceRunning(id) {
+    if (exports.nativeProcesses.has(id))
+        return true;
+    // Prefix fallback for reconnected sessions
+    return Array.from(exports.nativeProcesses.keys()).some(k => id.startsWith(k));
+}
+/**
+ * Returns the current runtime status of a workspace.
+ */
+function getWorkspaceStatus(id) {
+    if (exports.nativeProcesses.has(id))
+        return "ready";
+    if (exports.pendingProvisioning.has(id))
+        return "provisioning";
+    return "offline";
+}
+/**
+ * Helper for async delays.
+ */
+const delay = (ms) => new Promise(res => setTimeout(res, ms));
+/**
+ * Finds an available port in the 8100-9000 range.
+ */
+function findAvailablePort() {
+    const occupiedPorts = Array.from(exports.nativeProcesses.values()).map(p => p.port);
+    let port = Math.floor(Math.random() * (9000 - 8100) + 8100);
+    while (occupiedPorts.includes(port)) {
+        port = Math.floor(Math.random() * (9000 - 8100) + 8100);
+    }
+    return port;
+}
+/**
+ * Checks if Docker is available in the current environment.
+ */
+async function isDockerAvailable() {
+    const socketPath = process.platform === 'win32' ? '//./pipe/docker_engine' : '/var/run/docker.sock';
+    if (process.env.SIMULATE_HF === 'true') {
+        return { available: false, reason: "Hugging Face Simulation Mode (Artificial Sandbox)" };
+    }
+    if (process.env.SPACE_ID) {
+        return { available: false, reason: "Hugging Face Space (Native Sandboxed)" };
+    }
+    try {
+        const docker = new dockerode_1.default({ socketPath: process.platform === 'win32' ? undefined : socketPath });
+        await docker.ping();
+        return { available: true };
+    }
+    catch (_a) {
+        return { available: false, reason: "Docker daemon unreachable" };
+    }
+}
+/**
+ * Stops a native workspace process.
+ */
+async function stopNativeWorkspace(id) {
+    const entry = exports.nativeProcesses.get(id);
+    if (entry) {
+        try {
+            entry.process.kill();
+            exports.nativeProcesses.delete(id);
+            return true;
+        }
+        catch (e) {
+            console.error(`[MANAGER] Failed to kill code-server ${id}:`, e);
+            exports.nativeProcesses.delete(id);
+        }
+    }
+    return false;
+}
+/**
+ * Gets the internal port for a native workspace process.
+ * Supports fuzzy matching for reconnected sessions.
+ */
+function getNativeWorkspacePort(id) {
+    var _a;
+    const entry = exports.nativeProcesses.get(id);
+    if (entry)
+        return entry.port;
+    // Prefix fallback
+    const key = Array.from(exports.nativeProcesses.keys()).find(k => id.startsWith(k));
+    return key ? (_a = exports.nativeProcesses.get(key)) === null || _a === void 0 ? void 0 : _a.port : undefined;
+}
+/**
+ * Returns the global unified Android VNC port.
+ */
+function getAndroidPort() {
+    return 6080;
+}
+/**
+ * PREDICTIVE HYDRATION: Pre-warms Nix profile and SDKs.
+ */
+async function prewarmWorkspace(config) {
+    // CRITICAL (April 2026): Shorten paths to avoid Unix Domain Socket (UDS) path limit (104 chars)
+    const workspaceRoot = process.env.WORKSPACE_ROOT || path_1.default.join(/*turbopackIgnore: true*/ '/home/node/w');
+    const workspacePath = path_1.default.join(/*turbopackIgnore: true*/ workspaceRoot, config.id.slice(0, 8));
+    if (!fs_1.default.existsSync(workspacePath)) {
+        fs_1.default.mkdirSync(workspacePath, { recursive: true });
+    }
+    const idxConfig = idx_engine_1.IdxEngine.getIdxConfig(workspacePath);
+    if (idxConfig) {
+        // Run Nix sync in background if not already warmed
+        idx_engine_1.IdxEngine.syncNixEnvironment(workspacePath, idxConfig, (msg) => {
+            exports.provisioningBus.emit(`log:${config.id}`, `[HYDRATE] ${msg}`);
+        });
+    }
+}
+/**
+ * INTERNAL: Core provisioning logic with IDX support and auto-provisioning baseline.
+ */
+async function performProvisioning(config) {
+    const log = (msg) => {
+        if (config.onLog)
+            config.onLog(`[IDX:ENGINE] ${msg}`);
+        exports.provisioningBus.emit(`log:${config.id}`, msg);
+    };
+    try {
+        log(`Provisioning hermetic environment for '${config.projectName}'...`);
+        // 0. HF PERSISTENCE: Restore profile from Dataset if available
+        try {
+            await storage_1.HFStorage.syncFromDataset((msg) => log(msg));
+        }
+        catch (e) {
+            log(`[WARN] Persistent profile restoration failed: ${e instanceof Error ? e.message : String(e)}. Proceeding with clean environment.`);
+        }
+        // 1. Prepare Workspace Directory
+        const workspaceRoot = process.env.WORKSPACE_ROOT || path_1.default.join(/*turbopackIgnore: true*/ '/home/node/w');
+        const workspacePath = path_1.default.join(/*turbopackIgnore: true*/ workspaceRoot, config.id.slice(0, 8));
+        const userDataPath = path_1.default.join(/*turbopackIgnore: true*/ workspacePath, '.vscode-server');
+        if (!fs_1.default.existsSync(workspacePath)) {
+            fs_1.default.mkdirSync(workspacePath, { recursive: true });
+            // Store full ID for reliable reconnection after server restarts
+            fs_1.default.writeFileSync(path_1.default.join(workspacePath, '.codeverse-id'), config.id);
+            log(`Allocated isolated filesystem segment: ${config.id.slice(0, 8)}`);
+        }
+        // 2. IDX Engine: Sync Environment
+        const idxConfig = idx_engine_1.IdxEngine.getIdxConfig(workspacePath);
+        log(`Declarative config detected (Packages: ${idxConfig.packages.length}). Initializing synchronization...`);
+        await idx_engine_1.IdxEngine.syncNixEnvironment(workspacePath, idxConfig, (msg) => log(msg));
+        const flagPath = path_1.default.join(/*turbopackIgnore: true*/ workspacePath, '.idx-created');
+        if (!fs_1.default.existsSync(flagPath)) {
+            if (idxConfig.onCreate) {
+                log(`Executing onCreate lifecycle hook...`);
+                await idx_engine_1.IdxEngine.runHook(workspacePath, 'onCreate', idxConfig.onCreate, (msg) => log(msg));
+            }
+            fs_1.default.writeFileSync(flagPath, new Date().toISOString());
+        }
+        // 4. Identify Target Port
+        const port = findAvailablePort();
+        // 5. Spawn code-server
+        const shellCommand = process.platform === 'win32' ? 'npx' : 'code-server';
+        const args = process.platform === 'win32' ? ['code-server'] : [];
+        const baseArgs = [
+            '--auth', 'none',
+            '--bind-addr', `127.0.0.1:${port}`,
+            '--user-data-dir', userDataPath,
+            '--disable-telemetry',
+            '--disable-update-check',
+            workspacePath
+        ];
+        const spawnEnv = { ...process.env, HOME: workspacePath };
+        delete spawnEnv.PORT;
+        delete spawnEnv.SERVER_PORT;
+        const child = (0, child_process_1.spawn)(shellCommand, [...args, ...baseArgs], {
+            env: spawnEnv,
+            cwd: workspacePath,
+            shell: process.platform === 'win32'
+        });
+        log(`Spawning VS Code Orchestrator (PID: ${child.pid})...`);
+        child.on('error', (err) => log(`[FATAL] IDE binary failure: ${err.message}`));
+        child.stdout.on('data', (data) => {
+            const out = data.toString().trim();
+            if (out.includes('listening on'))
+                log(`[IDX:UP] ${out}`);
+            else if (out.length > 0)
+                log(`[IDE:CORE] ${out}`);
+        });
+        child.stderr.on('data', (data) => {
+            const err = data.toString().trim();
+            if (err.length > 0)
+                log(`[IDE:ERR] ${err}`);
+        });
+        child.on('close', (code, signal) => {
+            log(`[IDE:EXIT] IDE process died with code ${code} (Signal: ${signal})`);
+        });
+        // 6. Register in active pool
+        exports.nativeProcesses.set(config.id, { pid: child.pid, port, process: child });
+        // 7. Handshake Loop
+        let attempts = 0;
+        while (attempts < 60) {
+            try {
+                const res = await fetch(`http://127.0.0.1:${port}`);
+                if (res.ok) {
+                    log(`Handshake verified. Studio Engine Online.`);
+                    if (idxConfig.onStart) {
+                        log(`Executing background onStart lifecycle hooks...`);
+                        idx_engine_1.IdxEngine.runHook(workspacePath, 'onStart', idxConfig.onStart, (msg) => log(msg), true);
+                    }
+                    const finalResult = {
+                        success: true,
+                        containerId: `native-${config.id}`,
+                        androidPort: config.withAndroidEmulator ? 6080 : undefined,
+                        port: port
+                    };
+                    exports.provisioningBus.emit(`ready:${config.id}`, finalResult);
+                    return finalResult;
+                }
+            }
+            catch (_a) {
+                if (attempts % 5 === 0)
+                    log(`[INFO] Scanning for IDE heartbeat... (Attempt ${attempts}/60)`);
+                if (attempts === 15)
+                    log(`[INFO] Nix evaluation in progress. Cold boot detected.`);
+                if (attempts === 45)
+                    log(`[WARN] Handshake threshold approaching. IDE core high load.`);
+                await delay(1000);
+                attempts++;
+            }
+        }
+        log(`[FATAL] Handshake timeout on 127.0.0.1:${port}.`);
+        const entry = exports.nativeProcesses.get(config.id);
+        if (entry) {
+            entry.process.kill();
+            exports.nativeProcesses.delete(config.id);
+        }
+        const errResult = { success: false, error: "IDE_HANDSHAKE_TIMEOUT" };
+        exports.provisioningBus.emit(`error:${config.id}`, errResult);
+        return errResult;
+    }
+    catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        log(`[FATAL] Provisioning pipeline collapsed: ${error}`);
+        const errResult = { success: false, error: "PROVISIONING_FAILED" };
+        exports.provisioningBus.emit(`error:${config.id}`, errResult);
+        return errResult;
+    }
+}
+/**
+ * Workspace provisioner with ATOMIC single-instance locking.
+ */
+async function startWorkspaceContainer(config) {
+    if (exports.nativeProcesses.has(config.id)) {
+        return {
+            success: true,
+            containerId: `native-${config.id}`,
+            port: exports.nativeProcesses.get(config.id).port
+        };
+    }
+    let pending = exports.pendingProvisioning.get(config.id);
+    if (!pending) {
+        pending = performProvisioning(config).finally(() => {
+            exports.pendingProvisioning.delete(config.id);
+        });
+        exports.pendingProvisioning.set(config.id, pending);
+    }
+    return await pending;
+}
+/**
+ * 🛠️ SELF-HEALING: Scans for running code-server instances to repopulate the proxy map.
+ * This allows the IDE to survive server restarts or cold boots by probing active ports.
+ */
+async function reconnectRunningWorkspaces() {
+    const workspaceRoot = process.env.WORKSPACE_ROOT || '/home/node/w';
+    console.log(`[BOOT] Probing filesystem segment: ${workspaceRoot} for existing sessions...`);
+    try {
+        // Find all code-server processes
+        // Note: Using a more robust ps grep that works across most POSIX environments
+        const psCmd = process.platform === 'win32' ? 'tasklist' : "ps aux | grep code-server | grep -v grep";
+        const output = (0, child_process_1.execSync)(psCmd).toString();
+        const lines = output.split('\n');
+        for (const line of lines) {
+            // Looking for: ... --bind-addr 127.0.0.1:8548 ... w/44c7597c
+            const bindMatch = line.match(/--bind-addr 127\.0\.0\.1:(\d+)/);
+            // Flexible path match: look for the ID prefix after 'w/' or 'workspaces/' or just the root
+            const pathMatch = line.match(/[ /](?:w|workspaces)\/([a-zA-Z0-9]{8})/);
+            if (bindMatch && pathMatch) {
+                const port = parseInt(bindMatch[1]);
+                const shortId = pathMatch[1];
+                const fullPath = path_1.default.join(workspaceRoot, shortId);
+                const idFile = path_1.default.join(fullPath, '.codeverse-id');
+                let foundFullId = "";
+                if (fs_1.default.existsSync(idFile)) {
+                    foundFullId = fs_1.default.readFileSync(idFile, 'utf-8').trim();
+                }
+                else {
+                    // Fallback: If no ID file, we use the shortId as the temporary key.
+                    foundFullId = shortId;
+                    console.warn(`[RECONNECT:WARN] No .codeverse-id for session ${shortId}. Using prefix mapping.`);
+                }
+                if (foundFullId && !exports.nativeProcesses.has(foundFullId)) {
+                    // Capture PID reliably from ps output (column 2)
+                    const psParts = line.trim().split(/\s+/);
+                    const pid = parseInt(psParts[1]);
+                    console.log(`[RECONNECT] Identified active IDE ${foundFullId} (PID: ${pid}) on port ${port}. Restoration complete.`);
+                    exports.nativeProcesses.set(foundFullId, {
+                        pid,
+                        port,
+                        process: {
+                            pid,
+                            kill: () => {
+                                try {
+                                    process.kill(pid, 'SIGKILL');
+                                    return true;
+                                }
+                                catch (_a) {
+                                    try {
+                                        (0, child_process_1.execSync)(`fuser -k ${port}/tcp`);
+                                    }
+                                    catch (_b) { }
+                                    return true;
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    }
+    catch (e) {
+        // No processes found or ps failed
+    }
+}
+/**
+ * 🟢 ENGINE WATCHDOG: Background health monitor for native IDE processes.
+ */
+function startEngineWatchdog() {
+    setInterval(async () => {
+        for (const [id, entry] of exports.nativeProcesses.entries()) {
+            try {
+                // 1. Zombie Check
+                try {
+                    process.kill(entry.pid, 0);
+                }
+                catch (_a) {
+                    console.log(`[WATCHDOG] Process ${entry.pid} for ${id} is missing. Pruning.`);
+                    exports.nativeProcesses.delete(id);
+                    continue;
+                }
+                // 2. Healthz Polling
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 2000);
+                try {
+                    const res = await fetch(`http://127.0.0.1:${entry.port}`, { signal: controller.signal });
+                    if (!res.ok)
+                        throw new Error('Unhealthy');
+                }
+                catch (_b) {
+                    console.warn(`[WATCHDOG] IDE ${id} (Port ${entry.port}) is non-responsive.`);
+                    // Optional: force restart if unhealthy for multiple cycles
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+            }
+            catch (e) {
+                console.error(`[WATCHDOG:ERR] ${e}`);
+            }
+        }
+    }, 60000);
+}
+startEngineWatchdog();
+/**
+ * Standardized stop method.
+ */
+async function stopWorkspaceContainer(id) {
+    const success = await stopNativeWorkspace(id);
+    return { success: success || true };
+}
+/**
+ * Modern Docker Manager class.
+ */
+class DockerManager {
+    async getContainerStatus(id) {
+        if (isNativeWorkspaceRunning(id))
+            return "running";
+        return "stopped";
+    }
+    async stopContainer(id) {
+        return stopNativeWorkspace(id);
+    }
+    async startWorkspace(config) {
+        const result = await startWorkspaceContainer(config);
+        return result.success;
+    }
+}
+exports.DockerManager = DockerManager;
+exports.dockerManager = new DockerManager();

dist/lib/env-config.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_CONFIG = void 0;
+exports.validateEnvironment = validateEnvironment;
+/**
+ * CodeVerse Environment Configuration & Requirements Manifest.
+ * Centralizing all system variables for production-grade reliability.
+ */
+exports.ENV_CONFIG = {
+    // 1. Storage & Persistence
+    HF_TOKEN: process.env.HF_TOKEN || process.env.hfToken || process.env.HF_SPACE || process.env.HuggingFaceToken,
+    HF_DATASET_ID: process.env.HF_DATASET_ID || process.env.hfDataset || process.env.HF_DATASET,
+    WORKSPACE_ROOT: process.env.WORKSPACE_ROOT || '/home/node/w',
+    // 2. Build Acceleration
+    CACHIX_CACHE_NAME: process.env.CACHIX_CACHE_NAME || 'code-nix',
+    CACHIX_AUTH_TOKEN: process.env.CACHIX_AUTH_TOKEN,
+    // 3. Infrastructure State
+    NODE_ENV: process.env.NODE_ENV || 'production',
+    SPACE_ID: process.env.SPACE_ID,
+    APP_BASE_URL: process.env.NEXTAUTH_URL || 'http://localhost:7860',
+    IS_SBC: !!process.env.SPACE_ID,
+    // 4. Database & Auth
+    AUTH_SECRET: process.env.AUTH_SECRET || process.env.authSecret,
+    TURSO_URL: process.env.TURSO_URL || process.env.turso_url || process.env.database_url || process.env.TURSO_DATABASE_URL || process.env.DB_URL || process.env.turso_database_url,
+    TURSO_AUTH_TOKEN: process.env.TURSO_AUTH_TOKEN || process.env.turso_auth_token || process.env.DB_TOKEN,
+    TMPDIR: '/tmp',
+    HF_HOME: '/tmp/.cache/huggingface',
+};
+/**
+ * Validates that all critical infrastructure secrets are available.
+ */
+function validateEnvironment() {
+    const missing = [];
+    if (!exports.ENV_CONFIG.HF_TOKEN)
+        missing.push('HF_TOKEN (Missing Persistence Link)');
+    if (!exports.ENV_CONFIG.HF_DATASET_ID)
+        missing.push('HF_DATASET_ID (Missing Data Segment)');
+    if (!exports.ENV_CONFIG.AUTH_SECRET)
+        missing.push('AUTH_SECRET (Security Risk)');
+    if (!exports.ENV_CONFIG.TURSO_URL)
+        missing.push('TURSO_URL (Database Missing)');
+    // Strategic Dataset Validation
+    if (exports.ENV_CONFIG.HF_DATASET_ID && !exports.ENV_CONFIG.HF_DATASET_ID.includes('/')) {
+        return { valid: false, missing: ['HF_DATASET_ID_FORMAT_ERROR: Must be "username/dataset"'] };
+    }
+    return {
+        valid: missing.length === 0,
+        missing: missing
+    };
+}

dist/lib/hf/storage.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HFStorage = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Hugging Face Storage Utility for 2026 CodeVerse Persistence.
+ */
+class HFStorage {
+    /**
+     * Internal helper for asynchronous execution with logging.
+     */
+    static async execAsync(command, onLog) {
+        return new Promise((resolve, reject) => {
+            const spawnEnv = {
+                ...process.env,
+                HF_TOKEN: this.HF_TOKEN,
+                HF_HOME: '/tmp/.cache/huggingface',
+                TMPDIR: '/tmp',
+                PATH: `/home/node/.local/bin:/home/node/.nix-profile/bin:/usr/local/bin:/usr/bin:${process.env.PATH}`
+            };
+            const child = (0, child_process_1.spawn)('/bin/bash', ['-c', command], {
+                env: spawnEnv
+            });
+            child.stdout.on('data', (data) => onLog === null || onLog === void 0 ? void 0 : onLog(data.toString().trim()));
+            child.stderr.on('data', (data) => {
+                const msg = data.toString().trim();
+                if (msg.includes('command not found')) {
+                    onLog === null || onLog === void 0 ? void 0 : onLog(`[CRITICAL] Binary missing: ${msg}. Current PATH: ${spawnEnv.PATH}`);
+                }
+                onLog === null || onLog === void 0 ? void 0 : onLog(`[WARN] ${msg}`);
+            });
+            child.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Command failed with code ${code}: ${command}`));
+            });
+        });
+    }
+    /**
+     * Synchronizes the environment FROM the Hugging Face Dataset (Pull).
+     */
+    static async syncFromDataset(onLog) {
+        if (!this.HF_TOKEN || !this.HF_DATASET_ID) {
+            onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Persistence layer inactive. Missing credentials.`);
+            return;
+        }
+        onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Pulling persistent profile from '${this.HF_DATASET_ID}'...`);
+        try {
+            const tmpDir = '/tmp/hf-sync';
+            if (!fs_1.default.existsSync(tmpDir))
+                fs_1.default.mkdirSync(tmpDir, { recursive: true });
+            // 🟢 DELTA SYNCING: Only sync the specific workspace and IDE state directories
+            const home = process.env.HOME || '/home/node';
+            const persistDirs = ['w', '.vscode-server', '.config/code-server'];
+            for (const dir of persistDirs) {
+                const localPath = path_1.default.join(home, dir);
+                if (!fs_1.default.existsSync(localPath))
+                    fs_1.default.mkdirSync(localPath, { recursive: true });
+                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli download ${this.HF_DATASET_ID} --local-dir ${localPath} --include "${dir}/*" --token ${this.HF_TOKEN}) || (hf download ${this.HF_DATASET_ID} --local-dir ${localPath} --include "${dir}/*" --token ${this.HF_TOKEN})`;
+                onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Restoring ${dir} from differential profile...`);
+                await this.execAsync(cmd, onLog).catch(() => { }); // Continue if one dir fails
+            }
+            onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Profile restoration complete.`);
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            onLog === null || onLog === void 0 ? void 0 : onLog(`[ERROR] Profile restoration failed: ${errorMessage}`);
+        }
+    }
+    /**
+     * Synchronizes the environment TO the Hugging Face Dataset (Push).
+     */
+    static async syncToDataset(onLog) {
+        if (!this.HF_TOKEN || !this.HF_DATASET_ID)
+            return;
+        try {
+            onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Saving persistent profile to '${this.HF_DATASET_ID}'...`);
+            const home = process.env.HOME || '/home/node';
+            const persistDirs = ['w', '.vscode-server', '.config/code-server'];
+            for (const dir of persistDirs) {
+                const localPath = path_1.default.join(home, dir);
+                if (!fs_1.default.existsSync(localPath))
+                    continue;
+                const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli upload ${this.HF_DATASET_ID} ${localPath} ${dir} --token ${this.HF_TOKEN} --message "CodeVerse Sync [${dir}]: ${new Date().toISOString()}" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*") || (hf upload ${this.HF_DATASET_ID} ${localPath} ${dir} --token ${this.HF_TOKEN})`;
+                onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Performing differential backup of ${dir}...`);
+                await this.execAsync(cmd, onLog).catch(err => onLog === null || onLog === void 0 ? void 0 : onLog(`[WARN] Sync failed for ${dir}: ${err.message}`));
+            }
+            onLog === null || onLog === void 0 ? void 0 : onLog(`[HF:STORAGE] Profile backup successful.`);
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            onLog === null || onLog === void 0 ? void 0 : onLog(`[ERROR] Profile synchronization failed: ${errorMessage}`);
+        }
+    }
+    static startAutoSave(intervalMs = 300000) {
+        if (this.autoSaveStarted)
+            return;
+        this.autoSaveStarted = true;
+        console.log(`[HF:STORAGE] Persistence heartbeat initialized (Interval: ${intervalMs}ms)`);
+        setInterval(async () => {
+            await this.syncToDataset((msg) => console.log(msg)).catch(() => { });
+        }, intervalMs);
+    }
+}
+exports.HFStorage = HFStorage;
+HFStorage.HF_TOKEN = process.env.HF_TOKEN;
+HFStorage.HF_DATASET_ID = process.env.HF_DATASET_ID;
+HFStorage.PROFILE_PATH = path_1.default.join(process.env.HOME || '/home/node', '.nix-profile');
+HFStorage.WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || '/home/node/w';
+/**
+ * Starts the periodic persistence interval (Singleton Heartbeat).
+ */
+HFStorage.autoSaveStarted = false;

dist/lib/idx/idx-engine.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdxEngine = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+/**
+ * IDX Engine for declarative workspace environments.
+ * Refactored for 2026 Asynchronous Execution to prevent Event Loop blocking.
+ */
+class IdxEngine {
+    /**
+     * Returns a robust baseline configuration for workspaces without a dev.nix.
+     */
+    static getDefaultConfig() {
+        return {
+            packages: ['pkgs.nodejs', 'pkgs.go', 'pkgs.python3', 'pkgs.docker', 'pkgs.python3Packages.huggingface-hub'],
+            onCreate: 'npm install',
+            onStart: 'sleep 5 && npm run dev'
+        };
+    }
+    /**
+     * Detects and parses the .idx/dev.nix file in the workspace root.
+     */
+    static getIdxConfig(workspacePath) {
+        const configPath = path_1.default.join(/*turbopackIgnore: true*/ workspacePath, '.idx', 'dev.nix');
+        if (!fs_1.default.existsSync(configPath))
+            return this.getDefaultConfig();
+        try {
+            const content = fs_1.default.readFileSync(configPath, 'utf8');
+            const packagesMatch = content.match(/packages\s*=\s*\[([\s\S]*?)\]/);
+            const onCreateMatch = content.match(/onCreate\s*=\s*"{1,3}([\s\S]*?)"{1,3}/);
+            const onStartMatch = content.match(/onStart\s*=\s*"{1,3}([\s\S]*?)"{1,3}/);
+            const config = {
+                packages: packagesMatch ? packagesMatch[1].split(/[\s\n,]+/).map(p => p.trim()).filter(p => p.length > 0) : [],
+                onCreate: onCreateMatch ? onCreateMatch[1].trim() : undefined,
+                onStart: onStartMatch ? onStartMatch[1].trim() : undefined
+            };
+            // Ensure baseline safety
+            if (config.packages.length === 0)
+                config.packages = this.getDefaultConfig().packages;
+            return config;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            console.warn(`[IDX-ENGINE] Failed to parse dev.nix, falling back to baseline:`, errorMessage);
+            return this.getDefaultConfig();
+        }
+    }
+    /**
+     * Synchronizes the Nix environment based on the declarative packages.
+     * ASYNCHRONOUS Spawning to prevent Blocking.
+     */
+    static async syncNixEnvironment(workspacePath, config, onLog) {
+        if (!config.packages || config.packages.length === 0)
+            return;
+        const log = (msg) => { if (onLog)
+            onLog(`[IDX:NIX] ${msg}`); };
+        log(`Syncing system packages: ${config.packages.join(', ')}...`);
+        // CACHIX ACCELERATION: Robust check for binary existence to prevent ENOENT crash
+        const cachixName = process.env.CACHIX_CACHE_NAME || 'code-nix';
+        let hasCachix = false;
+        try {
+            await new Promise((resolve) => {
+                const check = (0, child_process_1.spawn)('command', ['-v', 'cachix'], { shell: true });
+                check.on('close', (code) => {
+                    hasCachix = (code === 0);
+                    resolve();
+                });
+                check.on('error', () => {
+                    hasCachix = false;
+                    resolve();
+                });
+            });
+        }
+        catch (_a) {
+            hasCachix = false;
+        }
+        if (hasCachix) {
+            const cachixToken = process.env.CACHIX_AUTH_TOKEN;
+            if (cachixToken) {
+                log(`Cachix authentication detected. Configuring access...`);
+                await new Promise((resolve) => {
+                    const auth = (0, child_process_1.spawn)('cachix', ['authtoken', cachixToken], { env: { ...process.env, HOME: workspacePath } });
+                    auth.on('close', () => resolve());
+                });
+            }
+            log(`Cachix acceleration detected. Setting up cache: ${cachixName}...`);
+            try {
+                await new Promise((resolve, reject) => {
+                    const child = (0, child_process_1.spawn)('cachix', ['use', cachixName], {
+                        cwd: workspacePath,
+                        env: { ...process.env, HOME: workspacePath }
+                    });
+                    child.on('error', (err) => reject(err));
+                    child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`Cachix failed with code ${code}`)));
+                });
+            }
+            catch (_b) {
+                log(`[WARN] Cachix setup bypassed. Falling back to default binary cache.`);
+            }
+        }
+        // 🟢 HYDRATION GUARD: Skip synchronization if packages haven't changed or if pre-baked baseline is available
+        const idxDir = path_1.default.join(workspacePath, '.idx');
+        if (!fs_1.default.existsSync(idxDir))
+            fs_1.default.mkdirSync(idxDir, { recursive: true });
+        const manifestPath = path_1.default.join(idxDir, 'packages.json');
+        const bakedManifestPath = '/home/node/.idx/baked-packages.json';
+        // 1. Check local manifest
+        if (fs_1.default.existsSync(manifestPath)) {
+            try {
+                const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+                const currentSorted = [...config.packages].sort();
+                const manifestSorted = [...(manifest.packages || [])].sort();
+                if (JSON.stringify(currentSorted) === JSON.stringify(manifestSorted)) {
+                    log(`Environment already synchronized. Skipping profile update.`);
+                    return;
+                }
+            }
+            catch (e) {
+                log(`[WARN] Manifest corruption detected. Forcing re-sync.`);
+            }
+        }
+        // 2. Check pre-baked manifest (for default configs)
+        const sortedDefault = [...IdxEngine.getDefaultConfig().packages].sort();
+        const sortedCurrent = [...config.packages].sort();
+        const isDefaultConfig = JSON.stringify(sortedCurrent) === JSON.stringify(sortedDefault);
+        if (isDefaultConfig && fs_1.default.existsSync(bakedManifestPath)) {
+            log(`Pre-baked baseline detected. Hydrating instance instantly...`);
+            try {
+                fs_1.default.copyFileSync(bakedManifestPath, manifestPath);
+                log(`Hydration complete. Workspace ready.`);
+                return;
+            }
+            catch (e) {
+                log(`[WARN] Hydration failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        // CACHIX ...
+        // ... (Cachix code remains the same or slightly optimized)
+        const batchTargets = config.packages.map(pkg => `nixpkgs#${pkg.replace('pkgs.', '')}`);
+        log(`Batch installing: ${batchTargets.join(', ')}...`);
+        await new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)('nix', ['profile', 'add', ...batchTargets], {
+                cwd: workspacePath,
+                env: {
+                    ...process.env,
+                    HOME: workspacePath,
+                    NIX_CONFIG: 'experimental-features = nix-command flakes'
+                }
+            });
+            child.stdout.on('data', (data) => log(data.toString().trim()));
+            child.stderr.on('data', (data) => log(`[INFO] ${data.toString().trim()}`));
+            child.on('close', (code) => {
+                if (code === 0) {
+                    fs_1.default.writeFileSync(manifestPath, JSON.stringify({ packages: config.packages, timestamp: new Date().toISOString() }));
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Batch Nix installation failed with code ${code}`));
+                }
+            });
+        }).catch((err) => {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log(`[ERROR] ${errMsg}`);
+        });
+        log(`Environment synchronized successfully.`);
+    }
+    /**
+     * Executes the 'onCreate' and 'onStart' hooks.
+     * supports background execution for 'onStart' to prevent blocking the IDE handshake.
+     */
+    static async runHook(workspacePath, hookName, script, onLog, background = false) {
+        const log = (msg) => { if (onLog)
+            onLog(`[IDX:HOOK] ${hookName}: ${msg}`); };
+        log(`Executing script... ${background ? '(Background)' : ''}`);
+        const hookPromise = new Promise((resolve, reject) => {
+            // 🟢 PORT DE-CONFLICTION: Ensure hooks don't inherit the main orchestrator's port 7860
+            const spawnEnv = { ...process.env, HOME: workspacePath };
+            delete spawnEnv.PORT;
+            delete spawnEnv.SERVER_PORT;
+            const child = (0, child_process_1.spawn)('/bin/bash', ['-c', script], {
+                cwd: workspacePath,
+                env: spawnEnv
+            });
+            child.stdout.on('data', (data) => log(data.toString().trim()));
+            child.stderr.on('data', (data) => log(`[WARN] ${data.toString().trim()}`));
+            child.on('close', (code) => {
+                if (code === 0) {
+                    log(`Hook ${hookName} completed successfully.`);
+                    resolve();
+                }
+                else {
+                    const err = new Error(`Hook ${hookName} failed with code ${code}`);
+                    log(`[ERROR] ${err.message}`);
+                    reject(err);
+                }
+            });
+            // If background, resolve immediately after spawn
+            if (background) {
+                log(`Hook detached and running in baseline context.`);
+                resolve();
+            }
+        });
+        if (!background) {
+            await hookPromise.catch(() => { }); // Catch handled in promise
+        }
+    }
+}
+exports.IdxEngine = IdxEngine;

dist/lib/jobs/auto-sleep.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIdleContainers = checkIdleContainers;
+exports.startAutoSleepCron = startAutoSleepCron;
+const dockerode_1 = __importDefault(require("dockerode"));
+const manager_1 = require("../docker/manager");
+const db_1 = require("../db");
+const docker = new dockerode_1.default({ socketPath: process.platform === 'win32' ? '//./pipe/docker_engine' : '/var/run/docker.sock' });
+// Store previous network RX bytes to calculate delta
+const networkThresholds = new Map();
+async function checkIdleContainers() {
+    const status = await (0, manager_1.isDockerAvailable)();
+    if (!status.available) {
+        return;
+    }
+    console.log("[Auto-Sleep] Running idle container check...");
+    try {
+        const containers = await docker.listContainers({
+            filters: { name: ["codeverse-workspace-"] }
+        });
+        for (const c of containers) {
+            const containerName = c.Names[0].replace("/", "");
+            const workspaceId = containerName.replace("codeverse-workspace-", "");
+            const container = docker.getContainer(c.Id);
+            const stats = await container.stats({ stream: false });
+            // Extract network Rx (received) bytes
+            let currentRx = 0;
+            if (stats.networks && stats.networks.eth0) {
+                currentRx = stats.networks.eth0.rx_bytes;
+            }
+            const previousRx = networkThresholds.get(workspaceId);
+            if (previousRx !== undefined) {
+                const delta = currentRx - previousRx;
+                // If delta is less than 5KB over the interval, it's considered idle
+                if (delta < 5000) {
+                    console.log(`[Auto-Sleep] Workspace ${workspaceId} is idle. Shutting down.`);
+                    await (0, manager_1.stopWorkspaceContainer)(workspaceId);
+                    // Update DB
+                    await db_1.db.execute({
+                        sql: "UPDATE workspaces SET status = 'sleeping' WHERE id = ?",
+                        args: [workspaceId]
+                    });
+                    networkThresholds.delete(workspaceId);
+                    continue; // Skip setting new threshold
+                }
+            }
+            // Set threshold for next check
+            networkThresholds.set(workspaceId, currentRx);
+        }
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        console.error("[Auto-Sleep] Error running cron:", errorMessage);
+    }
+}
+function startAutoSleepCron() {
+    // Run every 30 minutes (1800000 ms)
+    // For testing/dev we run it every 5 minutes (300000 ms)
+    const interval = process.env.NODE_ENV === "production" ? 1800000 : 300000;
+    setInterval(checkIdleContainers, interval);
+    console.log(`[Auto-Sleep] Cron initialized. Running every ${interval / 60000} minutes.`);
+}

dist/server.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 🛰️ GLOBAL STABILIZATION (April 2026): Catch unhandled errors that cause HF Space restarts.
+ */
+process.on('uncaughtException', (err) => { console.error('[FATAL:EXCEPTION]', err); });
+process.on('unhandledRejection', (reason) => { console.error('[FATAL:REJECTION]', reason); });
+const http_1 = require("http");
+const next_1 = __importDefault(require("next"));
+const socket_io_1 = require("socket.io");
+const ws_1 = require("ws");
+const Y = __importStar(require("yjs"));
+const awarenessProtocol = __importStar(require("y-protocols/awareness"));
+const syncProtocol = __importStar(require("y-protocols/sync"));
+const encoding = __importStar(require("lib0/encoding"));
+const decoding = __importStar(require("lib0/decoding"));
+const map = __importStar(require("lib0/map"));
+const pty = __importStar(require("node-pty"));
+const os_1 = __importDefault(require("os"));
+const auto_sleep_1 = require("./lib/jobs/auto-sleep");
+const manager_1 = require("./lib/docker/manager");
+const schema_1 = require("./lib/db/schema");
+const db_1 = require("./lib/db");
+const storage_1 = require("./lib/hf/storage");
+const env_config_1 = require("./lib/env-config");
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const constants_1 = require("./constants");
+/**
+ * PRODUCTION HARDENING (April 2026): Force writable temp paths for HF Spaces.
+ */
+process.env.TMPDIR = constants_1.INFRA_CONFIG.TMPDIR;
+process.env.HF_HOME = constants_1.INFRA_CONFIG.HF_HOME;
+if (!process.env.HOME)
+    process.env.HOME = '/home/node';
+const dev = process.env.NODE_ENV !== "production";
+const app = (0, next_1.default)({ dev });
+const handle = app.getRequestHandler();
+const docs = new Map();
+const getOrCreateDoc = (docName) => {
+    return map.setIfUndefined(docs, docName, () => {
+        const doc = new Y.Doc();
+        const awareness = new awarenessProtocol.Awareness(doc);
+        return { doc, awareness };
+    });
+};
+const proxy = http_proxy_1.default.createProxyServer({
+    ws: true,
+    xfwd: true,
+    timeout: 30000,
+    proxyTimeout: 30000
+});
+function renderProxyError(res, error, id) {
+    res.writeHead(502, { 'Content-Type': 'text/html' });
+    res.end(`
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Workspace Connection Failure</title>
+            <style>
+                body { background: #0f1117; color: #e2e8f0; font-family: -apple-system, sans-serif; display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+                .card { background: #1e293b; padding: 2.5rem; border-radius: 1rem; border: 1px solid #334155; text-align: center; max-width: 450px; box-shadow: 0 25px 50px -12px rgba(0,0,0,0.5); }
+                h1 { color: #f87171; font-size: 1.5rem; margin-bottom: 1rem; }
+                p { font-size: 0.875rem; color: #94a3b8; line-height: 1.6; }
+                .id { font-family: monospace; background: #0f172a; padding: 0.4rem 0.6rem; border-radius: 0.4rem; color: #38bdf8; font-size: 0.8rem; }
+                .btn { display: inline-block; background: #38bdf8; color: #0f172a; padding: 0.6rem 1.2rem; border-radius: 0.4rem; text-decoration: none; font-weight: bold; margin-top: 1.5rem; transition: transform 0.2s; }
+                .btn:hover { transform: scale(1.05); }
+            </style>
+        </head>
+        <body>
+            <div class="card">
+                <h1>Workspace Connection Restricted</h1>
+                <p>Native isolation link for <span class="id">${id}</span> failed.</p>
+                <p style="margin-top: 1rem; text-align: left; padding: 1rem; background: #0f172a; border-radius: 0.5rem; font-size: 0.75rem; color: #64748b;">
+                    <b>Diagnostic:</b> ${error}<br>
+                    <b>Target:</b> Hugging Face Space (Sandboxed)
+                </p>
+                <a href="/dashboard/booting?id=${id}" class="btn">Auto-Repair & Boot</a>
+            </div>
+        </body>
+        </html>
+    `);
+}
+proxy.on("error", (err, req, res) => {
+    const host = req.headers.host || "";
+    const fullUrl = new URL(req.url || "/", `http://${host}`);
+    const pathname = fullUrl.pathname;
+    const headerId = req.headers['x-codeverse-id'];
+    const workspaceHostMatch = host.match(/^workspace-([a-zA-Z0-9-]+)\./);
+    const id = headerId || (workspaceHostMatch ? workspaceHostMatch[1] : (pathname.split("/")[2] || "unknown"));
+    console.error(`[Proxy Connection Error] ${err.message} for workspace/${id}`);
+    if (res instanceof http_1.ServerResponse) {
+        renderProxyError(res, err.message, id);
+    }
+});
+// Port and Host logic
+const PORT = Number(process.env.PORT) || 7860;
+const HOST = '0.0.0.0';
+let isAppReady = false;
+let envStatus = { valid: true, missing: [] };
+/**
+ *Autoritative Entrypoint: We initialize the HTTP server immediately to satisfy HF Spaces health checks.
+ */
+const server = (0, http_1.createServer)((req, res) => {
+    var _a;
+    const host = req.headers.host || "localhost";
+    const fullUrl = new URL(req.url || "/", `http://${host}`);
+    const { pathname } = fullUrl;
+    // 1. Initializing State
+    if (!isAppReady && !pathname.startsWith("/_next/static") && pathname !== "/favicon.ico") {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        return res.end(`
+            <html>
+                <head>
+                    <title>CodeVerse | Initializing</title>
+                    <style>
+                        body { background: #09090b; color: #71717a; font-family: sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+                        .container { text-align: center; border: 1px solid #27272a; padding: 2.5rem; border-radius: 1rem; background: #111113; max-width: 400px; }
+                        .spinner { width: 30px; height: 30px; border: 2px solid #3f3f46; border-top-color: #3b82f6; border-radius: 50%; animation: spin 1s linear infinite; margin: 0 auto 1.5rem; }
+                        h1 { color: #f4f4f5; font-size: 1.1rem; margin: 0; }
+                        p { font-size: 0.85rem; margin-top: 0.5rem; }
+                        @keyframes spin { to { transform: rotate(360deg); } }
+                    </style>
+                    <script>setTimeout(() => window.location.reload(), 5000);</script>
+                </head>
+                <body>
+                    <div class="container">
+                        <div class="spinner"></div>
+                        <h1>CodeVerse is waking up</h1>
+                        <p>Restoring your environment and securing persistent volumes...</p>
+                    </div>
+                </body>
+            </html>
+        `);
+    }
+    // 2. Maintenance / Misconfiguration State
+    if (isAppReady && !envStatus.valid && pathname !== "/api/health" && !pathname.startsWith("/_next/")) {
+        res.writeHead(503, { 'Content-Type': 'text/html' });
+        return res.end(`
+            <html>
+                <body style="background:#09090b;color:#f87171;padding:2rem;font-family:sans-serif;">
+                    <h1>Infrastructure Error</h1>
+                    <p>${constants_1.UI_STRINGS.MAINTENANCE_MESSAGE}</p>
+                    <ul>${envStatus.missing.map(m => `<li>${m}</li>`).join('')}</ul>
+                </body>
+            </html>
+        `);
+    }
+    // 3. Workspace Proxying
+    const workspaceHostMatch = host.match(/^workspace-([a-zA-Z0-9-]+)\./);
+    const id = workspaceHostMatch ? workspaceHostMatch[1] : ((pathname === null || pathname === void 0 ? void 0 : pathname.startsWith("/workspace/")) ? pathname.split("/")[2] : null);
+    if (id) {
+        const isReady = (0, manager_1.isNativeWorkspaceRunning)(id);
+        if (isReady) {
+            const port = (0, manager_1.getNativeWorkspacePort)(id) || 8080;
+            req.headers['x-codeverse-id'] = id;
+            req.headers['x-codeverse-type'] = 'workspace';
+            const prefix = `/workspace/${id}`;
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith(prefix)) {
+                req.url = req.url.substring(prefix.length);
+                if (!req.url.startsWith("/"))
+                    req.url = "/" + req.url;
+            }
+            return proxy.web(req, res, { target: `http://127.0.0.1:${port}`, changeOrigin: true });
+        }
+    }
+    // 4. Default Next.js Handle
+    handle(req, res);
+});
+// Setup Sockets
+const io = new socket_io_1.Server(server, { path: "/api/socketio" });
+const yjsWss = new ws_1.WebSocketServer({ noServer: true });
+// Start Listening Immediately
+server.listen(PORT, HOST, () => {
+    console.log('----------------------------------------------------');
+    console.log(`[READY] ${constants_1.APP_CONFIG.NAME} ${constants_1.APP_CONFIG.VERSION}`);
+    console.log(`[READY] Interface: ${HOST}:${PORT}`);
+    console.log('----------------------------------------------------');
+});
+// Background Async Initialization
+(async () => {
+    try {
+        console.log("[BOOT] Starting Next.js preparation...");
+        await app.prepare();
+        console.log("[BOOT] Next.js payload ready.");
+        envStatus = (0, env_config_1.validateEnvironment)();
+        if (envStatus.valid) {
+            console.log("[BOOT] Environment validated. Synchronizing database...");
+            await (0, schema_1.initDb)(db_1.client);
+            console.log("[BOOT] Database synchronized.");
+            // Reconnect and Warmup
+            (0, manager_1.reconnectRunningWorkspaces)().catch(() => { });
+            (0, manager_1.prewarmWorkspace)({ id: 'baseline-warmup', userId: 'system', projectName: 'CodeVerse-Internal' }).catch(() => { });
+            // Crons and Persistence
+            storage_1.HFStorage.startAutoSave(constants_1.INFRA_CONFIG.PERSISTENCE_INTERVAL_MS * 5);
+            (0, auto_sleep_1.startAutoSleepCron)();
+        }
+        isAppReady = true;
+        console.log("[BOOT] Global state stabilized. Application is fully operational.");
+    }
+    catch (err) {
+        console.error("[BOOT:ERROR] Fatal initialization failure:", err);
+    }
+})();
+// Terminal and Collaboration Handlers
+server.on("upgrade", (req, socket, head) => {
+    const { pathname } = new URL(req.url || "/", `http://${req.headers.host}`);
+    if (pathname === "/api/collab") {
+        yjsWss.handleUpgrade(req, socket, head, (ws) => {
+            yjsWss.emit("connection", ws, req);
+        });
+    }
+});
+yjsWss.on("connection", (conn, request) => {
+    const { doc, awareness } = getOrCreateDoc(new URL(request.url || "/", "http://l").searchParams.get('doc') || "default");
+    conn.binaryType = "arraybuffer";
+    const encoder = encoding.createEncoder();
+    encoding.writeVarUint(encoder, 0);
+    syncProtocol.writeSyncStep1(encoder, doc);
+    conn.send(encoding.toUint8Array(encoder));
+    conn.on("message", (message) => {
+        const encoder = encoding.createEncoder();
+        const decoder = decoding.createDecoder(new Uint8Array(message));
+        const messageType = decoding.readVarUint(decoder);
+        if (messageType === 0) {
+            encoding.writeVarUint(encoder, 0);
+            syncProtocol.readSyncMessage(decoder, encoder, doc, null);
+            if (encoding.length(encoder) > 1)
+                conn.send(encoding.toUint8Array(encoder));
+        }
+    });
+});
+io.on("connection", (socket) => {
+    let shell = null;
+    socket.on("terminal:start", ({ cols, rows }) => {
+        shell = pty.spawn(process.env.SHELL || (os_1.default.platform() === "win32" ? "powershell.exe" : "bash"), [], {
+            cols: cols || 80,
+            rows: rows || 24,
+            cwd: constants_1.INFRA_CONFIG.WORKSPACE_ROOT,
+            env: process.env,
+        });
+        shell.onData((data) => socket.emit("terminal:data", data));
+    });
+    socket.on("terminal:write", (data) => { if (shell)
+        shell.write(data); });
+    socket.on("disconnect", () => { if (shell)
+        shell.kill(); });
+});

lib/db/index.ts

@@ -1,5 +1,4 @@
 import { createClient, type Client } from "@libsql/client";
-import { initDb } from "./schema";
 
 const url = process.env.TURSO_URL || "file:local.db";
 const authToken = process.env.TURSO_AUTH_TOKEN;
@@ -20,8 +19,4 @@ export const client: Client = createClient({
  */
 export const db = client; 
 
-// 🚀 Self-Bootstrapping Database
-// We pass the client directly to avoid circular dependency with schema.ts
-initDb(client).catch((err: unknown) => {
-  console.error("[DB:ERROR] Database bootstrap failed:", err);
-});
+// 🚀 Database lifecycle is managed by the server entrypoint to ensure proper synchronization.

package.json

@@ -4,6 +4,7 @@
   "private": true,
   "scripts": {
     "dev": "next dev",
+    "prebuild": "npx rimraf dist",
     "build": "next build && tsc server.ts --esModuleInterop --skipLibCheck --target es2018 --module commonjs --moduleResolution node --downlevelIteration --outDir ./dist",
     "start": "node dist/server.js",
     "lint": "eslint . --ignore-pattern dist/ --ignore-pattern .next/"

server.ts

@@ -18,7 +18,7 @@ import * as pty from "node-pty";
 import os from "os";
 import { Duplex } from "stream";
 import { startAutoSleepCron } from "./lib/jobs/auto-sleep";
-import { getNativeWorkspacePort, getAndroidPort, isNativeWorkspaceRunning, prewarmWorkspace, reconnectRunningWorkspaces } from "./lib/docker/manager";
+import { getNativeWorkspacePort, isNativeWorkspaceRunning, prewarmWorkspace, reconnectRunningWorkspaces } from "./lib/docker/manager";
 import { initDb } from "./lib/db/schema";
 import { client as dbClient } from "./lib/db";
 import { HFStorage } from "./lib/hf/storage";
@@ -46,9 +46,6 @@ const getOrCreateDoc = (docName: string) => {
     });
 };
 
-/**
- * PRODUCTION PROXY CONFIG (2026 Optimized)
- */
 const proxy = httpProxy.createProxyServer({
     ws: true,
     xfwd: true,
@@ -56,17 +53,6 @@ const proxy = httpProxy.createProxyServer({
     proxyTimeout: 30000
 });
 
-// 🟢 Production Pre-flight Diagnostics (April 2026)
-console.log('----------------------------------------------------');
-console.log(`[BOOT] ${APP_CONFIG.NAME} ${APP_CONFIG.VERSION} Initialized.`);
-console.log(`[BOOT] Environment: ${process.env.NODE_ENV || 'development'}`);
-console.log(`[BOOT] Database State: ${process.env.TURSO_URL ? '✅ CONFIGURED' : '❌ MISSING'}`);
-console.log(`[BOOT] Persistence Link: ${process.env.HF_TOKEN ? '✅ CONFIGURED' : '⚠️ UNLINKED'}`);
-console.log('----------------------------------------------------');
-
-/**
- * Custom renderer for Proxy Errors and Booting screens.
- */
 function renderProxyError(res: ServerResponse, error: string, id: string) {
     res.writeHead(502, { 'Content-Type': 'text/html' });
     res.end(`
@@ -117,239 +103,168 @@ proxy.on("error", (err: Error, req: IncomingMessage, res: ServerResponse | Duple
     }
 });
 
-proxy.on("proxyReq", (proxyReq, req: IncomingMessage) => {
-    const id = req.headers['x-codeverse-id'] as string;
-    const type = req.headers['x-codeverse-type'] as string;
-    if (id && type) {
-        proxyReq.setHeader('x-codeverse-id', id);
-        proxyReq.setHeader('x-codeverse-type', type);
-    }
-});
-
-proxy.on("proxyRes", (proxyRes, req: IncomingMessage) => {
-    const id = req.headers['x-codeverse-id'] as string;
-    const type = req.headers['x-codeverse-type'] as string;
-    if (id && type && proxyRes.headers.location) {
-        const originalLocation = proxyRes.headers.location;
-        if (originalLocation.startsWith('/') && !originalLocation.startsWith(`/${type}/${id}`)) {
-            proxyRes.headers.location = `/${type}/${id}${originalLocation}`;
-        }
-    }
-});
-
-app.prepare()
-  .then(() => {
-    // Validate Production Environment (April 2026 Resilience)
-    const envStatus = validateEnvironment();
-    if (!envStatus.valid) {
-        console.error("[BOOT:ERROR] Infrastructure missing core secrets:", envStatus.missing.join(', '));
-    }
+// Port and Host logic
+const PORT = Number(process.env.PORT) || 7860;
+const HOST = '0.0.0.0';
 
-    if (envStatus.valid) {
-        // Correct initDb call passing the client to avoid circular dependencies
-        initDb(dbClient)
-            .then(() => {
-                console.log("[BOOT] Database synchronized.");
-                prewarmWorkspace({ 
-                    id: 'baseline-warmup', 
-                    userId: 'system', 
-                    projectName: 'CodeVerse-Internal' 
-                }).catch(err => console.error("[BOOT] Warmup failed:", err));
-            })
-            .catch(err => console.error("[BOOT] Database init failed:", err));
-        
-        // 🛠️ Self-Healing: Reconnect to orphans from previous instance
-        reconnectRunningWorkspaces().catch(err => console.error("[BOOT] Reconnection failed:", err));
-        
-        // 🛡️ Persistence: Global heartbeat
-        HFStorage.startAutoSave(INFRA_CONFIG.PERSISTENCE_INTERVAL_MS * 5); 
-        startAutoSleepCron();
-    }
+let isAppReady = false;
+let envStatus = { valid: true, missing: [] as string[] };
 
-    const server = createServer((req: IncomingMessage, res: ServerResponse) => {
-        const host = req.headers.host || "localhost";
-        const fullUrl = new URL(req.url || "/", `http://${host}`);
-        const { pathname } = fullUrl;
+/**
+ *Autoritative Entrypoint: We initialize the HTTP server immediately to satisfy HF Spaces health checks.
+ */
+const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+    const host = req.headers.host || "localhost";
+    const fullUrl = new URL(req.url || "/", `http://${host}`);
+    const { pathname } = fullUrl;
 
-        // 🚑 INFRASTRUCTURE MAINTENANCE (April 2026): Intercept requests if configuration is missing
-        if (!envStatus.valid && pathname !== "/api/health" && !pathname.startsWith("/_next/")) {
-            res.writeHead(503, { 'Content-Type': 'text/html' });
-            return res.end(`
-                <!DOCTYPE html>
-                <html>
+    // 1. Initializing State
+    if (!isAppReady && !pathname.startsWith("/_next/static") && pathname !== "/favicon.ico") {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        return res.end(`
+            <html>
                 <head>
-                    <title>${APP_CONFIG.NAME} | ${UI_STRINGS.MAINTENANCE_TITLE}</title>
+                    <title>CodeVerse | Initializing</title>
                     <style>
-                        body { background: #09090b; color: #a1a1aa; font-family: sans-serif; height: 100vh; display: flex; align-items: center; justify-content: center; margin: 0; }
-                        .panic-card { background: #18181b; border: 1px solid #27272a; padding: 2.5rem; border-radius: 1rem; max-width: 550px; box-shadow: 0 25px 50px -12px rgba(0,0,0,0.5); }
-                        h1 { color: #f4f4f5; font-size: 1.5rem; margin: 0 0 1rem; }
-                        .desc { font-size: 0.9rem; line-height: 1.6; margin-bottom: 2rem; }
-                        .status { display: flex; flex-direction: column; gap: 0.75rem; margin: 1.5rem 0; }
-                        .item { padding: 0.75rem; border-radius: 0.5rem; background: #09090b; font-size: 0.875rem; border: 1px solid #27272a; display: flex; align-items: center; gap: 0.5rem; }
-                        .item.missing { color: #f87171; border-color: #450a0a; }
+                        body { background: #09090b; color: #71717a; font-family: sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+                        .container { text-align: center; border: 1px solid #27272a; padding: 2.5rem; border-radius: 1rem; background: #111113; max-width: 400px; }
+                        .spinner { width: 30px; height: 30px; border: 2px solid #3f3f46; border-top-color: #3b82f6; border-radius: 50%; animation: spin 1s linear infinite; margin: 0 auto 1.5rem; }
+                        h1 { color: #f4f4f5; font-size: 1.1rem; margin: 0; }
+                        p { font-size: 0.85rem; margin-top: 0.5rem; }
+                        @keyframes spin { to { transform: rotate(360deg); } }
                     </style>
+                    <script>setTimeout(() => window.location.reload(), 5000);</script>
                 </head>
                 <body>
-                    <div class="panic-card">
-                        <h1>${UI_STRINGS.MAINTENANCE_TITLE}</h1>
-                        <p class="desc">${UI_STRINGS.MAINTENANCE_MESSAGE}</p>
-                        <div class="status">
-                            ${envStatus.missing.map(m => `<div class="item missing"><span>❌</span> ${m}</div>`).join('')}
-                        </div>
+                    <div class="container">
+                        <div class="spinner"></div>
+                        <h1>CodeVerse is waking up</h1>
+                        <p>Restoring your environment and securing persistent volumes...</p>
                     </div>
                 </body>
-                </html>
-            `);
-        }
-
-        const workspaceHostMatch = host.match(/^workspace-([a-zA-Z0-9-]+)\./);
-        const id = workspaceHostMatch ? workspaceHostMatch[1] : (pathname?.startsWith("/workspace/") ? pathname.split("/")[2] : null);
-
-        if (id) {
-            const isReady = isNativeWorkspaceRunning(id);
-            if (isReady) {
-                const port = getNativeWorkspacePort(id) || 8080;
-                req.headers['x-codeverse-id'] = id;
-                req.headers['x-codeverse-type'] = 'workspace';
-                
-                const prefix = `/workspace/${id}`;
-                if (req.url?.startsWith(prefix)) {
-                    req.url = req.url.substring(prefix.length);
-                    if (!req.url.startsWith("/")) req.url = "/" + req.url;
-                }
-                
-                return proxy.web(req, res, { target: `http://127.0.0.1:${port}`, changeOrigin: true });
-            } else if (!pathname?.startsWith("/api/")) {
-                res.writeHead(503, { 'Content-Type': 'text/html', 'Retry-After': '5' });
-                res.end(`
-                    <html>
-                        <head>
-                            <title>${APP_CONFIG.NAME} | Booting Workspace</title>
-                            <style>
-                                body { background: #09090b; color: #71717a; font-family: sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
-                                .container { text-align: center; border: 1px solid #27272a; padding: 2rem; border-radius: 1rem; background: #111113; }
-                                .spinner { width: 40px; height: 40px; border: 3px solid #3f3f46; border-top-color: #3b82f6; border-radius: 50%; animation: spin 1s linear infinite; margin: 0 auto 1.5rem; }
-                                h1 { color: #f4f4f5; font-size: 1.25rem; }
-                                @keyframes spin { to { transform: rotate(360deg); } }
-                            </style>
-                            <script>setTimeout(() => window.location.reload(), 3000);</script>
-                        </head>
-                        <body>
-                            <div class="container">
-                                <div class="spinner"></div>
-                                <h1>Workspace is Booting</h1>
-                                <p>Preparing your agentic session...</p>
-                            </div>
-                        </body>
-                    </html>
-                `);
-                return;
-            }
-        }
-
-        handle(req, res);
-    });
-
-    const io = new Server(server, { path: "/api/socketio" });
-    const yjsWss = new WebSocketServer({ noServer: true });
+            </html>
+        `);
+    }
 
-    server.on("upgrade", (req: IncomingMessage, socket: Duplex, head: Buffer) => {
-        const host = req.headers.host || "localhost";
-        const fullUrl = new URL(req.url || "/", `http://${host}`);
-        const { pathname } = fullUrl;
+    // 2. Maintenance / Misconfiguration State
+    if (isAppReady && !envStatus.valid && pathname !== "/api/health" && !pathname.startsWith("/_next/")) {
+        res.writeHead(503, { 'Content-Type': 'text/html' });
+        return res.end(`
+            <html>
+                <body style="background:#09090b;color:#f87171;padding:2rem;font-family:sans-serif;">
+                    <h1>Infrastructure Error</h1>
+                    <p>${UI_STRINGS.MAINTENANCE_MESSAGE}</p>
+                    <ul>${envStatus.missing.map(m => `<li>${m}</li>`).join('')}</ul>
+                </body>
+            </html>
+        `);
+    }
 
-        const workspaceHostMatch = host.match(/^workspace-([a-zA-Z0-9-]+)\./);
-        const id = workspaceHostMatch ? workspaceHostMatch[1] : (pathname?.startsWith("/workspace/") ? pathname.split("/")[2] : null);
+    // 3. Workspace Proxying
+    const workspaceHostMatch = host.match(/^workspace-([a-zA-Z0-9-]+)\./);
+    const id = workspaceHostMatch ? workspaceHostMatch[1] : (pathname?.startsWith("/workspace/") ? pathname.split("/")[2] : null);
 
-        if (id && isNativeWorkspaceRunning(id)) {
+    if (id) {
+        const isReady = isNativeWorkspaceRunning(id);
+        if (isReady) {
             const port = getNativeWorkspacePort(id) || 8080;
             req.headers['x-codeverse-id'] = id;
             req.headers['x-codeverse-type'] = 'workspace';
-            
             const prefix = `/workspace/${id}`;
             if (req.url?.startsWith(prefix)) {
                 req.url = req.url.substring(prefix.length);
                 if (!req.url.startsWith("/")) req.url = "/" + req.url;
             }
-            return proxy.ws(req, socket, head, { target: `http://127.0.0.1:${port}` });
+            return proxy.web(req, res, { target: `http://127.0.0.1:${port}`, changeOrigin: true });
         }
+    }
 
-        if (pathname === "/api/collab") {
-            yjsWss.handleUpgrade(req, socket, head, (ws) => {
-                yjsWss.emit("connection", ws, req);
-            });
-            return;
-        }
-    });
+    // 4. Default Next.js Handle
+    handle(req, res);
+});
 
-    yjsWss.on("connection", (conn: WebSocket, request: IncomingMessage) => {
-        const host = request.headers.host || "localhost";
-        const fullUrl = new URL(request.url || "/", `http://${host}`);
-        const docName = fullUrl.searchParams.get('doc') || "default";
-        const { doc, awareness } = getOrCreateDoc(docName);
-        conn.binaryType = "arraybuffer";
+// Setup Sockets
+const io = new Server(server, { path: "/api/socketio" });
+const yjsWss = new WebSocketServer({ noServer: true });
 
-        const encoder = encoding.createEncoder();
-        encoding.writeVarUint(encoder, 0);
-        syncProtocol.writeSyncStep1(encoder, doc);
-        conn.send(encoding.toUint8Array(encoder));
+// Start Listening Immediately
+server.listen(PORT, HOST, () => {
+    console.log('----------------------------------------------------');
+    console.log(`[READY] ${APP_CONFIG.NAME} ${APP_CONFIG.VERSION}`);
+    console.log(`[READY] Interface: ${HOST}:${PORT}`);
+    console.log('----------------------------------------------------');
+});
 
-        const awarenessEncoder = encoding.createEncoder();
-        encoding.writeVarUint(awarenessEncoder, 1);
-        encoding.writeVarUint8Array(awarenessEncoder, awarenessProtocol.encodeAwarenessUpdate(awareness, Array.from(awareness.getStates().keys())));
-        conn.send(encoding.toUint8Array(awarenessEncoder));
+// Background Async Initialization
+(async () => {
+    try {
+        console.log("[BOOT] Starting Next.js preparation...");
+        await app.prepare();
+        console.log("[BOOT] Next.js payload ready.");
 
-        conn.on("message", (message: ArrayBuffer) => {
-            const encoder = encoding.createEncoder();
-            const decoder = decoding.createDecoder(new Uint8Array(message));
-            const messageType = decoding.readVarUint(decoder);
-            if (messageType === 0) {
-                encoding.writeVarUint(encoder, 0);
-                syncProtocol.readSyncMessage(decoder, encoder, doc, null);
-                if (encoding.length(encoder) > 1) {
-                    conn.send(encoding.toUint8Array(encoder));
-                }
-            } else if (messageType === 1) {
-                awarenessProtocol.applyAwarenessUpdate(awareness, decoding.readVarUint8Array(decoder), conn);
-            }
-        });
+        envStatus = validateEnvironment();
+        if (envStatus.valid) {
+            console.log("[BOOT] Environment validated. Synchronizing database...");
+            await initDb(dbClient);
+            console.log("[BOOT] Database synchronized.");
+            
+            // Reconnect and Warmup
+            reconnectRunningWorkspaces().catch(() => {});
+            prewarmWorkspace({ id: 'baseline-warmup', userId: 'system', projectName: 'CodeVerse-Internal' }).catch(() => {});
+            
+            // Crons and Persistence
+            HFStorage.startAutoSave(INFRA_CONFIG.PERSISTENCE_INTERVAL_MS * 5); 
+            startAutoSleepCron();
+        }
 
-        const updateHandler = (update: Uint8Array, origin: unknown) => {
-            if (origin !== conn) {
-                const encoder = encoding.createEncoder();
-                encoding.writeVarUint(encoder, 0);
-                syncProtocol.writeUpdate(encoder, update);
-                conn.send(encoding.toUint8Array(encoder));
-            }
-        };
+        isAppReady = true;
+        console.log("[BOOT] Global state stabilized. Application is fully operational.");
+    } catch (err) {
+        console.error("[BOOT:ERROR] Fatal initialization failure:", err);
+    }
+})();
 
-        doc.on("update", updateHandler);
-        conn.on("close", () => {
-            doc.off("update", updateHandler);
-            awarenessProtocol.removeAwarenessStates(awareness, [doc.clientID], null);
+// Terminal and Collaboration Handlers
+server.on("upgrade", (req, socket, head) => {
+    const { pathname } = new URL(req.url || "/", `http://${req.headers.host}`);
+    if (pathname === "/api/collab") {
+        yjsWss.handleUpgrade(req, socket, head, (ws) => {
+            yjsWss.emit("connection", ws, req);
         });
-    });
+    }
+});
 
-    io.on("connection", (socket) => {
-        let shell: pty.IPty | null = null;
-        socket.on("terminal:start", ({ cols, rows }: { cols: number; rows: number }) => {
-            const shellPath = process.env.SHELL || (os.platform() === "win32" ? "powershell.exe" : "bash");
-            shell = pty.spawn(shellPath, [], {
-                name: "xterm-color",
-                cols: cols || 80,
-                rows: rows || 24,
-                cwd: INFRA_CONFIG.WORKSPACE_ROOT,
-                env: process.env as Record<string, string>,
-            });
-            shell.onData((data: string) => socket.emit("terminal:data", data));
-        });
-        socket.on("terminal:write", (data: string) => { if (shell) shell.write(data); });
-        socket.on("terminal:resize", ({ cols, rows }: { cols: number; rows: number }) => { if (shell) try { shell.resize(cols, rows); } catch {} });
-        socket.on("disconnect", () => { if (shell) { shell.kill(); shell = null; } });
+yjsWss.on("connection", (conn: WebSocket, request: IncomingMessage) => {
+    const { doc, awareness } = getOrCreateDoc(new URL(request.url || "/", "http://l").searchParams.get('doc') || "default");
+    conn.binaryType = "arraybuffer";
+    const encoder = encoding.createEncoder();
+    encoding.writeVarUint(encoder, 0);
+    syncProtocol.writeSyncStep1(encoder, doc);
+    conn.send(encoding.toUint8Array(encoder));
+
+    conn.on("message", (message: ArrayBuffer) => {
+        const encoder = encoding.createEncoder();
+        const decoder = decoding.createDecoder(new Uint8Array(message));
+        const messageType = decoding.readVarUint(decoder);
+        if (messageType === 0) {
+            encoding.writeVarUint(encoder, 0);
+            syncProtocol.readSyncMessage(decoder, encoder, doc, null);
+            if (encoding.length(encoder) > 1) conn.send(encoding.toUint8Array(encoder));
+        }
     });
+});
 
-    const PORT = process.env.PORT || 7860;
-    server.listen(PORT, () => {
-        console.log(`> Ready on http://localhost:${PORT}`);
+io.on("connection", (socket) => {
+    let shell: pty.IPty | null = null;
+    socket.on("terminal:start", ({ cols, rows }) => {
+        shell = pty.spawn(process.env.SHELL || (os.platform() === "win32" ? "powershell.exe" : "bash"), [], {
+            cols: cols || 80,
+            rows: rows || 24,
+            cwd: INFRA_CONFIG.WORKSPACE_ROOT,
+            env: process.env as Record<string, string>,
+        });
+        shell.onData((data: string) => socket.emit("terminal:data", data));
     });
+    socket.on("terminal:write", (data) => { if (shell) shell.write(data); });
+    socket.on("disconnect", () => { if (shell) shell.kill(); });
 });