plusui-native 0.2.0

package/src/assets/resource-embedder.js

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+
+/**
+ * Cross-Platform Resource Embedder for PlusUI
+ * 
+ * Embeds frontend assets and icons into the binary for single-executable distribution:
+ * - Windows: Generates .rc file with RCDATA resources
+ * - macOS: Copies resources to app bundle
+ * - Linux: Generates C++ header with binary data
+ */
+
+import { readFile, writeFile, readdir, mkdir, stat, copyFile } from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+import { join, relative, basename, extname, dirname } from 'path';
+import { createHash } from 'crypto';
+
+class ResourceEmbedder {
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.compression = options.compression !== false;
+    }
+
+    log(msg) {
+        if (this.verbose) console.log(msg);
+    }
+
+    /**
+     * Get all files recursively from a directory
+     */
+    async getAllFiles(dirPath, arrayOfFiles = []) {
+        const files = await readdir(dirPath);
+
+        for (const file of files) {
+            const filePath = join(dirPath, file);
+            const s = await stat(filePath);
+
+            if (s.isDirectory()) {
+                arrayOfFiles = await this.getAllFiles(filePath, arrayOfFiles);
+            } else {
+                arrayOfFiles.push(filePath);
+            }
+        }
+
+        return arrayOfFiles;
+    }
+
+    /**
+     * Generate Windows .rc resource file
+     */
+    async generateWindowsRC(assetsDir, outputPath) {
+        console.log('  🪟 Generating Windows resource file (.rc)...');
+
+        if (!existsSync(assetsDir)) {
+            console.log('     ⚠️  Assets directory not found, skipping');
+            return;
+        }
+
+        const files = await this.getAllFiles(assetsDir);
+        let rcContent = `// Auto-generated by PlusUI - DO NOT EDIT
+// Embedded resources for single-executable distribution
+
+#include <windows.h>
+
+`;
+
+        let count = 0;
+        const resources = [];
+
+        for (const file of files) {
+            const relPath = relative(assetsDir, file).replace(/\\/g, '/');
+            const resourceId = `IDR_${relPath.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase()}`;
+            const winPath = file.replace(/\//g, '\\\\');
+
+            // Store for manifest
+            resources.push({ id: resourceId, path: relPath, file });
+
+            rcContent += `${resourceId} RCDATA "${winPath}"\n`;
+            count++;
+        }
+
+        // Add icon if exists
+        const iconPaths = [
+            join(assetsDir, 'icons', 'windows', 'app.ico'),
+            join(assetsDir, 'icon.ico'),
+        ];
+
+        for (const iconPath of iconPaths) {
+            if (existsSync(iconPath)) {
+                rcContent += `\n// Application icon\nIDI_APP_ICON ICON "${iconPath.replace(/\//g, '\\\\')}"\n`;
+                console.log(`     ✓ Added app icon: ${basename(iconPath)}`);
+                break;
+            }
+        }
+
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, rcContent);
+
+        // Generate resource manifest (C++ header)
+        await this.generateResourceManifest(resources, outputPath.replace('.rc', '_manifest.hpp'));
+
+        console.log(`     ✓ Created ${basename(outputPath)} (${count} resources)`);
+        return outputPath;
+    }
+
+    /**
+     * Generate C++ header with resource manifest
+     */
+    async generateResourceManifest(resources, outputPath) {
+        let content = `// Auto-generated by PlusUI - DO NOT EDIT
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+namespace plusui {
+namespace resources {
+
+// Resource ID to path mapping
+static const std::unordered_map<std::string, int> RESOURCE_MAP = {
+`;
+
+        let idCounter = 100;
+        for (const res of resources) {
+            content += `    {"${res.path}", ${idCounter}},\n`;
+            idCounter++;
+        }
+
+        content += `};
+
+// Get resource data from embedded resources
+#ifdef _WIN32
+#include <windows.h>
+inline std::string getResource(const std::string& path) {
+    auto it = RESOURCE_MAP.find(path);
+    if (it == RESOURCE_MAP.end()) return "";
+    
+    HRSRC hRes = FindResource(NULL, MAKEINTRESOURCE(it->second), RT_RCDATA);
+    if (!hRes) return "";
+    
+    HGLOBAL hData = LoadResource(NULL, hRes);
+    if (!hData) return "";
+    
+    DWORD size = SizeofResource(NULL, hRes);
+    const char* data = static_cast<const char*>(LockResource(hData));
+    
+    return std::string(data, size);
+}
+#else
+inline std::string getResource(const std::string& path) {
+    // Use embedded data from binary (see embedded_resources.hpp)
+    extern const std::unordered_map<std::string, std::pair<const unsigned char*, size_t>>& EMBEDDED_DATA;
+    auto it = EMBEDDED_DATA.find(path);
+    if (it == EMBEDDED_DATA.end()) return "";
+    return std::string(reinterpret_cast<const char*>(it->second.first), it->second.second);
+}
+#endif
+
+} // namespace resources
+} // namespace plusui
+`;
+
+        await writeFile(outputPath, content);
+        console.log(`     ✓ Created resource manifest`);
+    }
+
+    /**
+     * Generate Linux/macOS binary embedding header
+     */
+    async generateBinaryHeader(assetsDir, outputPath) {
+        console.log('  🐧 Generating binary embedded resources...');
+
+        if (!existsSync(assetsDir)) {
+            console.log('     ⚠️  Assets directory not found, skipping');
+            return;
+        }
+
+        const files = await this.getAllFiles(assetsDir);
+
+        let content = `// Auto-generated by PlusUI - DO NOT EDIT
+#pragma once
+
+#include <unordered_map>
+#include <utility>
+#include <string>
+
+namespace plusui {
+namespace resources {
+
+`;
+
+        let count = 0;
+        const dataMap = [];
+
+        for (const file of files) {
+            const relPath = relative(assetsDir, file).replace(/\\/g, '/');
+            const varName = `ASSET_${relPath.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase()}`;
+            const data = await readFile(file);
+
+            content += `// ${relPath}\nstatic const unsigned char ${varName}[] = {\n`;
+
+            for (let i = 0; i < data.length; i++) {
+                if (i % 16 === 0) content += '  ';
+                content += `0x${data[i].toString(16).padStart(2, '0')}`;
+                if (i < data.length - 1) content += ',';
+                if ((i + 1) % 16 === 0 || i === data.length - 1) content += '\n';
+                else content += ' ';
+            }
+
+            content += `};\nstatic const size_t ${varName}_LEN = ${data.length};\n\n`;
+
+            dataMap.push({ path: relPath, varName, size: data.length });
+            count++;
+        }
+
+        // Generate lookup map
+        content += `// Resource lookup map\nstatic const std::unordered_map<std::string, std::pair<const unsigned char*, size_t>> EMBEDDED_DATA = {\n`;
+
+        for (const item of dataMap) {
+            content += `    {"${item.path}", {${item.varName}, ${item.varName}_LEN}},\n`;
+        }
+
+        content += `};\n\n`;
+
+        // Add convenience function
+        content += `inline std::string getResource(const std::string& path) {
+    auto it = EMBEDDED_DATA.find(path);
+    if (it == EMBEDDED_DATA.end()) return "";
+    return std::string(reinterpret_cast<const char*>(it->second.first), it->second.second);
+}
+
+} // namespace resources
+} // namespace plusui
+`;
+
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, content);
+
+        console.log(`     ✓ Created ${basename(outputPath)} (${count} resources)`);
+        return outputPath;
+    }
+
+    /**
+     * Generate macOS app bundle resources
+     */
+    async generateMacOSBundle(assetsDir, bundlePath) {
+        console.log('  🍎 Copying resources to macOS bundle...');
+
+        if (!existsSync(assetsDir)) {
+            console.log('     ⚠️  Assets directory not found, skipping');
+            return;
+        }
+
+        const resourcesDir = join(bundlePath, 'Contents', 'Resources');
+        await mkdir(resourcesDir, { recursive: true });
+
+        const files = await this.getAllFiles(assetsDir);
+        let count = 0;
+
+        for (const file of files) {
+            const relPath = relative(assetsDir, file);
+            const dest = join(resourcesDir, relPath);
+            await mkdir(dirname(dest), { recursive: true });
+            await copyFile(file, dest);
+            count++;
+        }
+
+        // Copy icon if exists
+        const iconPath = join(assetsDir, 'icons', 'macos', 'app.icns');
+        if (existsSync(iconPath)) {
+            await copyFile(iconPath, join(resourcesDir, 'app.icns'));
+            console.log(`     ✓ Added app icon`);
+        }
+
+        console.log(`     ✓ Copied ${count} resources to bundle`);
+    }
+
+    /**
+     * Main embed function - chooses platform
+     */
+    async embed(assetsDir, outputDir, platform = process.platform) {
+        console.log(`\n📦 Embedding resources for ${platform}...\n`);
+
+        await mkdir(outputDir, { recursive: true });
+
+        switch (platform) {
+            case 'win32':
+                return await this.generateWindowsRC(
+                    assetsDir,
+                    join(outputDir, 'resources.rc')
+                );
+
+            case 'darwin':
+                // macOS uses both binary embedding and bundle resources
+                await this.generateBinaryHeader(
+                    assetsDir,
+                    join(outputDir, 'embedded_resources.hpp')
+                );
+                // Bundle copying happens at app bundle creation time
+                break;
+
+            case 'linux':
+                return await this.generateBinaryHeader(
+                    assetsDir,
+                    join(outputDir, 'embedded_resources.hpp')
+                );
+
+            default:
+                throw new Error(`Unsupported platform: ${platform}`);
+        }
+
+        console.log('\n✨ Resource embedding complete!\n');
+    }
+
+    /**
+     * Embed for all platforms
+     */
+    async embedAll(assetsDir, outputDir) {
+        console.log('\n📦 Embedding resources for all platforms...\n');
+
+        await this.embed(assetsDir, join(outputDir, 'windows'), 'win32');
+        await this.embed(assetsDir, join(outputDir, 'linux'), 'linux');
+        await this.embed(assetsDir, join(outputDir, 'darwin'), 'darwin');
+
+        console.log('\n✨ All platforms complete!\n');
+    }
+}
+
+// CLI
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const assetsDir = args[1] || join(process.cwd(), 'frontend', 'dist');
+    const outputDir = args[2] || join(process.cwd(), 'generated', 'resources');
+
+    const embedder = new ResourceEmbedder({ verbose: true });
+
+    if (command === 'all') {
+        embedder.embedAll(assetsDir, outputDir).catch(err => {
+            console.error('❌ Error:', err.message);
+            process.exit(1);
+        });
+    } else {
+        const platform = command || process.platform;
+        embedder.embed(assetsDir, outputDir, platform).catch(err => {
+            console.error('❌ Error:', err.message);
+            process.exit(1);
+        });
+    }
+}
+
+export { ResourceEmbedder };

