fleetbo-cockpit-cli 1.0.74 → 1.0.75

package/cli.js

@@ -31,64 +31,238 @@ process.env.DOTENV_SILENT = 'true';
 const envPath = path.join(process.cwd(), '.env');
 
 if (!fs.existsSync(envPath)) {
-    console.error('\x1b[31m[Fleetbo] ❌ Error: .env file not found in current directory.\x1b[0m');
+    console.error('\x1b[31m%s\x1b[0m', '\n❌ Error: Configuration file (.env) not found.');
+    console.error('\x1b[90m%s\x1b[0m', 'Make sure you are in a Fleetbo project directory.\n');
     process.exit(1);
 }
 
-dotenv.config({ path: envPath });
+dotenv.config({ path: envPath, quiet: true });
 
-const projectId = process.env.FLEETBO_PROJECT_ID;
-const developerToken = process.env.FLEETBO_DEVELOPER_TOKEN;
+const projectId = process.env.REACT_APP_ENTERPRISE_ID; 
+const keyApp = process.env.REACT_KEY_APP; 
+const testerEmail = process.env.REACT_APP_TESTER_EMAIL;
 
-if (!projectId || !developerToken) {
-    console.error('\x1b[31m[Fleetbo] ❌ Error: FLEETBO_PROJECT_ID or FLEETBO_DEVELOPER_TOKEN missing in .env\x1b[0m');
+if (!projectId) {
+    console.error('\n\x1b[31m❌ Error: Project ID missing in .env.\x1b[0m\n');
     process.exit(1);
 }
 
 // ============================================
-// CORE LOGIC: ALEX ENGINE (Generation)
+// HELPERS
 // ============================================
+const wrapText = (text, maxWidth) => {
+    if (!text) return "";
+    const rawLines = text.split('\n'); 
+    let formattedLines = [];
+    rawLines.forEach(line => {
+        if (line.trim().length === 0) {
+            formattedLines.push("");
+            return;
+        }
+        const isSpecialFormat = /^[\s]*[-*•\d]/.test(line) || line.startsWith("    ");
+        if (isSpecialFormat) {
+            formattedLines.push(line);
+        } else {
+            const words = line.split(" ");
+            let currentLine = words[0];
+            for (let i = 1; i < words.length; i++) {
+                if (currentLine.length + 1 + words[i].length <= maxWidth) {
+                    currentLine += " " + words[i];
+                } else {
+                    formattedLines.push(currentLine);
+                    currentLine = words[i];
+                }
+            }
+            formattedLines.push(currentLine);
+        }
+    });
+    return formattedLines.join('\n   ');
+};
+
+const checkGitSecurity = () => {
+    const gitDir = path.join(process.cwd(), '.git');
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    if (fs.existsSync(gitDir)) {
+        if (!fs.existsSync(gitignorePath)) {
+            console.error('\n\x1b[31m🚨 SECURITY ALERT:\x1b[0m .git detected but no .gitignore found.');
+            process.exit(1);
+        }
+        const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+        if (!gitignoreContent.includes('.env')) {
+            console.error('\n\x1b[31m🚨 CRITICAL RISK:\x1b[0m .env is NOT ignored by Git.');
+            process.exit(1);
+        }
+    }
+};
+
+const injectRouteIntoAppJs = (moduleName, subPath = '') => {
+    const appJsPath = path.join(process.cwd(), 'src', 'App.js');
+    if (!fs.existsSync(appJsPath)) {
+        console.error(`   \x1b[31m[Safety Stop]\x1b[0m App.js missing.`);
+        return false;
+    }
+
+    let content = fs.readFileSync(appJsPath, 'utf8');
+    const importAnchor = '// FLEETBO_MORE_IMPORTS';
+    const routeAnchor = '{/* FLEETBO_DYNAMIC ROUTES */}';
+
+    if (!content.includes(importAnchor) || !content.includes(routeAnchor)) {
+        console.log(`   \x1b[33m[Skipped]\x1b[0m Anchors missing in App.js. Manual injection required.`);
+        return false;
+    }
+
+    const cleanSubPath = subPath ? `${subPath}/` : '';
+    const importLine = `import ${moduleName} from './app/${cleanSubPath}${moduleName}';`;
+    const routeLine = `<Route path="/${cleanSubPath}${moduleName.toLowerCase()}" element={<${moduleName} />} />`;
+
+    let modified = false;
+
+    if (!content.includes(importLine)) {
+        content = content.replace(importAnchor, `${importLine}\n${importAnchor}`);
+        modified = true;
+    }
+    if (!content.includes(routeLine)) {
+        content = content.replace(routeAnchor, `${routeLine}\n            ${routeAnchor}`);
+        modified = true;
+    }
+    if (modified) {
+        fs.writeFileSync(appJsPath, content);
+        console.log(`   \x1b[32m[Routed]\x1b[0m ${moduleName} injected into App.js safely.`);
+    }
+    
+    return modified;
+};
 
-const runAlexEngine = async () => {
-    const prompt = args.slice(1).join(' ');
-    if (!prompt) {
-        console.log('\n\x1b[36mAlex ❯\x1b[0m I am ready. Describe your feature, and I will architect the solution.\n');
-        process.exit(0);
+const showEnergyTransfer = async () => {
+    const width = 30;
+    for (let i = 0; i <= width; i++) {
+        const dots = "█".repeat(i); 
+        const empty = "░".repeat(width - i);
+        process.stdout.write(`\r   \x1b[32m⚡ Propulsion Sync:\x1b[0m [${dots}${empty}] ${Math.round((i / width) * 100)}%`);
+        await new Promise(r => setTimeout(r, 45));
     }
+    process.stdout.write('\n');
+};
+
+// Détecte TOUS les mots en PascalCase (ex: GuestCreator, CameraModule, Tab2)
+const extractPotentialModules = (text) => {
+    // Regex stricte : Majuscule + minuscules + Majuscule (ex: ProfileCreator, UserConfig)
+    const regex = /\b[A-Z][a-z]+[A-Z][a-zA-Z0-9_]*\b/g;
+    const matches = text.match(regex) || [];
+    return [...new Set(matches)];
+};
+
 
-    console.log(`\n\x1b[90m🧠 Alex is thinking...\x1b[0m`);
-    process.stdout.write(`\x1b[90m                                                  \x1b[0m`);
+// Sert uniquement à définir le TON du contexte envoyé à Alex
+const getContextIntent = (text) => {
+    const modifierKeywords = [
+        'modifier', 'corrige', 'ajoute', 'erreur', 'plante', 'problème', 'bug', 'change',
+        'update', 'fix', 'edit', 'error', 'fail', 'crash', 'issue', 'add'
+    ];
+    const inspireKeywords = [
+        'inspire', 'base', 'comme', 'modèle', 'reference', 'reprends', 'copie',
+        'inspire', 'based on', 'model', 'reference', 'like', 'copy', 'similar'
+    ];
+    
+    const lower = text.toLowerCase();
+    if (modifierKeywords.some(k => lower.includes(k))) return "MODIFICATION";
+    if (inspireKeywords.some(k => lower.includes(k))) return "INSPIRATION";
+    return "REFERENCE"; 
+};
 
+const getModuleCache = async ({ projectId, moduleName }) => {
     try {
-        // --- MEMORY SYSTEM (SMART CACHE SCANNER V3 - SOUVERAINETÉ DU MÉTAL) ---
-        // On cherche les noms de modules (PascalCase) dans le prompt
-        const moduleMatches = prompt.match(/\b[A-Z][a-z]+[A-Z][a-zA-Z0-9_]*\b/g) || [];
-        const uniqueModules = [...new Set(moduleMatches)];
-        
-        let targetModuleContext = "";
-        let referenceContexts = "";
+        const res = await axios.post(CACHE_URL, { projectId, moduleName });
+        if (res.data && res.data.found) {
+            // On renvoie à la fois "module" (pour un seul) et "modules" (pour la liste)
+            return { found: true, module: res.data.module, modules: res.data.modules };
+        }
+        return { found: false };
+    } catch (e) {
+        return { found: false };
+    }
+};
 
-        if (uniqueModules.length > 0) {
-            const cachePromises = uniqueModules.map(async (modName) => {
-                const isReferenceOnly = modName.endsWith('Ref');
-                const cleanModName = isReferenceOnly ? modName.replace('Ref', '') : modName;
+const removeRouteFromAppJs = (moduleName) => {
+    const appJsPath = path.join(process.cwd(), 'src', 'App.js');
+    if (!fs.existsSync(appJsPath)) return false;
+
+    let content = fs.readFileSync(appJsPath, 'utf8');
+    
+    // Pattern exact pour l'import et la route (gestion du sous-dossier mocks/)
+    const importLine = `import ${moduleName} from './app/mocks/${moduleName}';`;
+    const routeLine = `<Route path="/mocks/${moduleName.toLowerCase()}" element={<${moduleName} />} />`;
+
+    const originalContent = content;
+    
+    // On retire les lignes si elles existent (avec le retour à la ligne)
+    content = content.replace(new RegExp(`${importLine.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n?`, 'g'), '');
+    content = content.replace(new RegExp(`\\s*${routeLine.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n?`, 'g'), '');
+
+    if (content !== originalContent) {
+        fs.writeFileSync(appJsPath, content);
+        console.log(`   \x1b[32m[Unrouted]\x1b[0m ${moduleName} removed from App.js.`);
+        return true;
+    }
+    return false;
+};
 
-                try {
-                    const cacheRes = await axios.post(CACHE_URL, { 
-                        projectId, 
-                        developerToken, 
-                        moduleName: cleanModName 
-                    });
+// ============================================
+// COMMAND: alex
+// ============================================
+if (command === 'alex') {
+    checkGitSecurity();
+    const initialPrompt = args.slice(1).join(' ');
+    
+    const processAlexRequest = async (prompt) => {
+        if (prompt.length > 1000) {
+            console.log('\n\x1b[31m⛔ [Alex Safety] Request too long (' + prompt.length + '/1000 chars).\x1b[0m');
+            return;
+        }
 
-                    return { name: cleanModName, isRef: isReferenceOnly, found: cacheRes.data.found, module: cacheRes.data.module };
-                } catch (e) {
-                    return { name: cleanModName, isRef: isReferenceOnly, found: false };
-                }
-            });
+        // 📋 INTERCEPTION: LIST MODULES
+        const isListingRequest = /^(liste|list|quels modules|montre les modules|show modules)/i.test(prompt);
+        if (isListingRequest) {
+            process.stdout.write(`   \x1b[90m🔍 Scanning OS Cache...\x1b[0m\n`);
+            const cacheRes = await getModuleCache({ projectId, moduleName: null });
+            
+            if (cacheRes.found !== false && cacheRes.modules && cacheRes.modules.length > 0) { 
+                console.log(`\n\x1b[36m⚡ FLEETBO OS MODULES (${cacheRes.modules.length}):\x1b[0m`);
+                cacheRes.modules.forEach(m => {
+                    const metalColor = m.platform === 'android' ? '\x1b[32m' : '\x1b[34m';
+                    console.log(`   ${metalColor}■\x1b[0m \x1b[1m${m.moduleName}\x1b[0m \x1b[90m(${m.platform})\x1b[0m`);
+                });
+            } else {
+                console.log(`\n   \x1b[90mNo modules found in the infrastructure of this project.\x1b[0m`);
+            }
+            return; 
+        }
 
-            const results = await Promise.all(cachePromises);
+        console.log('\x1b[33m🧠 Alex is thinking...\x1b[0m');
+        
+        try {
+            // --- MEMORY SYSTEM (SMART CACHE SCANNER V3 - SOUVERAINETÉ DU MÉTAL) ---
+            let contextInjection = "";
+            const potentialModules = extractPotentialModules(prompt);
+            
+            let targetModuleContext = "";
+            let referenceContexts = "";
+
+            for (let modName of potentialModules) {
+                let isReferenceOnly = false;
+                
+                // 🟢 LE DÉTECTEUR D'INSPIRATION
+                if (modName.endsWith('Ref')) {
+                    isReferenceOnly = true;
+                    modName = modName.replace('Ref', '');
+                } else if (modName.endsWith('Schema')) {
+                    isReferenceOnly = true;
+                    modName = modName.replace('Schema', '');
+                }
 
-            results.forEach(cache => {
+                process.stdout.write(`   \x1b[90m🔍 Checking OS cache for ${modName}...\x1b[0m`);
+                const cache = await getModuleCache({ projectId, moduleName: modName });
+                
                 if (cache.found) {
                     process.stdout.write(` \x1b[32mFOUND METAL\x1b[0m\n`);
                     
@@ -97,107 +271,737 @@ const runAlexEngine = async () => {
                     if (cache.module.dataSchema) memoryScript += `\n[SCRIPT MÉMOIRE DONNÉES]\n${cache.module.dataSchema}\n`;
                     if (cache.module.uiSchema) memoryScript += `\n[SCRIPT MÉMOIRE UI NATIF]\n${cache.module.uiSchema}\n`;
                     
-                    if (!memoryScript) memoryScript = `\n[SCRIPT MÉMOIRE DU MODULE ${cache.name}]\nAucun schéma enregistré pour ce module.\n`;
+                    if (!memoryScript) memoryScript = `\n[SCRIPT MÉMOIRE DU MODULE ${modName}]\nAucun schéma enregistré pour ce module.\n`;
 
-                    if (cache.isRef) {
+                    if (isReferenceOnly) {
                         // 🚨 CAS A : INSPIRATION (Lecture seule)
-                        referenceContexts += `\n--- CONTEXTE : MODULE DE RÉFÉRENCE (${cache.name}) ---\nDOGME : Ne modifie pas ce module (Lecture seule). Tu dois l'utiliser comme modèle. Aligne-toi sur ses Scripts Mémoires (Données et/ou UI) et sur son Code Natif en fonction de ce que le Pilote te demande d'imiter.\n${memoryScript}\n[CODE NATIF DE RÉFÉRENCE]\n${cache.module.code}\n`;
-                    } else {
-                        // 🚨 CAS B : MODIFICATION (Souveraineté du Métal - Amnésie du Mock)
-                        targetModuleContext += `\n--- CONTEXTE : MÉTAL EXISTANT À MODIFIER (${cache.name}) ---\nDOGME : Tu dois modifier ce code Natif. Ensuite, tu forgeras un Mock JSX entièrement neuf basé UNIQUEMENT sur ton nouveau code Natif.\n${memoryScript}\n[CODE NATIF EXISTANT]\n${cache.module.code}\n`;
+                        referenceContexts += `\n--- CONTEXTE : MODULE DE RÉFÉRENCE (${modName}) ---\nDOGME : Ne modifie pas ce module (Lecture seule). Tu dois l'utiliser comme modèle. Aligne-toi sur ses Scripts Mémoires (Données et/ou UI) et sur son Code Natif en fonction de ce que le Pilote te demande d'imiter.\n${memoryScript}\n[CODE NATIF DE RÉFÉRENCE]\n${cache.module.code}\n`;
+                    } else if (!targetModuleContext) {
+                        // 🚨 CAS B : CIBLE PRINCIPALE (Modification)
+                        // LE MOCK EST BANI ! Le Métal est la seule source de vérité.
+                        const intent = getContextIntent(prompt);
+                        if (intent === "MODIFICATION") {
+                            targetModuleContext = `\n--- CONTEXTE : MÉTAL EXISTANT À MODIFIER (${modName}) ---\nDOGME: Tu dois modifier ce code Natif. Ensuite, tu forgeras un Mock JSX entièrement neuf basé UNIQUEMENT sur ton nouveau code Natif.\n${memoryScript}\n[CODE NATIF EXISTANT]\n${cache.module.code}\n--- FIN DU CONTEXTE ---\n`;
+                        } else {
+                            targetModuleContext = `\n--- CONTEXTE : BASE DE TRAVAIL (${modName}) ---\n${memoryScript}\n`;
+                        }
                     }
+                } else {
+                    process.stdout.write(` \x1b[31mNOT FOUND\x1b[0m\n`);
                 }
+            }
+
+            contextInjection = referenceContexts + targetModuleContext;
+            if (contextInjection) {
+                prompt = contextInjection + "\n\n[INSTRUCTION DU PILOTE]\n" + prompt;
+            }
+            // --- END MEMORY MODIFICATION ---
+
+            // 🟢 NEW: Real-time timestamp injection
+            const now = new Date();
+            // Clean format: YYYY-MM-DD at HH:MM:SS
+            const exactTime = now.toISOString().split('T')[0] + ' at ' + now.toTimeString().split(' ')[0];
+            
+            const promptWithTime = prompt + `\n\n[SYSTEM INFO: The exact current timestamp is ${exactTime}. Use it STRICTLY for your signature '// ⚡ Forged by Alex on...' at the bottom of your files.]`;
+
+            const result = await axios.post(ALEX_ENGINE_URL, { prompt: promptWithTime, projectType: 'android' }, {
+                headers: { 'x-project-id': projectId }
             });
-        }
 
-        const fullPrompt = `${referenceContexts}\n${targetModuleContext}\n--- FIN DU CONTEXTE ---\n\n[INSTRUCTION DU PILOTE]\n${prompt}`;
+            let aiData = result.data;
 
-        // Requête à l'IA
-        const exactTime = new Date().toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit' });
-        const res = await axios.post(ALEX_ENGINE_URL, {
-            prompt: fullPrompt,
-            projectId,
-            developerToken,
-            systemInfo: `[SYSTEM INFO: The exact current timestamp is ${exactTime}. Use it STRICTLY for your signature '// Forged by Alex on...' at the end of 'code' and 'mockCode'.]`
-        });
+            if (typeof aiData === 'string') {
+                try { aiData = JSON.parse(aiData); } catch (_) {}
+            }
 
-        const aiData = res.data;
+            // 🟢 DISPLAY REASONING IN TERMINAL
+            if (aiData.thinking_process) {
+                // Show start of reasoning in gray for info
+                console.log(`   \x1b[90m🧠 Alex Analysis: ${aiData.thinking_process.substring(0, 150)}...\x1b[0m`);
+            }
+
+            process.stdout.write('\x1b[A\r' + ' '.repeat(50) + '\r');
+            
+            if (aiData.status === 'quota_exceeded') {
+                console.log(`\n\x1b[31m⛔ ARCHITECT QUOTA REACHED:\x1b[0m ${aiData.message}`);
+                return;
+            }
+            
+            if (aiData.status === 'success' || aiData.status === 'message' || aiData.status === 'complex_refusal') {
+                console.log(''); 
+                let rawMsg = aiData.message || "I'm ready.";
+
+                if (typeof rawMsg === 'string' && rawMsg.trimStart().startsWith('{')) {
+                    try {
+                        const nested = JSON.parse(rawMsg);
+                        if (nested && nested.message) {
+                            rawMsg = nested.message;
+                            if (!aiData.moduleData && nested.moduleData) {
+                                aiData.moduleData = nested.moduleData;
+                            }
+                        }
+                    } catch (_) {}
+                }
+                
+                if (typeof rawMsg === 'object') {
+                    rawMsg = rawMsg.message || rawMsg.text || "Module generated.";
+                }
+                try {
+                    const testParse = JSON.parse(rawMsg);
+                    if (testParse && typeof testParse === 'object' && testParse.status) {
+                        rawMsg = testParse.message || "Module generated.";
+                    }
+                } catch (_) { }
+                
+                const formattedMsg = wrapText(rawMsg, 85);
+                console.log('\x1b[32mAlex ❯\x1b[0m ' + formattedMsg);
+
+            }
+            
+            // --- FILE CREATION LOGIC ---
+            if (aiData.status === 'success' && aiData.moduleData) {
+                let { fileName, code, mockFileName, mockCode, moduleName, instructions, config_offload, dataSchema, uiSchema } = aiData.moduleData;
+
+                // 🛡️ ANTI-DUMP SHIELD (Prevents terminal flooding)
+                if (moduleName) {
+                    // Cleanup module name
+                    moduleName = moduleName.split('\n')[0].replace(/["'{}]/g, '').trim();
+                    if (moduleName.length > 40) moduleName = moduleName.substring(0, 40) + "...";
+                }
 
-        if (aiData.message) {
-            readline.clearLine(process.stdout, 0);
-            readline.cursorTo(process.stdout, 0);
-            console.log(`\x1b[36mAlex ❯\x1b[0m ${aiData.message}\n`);
+                console.log(`   \x1b[90m  Architecting: ${moduleName}\x1b[0m`);
+
+                const writeFile = (dir, name, content) => {
+                    const fullPath = path.join(process.cwd(), dir);
+                    const filePath = path.join(fullPath, name);
+                    if (!fs.existsSync(fullPath)) fs.mkdirSync(fullPath, { recursive: true });
+                    fs.writeFileSync(filePath, content);
+                    console.log(`   \x1b[32m[Written]\x1b[0m ${dir}${name}`);
+                };
+                
+                if (instructions && Array.isArray(instructions) && instructions.length > 0) {
+                    console.log('\n\x1b[33m--- GUIDE (MCI) ---\x1b[0m');
+                    instructions.forEach(line => {
+                        if (typeof line === 'string') {
+                            const formattedLine = line.replace(/ACTION|CAPTURE|PERSPECTIVE/g, '\x1b[1m$&\x1b[0m');
+                            console.log(`   ${formattedLine}`);
+                        }
+                    });
+                }
+                
+                if (code && fileName) {
+                    const folder = fileName.endsWith('.kt') ? 'public/native/android/' : 'src/app/';
+                    writeFile(folder, fileName, code);
+                    if (fileName.endsWith('.jsx')) injectRouteIntoAppJs(fileName.replace('.jsx', ''));
+                }
+                
+                if (mockCode && mockFileName) {
+                    const pageName = mockFileName.replace('.jsx', '');
+                    writeFile('src/app/mocks/', mockFileName, mockCode);
+                    const injected = injectRouteIntoAppJs(pageName, 'mocks');
+                    if (injected) {
+                        console.log(`   \x1b[32m[Routed]\x1b[0m App.js -> /mocks/${pageName.toLowerCase()}`);
+                    }
+                }
+                
+                // --- KERNEL SYNCHRONIZATION ---
+                const depsCount = config_offload?.dependencies?.length || 0;
+                process.stdout.write(`   \x1b[33m[Cloud Inject]\x1b[0m Archiving ${moduleName} to OS (${depsCount} libs)...`);
+                
+                try {
+                    await axios.post(INJECT_DEPS_URL, {
+                        projectId: projectId,
+                        fileData: { 
+                            path: fileName, 
+                            moduleName: moduleName, 
+                            fileName: fileName,     
+                            code: code,             
+                            mockFileName: mockFileName,
+                            mockCode: mockCode,     
+                            config_offload: config_offload || { dependencies: [], permissions: [] },
+                            dataSchema: dataSchema || null, // 👈 LA LIGNE MAGIQUE
+                            uiSchema: uiSchema || null
+                        }
+                    });
+                    process.stdout.write(`  \x1b[32mOK\x1b[0m\n`);
+                } catch (err) {
+                    process.stdout.write(` \x1b[31mFAILED\x1b[0m\n`);
+                    console.error(`  ⚠️ OS sync failed: ${err.message}`);
+                }
+                // 🟢 LE FUEL EST DÉPLACÉ ICI (TOUTE FIN DU TRY)
+                if (aiData.remainingConsultations !== undefined) {
+                    const remaining = aiData.remainingConsultations;
+                    const limit = aiData.consultationLimit || 7; 
+                    const tierLabel = aiData.tier.toUpperCase();
+                    const percent = Math.round((remaining / limit) * 100);
+                    const energyColor = percent > 20 ? '\x1b[32m' : '\x1b[31m';
+                    console.log(`\n\x1b[36m⚡ Architect Fuel:\x1b[0m ${energyColor}${percent}%\x1b[0m (${remaining}/${limit} instructions left) [${tierLabel}]\n`);
+                }
+            } else if (aiData.status === 'success' && !aiData.moduleData) {
+                // SAFETY: If formatting is broken
+                console.log(`\n\x1b[31m⚠️  Error: Alex replied, but source code could not be extracted. Try the command again.\x1b[0m\n`);
+            }
+        } catch (error) { 
+            process.stdout.write('\r' + ' '.repeat(50) + '\r');
+            console.error('\n\x1b[31m Alex Error:\x1b[0m ' + (error.response?.data?.message || error.message)); 
         }
+    };
+    
+    const startAlexSession = async () => {
+        process.stdout.write('\x1b[33m🛡️  Alex is checking runtime state...\x1b[0m\r');
+        let attempts = 0;
+        const maxAttempts = 5;
+        let isReady = false;
+        let dynamicUsername = 'Pilot';
+        
+        while (attempts < maxAttempts && !isReady) {
+            try {
+                const validation = await axios.post(ALEX_ENGINE_URL, { 
+                    prompt: "ping", validateProject: true, checkNetwork: true, projectKey: keyApp
+                }, { headers: { 'x-project-id': projectId }, timeout: 5000 });
+
+                if (validation.data?.isRunning) { 
+                    isReady = true; 
+                    dynamicUsername = validation.data.username || 'Pilot'; 
+                    break; 
+                }
+                attempts++;
+                if (attempts < maxAttempts) await new Promise(r => setTimeout(r, 2000));
+            } catch (error) {
+                attempts++;
+                await new Promise(r => setTimeout(r, 2000));
+            }
+        }
+        
+        if (!isReady) {
+            console.error('\n\x1b[31m⚠️  ENGINE OFFLINE:\x1b[0m Start Fleetbo runtime first: "npm run fleetbo" ');
+            console.error(`\x1b[90m(Ensure you are running the runtime for project: ${keyApp})\x1b[0m`);
+            process.exit(1);
+        }
+        
+        process.stdout.write(' '.repeat(60) + '\r'); 
+        
+        // 1. IDENTITY
+        console.log('\n\x1b[32m🤖 Alex is online.\x1b[0m');
+        console.log('\x1b[90m   Your JS stays the brain. I forge the native muscle.\x1b[0m');
+
+        // 2. FORGE CAPABILITIES
+        console.log('\n\x1b[36m⚡ WHAT I CAN FORGE:\x1b[0m');
+        console.log('');
+        console.log('   \x1b[1m📷 Hardware\x1b[0m\x1b[90m   Camera, Scanner, GPS, Biometrics, Sensors\x1b[0m');
+        console.log('   \x1b[1m🎬 High-Perf\x1b[0m\x1b[90m  Infinite Feeds, Video Players, Swipe Decks\x1b[0m');
+        console.log('   \x1b[1m🏗️  Sovereign\x1b[0m\x1b[90m  Full screens: form + photo + save-to-cloud\x1b[0m');
+
+        // 3. COLLABORATION
+        console.log('\n\x1b[36m💡 TELL ME "WHAT + WHY":\x1b[0m');
+        console.log('\x1b[90m   I will analyze your need and recommend the perfect module to forge.\x1b[0m');
+        console.log('');
+        console.log('   \x1b[33m"I need a camera [WHAT] to scan receipts for my expense tracker [WHY]"\x1b[0m');
+        console.log('   \x1b[33m"I need a form [WHAT] to add products with photos to my catalog [WHY]"\x1b[0m');
+
+        // 4. READINESS
+        console.log('\n\x1b[32mAlex ❯\x1b[0m I am ready. Describe your feature, and I will architect the solution.');
+        console.log('');
+        
+        const rl = readline.createInterface({ 
+            input: process.stdin, 
+            output: process.stdout,
+            prompt: `\x1b[34m${dynamicUsername} ❯ \x1b[0m` 
+        });
+        
+        process.stdout.write('\n\x1b[F');
+        rl.prompt();
+
+        let inputBuffer = ""; 
+        let isProcessing = false; 
 
-        // --- FILE CREATION LOGIC ---
-        if (aiData.status === 'success' && aiData.moduleData) {
-            let { fileName, code, mockFileName, mockCode, moduleName, instructions, config_offload, dataSchema, uiSchema } = aiData.moduleData;
+        rl.on('line', async (line) => {
+            if (isProcessing) return; 
 
-            if (!fileName || !code) {
-                console.error('\x1b[31m[Fleetbo] ❌ Critical: Alex provided incomplete source code.\x1b[0m');
-                process.exit(1);
+            const trimmedLine = line.trim();
+
+            if (['exit', 'quit'].includes(trimmedLine.toLowerCase())) { 
+                console.log('\n\x1b[90m Alex session closed.\x1b[0m');
+                rl.close(); 
+                return; 
             }
 
-            // Correction automatique du format de fichier
-            if (!fileName.includes('.')) fileName += '.kt';
-            if (mockFileName && !mockFileName.includes('.')) mockFileName += '.jsx';
+            if (trimmedLine !== "") {
+                inputBuffer += (inputBuffer ? "\n" : "") + line;
+                rl.setPrompt(""); 
+            } 
+            else {
+                if (inputBuffer.trim() !== "") {
+                    const finalPrompt = inputBuffer.trim();
+                    inputBuffer = ""; 
+                    
+                    if (finalPrompt.length > 1000) {
+                        console.log(`\n\x1b[31m⛔ [Alex Safety] Mission rejected: Excessive size (${finalPrompt.length}/1000 characters).\x1b[0m`);
+                        rl.setPrompt(`\x1b[34m${dynamicUsername} ❯ \x1b[0m`);
+                        rl.prompt(); 
+                        return; 
+                    }
 
-            // Sauvegarde locale (optionnelle pour debug, mais prioritairement injection Cloud)
-            const buildPath = path.join(process.cwd(), 'fleetbo_build');
-            if (!fs.existsSync(buildPath)) fs.mkdirSync(buildPath);
-            fs.writeFileSync(path.join(buildPath, fileName), code);
-            if (mockCode && mockFileName) {
-                fs.writeFileSync(path.join(buildPath, mockFileName), mockCode);
+                    isProcessing = true; 
+                    rl.setPrompt(""); 
+                    await processAlexRequest(finalPrompt);
+                    isProcessing = false; 
+                    
+                    console.log(''); 
+                    rl.setPrompt(`\x1b[34m${dynamicUsername} ❯ \x1b[0m`);
+                    rl.prompt(); 
+                } else {
+                    rl.setPrompt(`\x1b[34m${dynamicUsername} ❯ \x1b[0m`);
+                    rl.prompt(); 
+                }
             }
+        });
+    };
+
+    if (!initialPrompt || initialPrompt === '?') startAlexSession();
+    else processAlexRequest(initialPrompt);
+    
+}
 
-            // INJECTION CLOUD (Indispensable pour le build et la mémoire d'Alex)
+// ============================================
+// COMMAND: rm (MODULE ANNIHILATION)
+// ============================================
+else if (command === 'rm') {
+    const moduleName = args[1];
+    if (!moduleName) {
+        console.error('\n\x1b[31m❌ Error: Module name required.\x1b[0m');
+        console.log('\x1b[90mUsage: npm run fleetbo rm [ModuleName]\x1b[0m\n');
+        process.exit(1);
+    }
+
+    console.log(`\n\x1b[33m🗑️  Annihilating module: ${moduleName}...\x1b[0m`);
+
+    // 1. Define physical paths
+    const ktPath = path.join(process.cwd(), 'public', 'native', 'android', `${moduleName}.kt`);
+    const jsxPath = path.join(process.cwd(), 'src', 'app', 'mocks', `${moduleName}.jsx`);
+
+    let actionsDone = 0;
+
+    // 2. Eradicate Metal Engine (Kotlin)
+    if (fs.existsSync(ktPath)) {
+        fs.unlinkSync(ktPath);
+        console.log(`   \x1b[32m[Deleted]\x1b[0m Metal file (.kt) eradicated.`);
+        actionsDone++;
+    }
+
+    // 3. Eradicate Virtual Twin (Mock JSX)
+    if (fs.existsSync(jsxPath)) {
+        fs.unlinkSync(jsxPath);
+        console.log(`   \x1b[32m[Deleted]\x1b[0m Virtual Twin (.jsx) eradicated.`);
+        actionsDone++;
+    }
+
+    // 4. Disinfect System Core (App.js)
+    const unrouted = removeRouteFromAppJs(moduleName);
+    if (unrouted) actionsDone++;
+
+    if (actionsDone === 0) {
+        console.log(`\n\x1b[31m⚠️  No trace of module "${moduleName}" found in the OS.\x1b[0m\n`);
+    } else {
+        console.log(`\n\x1b[32m Module ${moduleName} successfully eradicated from the OS.\x1b[0m\n`);
+    }
+}
+
+// ============================================
+// COMMAND: android / ios (PROPULSION BUILD)
+// ============================================
+else if (command === 'android' || command === 'ios') {
+
+    // 🟢 DÉBUT DE LA PROTECTION (Fonction Async Immédiate)
+    // Cela garantit que le code fonctionne partout, même via 'require()'
+    (async () => {
+
+        // 🛑 INTERCEPTION IOS : BLOQUAGE NET (MAINTENANCE/BETA)
+        if (command === 'ios') {
+            console.log(`\n\x1b[36m⚡ FLEETBO IOS PROPULSION\x1b[0m`);
+            console.log(`\x1b[33m[0/3] Initializing Neural Uplink...\x1b[0m`);
+            
+            // ✅ Ce 'await' est maintenant sécurisé
+            await new Promise(r => setTimeout(r, 800));
+
+            console.log(`\n\x1b[31m⛔ PROPULSION ABORTED: iOS Frequency Restricted.\x1b[0m`);
+            console.log(`\x1b[90m   This module is currently reserved for Vanguard Pilots (Closed Beta).\x1b[0m`);
+            console.log(`\x1b[90m   Please engage propulsion on Android frequency for now.\x1b[0m\n`);
+            
+            process.exit(1); 
+        }
+
+        checkGitSecurity();
+        const platform = command;
+        const nativeDir = platform === 'android' ? 'public/native/android/' : 'public/native/ios/';
+        const extension = platform === 'android' ? '.kt' : '.swift';
+        const nativePath = path.join(process.cwd(), nativeDir);
+        
+        // Vérification des modules natifs
+        let hasNativeFiles = false;
+        let nativeFileCount = 0;
+        if (fs.existsSync(nativePath)) {
+            const files = fs.readdirSync(nativePath);
+            const nativeFiles = files.filter(file => file.endsWith(extension));
+            hasNativeFiles = nativeFiles.length > 0;
+            nativeFileCount = nativeFiles.length;
+        }
+        
+        if (!hasNativeFiles) {
+            console.log(`\n\x1b[31m⚠️  ENGINE INCOMPLETE:\x1b[0m No native blueprints detected for \x1b[1m${platform.toUpperCase()}\x1b[0m.`);
+            console.log(`\x1b[90mAlex must architect at least one ${extension} module before deployment.\x1b[0m`);
+            console.log(`\x1b[90mRun: npm run fleetbo alex\x1b[0m\n`);
+            process.exit(1);
+        }
+        
+        const targetUrl = platform === 'android' ? ANDROID_BUILD_URL : IOS_BUILD_URL;
+        
+        console.log(`\n\x1b[36m⚡ FLEETBO ${platform.toUpperCase()} PROPULSION\x1b[0m`);
+        console.log(`\x1b[90m   ${nativeFileCount} native module(s) detected\x1b[0m\n`);
+        
+        try {
+            // ==========================================================
+            // PRE-FLIGHT CHECK QUOTAS & TIER
+            // ==========================================================
+            process.stdout.write(`\x1b[33m[0/3]\x1b[0m Checking Propulsion Access... `);
             try {
-                await axios.post(INJECT_DEPS_URL, {
-                    projectId,
-                    developerToken,
-                    fileData: { 
-                        path: fileName, 
-                        moduleName: moduleName || fileName.split('.')[0], 
-                        fileName: fileName,     
-                        code: code,             
-                        mockFileName: mockFileName,
-                        mockCode: mockCode,     
-                        config_offload: config_offload || { dependencies: [], permissions: [] },
-                        dataSchema: dataSchema || null,
-                        uiSchema: uiSchema || null
+                // On envoie le signal 'x-preflight' pour tester les droits sans builder
+                await axios.post(targetUrl, {}, { 
+                    headers: { 
+                        'x-project-id': projectId,
+                        'x-preflight': 'true' 
                     }
                 });
-                console.log(`\x1b[32m[Fleetbo] ✅ ${fileName} has been forged and fused with the Core.\x1b[0m`);
-            } catch (injectErr) {
-                console.error(`\x1b[31m[Fleetbo] ❌ Forge failed: Core rejection.\x1b[0m`, injectErr.response?.data || injectErr.message);
+                // Si ça passe (200 OK), c'est un Senior ou un Junior autorisé (si vous changez d'avis)
+                process.stdout.write(`\x1b[32mOK (Senior Pilot)\x1b[0m\n\n`);
+
+            } catch (preflightError) {
+                process.stdout.write(`\x1b[31mDENIED\x1b[0m\n`);
+                
+                const errData = preflightError.response?.data;
+
+                // 🛑 1. INTERCEPTION SPÉCIFIQUE JUNIOR
+                // C'est ici qu'on lit le code renvoyé par index.js
+                if (errData?.code === 'junior_restriction') {
+                    console.log(`\n\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m`);
+                    console.log(`\x1b[31m⛔ ACCESS DENIED: JUNIOR PILOT DETECTED\x1b[0m`);
+                    console.log(`\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m`);
+                    console.log(``);
+                    console.log(`   \x1b[33m This feature is locked for Junior Pilots.\x1b[0m`);
+                    console.log(`   \x1b[32m Upgrade to Senior on fleetbo.io to unlock Propulsion.\x1b[0m`);
+                    console.log(``);
+                    process.exit(1); // Arrêt immédiat et propre du script
+                }
+
+                // 2. Gestion des autres erreurs (Quota Senior dépassé, Serveur HS, etc.)
+                if (errData && errData.error) {
+                    throw new Error(errData.error);
+                }
+                throw preflightError; 
+            }
+            
+            // Étape 1: Build React
+            console.log(`\x1b[33m[1/3]\x1b[0m Synthesizing Fleetbo Core Logic...`);
+            execSync('npm run build', { stdio: 'inherit' });
+            
+            let buildDir = fs.existsSync(path.join(process.cwd(), 'dist')) ? 'dist' : 'build';
+            const buildPath = path.join(process.cwd(), buildDir);
+            
+            if (!fs.existsSync(buildPath)) {
+                throw new Error(`Build directory not found: ${buildDir}`);
+            }
+            
+            // Étape 2: Créer le ZIP
+            console.log(`\n\x1b[33m[2/3]\x1b[0m Packaging bundle + native modules...`);
+            
+            const zipBuffer = await new Promise((resolve, reject) => {
+                const chunks = []; 
+                const archive = archiver('zip', { zlib: { level: 9 } });
+                
+                archive.on('data', chunk => chunks.push(chunk));
+                archive.on('end', () => resolve(Buffer.concat(chunks)));
+                archive.on('error', reject);
+                archive.on('warning', (err) => {
+                    if (err.code !== 'ENOENT') reject(err);
+                });
+                
+                archive.directory(buildPath, 'build');
+                if (fs.existsSync(nativePath)) {
+                    archive.directory(nativePath, `build/native/${platform}`);
+                }
+                archive.finalize();
+            });
+            
+            const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(2);
+            console.log(`   \x1b[32m✓\x1b[0m Bundle ready: ${sizeMB} MB`);
+            
+            // Étape 3: Upload
+            console.log(`\n\x1b[33m[3/3]\x1b[0m Uploading to Fleetbo OS...`);
+            await showEnergyTransfer();
+            
+            let uploadResponse;
+            try {
+                uploadResponse = await axios.post(targetUrl, zipBuffer, { 
+                    headers: { 
+                        'Content-Type': 'application/zip', 
+                        'x-project-id': projectId 
+                    },
+                    maxContentLength: Infinity,
+                    maxBodyLength: Infinity,
+                    timeout: 120000 
+                });
+            } catch (axiosError) {
+                if (axiosError.response && axiosError.response.data && axiosError.response.data.error) {
+                    throw new Error(axiosError.response.data.error);
+                } else {
+                    throw new Error(`Connection to OS failed: ${axiosError.message}`);
+                }
+            }
+            
+            if (uploadResponse.data && uploadResponse.data.success) {
+                console.log(`\n\x1b[32m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m`);
+                console.log(`\x1b[32m✓ ${platform.toUpperCase()} PROPULSION SUCCESSFUL\x1b[0m`);
+                console.log(`\x1b[32m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m`);
+                console.log(`\x1b[90m  Deployment ID: ${uploadResponse.data.deploymentId || 'N/A'}\x1b[0m`);
+                console.log(`\x1b[90m  ${uploadResponse.data.message || 'Complete.'}\x1b[0m\n`);
+            } else {
+                throw new Error(uploadResponse.data?.error || 'Unknown logical error from Factory');
+            }
+            
+        } catch (error) { 
+            console.log(`\n\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m`);
+            console.log(`\x1b[31m✗ PROPULSION FAILED\x1b[0m`);
+            console.log(`\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m`);
+            
+            console.error(`\x1b[31m  Error:\x1b[0m ${error.message}`);
+            
+            if (error.message.includes('Limit') || error.message.includes('Quota')) {
+                console.log(`\n\x1b[33m  💡 Tip:\x1b[0m Upgrade to Senior Pilot for more builds.`);
+            } else if (error.message.includes('No native module')) {
+                console.log(`\n\x1b[33m  💡 Tip:\x1b[0m Run "npm run fleetbo alex" to create native modules first.`);
+            } else if (error.message.includes('Trial Period Ended')) {
+                console.log(`\n\x1b[33m  💡 Tip:\x1b[0m Your free sprint is over. Upgrade to Senior Pilot on fleetbo.io.`);
             }
-        } else if (aiData.status === 'success') {
-             console.error('\x1b[33m⚠️  Error: Alex replied, but source code could not be extracted. Try the command again.\x1b[0m');
+            console.log('');
+            process.exit(1); 
         }
 
-    } catch (error) {
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        console.error(`\x1b[31m[Fleetbo] ❌ Alex Engine Error:\x1b[0m`, error.response?.data || error.message);
+    })(); // 🟢 FIN DE LA PROTECTION
+}
+// ============================================
+// COMMAND: page / g / generate
+// ============================================
+else if (['page', 'g', 'generate'].includes(command)) {
+    const pageGeneratorPath = path.join(__dirname, 'page.js');
+    try { 
+        require(pageGeneratorPath); 
+    } catch (e) { 
+        console.error('\x1b[31m Page Generator Error:\x1b[0m', e.message); 
+        process.exit(1); 
     }
-};
-
+}
 // ============================================
-// COMMAND ROUTER
+// COMMAND: (default) - Start Dev Environment
 // ============================================
+else {
+    const NULL_DEV = process.platform === 'win32' ? '>nul 2>&1' : '2>/dev/null';
+    
+    function killProcessOnPort(port) {
+        try {
+            if (process.platform !== 'win32') {
+                const pid = execSync(`lsof -ti:${port} ${NULL_DEV}`).toString().trim();
+                if (pid) execSync(`kill -9 ${pid.split('\n').join(' ')} ${NULL_DEV}`);
+            }
+        } catch (e) {}
+    }
+    
+    const killNetworkService = () => {
+        if (uplinkProcess) {
+            try {
+                uplinkProcess.kill('SIGINT');
+                console.log('[Fleetbo] Engine closed.');
+            } catch (e) {
+                console.error('[Fleetbo] Error closing tunnel:', e.message);
+            }
+        }
+    };
+    
+    let isExiting = false;
+    
+    async function cleanupAndExit(code = 0) {
+        if (isExiting) return;
+        isExiting = true;
+        console.log('\n\x1b[33m[Fleetbo] 🛑 Stopping environment & Cleaning Uplink...\x1b[0m');
+        try {
+            await axios.post(UPDATE_NETWORK_URL, { keyApp, networkUrl: '', tester: testerEmail });
+            console.log('\x1b[32m[Fleetbo] ✓ Network status reset to offline.\x1b[0m');
+        } catch (e) {
+            console.error('[Fleetbo] Network cleanup warning:', e.message);
+        }
+        killNetworkService();
+        killProcessOnPort(PORT);
+        console.log('[Fleetbo] Bye.');
+        process.exit(code);
+    }
+    
+    process.on('SIGINT', () => cleanupAndExit(0));
+    process.on('SIGTERM', () => cleanupAndExit(0));
+    
+    async function syncFirebase(keyApp, networkUrl, testerEmail) {
+        try {
+            await axios.post(UPDATE_NETWORK_URL, { keyApp, networkUrl, tester: testerEmail });
+            console.log('\n\x1b[32mEngine started successfully\x1b[0m');
+            console.log(`\x1b[32mFleetbo OS ❯\x1b[0m -------------------------------------------------------------`);
+            console.log('\x1b[32mFleetbo OS ❯\x1b[0m \x1b[1mGO GO GO ! OS IS READY\x1b[0m');
+            console.log('\x1b[32mFleetbo OS ❯\x1b[0m You can now start coding and previewing. 🚀');
+            console.log(`\x1b[32mFleetbo OS ❯\x1b[0m -------------------------------------------------------------`);
+            console.log(`\x1b[34mPilot Instruction ❯\x1b[0m Return to the Workspace. The Engine is ready for your orders.\n`);
+        } catch (err) {
+            console.error(`\x1b[31mFleetbo OS ❯\x1b[0m Sync Error: ${err.message}`);
+        }
+    }
+    
+    async function runDevEnvironment() {
+        console.log(`[Fleetbo] 🛡️  Initializing Dev Environment...`);
+        
+        // Mise à jour silencieuse de browserslist
+        try {
+            const npxExec = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+            execSync(`${npxExec} -y update-browserslist-db@latest`, { stdio: 'ignore' });
+        } catch (e) {}
+        
+        killNetworkService();
+        killProcessOnPort(PORT);
+        
+        if (!testerEmail) { 
+            console.error('\x1b[31mError: REACT_APP_TESTER_EMAIL missing in .env\x1b[0m'); 
+            process.exit(1); 
+        }
+        
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const devServer = spawn(npmCmd, ['start'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true,
+            env: { 
+                ...process.env, 
+                NODE_OPTIONS: '--no-deprecation',
+                BROWSER: 'none', 
+                PORT: PORT.toString(),
+                DANGEROUSLY_DISABLE_HOST_CHECK: 'true',
+                HOST: '0.0.0.0',      
+                WDS_SOCKET_HOST: 'localhost',
+                WDS_SOCKET_PORT: PORT.toString()
+            }
+        });
 
-switch (command) {
-    case 'alex':
-        runAlexEngine();
-        break;
+        //devServer.stdout.pipe(process.stdout);
+        devServer.stderr.pipe(process.stderr);
 
-    default:
-        console.log(`
-\x1b[36mFleetbo OS CLI\x1b[0m
-Usage: npm run fleetbo [command]
+        let connectionStarted = false;
+        
+        devServer.stdout.on('data', (data) => {
+            const output = data.toString();
+            
+            // 🛡️ FILTRE ANTI-PLOMBERIE FLEETBO
+            const lines = output.split('\n');
+            const forbiddenTerms = [
+                'Attempting to bind to HOST',
+                'If this was unintentional',
+                'Learn more here:',
+                'Starting the development server',
+                'You can now view',
+                'Local:',
+                'On Your Network:',
+                'Note that the development build',
+                'To create a production build',
+                'webpack compiled successfully'
+            ];
+
+            // On filtre les lignes pour ne garder que le vrai code/debug
+            const filteredOutput = lines.filter(line => {
+                return !forbiddenTerms.some(term => line.includes(term));
+            }).join('\n');
+
+            // S'il reste quelque chose d'utile (un console.log du dev, un warning, une vraie erreur), on l'affiche
+            if (filteredOutput.trim() !== '') {
+                process.stdout.write(filteredOutput + '\n');
+            }
+            
+            // 🚀 DÉTECTION DU DÉMARRAGE ET LANCEMENT DE L'UPLINK
+            if (!connectionStarted && (output.includes('Local:') || output.includes('Compiled successfully'))) {
+                connectionStarted = true;
+
+                console.log('\x1b[33mFleetbo OS ❯\x1b[0m ---------------------------------------------------');
+                console.log(`\x1b[33mFleetbo OS ❯\x1b[0m 🔗 Establishing Secure Uplink...`);
+                console.log(`\x1b[33mFleetbo OS ❯\x1b[0m ⏳ Please wait for the green message...`);
+                console.log('\x1b[33mFleetbo OS ❯\x1b[0m ---------------------------------------------------');
+
+                // ============================================
+                // UPLINK avec auto-retry (Fleetbo OS Resilience)
+                // ============================================
+                const MAX_UPLINK_RETRIES = 5;
+                const RETRY_DELAYS = [0, 10, 20, 30, 45];
+                let uplinkFound = false;
+
+                const startUplink = (attempt) => {
+                    if (uplinkFound) return;
+
+                    const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+
+                    if (attempt > 0) {
+                        console.log(`\x1b[33m[Fleetbo] 🔄 Uplink reconnection ${attempt}/${MAX_UPLINK_RETRIES - 1}...\x1b[0m`);
+                    }
+
+                    uplinkProcess = spawn(npxCmd, [
+                        '-y',
+                        'cloudflared', 
+                        'tunnel', 
+                        '--url', `http://127.0.0.1:${PORT}`,
+                        '--http-host-header', `127.0.0.1:${PORT}` 
+                    ], { shell: true });
+
+                    const handleUplinkOutput = (chunk) => {
+                        const text = chunk.toString();
+                        if (uplinkFound) return;
+                        const match = text.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+                        if (match) {
+                            uplinkFound = true;
+                            // ⚡ Stabilisation du noyau : on attend 1.5s
+                            setTimeout(() => {
+                                syncFirebase(process.env.REACT_KEY_APP, match[0], process.env.REACT_APP_TESTER_EMAIL);
+                            }, 1500);
+                        }
+                    };
+
+                    uplinkProcess.stdout.on('data', handleUplinkOutput);
+                    uplinkProcess.stderr.on('data', handleUplinkOutput);
+
+                    uplinkProcess.on('error', (err) => {
+                        if (uplinkFound) return;
+                        console.error(`\x1b[31m[Fleetbo] ⚠️  Uplink Connection failed to establish.\x1b[0m`);
+                    });
 
-Commands:
-  alex [prompt]    Talk to the Architect to forge or modify modules.
-        `);
-        break;
+                    uplinkProcess.on('close', (code) => {
+                        if (uplinkFound) return;
+
+                        const nextAttempt = attempt + 1;
+                        if (nextAttempt < MAX_UPLINK_RETRIES) {
+                            const delay = RETRY_DELAYS[nextAttempt] || 30;
+                            console.log(`\x1b[33m[Fleetbo] ⚠️  Uplink interrupted. Fleetbo OS retrying in ${delay}s... (${nextAttempt}/${MAX_UPLINK_RETRIES - 1})\x1b[0m`);
+                            setTimeout(() => startUplink(nextAttempt), delay * 1000);
+                        } else {
+                            console.error(`\x1b[31m[Fleetbo] ❌ Secure Uplink could not be established.\x1b[0m`);
+                            console.error(`\x1b[90m[Fleetbo] Fleetbo OS network is temporarily unavailable.\x1b[0m`);
+                            console.error(`\x1b[90m[Fleetbo] Your dev server is still running on http://localhost:${PORT}\x1b[0m`);
+                            console.error(`\x1b[90m[Fleetbo] Restart with "npm run fleetbo" when the network is back.\x1b[0m`);
+                        }
+                    });
+                };
+
+                startUplink(0);
+            }
+        });
+    }
+    
+    runDevEnvironment();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fleetbo-cockpit-cli",
-  "version": "1.0.74",
+  "version": "1.0.75",
   "description": "Fleetbo CLI - Build native mobile apps with React",
   "author": "Fleetbo",
   "license": "MIT",