create-fleetbo-project 1.2.40 → 1.2.42

package/install-react-template.js

@@ -31,12 +31,13 @@ const PORT = 3000;
 const args = process.argv.slice(2);
 const command = args[0];
 
+process.env.DOTENV_SILENT = 'true';
 const envPath = path.join(process.cwd(), '.env');
 if (!fs.existsSync(envPath)) {
     console.error('\\\\x1b[31m%s\\\\x1b[0m', '❌ Error: Configuration file (.env) not found.');
     process.exit(1);
 }
-dotenv.config({ path: envPath });
+dotenv.config({ path: envPath, quiet: true });
 
 const projectId = process.env.REACT_APP_ENTERPRISE_ID; 
 const keyApp = process.env.REACT_KEY_APP; 
@@ -63,24 +64,29 @@ if (!projectId) {
     process.exit(1);
 }
 
-const injectRouteIntoAppJs = (pageName) => {
+const injectRouteIntoAppJs = (pageName, subPath = '') => {
     if (!fs.existsSync(APP_JS_PATH)) return false;
     let content = fs.readFileSync(APP_JS_PATH, 'utf8');
-    if (!content.includes('// FLEETBO_IMPORTS') || !content.includes('{/* FLEETBO_ROUTES */}')) return false;
+    
+    const importAnchor = '// FLEETBO_MORE_IMPORTS';
+    const alexRouteAnchor = '{/* FLEETBO_DYNAMIC ROUTES */}';
+
+    if (!content.includes(alexRouteAnchor)) return false;
 
-    const importLine = \`import \\\${pageName} from './pages/\\\${pageName}';\`; 
-    const routeLine = \`<Route path="/\\\${pageName.toLowerCase()}" element=<\\\${pageName} /> />\`;
+    const pathPrefix = subPath ? \\\`\\\${subPath}/\\\` : '';
+    const importLine = \\\`import \\\${pageName} from './pages/\\\${pathPrefix}\\\${pageName}';\\\`; 
+    const routeLine = \\\`<Route path="/\\\${pathPrefix.toLowerCase()}\\\${pageName.toLowerCase()}" element=<\\\${pageName} /> />\\\`;
 
     let injected = false;
-    if (!content.includes(importLine) && !content.includes(\`import \\\${pageName} from\`)) {
-        content = content.replace('// FLEETBO_IMPORTS', \`\\\${importLine}\\\\n// FLEETBO_IMPORTS\`);
+    if (!content.includes(importLine)) {
+        content = content.replace(importAnchor, \\\`\\\${importLine}\\\\n\\\${importAnchor}\\\`);
         injected = true;
     }
-    if (!content.includes(routeLine) && !content.includes(\`path="/\\\${pageName.toLowerCase()}"\`)) {
-        const anchor = content.includes('{/* FLEETBO_ROUTES */}') ? '{/* FLEETBO_ROUTES */}' : '// FLEETBO_ROUTES';
-        content = content.replace(anchor, \`\\\${routeLine}\\\\n             \\\${anchor}\`);
+    if (!content.includes(routeLine)) {
+        content = content.replace(alexRouteAnchor, \\\`\\\${routeLine}\\\\n            \\\${alexRouteAnchor}\\\`);
         injected = true;
     }
+
     if (injected) fs.writeFileSync(APP_JS_PATH, content);
     return injected;
 };
@@ -89,7 +95,7 @@ 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⚡ Alex Energy Sync:\\\\x1b[0m [\\\${dots}\\\${empty}] \\\${Math.round((i / width) * 100)}%\`);
+        process.stdout.write(\\\`\\\\r   \\\\x1b[32m⚡ Alex Energy Sync:\\\\x1b[0m [\\\${dots}\\\${empty}] \\\${Math.round((i / width) * 100)}%\\\`);
         await new Promise(r => setTimeout(r, 45));
     }
     process.stdout.write('\\\\n');
@@ -100,68 +106,88 @@ if (command === 'alex') {
     const initialPrompt = args.slice(1).join(' ');
 
     const processAlexRequest = async (prompt) => {
-        process.stdout.write('\\\\n\\\\x1b[33m🧠 Alex is architecting...\\\\x1b[0m\\\\r');
+        process.stdout.write('\\\\x1b[33m🧠 Alex is thinking...\\\\x1b[0m');
         try {
             const result = await axios.post(ALEX_ENGINE_URL, { prompt, projectType: 'android' }, {
                 headers: { 'x-project-id': projectId }
             });
-            const aiData = result.data.data || result.data;
-            process.stdout.write(' '.repeat(30) + '\\\\r'); 
+            
+            const aiData = result.data;
+            process.stdout.write('\\\\r' + ' '.repeat(50) + '\\\\r'); 
+
+            if (aiData.status === 'quota_exceeded') {
+                console.log(\\\`\\\\n\\\\x1b[31m⛔ ENGINE OUT OF FUEL:\\\\x1b[0m \\\${aiData.message}\\\`);
+                return;
+            }
+
+            if (aiData.status === 'success' || aiData.status === 'message') {
+                console.log(''); 
+                console.log(\\\`\\\\x1b[32mAlex ❯\\\\x1b[0m \\\${aiData.message || "I'm ready."}\\\`);
+                
+                if (aiData.remainingTokens !== undefined) {
+                    const remaining = aiData.remainingTokens;
+                    const limit = aiData.limit || 2500;
+                    const percent = Math.round((remaining / limit) * 100);
+                    const energyColor = percent > 30 ? '\\\\x1b[32m' : '\\\\x1b[31m';
+                    console.log(\\\`\\\\x1b[36m📊 Energy:\\\\x1b[0m \\\${energyColor}\\\${percent}%\\\\x1b[0m (\\\${remaining}/\\\${limit} tokens left)\\\`);
+                }
+            }
 
             if (aiData.status === 'success' && aiData.moduleData) {
-                const { fileName, code, mockFileName, mockCode } = aiData.moduleData;
+                const { fileName, code, mockFileName, mockCode, moduleName } = aiData.moduleData;
+                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 });
-
-                    if (fs.existsSync(filePath)) {
-                        const backupPath = filePath.replace(/(\\\\.jsx|\\\\.kt|\\\\.swift)$/, '.original\\\$1');
-                        fs.copyFileSync(filePath, backupPath);
-                        fs.writeFileSync(filePath, content);
-                        console.log(\`   ✅ \\\\x1b[33m[Updated]\\\\x1b[0m  \\\${dir}\\\${name} \\\\x1b[90m(Backup created)\\\\x1b[0m\`);
-                    } else {
-                        fs.writeFileSync(filePath, content);
-                        console.log(\`   ✅ \\\\x1b[32m[Created]\\\\x1b[0m  \\\${dir}\\\${name}\`);
-                    }
+                    fs.writeFileSync(filePath, content);
+                    console.log(\\\`   ✅ \\\\x1b[32m[Written]\\\\x1b[0m \\\${dir}\\\${name}\\\`);
                 };
-                console.log('');
-                if (code && fileName && (fileName.endsWith('.kt') || fileName.endsWith('.swift'))) {
-                    writeFile(fileName.endsWith('.kt') ? 'public/native/android/' : 'public/native/ios/', fileName, code);
+
+                if (code && fileName) {
+                    const folder = fileName.endsWith('.kt') ? 'public/native/android/' : 'src/pages/';
+                    writeFile(folder, fileName, code);
+                    if (fileName.endsWith('.jsx')) injectRouteIntoAppJs(fileName.replace('.jsx', ''));
                 }
                 if (mockCode && mockFileName) {
                     writeFile('src/pages/mocks/', mockFileName, mockCode);
-                    writeFile('src/pages/mocks/', 'Quick.js', mockCode); 
-                }
-                if (code && fileName && fileName.endsWith('.jsx') && !mockCode) {
-                    const pageName = fileName.replace('.jsx', '');
-                    writeFile('src/pages/', fileName, code);
-                    injectRouteIntoAppJs(pageName);
+                    writeFile('src/pages/mocks/', 'Quick.jsx', mockCode); 
                 }
-                console.log('\\\\n\\\\x1b[32mAlex ❯\\\\x1b[0m ' + aiData.message);
             }
-        } catch (error) { console.error('\\\\n\\\\x1b[31m❌ Alex Error:\\\\x1b[0m ' + error.message); }
+        } 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('\\\\n\\\\x1b[33m🛡️  Alex is checking runtime state...\\\\x1b[0m\\\\r');
-        try {
-            const validation = await axios.post(ALEX_ENGINE_URL, { validateProject: true, checkNetwork: true, projectKey: keyApp, testerEmail: testerEmail }, { headers: { 'x-project-id': projectId } });
-            if (!validation.data.exists || !validation.data.isRunning) {
-                console.error('\\\\n\\\\x1b[31m⚠️  ENGINE OFFLINE:\\\\x1b[0m Alex needs a live Uplink.');
-                process.exit(1);
-            }
-            process.stdout.write(' '.repeat(60) + '\\\\r'); 
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: '\\\\x1b[32mAlex ❯ \\\\x1b[0m' });
-            console.log('\\\\n\\\\x1b[32m🤖 Alex is now online.\\\\x1b[0m Pilot safely.');
+        process.stdout.write('\\\\x1b[33m🛡️  Alex is checking runtime state...\\\\x1b[0m\\\\r');
+        let attempts = 0; const maxAttempts = 5; let isReady = false;
+        while (attempts < maxAttempts && !isReady) {
+            try {
+                const validation = await axios.post(ALEX_ENGINE_URL, { prompt: "ping", validateProject: true, checkNetwork: true }, { headers: { 'x-project-id': projectId }, timeout: 5000 });
+                if (validation.data?.isRunning) { isReady = true; 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" ');
+            process.exit(1);
+        }
+        process.stdout.write(' '.repeat(60) + '\\\\r');
+        console.log('\\\\n\\\\x1b[32m🤖 Alex is now online.\\\\x1b[0m');
+        console.log('\\\\x1b[32mAlex ❯\\\\x1b[0m Welcome! I am Alex, your architect. What are we building today?\\\\n');
+        const userName = testerEmail ? testerEmail.split('@')[0] : 'Dev';
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: \\\`\\\\x1b[34m\\\${userName} ❯ \\\\x1b[0m\\\` });
+        rl.prompt();
+        rl.on('line', async (line) => {
+            if (['exit', 'quit'].includes(line.trim().toLowerCase())) { console.log('\\\\n\\\\x1b[90m👋 Alex session closed.\\\\x1b[0m'); rl.close(); return; }
+            if (line.trim()) { await processAlexRequest(line.trim()); console.log(''); }
             rl.prompt();
-            rl.on('line', async (line) => {
-                if (['exit', 'quit', 'bye'].includes(line.trim().toLowerCase())) { rl.close(); return; }
-                if (line.trim()) await processAlexRequest(line.trim());
-                rl.prompt();
-            }).on('close', () => { console.log('\\\\n👋 Alex going offline.'); process.exit(0); });
-        } catch (error) { process.exit(1); }
+        }).on('close', () => { process.exit(0); });
     };
+
     if (!initialPrompt || initialPrompt === '?') startAlexSession();
     else processAlexRequest(initialPrompt);
     return;
@@ -192,21 +218,19 @@ if (command === 'deploy') {
 
 const GENERATOR_COMMANDS = ['page', 'g', 'generate', 'android', 'ios'];
 if (GENERATOR_COMMANDS.includes(command)) {
-    try { require('./page.js'); } catch (error) { process.exit(1); }
+    try { require('./page.js'); } catch (e) { console.error(e.message); process.exit(1); }
     return; 
 }
 
 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}\`); }
+            const pid = execSync(\\\`lsof -ti:\\\${port} \\\${NULL_DEV}\\\`).toString().trim();
+            if (pid) execSync(\\\`kill -9 \\\${pid.split('\\\\n').join(' ')} \\\${NULL_DEV}\\\`);
         }
     } catch (e) {}
 }
-
 function killNetworkService() {
     try {
         const cmd = process.platform === 'win32' ? 'taskkill /IM cloudflared.exe /F' : 'pkill cloudflared';
@@ -216,14 +240,10 @@ function killNetworkService() {
 
 let isExiting = false;
 async function cleanupAndExit(code = 0) {
-    if (isExiting) return;
-    isExiting = true;
-    try {
-        await axios.post(UPDATE_NETWORK_URL, { keyApp: keyApp, networkUrl: '', tester: testerEmail });
-    } catch (e) {}
-    killNetworkService();
-    killProcessOnPort(PORT);
-    process.exit(code);
+    if (isExiting) return; isExiting = true;
+    console.log('\\\\n[Fleetbo] 🛑 Stopping environment...');
+    try { await axios.post(UPDATE_NETWORK_URL, { keyApp, networkUrl: '', tester: testerEmail }); } catch (e) {}
+    killNetworkService(); killProcessOnPort(PORT); process.exit(code);
 }
 process.on('SIGINT', () => cleanupAndExit(0));
 process.on('SIGTERM', () => cleanupAndExit(0));
@@ -231,30 +251,37 @@ 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[Fleetbo] ✅ Uplink Status: Online for \\\${testerEmail}\`);
-        console.log(\`[Fleetbo] 🚀 Fleetbo Studio: https://fleetbo.io/studio/\\\${keyApp}\`);
-    } catch (err) { console.error(\`[Fleetbo] ⚠️ Sync Error: \\\${err.message}\`); }
+        console.log(\\\`\\\\n\\\\x1b[32m[Fleetbo]\\\\x1b[0m -------------------------------------------------------------\\\`);
+        console.log('\\\\x1b[32m[Fleetbo]  GO GO GO ! FLEETBO STUDIO IS READY \\\\x1b[0m');
+        console.log(\\\`\\\\x1b[32m[Fleetbo]  Link: https://fleetbo.io/studio/\\\${keyApp}\\\\x1b[0m\\\`);
+        console.log('\\\\x1b[32m[Fleetbo]  You can now start coding and previewing in Studio. 🚀\\\\x1b[0m\\\`);
+        console.log(\\\`\\\\x1b[32m[Fleetbo]\\\\x1b[0m -------------------------------------------------------------\\\`);
+    } catch (err) { console.error(\\\`[Fleetbo] ❌ Sync Error: \\\${err.message}\\\`); }
 }
 
 async function runDevEnvironment() {
-    killNetworkService();
-    killProcessOnPort(PORT);
+    console.log(\\\`[Fleetbo] 🛡️  Initializing Dev Environment...\\\`);
+    killNetworkService(); killProcessOnPort(PORT);
     const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
     const devServer = spawn(npmCmd, ['start'], { stdio: ['ignore', 'pipe', 'pipe'], shell: true, env: { ...process.env, BROWSER: 'none', PORT: PORT.toString() } });
+    devServer.stdout.pipe(process.stdout); devServer.stderr.pipe(process.stderr);
+    let connectionStarted = false;
     devServer.stdout.on('data', (data) => {
         const output = data.toString();
-        if (output.includes('Local:') || output.includes('Compiled successfully')) {
+        if (!connectionStarted && (output.includes('Local:') || output.includes('Compiled successfully'))) {
+            connectionStarted = true;
+            console.log('\\\\n[Fleetbo] ---------------------------------------------------');
+            console.log(\\\`[Fleetbo] 🔗 Establishing Secure Uplink...\\\\n[Fleetbo] 🛑 DO NOT open the Fleetbo Studio yet.\\\\n[Fleetbo] ⏳ Please wait green message...\\\\n[Fleetbo] ---------------------------------------------------\\\`);
             const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-            const uplink = spawn(npxCmd, ['cloudflared', 'tunnel', '--url', \`http://localhost:\\\${PORT}\`], { shell: true });
+            const uplink = spawn(npxCmd, ['cloudflared', 'tunnel', '--url', \\\`http://localhost:\\\${PORT}\\\`], { shell: true });
             uplink.stderr.on('data', (chunk) => {
-                const match = log.match(/https:[//][//][a-zA-Z0-9-]+[.]trycloudflare[.]com/);
+                const match = chunk.toString().match(/https:\\\\/\\\\/[a-zA-Z0-9-]+\\\\.trycloudflare\\\\.com/);
                 if (match) syncFirebase(keyApp, match[0], testerEmail);
             });
         }
     });
 }
-runDevEnvironment();
-`;
+runDevEnvironment();`;
 
 
 const args = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fleetbo-project",
-  "version": "1.2.40",
+  "version": "1.2.42",
   "description": "Creates a new Fleetbo project.",
   "main": "install-react-template.js",
   "bin": {