package/src/doctor/detectors/cmake.js

@@ -0,0 +1,84 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import semver from 'semver';
+
+const REQUIRED_VERSION = '3.16.0';
+
+function getPlatformCMakePaths() {
+  const platform = process.platform;
+  const paths = ['cmake']; // Always check PATH first
+
+  if (platform === 'win32') {
+    paths.push(
+      'C:\\Program Files\\CMake\\bin\\cmake.exe',
+      'C:\\Program Files (x86)\\CMake\\bin\\cmake.exe'
+    );
+  } else if (platform === 'darwin') {
+    paths.push(
+      '/usr/local/bin/cmake',
+      '/opt/homebrew/bin/cmake',
+      '/Applications/CMake.app/Contents/bin/cmake'
+    );
+  } else {
+    paths.push(
+      '/usr/bin/cmake',
+      '/usr/local/bin/cmake'
+    );
+  }
+
+  return paths;
+}
+
+function parseVersion(output) {
+  // Parse version from "cmake version 3.28.1"
+  const match = output.match(/cmake version (\d+\.\d+\.\d+)/i);
+  return match ? match[1] : null;
+}
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 5000
+    });
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+export async function detectCMake() {
+  const paths = getPlatformCMakePaths();
+
+  for (const cmakePath of paths) {
+    // Check if path exists for file paths
+    if (cmakePath !== 'cmake' && !existsSync(cmakePath)) {
+      continue;
+    }
+
+    const result = await tryCommand(`"${cmakePath}" --version`);
+    if (result.success) {
+      const version = parseVersion(result.output);
+      if (!version) continue;
+
+      const versionValid = semver.gte(version, REQUIRED_VERSION);
+
+      return {
+        found: true,
+        path: cmakePath,
+        version,
+        valid: versionValid,
+        requiredVersion: REQUIRED_VERSION
+      };
+    }
+  }
+
+  return {
+    found: false,
+    path: null,
+    version: null,
+    valid: false,
+    requiredVersion: REQUIRED_VERSION
+  };
+}

