fix

lib/docker/manager.ts

@@ -176,6 +176,8 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
     
     if (!fs.existsSync(workspacePath)) {
         fs.mkdirSync(workspacePath, { recursive: true });
+        // Store full ID for reliable reconnection after server restarts
+        fs.writeFileSync(path.join(workspacePath, '.codeverse-id'), config.id); 
         log(`Allocated isolated filesystem segment: ${config.id.slice(0, 8)}`);
     }
 
@@ -306,6 +308,49 @@ export async function startWorkspaceContainer(config: WorkspaceConfig): Promise<
     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.
+ */
+export async function reconnectRunningWorkspaces() {
+    const { execSync } = require('child_process');
+    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
+        const output = execSync("ps aux | grep code-server | grep -v grep").toString();
+        const lines = output.split('\n');
+        
+        for (const line of lines) {
+            // Looking for: ... --bind-addr 127.0.0.1:8548 ... /home/node/w/44c7597c
+            const bindMatch = line.match(/--bind-addr 127\.0\.0\.1:(\d+)/);
+            const pathMatch = line.match(new RegExp(`${workspaceRoot}/([a-zA-Z0-9]+)`));
+            
+            if (bindMatch && pathMatch) {
+                const port = parseInt(bindMatch[1]);
+                const shortId = pathMatch[1];
+                const fullPath = path.join(workspaceRoot, shortId);
+                const idFile = path.join(fullPath, '.codeverse-id');
+                
+                if (fs.existsSync(idFile)) {
+                    const fullId = fs.readFileSync(idFile, 'utf-8').trim();
+                    if (!nativeProcesses.has(fullId)) {
+                        console.log(`[RECONNECT] Identified active IDE ${fullId.slice(0,8)}... on port ${port}. Restoring proxy link.`);
+                        nativeProcesses.set(fullId, { 
+                            pid: 0, // Placeholder for PID
+                            port, 
+                            process: { kill: () => { try { execSync(`fuser -k ${port}/tcp`); } catch {} } } as any 
+                        });
+                    }
+                }
+            }
+        }
+    } catch (e) {
+        // No processes found or ps failed
+    }
+}
+
 /**
  * 🟢 ENGINE WATCHDOG: Background health monitor for native IDE processes.
  */

lib/env-config.ts

@@ -6,7 +6,7 @@ export const 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/app/workspaces',
+    WORKSPACE_ROOT: process.env.WORKSPACE_ROOT || '/home/node/w',
 
     // 2. Build Acceleration
     CACHIX_CACHE_NAME: process.env.CACHIX_CACHE_NAME || 'code-nix',
