@xaidenlabs/uso 1.1.45 → 1.1.48

package/README.md

@@ -1,6 +1,12 @@
 # Universal Solana Orchestrator (USO)
 
-The Universal Solana Orchestrator (USO) is a command-line interface designed to streamline the initialization and management of Solana development environments. By automating the installation of the Rust toolchain, Solana CLI, and Anchor framework, USO eliminates the complexity often associated with setting up a Web3 development workspace on Windows, macOS, and Linux.
+**The fastest way to build on Solana.**
+
+USO (Universal Solana Orchestrator) is a "Zero-Friction" toolchain that handles the complex setup of Rust, Anchor, and Solana CLI—instantly.
+
+**Native or Stealth Mode? Both.**
+-   **Universal:** Runs natively on macOS, Linux, and Windows.
+-   **Stealth WSL:** On Windows, USO can deploy a hidden "Uso Engine" (WSL2) to run your build, test, and validator commands in a rock-solid Linux environment, while you stay in PowerShell. No "Access Denied" errors. No friction.
 
 This tool is engineered to support developers at all levels, from beginners setting up their first environment to senior engineers managing multiple workstations.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xaidenlabs/uso",
-  "version": "1.1.45",
-  "description": "Universal Solana Orchestrator - A one-command setup tool for Solana and Anchor development environments on Windows, macOS, and Linux.",
+  "version": "1.1.48",
+  "description": "Universal Solana Development Toolchain. Native or Stealth WSL Mode. Build, test, and deploy without the friction.",
   "bin": {
     "uso": "bin/index.js"
   },

package/src/platforms/wsl.js

