add real system initialiasation

.agent/memory/session.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
-  "session_id": "f3d24462",
-  "started_at": "2026-04-06T15:31:08.523798+05:30",
+  "session_id": "56fef4b2",
+  "started_at": "2026-04-06T16:00:00.261811+05:30",
   "workspace": "D:\\Code\\codeverse",
   "active_task_id": null,
   "active_agent": null,

Dockerfile

@@ -4,6 +4,7 @@ FROM node:20-bookworm-slim AS base
 
 # Install build tools and compatibility layers for native modules (node-pty)
 # Also add code-server for Native Isolation Mode (when Docker is missing)
+# And the real implementation of Docker, Android, X11, and Desktop bridge
 RUN apt-get update && apt-get install -y \
     libc6 \
     libstdc++6 \
@@ -14,12 +15,34 @@ RUN apt-get update && apt-get install -y \
     curl \
     ca-certificates \
     tar \
+    unzip \
+    openjdk-17-jdk \
+    xvfb \
+    fluxbox \
+    novnc \
+    websockify \
+    libnss3 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libgtk-3-0 \
+    # Docker Client and Daemon (for build-time environment availability)
+    docker.io \
     && rm -rf /var/lib/apt/lists/* \
     && curl -fL https://github.com/coder/code-server/releases/download/v4.96.2/code-server-4.96.2-linux-amd64.tar.gz \
     | tar -C /usr/local/lib -xz \
     && mv /usr/local/lib/code-server-4.96.2-linux-amd64 /usr/local/lib/code-server \
     && ln -s /usr/local/lib/code-server/bin/code-server /usr/local/bin/code-server
 
+# Install Android SDK Command Line Tools
+ENV ANDROID_SDK_ROOT /app/android-sdk
+RUN mkdir -p ${ANDROID_SDK_ROOT}/cmdline-tools \
+    && curl -fL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o cmdline-tools.zip \
+    && unzip cmdline-tools.zip -d ${ANDROID_SDK_ROOT}/cmdline-tools \
+    && mv ${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools ${ANDROID_SDK_ROOT}/cmdline-tools/latest \
+    && rm cmdline-tools.zip
+
+ENV PATH ${PATH}:${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin:${ANDROID_SDK_ROOT}/platform-tools
+
 # Step 1. Rebuild the source code only when needed
 FROM base AS builder
 WORKDIR /app

app/dashboard/booting/BootSequenceClient.tsx

@@ -13,68 +13,81 @@ export default function BootSequenceClient() {
     const [logs, setLogs] = useState<string[]>([]);
     const [status, setStatus] = useState<"booting" | "ready" | "error">("booting");
     const endRef = useRef<HTMLDivElement>(null);
+    const eventSourceRef = useRef<EventSource | null>(null);
+
+    // Stable log handler to avoid triggering synchronous re-renders in boot()
+    const addLog = useCallback((msg: string) => {
+        setLogs(prev => {
+            if (prev.includes(msg)) return prev;
+            return [...prev, msg];
+        });
+    }, []);
 
     const boot = useCallback(() => {
         if (!id) {
-            setLogs(["ERROR: No workspace ID provided."]);
+            addLog("ERROR: No workspace ID provided.");
             setStatus("error");
             return;
         }
 
+        // Close any existing connection before starting a new one
+        if (eventSourceRef.current) {
+            eventSourceRef.current.close();
+            eventSourceRef.current = null;
+        }
+
+        // We use a functional approach to initializing state to avoid synchronous cascade warnings
         setStatus("booting");
         setLogs([]);
 
-        // Initialize Real-Time SSE Stream for workspace initialization
         const eventSource = new EventSource(`/api/workspace/stream?id=${id}&withAndroid=${withAndroid}`);
+        eventSourceRef.current = eventSource;
 
         eventSource.addEventListener("log", (event) => {
-            const msg = event.data;
-            setLogs(prev => [...prev, msg]);
+            addLog(event.data);
         });
 
         eventSource.addEventListener("ready", (event) => {
             try {
-                JSON.parse(event.data);
-                setLogs(prev => [...prev, "[SYSTEM] Workspace Online. Handshake complete."]);
-                setStatus("ready");
-                
-                // Redirect to workspace after a brief success confirmation
-                setTimeout(() => {
+                const data = JSON.parse(event.data);
+                if (data.success === false) {
+                    addLog(`[FATAL] ${data.error || "Provisioning failed."}`);
+                    setStatus("error");
+                } else {
+                    addLog("[SYSTEM] Workspace Online. Handshake complete.");
+                    setStatus("ready");
+                    
+                    // Redirect immediately for performance
                     router.push(`/?workspace=${encodeURIComponent(id)}`);
-                }, 1000);
+                }
             } catch (e) {
                 console.error("Failed to parse ready event:", e);
                 setStatus("error");
             } finally {
-                eventSource.close();
+                if (eventSourceRef.current) {
+                    eventSourceRef.current.close();
+                    eventSourceRef.current = null;
+                }
             }
         });
 
         eventSource.addEventListener("error", (event) => {
             try {
-                const errData = JSON.parse((event as MessageEvent).data);
-                setLogs(prev => [...prev, `[FATAL] ${errData.message || "Unknown stream error."}`]);
+                const data = (event as MessageEvent).data;
+                const errData = data ? JSON.parse(data) : {};
+                addLog(`[FATAL] ${errData.message || "The deployment engine encountered an unexpected interruption."}`);
             } catch {
-                setLogs(prev => [...prev, "[FATAL] The boot stream was interrupted unexpectedly."]);
+                console.warn("Retrying SSE connection via EventSource auto-reconnect...");
             }
-            setStatus("error");
-            eventSource.close();
         });
 
-        // Basic error handler for connection issues
-        eventSource.onerror = () => {
-            setLogs(prev => {
-                if (prev.length > 0 && prev[prev.length - 1].startsWith("[FATAL]")) return prev;
-                return [...prev, "[FATAL] Lost connection to the provisioning engine."];
-            });
-            setStatus("error");
-            eventSource.close();
-        };
-
         return () => {
-            eventSource.close();
+            if (eventSourceRef.current) {
+                eventSourceRef.current.close();
+                eventSourceRef.current = null;
+            }
         };
-    }, [id, withAndroid, router]);
+    }, [id, withAndroid, router, addLog]);
 
     useEffect(() => {
         const cleanup = boot();
@@ -90,14 +103,14 @@ export default function BootSequenceClient() {
     return (
         <div className="flex flex-col gap-5">
             {/* Terminal Log */}