package/src/doctor/detectors/compiler.js

@@ -0,0 +1,145 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 10000
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+async function detectMSVC() {
+  // Use vswhere.exe to detect Visual Studio
+  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
+        };
+      }
+    }
+
+    return { found: false, name: 'Visual Studio', valid: false };
+  }
+
+  // Use vswhere to find VS with C++ workload
+  const command = `"${vswherePath}" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`;
+  const result = await tryCommand(command);
+
+  if (!result.success || !result.output) {
+    return { found: false, name: 'Visual Studio', valid: false };
+  }
+
+  const installPath = result.output.trim();
+
+  // Get version
+  const versionCommand = `"${vswherePath}" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property displayName`;
+  const versionResult = await tryCommand(versionCommand);
+
+  const name = versionResult.success ? versionResult.output.trim() : 'Visual Studio';
+
+  return {
+    found: true,
+    name,
+    path: installPath,
+    valid: true
+  };
+}
+
+async function detectXcode() {
+  // Check for Xcode Command Line Tools
+  const result = await tryCommand('xcode-select -p');
+
+  if (!result.success) {
+    return {
+      found: false,
+      name: 'Xcode Command Line Tools',
+      valid: false
+    };
+  }
+
+  // Verify clang++ is available
+  const clangResult = await tryCommand('clang++ --version');
+
+  if (!clangResult.success) {
+    return {
+      found: true,
+      name: 'Xcode Command Line Tools',
+      path: result.output.trim(),
+      valid: false,
+      error: 'clang++ not available'
+    };
+  }
+
+  // Parse clang version
+  const versionMatch = clangResult.output.match(/clang version (\d+\.\d+\.\d+)/i) ||
+                       clangResult.output.match(/Apple clang version (\d+\.\d+\.\d+)/i);
+  const version = versionMatch ? versionMatch[1] : 'unknown';
+
+  return {
+    found: true,
+    name: 'Xcode Command Line Tools',
+    path: result.output.trim(),
+    version,
+    valid: true
+  };
+}
+
+async function detectGCC() {
+  // Check for g++
+  const result = await tryCommand('g++ --version');
+
+  if (!result.success) {
+    return {
+      found: false,
+      name: 'GCC/G++',
+      valid: false
+    };
+  }
+
+  // Parse GCC version
+  const versionMatch = result.output.match(/g\+\+ .* (\d+\.\d+\.\d+)/i);
+  const version = versionMatch ? versionMatch[1] : 'unknown';
+
+  return {
+    found: true,
+    name: 'GCC/G++',
+    version,
+    valid: true
+  };
+}
+
+export async function detectCompiler() {
+  const platform = process.platform;
+
+  switch (platform) {
+    case 'win32':
+      return await detectMSVC();
+    case 'darwin':
+      return await detectXcode();
+    default:
+      return await detectGCC();
+  }
+}

