@xaidenlabs/uso 1.1.46 → 1.1.49

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.46",
-  "description": "Universal Solana Orchestrator - A one-command setup tool for Solana and Anchor development environments on Windows, macOS, and Linux.",
+  "version": "1.1.49",
+  "description": "Universal Solana Development Toolchain. Native or Stealth WSL Mode. Build, test, and deploy without the friction.",
   "bin": {
     "uso": "bin/index.js"
   },

package/src/commands/workflow.js

@@ -3,8 +3,32 @@ const os = require('os');
 const fs = require('fs');
 const path = require('path');
 const { log, spinner } = require('../utils/logger');
+const { isStealthMode } = require('../utils/stealth');
+const { runWsl, toWslPath } = require('../utils/wsl-bridge');
 
 const runProxyCommand = async (command, args = [], binary = 'anchor') => {
+    const stealth = isStealthMode();
+
+    // --- STEALTH WSL MODE ---
+    if (stealth.enabled) {
+        const fullCommand = `${binary} ${command} ${args.join(' ')}`;
+        log.header(`🚀 Running: ${fullCommand}`);
+        log.info(`🐧 Routing through Uso Engine...`);
+
+        // Source cargo/solana paths inside WSL before running
+        const envSetup = 'source $HOME/.cargo/env 2>/dev/null; export PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"';
+        const wslCwd = toWslPath(process.cwd());
+        const execution = runWsl(`${envSetup} && ${fullCommand}`, { distro: stealth.distro, cwd: process.cwd() });
+
+        if (execution.code === 0) {
+            log.success(`✅ '${command}' completed successfully.`);
+        } else {
+            log.error(`❌ '${command}' failed.`);
+        }
+        return;
+    }
+
+    // --- NATIVE MODE ---
     // Check if binary is available
     if (!shell.which(binary)) {
         log.error(`❌ ${binary} is not found in PATH.`);
@@ -169,6 +193,28 @@ const airdrop = (amount, recipient) => {
 };
 
 const validator = async (args = []) => {
+    const stealth = isStealthMode();
+
+    // --- STEALTH WSL MODE ---
+    if (stealth.enabled) {
+        const flags = Array.isArray(args) ? args : [];
+        const cmdArgs = flags.join(' ');
+        const fullCmd = cmdArgs ? `solana-test-validator ${cmdArgs}` : 'solana-test-validator';
+
+        log.header(`🚀 Starting Validator via Uso Engine...`);
+        log.info(`🐧 Running: ${fullCmd}`);
+        log.info("👉 Press Ctrl+C to stop it.");
+
+        const envSetup = 'source $HOME/.cargo/env 2>/dev/null; export PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"';
+        runWsl(`${envSetup} && ${fullCmd}`, {
+            distro: stealth.distro,
+            cwd: process.cwd(),
+            execOpts: { async: false }
+        });
+        return;
+    }
+
+    // --- NATIVE MODE ---
     if (!shell.which('solana-test-validator')) {
         log.error("❌ 'solana-test-validator' is not found in PATH.");
         log.warn("👉 Run 'uso init' to install it.");
@@ -340,10 +386,16 @@ module.exports = {
 };
 
 const dev = async () => {
+    const stealth = isStealthMode();
     log.header("🚀 Starting Development Environment...");
 
     // 1. Check if validator is running
     const isValidatorRunning = () => {
+        if (stealth.enabled) {
+            // Check from Windows side — validator in WSL still binds to host port
+            const res = shell.exec('netstat -an | findstr 8899', { silent: true });
+            return res.code === 0 && res.stdout.length > 0;
+        }
         const res = shell.exec('netstat -an | findstr 8899', { silent: true });
         return res.code === 0 && res.stdout.length > 0;
     };

package/src/platforms/wsl.js

@@ -18,11 +18,14 @@ 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)...");
 
         // Helper to try install commands
@@ -51,22 +54,25 @@ const installWsl = async () => {
 
         // Final Failure Handler
         if (!success) {
-            log.error("❌ Failed to install Ubuntu after multiple attempts.");
+            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
@@ -146,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/stealth.js

@@ -0,0 +1,25 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Checks if Stealth WSL Mode is enabled.
+ * Reads ~/.uso-config.json and returns the mode configuration.
+ * @returns {{ enabled: boolean, distro: string }}
+ */
+const isStealthMode = () => {
+    try {
+        const configPath = path.join(os.homedir(), '.uso-config.json');
+        if (!fs.existsSync(configPath)) return { enabled: false, distro: 'Ubuntu' };
+
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        return {
+            enabled: config.mode === 'wsl',
+            distro: config.distro || 'Ubuntu'
+        };
+    } catch (e) {
+        return { enabled: false, distro: 'Ubuntu' };
+    }
+};
+
+module.exports = { isStealthMode };

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;
 };
 
 /**