-            <div className="bg-[#0a0a0a] rounded-xl p-4 min-h-[300px] border border-[#222] shadow-[inset_0_0_30px_rgba(0,0,0,0.6)] overflow-y-auto font-mono text-sm h-[400px]">
+            <div className="bg-[#0a0a0a] rounded-xl p-4 min-h-[300px] border border-[#222] shadow-[inset_0_0_30px_rgba(0,0,0,0.6)] overflow-y-auto font-mono text-sm h-[450px]">
                 {logs.map((log, i) => (
                     <div key={i} className="mb-1 leading-relaxed">
-                        {log.startsWith("[ERROR]") || log.startsWith("[FATAL]") ? (
+                        {log.startsWith("[ERROR]") || log.startsWith("[FATAL]") || log.startsWith("[STDERR]") ? (
                             <span className="text-red-400">{log}</span>
                         ) : log.includes("Ready") || log.includes("Online") || log.includes("success") || log.includes("complete") ? (
                             <span className="text-green-400">{log}</span>
-                        ) : log.startsWith("[SYSTEM]") || log.startsWith("[MANAGER]") ? (
+                        ) : log.startsWith("[SYSTEM]") || log.startsWith("[MANAGER]") || log.startsWith("[IDE-MANAGER]") || log.startsWith("[UP]") ? (
                             <span className="text-blue-400">{log}</span>
                         ) : (
                             <span className="text-zinc-500">{log}</span>
@@ -108,19 +121,19 @@ export default function BootSequenceClient() {
                 {status === "booting" && (
                     <div className="flex items-center gap-2 mt-4 text-green-400">
                         <Loader2 size={14} className="animate-spin" />
-                        <span className="text-sm font-semibold animate-pulse">Establishing container link...</span>
+                        <span className="text-sm font-semibold animate-pulse">Synchronizing orchestration layers...</span>
                     </div>
                 )}
                 {status === "ready" && (
                     <div className="flex items-center gap-2 mt-4 text-green-400">
                         <CheckCircle2 size={14} />
-                        <span className="text-sm font-semibold">Boot successful! Redirecting...</span>
+                        <span className="text-sm font-semibold">Deployment Successful. Redirecting...</span>
                     </div>
                 )}
                 {status === "error" && (
                     <div className="flex items-center gap-2 mt-4 text-red-500">
                         <XCircle size={14} />
-                        <span className="text-sm font-semibold">Boot sequence interrupted.</span>
+                        <span className="text-sm font-semibold">Deployment Engine Stalled.</span>
                     </div>
                 )}
                 <div ref={endRef} />
@@ -134,7 +147,7 @@ export default function BootSequenceClient() {
                         className="flex items-center gap-2 px-4 py-2 bg-[#161b22] hover:bg-[#21262d] text-zinc-300 hover:text-white rounded-lg text-sm transition-all border border-[#30363d] hover:border-[#444]"
                     >
                         <ArrowLeft size={14} />
-                        Abort Boot
+                        Back to Dashboard
                     </button>
                     <button
                         onClick={() => boot()}

lib/docker/manager.ts

@@ -1,10 +1,13 @@
 import fs from 'fs';
+import { spawn, ChildProcess } from 'child_process';
+import path from 'path';
+import Docker from 'dockerode';
 
 /**
  * Registry for native workspace processes (IDE instances running outside Docker)
- * Map<workspaceId, { pid: number; port: number }>
+ * Map<workspaceId, { pid: number; port: number; process: ChildProcess }>
  */
-const nativeProcesses = new Map<string, { pid: number; port: number }>();
+const nativeProcesses = new Map<string, { pid: number; port: number; process: ChildProcess }>();
 
 /**
  * Checks if a native workspace is currently running.
@@ -18,17 +21,30 @@ export function isNativeWorkspaceRunning(id: string): boolean {
  */
 const delay = (ms: number) => new Promise(res => setTimeout(res, ms));
 
+/**
+ * Finds an available port in the 8081-8099 range.
+ */
+function findAvailablePort(): number {
+    const occupiedPorts = Array.from(nativeProcesses.values()).map(p => p.port);
+    for (let port = 8081; port <= 8099; port++) {
+        if (!occupiedPorts.includes(port)) return port;
+    }
+    return Math.floor(Math.random() * (8999 - 8100) + 8100);
+}
+
 /**
  * Checks if Docker is available in the current environment.
  */
-export async function isDockerAvailable(): Promise<boolean> {
+export async function isDockerAvailable(): Promise<{ available: boolean; reason?: string }> {
     const socketPath = process.platform === 'win32' ? '//./pipe/docker_engine' : '/var/run/docker.sock';
+    if (process.env.SPACE_ID) return { available: false, reason: "Hugging Face Space (Sandboxed)" };
+    if (!fs.existsSync(socketPath)) return { available: false, reason: "Docker socket missing" };
     try {
-        if (fs.existsSync(socketPath)) return true;
-        if (process.env.SPACE_ID) return false; 
-        return false;
+        const docker = new Docker({ socketPath: process.platform === 'win32' ? undefined : socketPath });
+        await docker.ping();
+        return { available: true };
     } catch {
-        return false;
+        return { available: false, reason: "Docker daemon unreachable" };
     }
 }
 
@@ -36,14 +52,14 @@ export async function isDockerAvailable(): Promise<boolean> {
  * Stops a native workspace process.
  */
 export async function stopNativeWorkspace(id: string): Promise<boolean> {
-    const proc = nativeProcesses.get(id);
-    if (proc) {
+    const entry = nativeProcesses.get(id);
+    if (entry) {
         try {
-            if (proc.pid > 0) process.kill(proc.pid);
+            entry.process.kill();
             nativeProcesses.delete(id);
             return true;
         } catch (e) {
-            console.error(`Failed to kill process ${proc.pid}:`, e);
+            console.error(`[MANAGER] Failed to kill code-server ${entry.pid}:`, e);
             nativeProcesses.delete(id);
         }
     }
@@ -87,52 +103,104 @@ export interface WorkspaceOperationResult {
 }
 
 /**
- * Workspace provisioner with granular progress tracking for the terminal UI.
+ * Workspace provisioner with REAL child-process orchestration.
+ * Robust handshake and error handling to prevent "Deployment Engine Failure".
  */
 export async function startWorkspaceContainer(config: WorkspaceConfig): Promise<WorkspaceOperationResult> {
     const log = (msg: string) => { if (config.onLog) config.onLog(`[MANAGER] ${msg}`); };
-    
-    log(`Initializing Provisioning Sequence for '${config.projectName}'...`);
-    await delay(300);
-
-    const dockerReal = await isDockerAvailable();
-    if (dockerReal) {
-        log(`Docker daemon detected. Attempting to pull baseline images...`);
-        await delay(500);
-        // Real Docker logic here (skipped for mock mode)
-    } else {
-        log(`Restricted environment detected. Reverting to Native Isolation...`);
-        await delay(400);
-    }
 
-    log(`Allocating system resources for context isolation...`);
-    await delay(600);
+    if (nativeProcesses.has(config.id)) {
+        log(`Workspace detected. Re-establishing secure proxy link...`);
+        return {
+            success: true,
+            containerId: `native-${config.id}`,
+            port: nativeProcesses.get(config.id)!.port
+        };
+    }
 
-    log(`Setting up virtual filesystem mount in /app/workspaces/${config.id}...`);
-    await delay(800);
+    log(`Provisioning real-time isolation for '${config.projectName}'...`);
+    
+    // 1. Prepare Workspace Directory
+    const workspaceRoot = process.env.WORKSPACE_ROOT || path.join(process.cwd(), 'workspaces');
+    const workspacePath = path.join(workspaceRoot, config.id);
+    const userDataPath = path.join(workspacePath, '.vscode-server');
+    
+    if (!fs.existsSync(workspacePath)) {
+        fs.mkdirSync(workspacePath, { recursive: true });
+        log(`Created isolated filesystem segment: ${config.id.slice(0, 8)}`);
+    }
 
-    log(`Verifying workspace integrity...`);
-    await delay(500);
+    // 2. Identify Target Port
+    const port = findAvailablePort();
+    log(`Assigned dynamic port: ${port}`);
 
-    if (!nativeProcesses.has(config.id)) {
-        log(`Spawning workspace proxy on 127.0.0.1:8080...`);
-        nativeProcesses.set(config.id, { pid: process.pid, port: 8080 });
-        await delay(1000); // Simulate boot-up time of the editor
-    } else {
-        log(`Workspace process already warm. Re-attaching to existing proxy...`);
-        await delay(400);
+    // 3. Spawn Real code-server Process (Linux priority)
+    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 child = spawn(shellCommand, [...args, ...baseArgs], {
+        env: { ...process.env, HOME: workspacePath },
+        cwd: workspacePath,
+        shell: process.platform === 'win32'
+    });
+
+    log(`Spawning VS Code Orchestrator (PID: ${child.pid})...`);
+
+    // Handle startup errors early
+    child.on('error', (err) => {
+        log(`[FATAL] Failed to launch IDE binary: ${err.message}`);
+    });
+
+    child.stdout.on('data', (data) => {
+        const out = data.toString();
+        if (out.includes('listening on')) log(`[UP] ${out.trim()}`);
+    });
+
+    child.stderr.on('data', (data) => {
+        const err = data.toString();
+        if (err.toLowerCase().includes('error')) log(`[STDERR] ${err.trim()}`);
+    });
+
+    // 4. Register in active pool
+    nativeProcesses.set(config.id, { pid: child.pid!, port, process: child });
+
+    // 5. Robust Handshake Loop (Increased attempts + explicit error on failure)
+    let attempts = 0;
+    while (attempts < 15) {
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}`);
+            if (res.ok) {
+                log(`Handshake verified. CodeVerse Engine Online.`);
+                return {
+                    success: true,
+                    containerId: `native-${config.id}`,
+                    androidPort: config.withAndroidEmulator ? 6080 : undefined,
+                    port: port
+                };
+            }
+        } catch {
+            await delay(1000);
+            attempts++;
+            if (attempts % 3 === 0) log(`Warming up IDE core (attempt ${attempts}/15)...`);
+        }
     }
 
-    log(`Handshaking with system orchestrator...`);
-    await delay(300);
-
-    log(`Workspace Successfully Provisioned. Redirecting...`);
+    // Failure Case
+    log(`[FATAL] IDE core failed to respond on 127.0.0.1:${port} after 15 attempts.`);
+    stopNativeWorkspace(config.id);
     
     return {
-        success: true,
-        containerId: `native-${config.id}`,
-        androidPort: config.withAndroidEmulator ? 6080 : undefined,
-        port: 8080
+        success: false,
+        error: "IDE_HANDSHAKE_TIMEOUT: The orchestration layer failed to reach the IDE process. Check resource limits on Hugging Face."
     };
 }