@xaidenlabs/uso 1.1.42 → 1.1.43

package/bin/index.js

@@ -16,6 +16,7 @@ program
     .command('init [component]')
     .alias('install')
     .description('Install Rust, Solana CLI, Anchor Framework, or specific component (rust, solana, anchor)')
+    .option('--wsl', 'Install in Stealth WSL Mode (Windows Only)')
     .action(init);
 
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xaidenlabs/uso",
-  "version": "1.1.42",
+  "version": "1.1.43",
   "description": "Universal Solana Orchestrator - A one-command setup tool for Solana and Anchor development environments on Windows, macOS, and Linux.",
   "bin": {
     "uso": "bin/index.js"

package/src/commands/init.js

@@ -10,9 +10,21 @@ const { ensureWalletInteractive } = require('../utils/wallet');
 const path = require('path');
 const fs = require('fs');
 
-const init = async (component) => {
+const { installWsl } = require('../platforms/wsl');
+
+const init = async (component, options) => {
     const platform = os.platform();
 
+    // Check for Stealth WSL Mode
+    if (options && options.wsl) {
+        if (platform !== 'win32') {
+            log.error("❌ WSL Stealth Mode is only available on Windows.");
+            return;
+        }
+        await installWsl();
+        return;
+    }
+
     if (component) {
         component = component.toLowerCase();
         log.info(`🎯 Targeted installation: ${component}`);

package/src/platforms/wsl.js

@@ -0,0 +1,122 @@
+const shell = require('shelljs');
+const { log, spinner } = require('../utils/logger');
+const { isWslInstalled, runWsl, toWslPath } = require('../utils/wsl-bridge');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const installWsl = async () => {
+    log.header("🐧 Configuring Stealth WSL Environment...");
+
+    // 1. Check if WSL is enabled
+    if (!shell.which('wsl')) {
+        log.error("❌ WSL is not enabled on this Windows machine.");
+        log.warn("👉 Please enable 'Windows Subsystem for Linux' in 'Turn Windows features on or off'.");
+        log.warn("👉 Or run this in PowerShell as Admin: wsl --install");
+        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 (This may prompt for Admin access)...");
+
+        // This command usually triggers a UAC prompt and a console window.
+        // We can't fully hide the install process itself, but we can automate it.
+        const install = shell.exec('wsl --install -d Ubuntu');
+
+        if (install.code !== 0) {
+            log.error("❌ Failed to install Ubuntu.");
+            log.warn("👉 Try running manually: wsl --install -d Ubuntu");
+            return false;
+        }
+        log.success("✅ Ubuntu installed.");
+    } else {
+        log.success("✅ Ubuntu is already installed.");
+    }
+
+    // 3. Configure Internal Environment (Rust + Solana + Anchor)
+    // We create a shell script and run it inside WSL.
+
+    log.info("⚙️  Configuring internal Linux environment...");
+
+    const setupScript = `
+        #!/bin/bash
+        set -e
+        
+        # 1. Hush Login
+        touch ~/.hushlogin
+        
+        # 2. Update & Install Dependencies
+        if ! command -v curl &> /dev/null; then
+            sudo apt-get update && sudo apt-get install -y curl build-essential pkg-config libssl-dev
+        fi
+
+        # 3. Install Rust
+        if ! command -v cargo &> /dev/null; then
+            echo "Installing Rust..."
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+            source $HOME/.cargo/env
+        fi
+
+        # 4. Install Solana
+        if ! command -v solana &> /dev/null; then
+            echo "Installing Solana..."
+            sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
+            export PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"
+        fi
+
+        # 5. Install Anchor (AVM)
+        if ! command -v avm &> /dev/null; then
+            echo "Installing AVM..."
+            cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
+            avm install latest
+            avm use latest
+        fi
+        
+        echo "✅ WSL Setup Complete."
+    `;
+
+    // Write script to a temporary file in Windows (which is mounted in WSL)
+    const scriptPath = path.join(process.cwd(), 'setup_wsl.sh');
+    fs.writeFileSync(scriptPath, setupScript);
+
+    // Convert path to WSL format
+    const wslScriptPath = toWslPath(scriptPath);
+
+    // Run the script inside WSL
+    // We pipe the script content to bash to avoid permission issues with the file itself
+    // Or just run it. Let's run it.
+
+    const spin = spinner('Running Linux setup script (this takes a while)...').start();
+
+    // Ensure line endings are LF
+    const linuxScript = setupScript.replace(/\r\n/g, '\n');
+    fs.writeFileSync(scriptPath, linuxScript);
+
+    const res = shell.exec(`wsl -d Ubuntu -e bash "${wslScriptPath}"`);
+
+    // Clean up
+    fs.unlinkSync(scriptPath);
+
+    if (res.code === 0) {
+        spin.succeed('Linux environment configured successfully.');
+
+        // 4. Set "Stealth Mode" config (could be a local file or env var)
+        // For now, we assume if the user ran --wsl, they want to use it.
+        // We could create a .uso-config.json
+        const configPath = path.join(os.homedir(), '.uso-config.json');
+        const config = { mode: 'wsl', distro: 'Ubuntu' };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+        log.success("✅ Stealth Mode Enabled. 'uso' commands will now run via WSL.");
+        return true;
+    } else {
+        spin.fail('Setup script failed.');
+        log.error(res.stderr);
+        return false;
+    }
+};
+
+module.exports = { installWsl };

package/src/utils/wsl-bridge.js

@@ -0,0 +1,84 @@
+const shell = require('shelljs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./logger');
+
+/**
+ * Checks if WSL is installed and enabled.
+ */
+const isWslInstalled = () => {
+    if (os.platform() !== 'win32') return false;
+    const res = shell.exec('wsl --status', { silent: true });
+    return res.code === 0;
+};
+
+/**
+ * Checks if a specific distro is installed.
+ * @param {string} distro Name of the distro (e.g., "Ubuntu")
+ */
+const isDistroInstalled = (distro = 'Ubuntu') => {
+    if (os.platform() !== 'win32') return false;
+    // wsl --list --quiet returns names only, utf-16le encoded often in PowerShell.
+    // simpler to use wsl -l -v and check output
+    const res = shell.exec('wsl -l -v', { silent: true });
+    return res.stdout.includes(distro) || res.stderr.includes(distro); // sometimes stderr depending on version
+};
+
+/**
+ * Converts a Windows path (C:\Users\...) to a WSL path (/mnt/c/Users/...).
+ * @param {string} windowsPath 
+ */
+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;
+};
+
+/**
+ * Runs a command inside the default WSL distro (or specified one).
+ * @param {string} command The shell command to run in Linux
+ * @param {object} options { distro: 'Ubuntu', cwd: 'C:\\...', interactive: false }
+ */
+const runWsl = (command, options = {}) => {
+    const distro = options.distro || 'Ubuntu';
+    const cwd = options.cwd ? toWslPath(options.cwd) : '';
+
+    // Construct the WSL command
+    // wsl -d Ubuntu -e bash -c "cd /mnt/c/... && <command>"
+
+    let wslCmd = `wsl -d ${distro}`;
+
+    if (options.user) {
+        wslCmd += ` -u ${options.user}`;
+    }
+
+    // Prepare the bash script
+    let bashScript = '';
+    if (cwd) {
+        bashScript += `cd "${cwd}" && `;
+    }
+    bashScript += command;
+
+    // Execute
+    // Note: We use shell.exec. If interactive, maybe spawn?
+    // For "Stealth Mode", we usually want to capture output or just run it.
+
+    // Escape double quotes for the -c argument
+    const escapedScript = bashScript.replace(/"/g, '\\"');
+
+    const fullCmd = `${wslCmd} -e bash -c "${escapedScript}"`;
+
+    // log.info(`[WSL Bridge] Executing: ${fullCmd}`); // Debug
+
+    return shell.exec(fullCmd, options.execOpts || {});
+};
+
+module.exports = {
+    isWslInstalled,
+    isDistroInstalled,
+    toWslPath,
+    runWsl
+};