plusui-native 0.2.68 → 0.2.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "description": "PlusUI CLI - Build C++ desktop apps modern UI ",
   "main": "src/index.js",
   "type": "module",
@@ -27,11 +27,11 @@
     "semver": "^7.6.0",
     "which": "^4.0.0",
     "execa": "^8.0.1",
-    "plusui-native-builder": "^0.1.67",
-    "plusui-native-connect": "^0.1.67"
+    "plusui-native-builder": "^0.1.69",
+    "plusui-native-connect": "^0.1.69"
   },
   "peerDependencies": {
-    "plusui-native-connect": "^0.1.67"
+    "plusui-native-connect": "^0.1.69"
   },
   "publishConfig": {
     "access": "public"

package/src/doctor/detectors/compiler.js

@@ -19,25 +19,21 @@ async function detectMSVC() {
   const vswherePath = 'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe';
 
   if (!existsSync(vswherePath)) {
-    // Fallback: check common VS paths manually
-    const vsPaths = [
-      'C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC',
-      'C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC',
-      'C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Tools\\MSVC',
-      'C:\\Program Files\\Microsoft Visual Studio\\2019\\Community\\VC\\Tools\\MSVC',
-      'C:\\Program Files\\Microsoft Visual Studio\\2019\\Professional\\VC\\Tools\\MSVC',
-      'C:\\Program Files\\Microsoft Visual Studio\\2019\\Enterprise\\VC\\Tools\\MSVC'
-    ];
-
-    for (const vsPath of vsPaths) {
-      if (existsSync(vsPath)) {
-        const version = vsPath.includes('2022') ? 'Visual Studio 2022' : 'Visual Studio 2019';
-        return {
-          found: true,
-          name: version,
-          path: vsPath,
-          valid: true
-        };
+    // Fallback: check common VS paths for years 2019–2026
+    const vsYears = ['2026', '2025', '2024', '2023', '2022', '2019'];
+    const vsEditions = ['Community', 'Professional', 'Enterprise', 'BuildTools'];
+
+    for (const year of vsYears) {
+      for (const edition of vsEditions) {
+        const vsPath = `C:\\Program Files\\Microsoft Visual Studio\\${year}\\${edition}\\VC\\Tools\\MSVC`;
+        if (existsSync(vsPath)) {
+          return {
+            found: true,
+            name: `Visual Studio ${year} ${edition}`,
+            path: vsPath,
+            valid: true
+          };
+        }
       }
     }
 
@@ -95,7 +91,7 @@ async function detectXcode() {
 
   // Parse clang version
   const versionMatch = clangResult.output.match(/clang version (\d+\.\d+\.\d+)/i) ||
-                       clangResult.output.match(/Apple clang version (\d+\.\d+\.\d+)/i);
+    clangResult.output.match(/Apple clang version (\d+\.\d+\.\d+)/i);
   const version = versionMatch ? versionMatch[1] : 'unknown';
 
   return {

package/src/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { mkdir, readFile, stat, rm, readdir, writeFile, copyFile } from 'fs/promises';
 import { existsSync, watch, statSync, mkdirSync } from 'fs';
@@ -74,23 +74,38 @@ function checkTools() {
         }
     }
 
+    // Compiler / build tools check
     if (platform === 'win32') {
-        const vsPaths = [
-            'C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC',
-            'C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC',
-            'C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Tools\\MSVC'
-        ];
-
+        // Use vswhere.exe first (same detection as `plusui doctor`)
         let vsFound = false;
-        for (const p of vsPaths) {
-            if (existsSync(p)) {
-                vsFound = true;
-                break;
+        const vswherePath = 'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe';
+        if (existsSync(vswherePath)) {
+            try {
+                const output = execSync(
+                    `"${vswherePath}" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`,
+                    { stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf8', timeout: 10000 }
+                ).trim();
+                if (output) vsFound = true;
+            } catch { }
+        }
+
+        // Fallback: check common VS paths for years 2019–2026
+        if (!vsFound) {
+            const vsYears = ['2026', '2025', '2024', '2023', '2022', '2019'];
+            const vsEditions = ['Community', 'Professional', 'Enterprise', 'BuildTools'];
+            for (const year of vsYears) {
+                for (const edition of vsEditions) {
+                    if (existsSync(`C:\\Program Files\\Microsoft Visual Studio\\${year}\\${edition}\\VC\\Tools\\MSVC`)) {
+                        vsFound = true;
+                        break;
+                    }
+                }
+                if (vsFound) break;
             }
         }
 
         if (!vsFound) {
-            required.push({ name: 'Visual Studio 2022', install: 'Download from visualstudio.microsoft.com with C++ workload', auto: null });
+            required.push({ name: 'Visual Studio (C++ workload)', install: 'Download from visualstudio.microsoft.com with C++ workload', auto: null });
         }
     } else if (platform === 'darwin') {
         try {
@@ -196,16 +211,64 @@ function getCMakePath() {
     return 'cmake';
 }
 
+// Find vcvarsall.bat for Windows builds (needed for Ninja generator)
+let _vcvarsallCache = undefined;
+function findVcvarsall() {
+    if (_vcvarsallCache !== undefined) return _vcvarsallCache;
+
+    const vswherePath = 'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe';
+    if (existsSync(vswherePath)) {
+        try {
+            const installPath = execSync(
+                `"${vswherePath}" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`,
+                { stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf8', timeout: 10000 }
+            ).trim();
+            if (installPath) {
+                const vcvars = join(installPath, 'VC', 'Auxiliary', 'Build', 'vcvarsall.bat');
+                if (existsSync(vcvars)) {
+                    _vcvarsallCache = vcvars;
+                    return vcvars;
+                }
+            }
+        } catch { }
+    }
+
+    // Fallback: scan known paths
+    const vsYears = ['2026', '2025', '2024', '2023', '2022', '2019'];
+    const vsEditions = ['Community', 'Professional', 'Enterprise', 'BuildTools'];
+    for (const year of vsYears) {
+        for (const edition of vsEditions) {
+            const vcvars = `C:\\Program Files\\Microsoft Visual Studio\\${year}\\${edition}\\VC\\Auxiliary\\Build\\vcvarsall.bat`;
+            if (existsSync(vcvars)) {
+                _vcvarsallCache = vcvars;
+                return vcvars;
+            }
+        }
+    }
+
+    _vcvarsallCache = null;
+    return null;
+}
+
 function runCMake(args, options = {}) {
     const cmake = getCMakePath();
+
+    // On Windows, wrap cmake in vcvarsall to ensure cl.exe is in PATH (needed for Ninja)
+    if (process.platform === 'win32') {
+        const vcvarsall = findVcvarsall();
+        if (vcvarsall) {
+            return execSync(`cmd /c ""${vcvarsall}" x64 >nul 2>&1 && "${cmake}" ${args}"`, { stdio: 'inherit', shell: true, ...options });
+        }
+    }
+
     return execSync(`"${cmake}" ${args}`, { stdio: 'inherit', ...options });
 }
 
 function getInstalledPackageVersion(packageName) {
     try {
-        const result = execSync(`npm list ${packageName} --depth=0 --json`, { 
-            encoding: 'utf8', 
-            stdio: ['pipe', 'pipe', 'ignore'] 
+        const result = execSync(`npm list ${packageName} --depth=0 --json`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore']
         });
         const json = JSON.parse(result);
         if (json.dependencies && json.dependencies[packageName]) {
@@ -214,12 +277,12 @@ function getInstalledPackageVersion(packageName) {
     } catch {
         // Package not installed locally
     }
-    
+
     // Try global installation
     try {
-        const result = execSync(`npm list -g ${packageName} --depth=0 --json`, { 
-            encoding: 'utf8', 
-            stdio: ['pipe', 'pipe', 'ignore'] 
+        const result = execSync(`npm list -g ${packageName} --depth=0 --json`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore']
         });
         const json = JSON.parse(result);
         if (json.dependencies && json.dependencies[packageName]) {
@@ -228,15 +291,15 @@ function getInstalledPackageVersion(packageName) {
     } catch {
         return null;
     }
-    
+
     return null;
 }
 
 function getLatestPackageVersion(packageName) {
     try {
-        const result = execSync(`npm view ${packageName} version`, { 
-            encoding: 'utf8', 
-            stdio: ['pipe', 'pipe', 'ignore'] 
+        const result = execSync(`npm view ${packageName} version`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore']
         });
         return result.trim();
     } catch {
@@ -247,7 +310,7 @@ function getLatestPackageVersion(packageName) {
 function compareVersions(v1, v2) {
     const parts1 = v1.split('.').map(Number);
     const parts2 = v2.split('.').map(Number);
-    
+
     for (let i = 0; i < 3; i++) {
         if (parts1[i] > parts2[i]) return 1;
         if (parts1[i] < parts2[i]) return -1;
@@ -262,9 +325,9 @@ function showVersionInfo() {
         'plusui-native-builder',
         'plusui-native-connect'
     ];
-    
+
     logSection('PlusUI Package Versions');
-    
+
     packages.forEach(pkg => {
         let version;
         if (pkg === cliPackageJson.name) {
@@ -279,33 +342,33 @@ function showVersionInfo() {
             }
         }
     });
-    
+
     console.log('');
 }
 
 async function updatePlusUIPackages() {
     logSection('Updating PlusUI Packages');
-    
+
     const packages = [
         cliPackageJson.name,
         'plusui-native-core',
         'plusui-native-builder',
         'plusui-native-connect'
     ];
-    
+
     log('Checking for updates...\n', 'blue');
-    
+
     // Check if packages are installed locally or globally
     const isInProject = existsSync(join(process.cwd(), 'package.json'));
-    
+
     if (isInProject) {
         let updatedCount = 0;
         let upToDateCount = 0;
         let installedCount = 0;
-        
+
         for (const pkg of packages) {
             const currentVersion = getInstalledPackageVersion(pkg);
-            
+
             if (!currentVersion) {
                 const latestVersion = getLatestPackageVersion(pkg);
 
@@ -327,22 +390,22 @@ async function updatePlusUIPackages() {
                 }
                 continue;
             }
-            
+
             // Get latest version from npm
             const latestVersion = getLatestPackageVersion(pkg);
-            
+
             if (!latestVersion) {
                 log(`${COLORS.yellow}${pkg}: couldn't check for updates${COLORS.reset}`);
                 continue;
             }
-            
+
             const comparison = compareVersions(latestVersion, currentVersion);
-            
+
             if (comparison > 0) {
                 // Newer version available
                 try {
                     log(`${COLORS.blue}${pkg}: ${currentVersion} → ${latestVersion}${COLORS.reset}`);
-                    execSync(`npm install ${pkg}@${latestVersion}`, { 
+                    execSync(`npm install ${pkg}@${latestVersion}`, {
                         stdio: ['ignore', 'ignore', 'pipe'],
                         encoding: 'utf8'
                     });
@@ -357,7 +420,7 @@ async function updatePlusUIPackages() {
                 upToDateCount++;
             }
         }
-        
+
         console.log('');
         if (updatedCount > 0) {
             log(`Updated ${updatedCount} package${updatedCount !== 1 ? 's' : ''}`, 'green');
@@ -370,17 +433,17 @@ async function updatePlusUIPackages() {
         }
     } else {
         log('Updating global CLI package...', 'cyan');
-        
+
         const currentVersion = cliPackageJson.version;
         const latestVersion = getLatestPackageVersion(cliPackageJson.name);
-        
+
         if (!latestVersion) {
             log('Couldn\'t check for updates', 'yellow');
             return;
         }
-        
+
         const comparison = compareVersions(latestVersion, currentVersion);
-        
+
         if (comparison > 0) {
             try {
                 log(`${COLORS.blue}${cliPackageJson.name}: ${currentVersion} → ${latestVersion}${COLORS.reset}`);
@@ -393,7 +456,7 @@ async function updatePlusUIPackages() {
             log(`✓ ${cliPackageJson.name} v${currentVersion} (already up to date)`, 'green');
         }
     }
-    
+
     console.log('');
 }
 
@@ -411,7 +474,7 @@ function findLikelyProjectDirs(baseDir) {
         if (entries) {
             // noop; just to ensure cwd is a Node project when possible
         }
-    } catch {}
+    } catch { }
 
     const candidates = [];
     try {
@@ -431,7 +494,7 @@ function findLikelyProjectDirs(baseDir) {
                 candidates.push(dirName);
             }
         }
-    } catch {}
+    } catch { }
 
     return candidates;
 }
@@ -583,6 +646,9 @@ function buildBackend(platform = null, devMode = false) {
 
     if (platformConfig.generator) {
         cmakeArgs += ` -G "${platformConfig.generator}"`;
+    } else if (process.platform === 'win32') {
+        // Use Ninja on Windows to avoid VS generator compatibility issues
+        cmakeArgs += ' -G Ninja';
     }
 
     log(`Configuring CMake...`, 'blue');
@@ -645,30 +711,30 @@ async function embedAssets() {
     if (!existsSync(assetsDir)) {
         try {
             await mkdir(assetsDir, { recursive: true });
-        } catch(e) {}
+        } catch (e) { }
     }
 
     logSection('Embedding Assets');
-    
+
     // Always generate the header file, even if empty
     let headerContent = '#pragma once\n\n';
     headerContent += '// THIS FILE IS AUTO-GENERATED BY PLUSUI CLI\n';
     headerContent += '// DO NOT MODIFY MANUALLY\n\n';
-    
-    const files = existsSync(assetsDir) 
+
+    const files = existsSync(assetsDir)
         ? (await readdir(assetsDir)).filter(f => !statSync(join(assetsDir, f)).isDirectory())
         : [];
-    
+
     if (files.length === 0) {
         log('No assets found in assets/ folder', 'dim');
     } else {
         for (const file of files) {
             const filePath = join(assetsDir, file);
             log(`Processing ${file}...`, 'dim');
-            
+
             const varName = file.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase();
             const data = await readFile(filePath);
-            
+
             headerContent += `static const unsigned char ASSET_${varName}[] = {`;
             for (let i = 0; i < data.length; i++) {
                 if (i % 16 === 0) headerContent += '\n  ';
@@ -681,7 +747,7 @@ async function embedAssets() {
 
     const genDir = join(process.cwd(), 'generated');
     if (!existsSync(genDir)) await mkdir(genDir, { recursive: true });
-    
+
     await writeFile(join(genDir, 'assets.h'), headerContent);
     log(`✓ Assets header generated: generated/assets.h`, 'green');
 }
@@ -774,9 +840,15 @@ async function startBackend() {
 
     const buildDir = getDevBuildDir();
 
+    // On Windows, use Ninja generator to avoid VS generator compatibility issues
+    let generatorArgs = '';
+    if (process.platform === 'win32') {
+        generatorArgs = ' -G Ninja';
+    }
+
     // Always configure with dev mode to ensure PLUSUI_DEV_MODE is set correctly
     log('Configuring CMake...', 'blue');
-    runCMake(`-S . -B "${buildDir}" -DPLUSUI_DEV_MODE=ON`);
+    runCMake(`-S . -B "${buildDir}" -DPLUSUI_DEV_MODE=ON${generatorArgs}`);
 
     log('Compiling...', 'blue');
     runCMake(`--build "${buildDir}"`);
@@ -784,16 +856,17 @@ async function startBackend() {
     // Find executable
     let exePath;
     if (process.platform === 'win32') {
-        // Visual Studio puts exe in build/dev/<projectname>/Debug/<projectname>.exe
-        exePath = join(buildDir, projectName, 'Debug', `${projectName}.exe`);
+        // Ninja puts exe directly in build dir
+        exePath = join(buildDir, `${projectName}.exe`);
         if (!existsSync(exePath)) {
-            exePath = join(buildDir, 'Debug', `${projectName}.exe`);
+            exePath = join(buildDir, 'bin', `${projectName}.exe`);
         }
+        // Fallback for VS generator (Debug subfolder)
         if (!existsSync(exePath)) {
-            exePath = join(buildDir, 'bin', `${projectName}.exe`);
+            exePath = join(buildDir, projectName, 'Debug', `${projectName}.exe`);
         }
         if (!existsSync(exePath)) {
-            exePath = join(buildDir, `${projectName}.exe`);
+            exePath = join(buildDir, 'Debug', `${projectName}.exe`);
         }
     } else {
         exePath = join(buildDir, projectName);
@@ -828,7 +901,7 @@ async function killPort(port) {
             try {
                 const output = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
                 const lines = output.split('\n').filter(line => line.includes(`:${port}`) && line.includes('LISTENING'));
-                
+
                 for (const line of lines) {
                     const parts = line.trim().split(/\s+/);
                     const pid = parts[parts.length - 1];
@@ -1097,7 +1170,7 @@ async function runBindgen(providedArgs = null, options = {}) {
         defaultOutputDir = appOutputDir;
         log(`Project mode: ${process.cwd()} -> ${appOutputDir}`, 'dim');
     }
-    
+
     // Spawn node process
     const proc = spawn(process.execPath, [scriptPath, ...bindgenArgs], {
         stdio: 'inherit',