@@ -22,6 +22,8 @@ export const ENV_CONFIG = {
     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',
 };
 
 /**

lib/fs/isolation.ts

@@ -1,23 +1,17 @@
 import path from "path";
 import fs from "fs/promises";
-import { existsSync, mkdirSync, writeFileSync, unlinkSync } from "fs";
+import { existsSync, mkdirSync } from "fs";
 
 import { ENV_CONFIG } from "@/lib/env-config";
 
 function resolveWorkspaceBase(): string {
     // Standardize for production-grade isolation
-    const workspaceRoot = ENV_CONFIG.WORKSPACE_ROOT || path.join(/*turbopackIgnore: true*/ '/home/nodejs/app/workspaces');
+    const workspaceRoot = ENV_CONFIG.WORKSPACE_ROOT;
     
     try {
         if (!existsSync(workspaceRoot)) {
             mkdirSync(workspaceRoot, { recursive: true });
         }
-        
-        // Critical Test: Check if we can actually write to this path
-        const testFile = path.join(/*turbopackIgnore: true*/ workspaceRoot, `.write_test_${Math.random().toString(36).substring(7)}`);
-        writeFileSync(testFile, "test");
-        unlinkSync(testFile);
-        
         return workspaceRoot;
     } catch (e) {
         console.error(`[SYSTEM] Critical Storage Error for ${workspaceRoot}:`, e);

lib/hf/storage.ts

@@ -57,12 +57,18 @@ export class HFStorage {
             const tmpDir = '/tmp/hf-sync';
             if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
 
-        // 🟢 DELTA SYNCING: Use 'download' for raw folder syncing instead of tarballs
-        // This allows HF CLI to perform block-level diffing internally.
-        const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli download ${this.HF_DATASET_ID} --local-dir ${process.env.HOME || '/home/node'} --local-dir-use-symlinks False --token ${this.HF_TOKEN} --include "*" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*") || (hf download ${this.HF_DATASET_ID} --local-dir ${process.env.HOME || '/home/node'} --token ${this.HF_TOKEN})`;
+        // 🟢 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'];
         
-        onLog?.(`[HF:STORAGE] Restoring differential profile from '${this.HF_DATASET_ID}'...`);
-        await this.execAsync(cmd, onLog);
+        for (const dir of persistDirs) {
+            const localPath = path.join(home, dir);
+            if (!fs.existsSync(localPath)) fs.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?.(`[HF:STORAGE] Restoring ${dir} from differential profile...`);
+            await this.execAsync(cmd, onLog).catch(() => {}); // Continue if one dir fails
+        }
         onLog?.(`[HF:STORAGE] Profile restoration complete.`);
         } catch (e: unknown) {
             const errorMessage = e instanceof Error ? e.message : String(e);
@@ -76,16 +82,20 @@ export class HFStorage {
     static async syncToDataset(onLog?: (msg: string) => void): Promise<void> {
         if (!this.HF_TOKEN || !this.HF_DATASET_ID) return;
 
-        onLog?.(`[HF:STORAGE] Saving persistent profile to '${this.HF_DATASET_ID}'...`);
         try {
-        // 🟢 DELTA SYNCING: Use 'upload-folder' for granular updates
-        // This skips files that haven't changed, making uploads nearly instant for small edits.
-        // We MUST exclude .cache/ and other high-volume folders to prevent HF Dataset 'CommitOperation' errors and 'Large Folder' warnings.
-        const cmd = `(command -v huggingface-cli >/dev/null && huggingface-cli upload ${this.HF_DATASET_ID} ${process.env.HOME || '/home/node'} . --token ${this.HF_TOKEN} --message "CodeVerse Sync: ${new Date().toISOString()}" --exclude "node_modules/*" --exclude ".nix/*" --exclude ".direnv/*" --exclude ".cache/*" --exclude ".npm/*" --exclude ".local/share/code-server/*" --exclude ".vscode-server/extensions/*") || (hf upload ${this.HF_DATASET_ID} ${process.env.HOME || '/home/node'} . --token ${this.HF_TOKEN})`;
-        
-        onLog?.(`[HF:STORAGE] Performing differential backup to '${this.HF_DATASET_ID}'...`);
-        await this.execAsync(cmd, onLog);
-        onLog?.(`[HF:STORAGE] Profile backup successful.`);
+            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.join(home, dir);
+                if (!fs.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?.(`[HF:STORAGE] Performing differential backup of ${dir}...`);
+                await this.execAsync(cmd, onLog).catch(err => onLog?.(`[WARN] Sync failed for ${dir}: ${err.message}`));
+            }
+            onLog?.(`[HF:STORAGE] Profile backup successful.`);
         } catch (e: unknown) {
             const errorMessage = e instanceof Error ? e.message : String(e);
             onLog?.(`[ERROR] Profile synchronization failed: ${errorMessage}`);

server.ts

@@ -12,11 +12,18 @@ 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 } from "./lib/docker/manager";
+import { getNativeWorkspacePort, getAndroidPort, isNativeWorkspaceRunning, prewarmWorkspace, reconnectRunningWorkspaces } from "./lib/docker/manager";
 import { initDb } from "./lib/db/schema";
-import { validateEnvironment } from "./lib/env-config";
+import { ENV_CONFIG, validateEnvironment } from "./lib/env-config";
 import httpProxy from "http-proxy";
 
+/**
+ * PRODUCTION HARDENING (April 2026): Force writable temp paths for HF Spaces.
+ */
+process.env.TMPDIR = '/tmp';
+process.env.HF_HOME = '/tmp/.cache/huggingface';
+if (!process.env.HOME) process.env.HOME = '/home/node';
+
 const dev = process.env.NODE_ENV !== "production";
 const app = next({ dev });
 const handle = app.getRequestHandler();
@@ -142,7 +149,9 @@ app.prepare()
                 .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();
     startAutoSleepCron();
 
     const server = createServer((req: IncomingMessage, res: ServerResponse) => {