@@ -5,6 +5,7 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const { spawnSync } = require('child_process');
+const chalk = require('chalk');
 
 const installWsl = async () => {
     log.header("🐧 Configuring Stealth WSL Environment...");
@@ -17,30 +18,61 @@ const installWsl = async () => {
         return false;
     }
 
-    // 2. Install Ubuntu silently if missing
-    // We target 'Ubuntu' as the standard distro.
-    const checkDistro = shell.exec('wsl -l -v', { silent: true });
-    if (!checkDistro.stdout.includes('Ubuntu')) {
-        log.info("📦 Installing Ubuntu (Please approve UAC prompt if asked)...");
+    // 2. Install Ubuntu silently (Branded as Uso Engine)
+    // We use 'wsl -d Ubuntu -e true' to check if it's installed and runnable.
+    // 'wsl -l -v' output is notoriously unreliable due to charset encoding (UTF-16) on Windows.
+    const checkDistro = shell.exec('wsl -d Ubuntu -e true', { silent: true });
+
+    // If exit code is 0, it's installed and working.
+    if (checkDistro.code !== 0) {
+        log.info("📦 Configuring Uso Engine (Please approve UAC prompt if asked)...");
         log.warn("⏳ This may take a few minutes (Downloading ~500MB)...");
 
-        // Use spawnSync with inherit to let the user see the WSL download progress bar
-        const installCursor = spawnSync('wsl', ['--install', '-d', 'Ubuntu'], { stdio: 'inherit', shell: true });
+        // Helper to try install commands
+        const tryInstall = (args, description) => {
+            log.info(`👉 Attempting: ${description}...`);
+            // Fix Deprecation: shell: false is safer and prevents warning
+            const proc = spawnSync('wsl', args, { stdio: 'inherit', shell: false });
+            return proc.status === 0;
+        };
+
+        // Attempt 1: Standard Install
+        let success = tryInstall(['--install', '-d', 'Ubuntu'], 'Standard Install');
+
+        // Attempt 2: Update WSL Kernel (Fixes network/protocol issues)
+        if (!success) {
+            log.warn("⚠️  Standard install failed. Attempting to update WSL kernel...");
+            spawnSync('wsl', ['--update'], { stdio: 'inherit', shell: false });
+            success = tryInstall(['--install', '-d', 'Ubuntu'], 'Install after Update');
+        }
 
-        if (installCursor.status !== 0) {
-            log.error("❌ Failed to install Ubuntu.");
-            log.warn("👉 Try running manually: wsl --install -d Ubuntu");
+        // Attempt 3: Web Download (Bypasses Microsoft Store blocks)
+        if (!success) {
+            log.warn("⚠️  Still failing. Trying --web-download (Bypasses Store)...");
+            success = tryInstall(['--install', '-d', 'Ubuntu', '--web-download'], 'Web Download Install');
+        }
+
+        // Final Failure Handler
+        if (!success) {
+            log.error("❌ Failed to configure Uso Engine.");
+            log.error("🛑 Possible Causes: Internet Timeout, Firewall, or VPN.");
+            log.warn("\n👉 ACTION REQUIRED: Run this command manually in PowerShell as Administrator:");
+            console.log(chalk.bold.yellow("    wsl --install -d Ubuntu --web-download"));
+            log.warn("\nOnce that completes successfully, run 'uso setup --wsl' again.");
             return false;
         }
-        log.success("✅ Ubuntu installed.");
+        log.success("✅ Uso Engine configured.");
     } else {
-        log.success("✅ Ubuntu is already installed.");
+        log.success("✅ Uso Engine is ready.");
     }
 
+    // 2.5 Hide from Windows Terminal (Stealth Mode)
+    hideFromWindowsTerminal();
+
     // 3. Configure Internal Environment (Rust + Solana + Anchor)
     // We create a shell script and run it inside WSL.
 
-    log.info("⚙️  Configuring internal Linux environment...");
+    log.info("⚙️  Initializing Uso Engine environment...");
 
     const setupScript = `
         #!/bin/bash
@@ -120,4 +152,57 @@ const installWsl = async () => {
     }
 };
 
+const hideFromWindowsTerminal = () => {
+    try {
+        const localAppData = process.env.LOCALAPPDATA;
+        const packagesPath = path.join(localAppData, 'Packages');
+
+        // Find Windows Terminal package folder (name varies slightly but starts with Microsoft.WindowsTerminal)
+        if (!fs.existsSync(packagesPath)) return;
+
+        const terminalDirs = fs.readdirSync(packagesPath).filter(name => name.startsWith('Microsoft.WindowsTerminal'));
+
+        if (terminalDirs.length === 0) return;
+
+        const settingsPath = path.join(packagesPath, terminalDirs[0], 'LocalState', 'settings.json');
+
+        if (fs.existsSync(settingsPath)) {
+            // Read settings
+            // Note: settings.json can contain comments which JSON.parse fails on. 
+            // We'll use a simple regex to set hidden: true for Ubuntu if simpler parsing fails or just try.
+            // Actually, modifying this file safely without a robust comment-stripping parser is risky.
+            // A safer approach for "Stealth" might be just log that we configured it.
+            // BUT, if we want to do it, we should be careful.
+
+            // For now, let's just log a message that we would hide it, 
+            // or maybe we skip the robust parsing complexity to avoid breaking their terminal settings.
+            // User requested "Programmatically edit".
+
+            const content = fs.readFileSync(settingsPath, 'utf8');
+            // Check if Ubuntu is already there
+            if (content.includes('"name": "Ubuntu"')) {
+                // Very naive replacement to inject hidden: true. 
+                // We look for the Ubuntu profile block.
+                // This is brittle. Let's try to parse if valid JSON.
+                try {
+                    const settings = JSON.parse(content);
+                    if (settings.profiles && settings.profiles.list) {
+                        const profile = settings.profiles.list.find(p => p.name === 'Ubuntu');
+                        if (profile) {
+                            profile.hidden = true;
+                            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 4));
+                            log.info("🕵️  Hid 'Ubuntu' from Windows Terminal (Stealth Mode Active).");
+                        }
+                    }
+                } catch (e) {
+                    // JSON parse failed (likely due to comments in settings.json)
+                    log.warn("⚠️  Could not automatically hide Ubuntu icon (Comments in settings.json).");
+                }
+            }
+        }
+    } catch (e) {
+        // Silently fail to avoid alarming user
+    }
+};
+
 module.exports = { installWsl };

package/src/utils/wsl-bridge.js

@@ -30,11 +30,14 @@ const isDistroInstalled = (distro = 'Ubuntu') => {
  */
 const toWslPath = (windowsPath) => {
     if (!windowsPath) return '';
-    // Handle drive letter
-    let wslPath = windowsPath.replace(/^([a-zA-Z]):/, (match, drive) => `/mnt/${drive.toLowerCase()}`);
-    // Replace backslashes with forward slashes
-    wslPath = wslPath.replace(/\\/g, '/');
-    return wslPath;
+    // 1. Normalize the path to use forward slashes
+    let normalized = windowsPath.replace(/\\/g, '/');
+
+    // 2. Extract and replace the drive letter (e.g., 'C:') with '/mnt/c/'
+    // This regex ensures we only match the start of the string
+    normalized = normalized.replace(/^([a-zA-Z]):/, (match, drive) => `/mnt/${drive.toLowerCase()}`);
+
+    return normalized;
 };
 
 /**