package/src/doctor/detectors/just.js

@@ -0,0 +1,45 @@
+import { execSync } from 'child_process';
+import semver from 'semver';
+
+const REQUIRED_JUST_VERSION = '1.0.0';
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 5000
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+export async function detectJust() {
+  const result = await tryCommand('just --version');
+
+  if (!result.success) {
+    return {
+      found: false,
+      version: null,
+      valid: false,
+      requiredVersion: REQUIRED_JUST_VERSION
+    };
+  }
+
+  // Parse version (output format: "just 1.34.0")
+  const versionMatch = result.output.match(/just (\d+\.\d+\.\d+)/);
+  const version = versionMatch ? versionMatch[1] : null;
+
+  // If we can't parse the version but the command succeeded, assume it's valid enough
+  // but ideally we check version. Just is usually pretty standard.
+  const valid = version ? semver.gte(version, REQUIRED_JUST_VERSION) : true;
+
+  return {
+    found: true,
+    version: version || 'unknown',
+    valid,
+    requiredVersion: REQUIRED_JUST_VERSION
+  };
+}

package/src/doctor/detectors/nodejs.js

@@ -0,0 +1,57 @@
+import { execSync } from 'child_process';
+import semver from 'semver';
+
+const REQUIRED_NODE_VERSION = '18.0.0';
+const REQUIRED_NPM_VERSION = '9.0.0';
+
+async function tryCommand(command) {
+  try {
+    const output = execSync(command, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+      timeout: 5000
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
+
+export async function detectNodeJS() {
+  const nodeResult = await tryCommand('node --version');
+  const npmResult = await tryCommand('npm --version');
+
+  if (!nodeResult.success) {
+    return {
+      found: false,
+      version: null,
+      valid: false,
+      requiredVersion: REQUIRED_NODE_VERSION,
+      npm: {
+        found: false,
+        version: null,
+        valid: false
+      }
+    };
+  }
+
+  // Parse versions (remove 'v' prefix from node version)
+  const nodeVersion = nodeResult.output.replace(/^v/, '');
+  const npmVersion = npmResult.success ? npmResult.output : null;
+
+  const nodeValid = semver.gte(nodeVersion, REQUIRED_NODE_VERSION);
+  const npmValid = npmVersion ? semver.gte(npmVersion, REQUIRED_NPM_VERSION) : false;
+
+  return {
+    found: true,
+    version: nodeVersion,
+    valid: nodeValid,
+    requiredVersion: REQUIRED_NODE_VERSION,
+    npm: {
+      found: npmResult.success,
+      version: npmVersion,
+      valid: npmValid,
+      requiredVersion: REQUIRED_NPM_VERSION
+    }
+  };
+}