@xaidenlabs/uso 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xaiden Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# 🦀 USO ☀️
+### The **Magic Button** for Solana! ✨
+
+Do you want to build cool blockchain apps on Solana? 
+Usually, installing all the tools is super hard and boring. 
+**USO does it all for you with just ONE CLICK!**
+
+---
+
+## 🚀 Step 1: Get USO
+First, let's put USO on your computer.Open your **Terminal** (or Command Prompt) and type this magic spell:
+
+```bash
+npm install -g @xaidenlabs/uso
+```
+*(If that doesn't work, ensure you have Node.js installed!)*
+
+---
+
+## 🩺 Step 2: Check Your Computer
+Is your computer ready? Ask the Doctor!
+```bash
+uso doctor
+```
+It will check everything for you.
+- ✅ means GOOD!
+- ❌ means MISSING (Don't worry, USO will fix it!)
+
+---
+
+## ✨ Step 3: Install Everything!
+This is the best part. To install **Rust**, **Solana**, and **Anchor** all at once, just type:
+```bash
+uso init
+```
+- It will download everything.
+- It might ask for permission (click **Yes**!).
+- **IMPORTANT**: When it's done, close your terminal and open it again!
+
+---
+
+## 🎯 Step 4: Install Just One Thing (Optional)
+Maybe you only want one toy? You can do that too!
+
+- **Want just Rust?** 🦀
+  ```bash
+  uso install rust
+  ```
+
+- **Want just Solana?** ☀️
+  ```bash
+  uso install solana
+  ```
+
+- **Want just Anchor?** ⚓
+  ```bash
+  uso install anchor
+  ```
+
+---
+
+## ✅ Step 5: Test It!
+Let's make sure everything works perfectly.
+```bash
+uso verify
+```
+If this says "Success", you are ready to build the future! 🚀
+
+---
+
+## 🗑️ Step 6: Removing It (Uninstall)
+If you don't want these tools anymore, USO can clean up for you.
+
+- **Remove Everything:**
+  ```bash
+  uso uninstall
+  ```
+  *(Be careful! It might ask to delete your wallet with your crypto keys!)*
+
+- **Remove Just One Thing:**
+  ```bash
+  uso uninstall solana
+  ```
+
+---
+
+## ❓ Help! It's not working!
+
+**"Permission Denied" or "Error"?**
+- Try running your terminal as **Administrator** (Right-click -> Run as Administrator).
+
+**"Command not found"?**
+- Did you close and reopen your terminal after installing? Do that now!
+
+---
+
+**Made with ❤️ for You.**

package/bin/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+const { program } = require('commander');
+const { init } = require('../src/commands/init');
+const { doctor } = require('../src/commands/doctor');
+const { verify } = require('../src/commands/verify');
+const { build, test, deploy, clean } = require('../src/commands/workflow');
+const { uninstall } = require('../src/commands/uninstall');
+
+program
+    .name('uso')
+    .description('Universal Solana Orchestrator - One-command setup for all OS')
+    .version('1.0.0');
+
+program
+    .command('init [component]')
+    .alias('install')
+    .description('Install Rust, Solana CLI, Anchor Framework, or specific component (rust, solana, anchor)')
+    .action(init);
+
+program
+    .command('doctor')
+    .description('Check if the environment is ready for Solana development')
+    .action(doctor);
+
+program
+    .command('verify')
+    .description('Verify installation by building a test Anchor project')
+    .action(verify);
+
+program
+    .command('build')
+    .description('Build the Anchor project (wraps "anchor build")')
+    .action(build);
+
+program
+    .command('test')
+    .description('Run Anchor tests (wraps "anchor test")')
+    .action(test);
+
+program
+    .command('deploy')
+    .description('Deploy the program (wraps "anchor deploy")')
+    .action(deploy);
+
+program
+    .command('clean')
+    .description('Clean the project (wraps "anchor clean")')
+    .action(clean);
+
+program
+    .command('uninstall [component]')
+    .description('Uninstall uso components (rust, solana, anchor) or all')
+    .action(uninstall);
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@xaidenlabs/uso",
+  "version": "1.0.0",
+  "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"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "solana",
+    "anchor",
+    "web3",
+    "rust",
+    "install",
+    "setup",
+    "developer-tools"
+  ],
+  "author": "Xaiden Labs",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^14.0.3",
+    "ora": "^5.4.1",
+    "shelljs": "^0.10.0"
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,127 @@
+const shell = require('shelljs');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { log } = require('../utils/logger');
+
+const checkGit = (silent = false) => {
+    const installed = !!shell.which('git');
+    if (!silent) {
+        if (installed) log.success("✅ Git installed");
+        else log.error("❌ Git not found");
+    }
+    return installed;
+};
+
+const checkRust = (silent = false) => {
+    const rustc = shell.exec('rustc --version', { silent: true });
+    const installed = rustc.code === 0;
+    if (!silent) {
+        if (installed) log.success(`✅ Rust installed (${rustc.stdout.trim()})`);
+        else log.error("❌ Rust not found");
+    }
+    return installed;
+};
+
+const checkSolana = (silent = false) => {
+    // 1. Try PATH first
+    let solana = shell.exec('solana --version', { silent: true });
+    if (solana.code === 0) {
+        if (!silent) log.success(`✅ Solana CLI installed (${solana.stdout.trim()})`);
+        return true;
+    }
+
+    // 2. Try default Windows path if on Windows
+    if (os.platform() === 'win32') {
+        const home = os.homedir();
+        // Modern path (Agave/Solana)
+        const defaultPath = path.join(home, '.local', 'share', 'solana', 'install', 'active_release', 'bin', 'solana.exe');
+
+        if (fs.existsSync(defaultPath)) {
+            if (!silent) log.success(`✅ Solana CLI installed (Found at ${defaultPath})`);
+            // Optionally we could try to get version from it, but existence is enough to skip install
+            return true;
+        }
+    }
+
+    if (!silent) log.error("❌ Solana CLI not found");
+    return false;
+};
+
+const checkAnchor = (silent = false) => {
+    const anchor = shell.exec('anchor --version', { silent: true });
+    const installed = anchor.code === 0;
+    if (!silent) {
+        if (installed) log.success(`✅ Anchor installed (${anchor.stdout.trim()})`);
+        else log.error("❌ Anchor not found");
+    }
+    return installed;
+};
+
+const checkCppTools = (silent = false) => {
+    if (os.platform() !== 'win32') return true; // Not needed on others
+
+    // 1. Check PATH
+    const hasCl = !!shell.which('cl');
+    if (hasCl) {
+        if (!silent) log.success("✅ C++ Build Tools (cl.exe) found in PATH");
+        return true;
+    }
+
+    // 2. Check via vswhere
+    const programFiles = process.env['ProgramFiles(x86)'] || process.env['ProgramFiles'];
+    const vswherePath = path.join(programFiles, 'Microsoft Visual Studio', 'Installer', 'vswhere.exe');
+
+    if (fs.existsSync(vswherePath)) {
+        // Use quotes around * to prevent shell globbing issues
+        // We look for ANY product that installs VC tools. 
+        // We relax the requirement to just 'installationPath' to confirm VS is present, 
+        // as 'Desktop development with C++' is the standard workload.
+        // But to be safe, we should check for the VC component if possible.
+        // Tests showed that -products * returned the install path successfully.
+
+        const cmd = `"${vswherePath}" -latest -products "*" -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`;
+        const result = shell.exec(cmd, { silent: true });
+
+        if (result.code === 0 && result.stdout.trim().length > 0) {
+            if (!silent) log.success("✅ C++ Build Tools detected (via vswhere).");
+            return true;
+        }
+
+        // Fallback: Check for just the workload, or even just the existence of VS Build Tools
+        // usage: vswhere -latest -products * -requires Microsoft.VisualStudio.Workload.VCTools
+        const cmd2 = `"${vswherePath}" -latest -products "*" -requires Microsoft.VisualStudio.Workload.VCTools -property installationPath`;
+        const result2 = shell.exec(cmd2, { silent: true });
+
+        if (result2.code === 0 && result2.stdout.trim().length > 0) {
+            if (!silent) log.success("✅ C++ Build Tools detected (via vswhere workload).");
+            return true;
+        }
+    }
+
+    if (!silent) {
+        log.warn("⚠️  C++ Build Tools (cl.exe) not found.");
+        log.warn("   Rust requires 'Desktop development with C++' to compile.");
+    }
+    return false;
+};
+
+const doctor = async () => {
+    const platform = os.platform();
+    log.header(`🩺 Running Doctor for ${platform}...`);
+
+    checkGit();
+    checkRust();
+    checkSolana();
+    checkAnchor();
+    checkCppTools();
+};
+
+module.exports = {
+    doctor,
+    checkGit,
+    checkRust,
+    checkSolana,
+    checkAnchor,
+    checkCppTools
+};

package/src/commands/init.js

@@ -0,0 +1,211 @@
+const os = require('os');
+const shell = require('shelljs');
+const { log, spinner } = require('../utils/logger');
+const { installWindows } = require('../platforms/windows');
+const { installMacOS } = require('../platforms/macos');
+const { installLinux } = require('../platforms/linux');
+const { getCargoBinPath } = require('../utils/paths');
+const { checkRust, checkSolana, checkAnchor } = require('./doctor');
+const { ensureWalletInteractive } = require('../utils/wallet');
+const path = require('path');
+const fs = require('fs');
+
+const init = async (component) => {
+    const platform = os.platform();
+
+    if (component) {
+        component = component.toLowerCase();
+        log.info(`🎯 Targeted installation: ${component}`);
+
+        if (component === 'rust') {
+            if (checkRust(true)) {
+                log.success("✅ Rust is already installed.");
+                return;
+            }
+            log.info("🦀 Installing Rust...");
+            let success = false;
+            if (platform === 'win32') success = await installWindows(true, false);
+            else if (platform === 'darwin') success = await installMacOS(true, false);
+            else success = await installLinux(true, false);
+
+            if (success) log.success("✅ Rust installed successfully.");
+            else log.error("❌ Rust installation failed.");
+            return;
+        }
+
+        if (component === 'solana') {
+            if (checkSolana(true)) {
+                log.success("✅ Solana CLI is already installed.");
+                return;
+            }
+            log.info("☀️ Installing Solana CLI...");
+            let success = false;
+            if (platform === 'win32') success = await installWindows(false, true);
+            else if (platform === 'darwin') success = await installMacOS(false, true);
+            else success = await installLinux(false, true);
+
+            if (success) log.success("✅ Solana CLI installed successfully.");
+            else log.error("❌ Solana CLI installation failed.");
+            return;
+        }
+
+        if (component === 'anchor') {
+            if (checkAnchor(true)) {
+                log.success("✅ Anchor is already installed.");
+                return;
+            }
+            // Fall through to Anchor installation logic below, but skip others
+        } else if (component !== 'anchor') { // If it's not rust, solana, or anchor
+            log.error(`❌ Unknown component: ${component}. Available: rust, solana, anchor`);
+            return;
+        }
+    }
+
+    // --- FULL INSTALLATION / ANCHOR ONLY FLOW ---
+
+    // If authenticating for just Anchor, we assume Rust/Solana are prerequisites or we skip them
+    let installRust = !checkRust(true);
+    let installSolana = !checkSolana(true);
+    const hasAnchor = checkAnchor(true);
+
+    if (component === 'anchor') {
+        // ensuring prerequisites for anchor
+        if (installRust) {
+            log.warn("⚠️  Rust is required for Anchor but not installed.");
+            // asking or just failing? For granular, let's just fail or warn.
+            // But let's proceed to install Anchor logic which handles cargo check
+        }
+        installRust = false; // Don't run platform installers for these
+        installSolana = false;
+    }
+
+    // Validating state for full install
+    if (!component && !installRust && !installSolana && hasAnchor) {
+        log.success("🎉 Everything is already installed!");
+        await ensureWalletInteractive();
+        return;
+    }
+
+    if (!component) {
+        log.header("🔍 Checking current environment state...");
+        log.info(`\n📦 Missing components:`);
+        if (installRust) log.error(" - Rust");
+        if (installSolana) log.error(" - Solana CLI");
+        if (!hasAnchor) log.error(" - Anchor");
+        console.log("");
+
+        const spin = spinner('Starting Installation...').start();
+
+        try {
+            let success = false;
+
+            if (platform === 'win32') {
+                spin.stop();
+                success = await installWindows(installRust, installSolana);
+            } else if (platform === 'darwin') {
+                spin.stop();
+                success = await installMacOS(installRust, installSolana);
+            } else {
+                spin.stop();
+                success = await installLinux(installRust, installSolana);
+            }
+
+            if (!success) {
+                log.error("❌ Platform-specific installation failed.");
+                return;
+            }
+        } catch (e) {
+            spin.stop();
+            log.error(e.message);
+            return;
+        }
+    }
+
+    // Install Anchor (Universal) - Runs if component='anchor' OR full install
+    if (!hasAnchor && (!component || component === 'anchor')) {
+        log.info("⚓ Installing Anchor Framework...");
+
+        const cargoBin = getCargoBinPath();
+        const cargoExe = platform === 'win32' ? 'cargo.exe' : 'cargo';
+        const avmExe = platform === 'win32' ? 'avm.exe' : 'avm';
+
+        // Resolve cargo command
+        let cargoCmd = cargoExe;
+        if (fs.existsSync(path.join(cargoBin, cargoExe))) {
+            cargoCmd = `"${path.join(cargoBin, cargoExe)}"`;
+        } else if (!installRust && checkRust(true)) {
+            cargoCmd = 'cargo';
+        }
+
+        log.subHeader(`Using cargo: ${cargoCmd}`);
+
+        // Try installing AVM first (Preferred)
+        log.info("   Attempting AVM install...");
+        const avmInstall = shell.exec(`${cargoCmd} install --git https://github.com/coral-xyz/anchor avm --locked --force`);
+
+        if (avmInstall.code === 0) {
+            // Use AVM
+            let avmCmd = avmExe;
+            if (fs.existsSync(path.join(cargoBin, avmExe))) {
+                avmCmd = `"${path.join(cargoBin, avmExe)}"`;
+            }
+
+            log.subHeader(`Using avm: ${avmCmd}`);
+            const avmUse = shell.exec(`${avmCmd} install latest`);
+
+            // Detect Permission Error for AVM
+            if (avmUse.code !== 0) {
+                const output = avmUse.stderr + avmUse.stdout;
+                if (output.includes("os error 1314") && platform === 'win32') {
+                    log.warn("⚠️  AVM Permission denied (Symlink creation failed).");
+                    log.info("🛡️  Triggering Run as Administrator (UAC) for Anchor...");
+                    const absAvmPath = path.join(cargoBin, avmExe);
+                    const elevateCmd = `powershell -Command "Start-Process -FilePath '${absAvmPath}' -ArgumentList 'install latest' -Verb RunAs -Wait; Start-Process -FilePath '${absAvmPath}' -ArgumentList 'use latest' -Verb RunAs -Wait"`;
+                    const elevatedRun = shell.exec(elevateCmd);
+
+                    if (elevatedRun.code === 0) {
+                        log.success("✅ Anchor installed (Elevated).");
+                    } else {
+                        log.error("❌ Elevated installation failed. Trying fallback...");
+                        fallbackDirectInstall(cargoCmd);
+                    }
+
+                } else {
+                    log.warn("⚠️  AVM installation failed. Trying fallback...");
+                    fallbackDirectInstall(cargoCmd);
+                }
+            } else {
+                shell.exec(`${avmCmd} use latest`);
+                log.success("✅ Anchor installed.");
+            }
+        } else {
+            log.error("❌ Failed to install AVM via Cargo.");
+            return;
+        }
+    } else if (component === 'anchor' && hasAnchor) {
+        log.success("✅ Anchor is already installed.");
+    }
+
+
+    if (!component) {
+        log.header('\n✅ Uso Setup Complete!');
+        await ensureWalletInteractive();
+
+        if (installRust || installSolana || !hasAnchor) {
+            log.warn('👉 Please RESTART your terminal/VS Code to ensure all PATH variables are updated.');
+        }
+        log.info('🚀 Try running: uso verify');
+    }
+};
+
+const fallbackDirectInstall = (cargoCmd) => {
+    log.info("👉 Falling back to direct 'anchor-cli' installation...");
+    const directInstall = shell.exec(`${cargoCmd} install --git https://github.com/coral-xyz/anchor anchor-cli --locked --force`);
+    if (directInstall.code !== 0) {
+        log.error("❌ Failed to install Anchor via fallback method.");
+    } else {
+        log.success("✅ Anchor installed (Direct Cargo).");
+    }
+};
+
+module.exports = { init };

package/src/commands/uninstall.js

@@ -0,0 +1,242 @@
+const shell = require('shelljs');
+const { log, spinner } = require('../utils/logger');
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const askQuestion = (query) => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }));
+};
+
+/**
+ * Runs a command and attempts to elevate privileges if it fails with a permission error.
+ */
+const runOrElevate = (command, description) => {
+    log.info(`Running: ${description}...`);
+
+    // We run without silent:true initially to let the user see output, 
+    // but detecting the error code is what matters.
+    // actually, to detect the specific string "os error 1314", we need to capture output.
+    // So we run silently first? Or we just run and if it fails, we assume it *might* be elevation if on Windows?
+    // Let's run synchronously and capture output.
+
+    const result = shell.exec(command, { silent: true });
+
+    if (result.code === 0) {
+        console.log(result.stdout);
+        return true;
+    }
+
+    // Print the error output to the user
+    console.log(result.stdout);
+    console.error(result.stderr);
+
+    const output = result.stderr + result.stdout;
+
+    // Check for common permission errors
+    // "os error 1314" is specific to Windows symlink privilege
+    if ((output.includes("os error 1314") || output.includes("EPERM") || output.includes("permission denied")) && os.platform() === 'win32') {
+        log.warn(`⚠️  Permission denied during: ${description}`);
+        log.info("🛡️  Triggering Run as Administrator (UAC) to retry...");
+
+        // Construct PowerShell command to run cmd /c <command> as admin
+        // We need to be careful with quoting.
+        const escapedCommand = command.replace(/'/g, "''"); // Basic PowerShell escaping for single quotes
+        const elevateCmd = `powershell -Command "Start-Process -FilePath 'cmd.exe' -ArgumentList '/c ${escapedCommand}' -Verb RunAs -Wait"`;
+
+        const elevatedRun = shell.exec(elevateCmd);
+
+        if (elevatedRun.code === 0) {
+            log.success(`✅ ${description} completed (Elevated).`);
+            return true;
+        } else {
+            log.error(`❌ Elevated execution failed for: ${description}`);
+            return false;
+        }
+    }
+
+    log.error(`❌ Command failed: ${description}`);
+    return false;
+};
+
+const uninstall = async (component) => {
+    log.header("🗑️  USO Uninstallation & Cleanup");
+
+    if (component) {
+        component = component.toLowerCase();
+        log.info(`🎯 Targeted uninstallation: ${component}`);
+
+        if (component === 'anchor') {
+            const anchorInstalled = shell.which('anchor');
+            if (anchorInstalled) {
+                log.info("Removing Anchor...");
+                // Try avm uninstall first if available
+                if (shell.which('avm')) {
+                    runOrElevate('avm uninstall latest', 'Uninstall Anchor (AVM)');
+                }
+                runOrElevate('cargo uninstall anchor-cli', 'Uninstall anchor-cli');
+                runOrElevate('cargo uninstall avm', 'Uninstall avm');
+                log.success("Anchor removal steps completed.");
+            } else {
+                log.success("✅ Anchor is not installed.");
+            }
+            return;
+        }
+
+        if (component === 'solana') {
+            // Check PATH first
+            let solanaInstalled = shell.which('solana');
+            const localShareSolana = path.join(os.homedir(), '.local', 'share', 'solana');
+
+            // If not found in PATH, check default location
+            if (!solanaInstalled && fs.existsSync(localShareSolana)) {
+                solanaInstalled = true;
+            }
+
+            if (solanaInstalled) {
+                log.info("Removing Solana CLI...");
+
+                if (fs.existsSync(localShareSolana)) {
+                    try {
+                        fs.rmSync(localShareSolana, { recursive: true, force: true });
+                        log.success(`Removed ${localShareSolana}`);
+                    } catch (err) {
+                        log.warn(`Failed to remove ${localShareSolana} directly: ${err.message}`);
+                        log.info("Trying to remove via elevated command...");
+                        runOrElevate(`rmdir /s /q "${localShareSolana}"`, `Remove folder ${localShareSolana}`);
+                    }
+                } else {
+                    log.warn(`Could not find Solana folder at ${localShareSolana}. It might be removed already.`);
+                }
+            } else {
+                log.success("✅ Solana CLI is not installed.");
+            }
+            return;
+        }
+
+        if (component === 'rust') {
+            const rustInstalled = shell.which('rustc');
+            if (rustInstalled) {
+                log.info("Running rustup self uninstall...");
+                runOrElevate('rustup self uninstall -y', 'Uninstall Rust');
+            } else {
+                log.success("✅ Rust is not installed.");
+            }
+            return;
+        }
+
+        log.error(`❌ Unknown component: ${component}. Available: rust, solana, anchor`);
+        return;
+    }
+
+    // --- FULL INTERACTIVE UNINSTALL ---
+
+    log.warn("This process allows you to remove components installed by uso.");
+    log.warn("Please be careful, especially with wallet removal!");
+
+    const proceed = await askQuestion("👉 Do you want to proceed with uninstallation? (y/N): ");
+    if (proceed.toLowerCase() !== 'y') {
+        log.info("Operation cancelled.");
+        return;
+    }
+
+    // 1. Uninstall Anchor
+    const anchorInstalled = shell.which('anchor');
+    if (anchorInstalled) {
+        const removeAnchor = await askQuestion("\n⚓ Remove Anchor Framework? (y/N): ");
+        if (removeAnchor.toLowerCase() === 'y') {
+            log.info("Removing Anchor...");
+            // Try avm uninstall first if available
+            if (shell.which('avm')) {
+                runOrElevate('avm uninstall latest', 'Uninstall Anchor (AVM)');
+            }
+            runOrElevate('cargo uninstall anchor-cli', 'Uninstall anchor-cli');
+            runOrElevate('cargo uninstall avm', 'Uninstall avm');
+            log.success("Anchor removal steps completed.");
+        }
+    }
+
+    // 2. Uninstall Solana
+    let solanaInstalled = shell.which('solana');
+    const localShareSolana = path.join(os.homedir(), '.local', 'share', 'solana');
+
+    // If not found in PATH, check default location (like doctor does)
+    if (!solanaInstalled && fs.existsSync(localShareSolana)) {
+        solanaInstalled = true;
+    }
+
+    if (solanaInstalled) {
+        const removeSolana = await askQuestion("\n☀️  Remove Solana CLI? (y/N): ");
+        if (removeSolana.toLowerCase() === 'y') {
+            log.info("Removing Solana CLI...");
+
+            // Default locations
+            // const localShareSolana = path.join(os.homedir(), '.local', 'share', 'solana'); // Already defined
+
+            if (fs.existsSync(localShareSolana)) {
+                try {
+                    fs.rmSync(localShareSolana, { recursive: true, force: true });
+                    log.success(`Removed ${localShareSolana}`);
+                } catch (err) {
+                    log.warn(`Failed to remove ${localShareSolana} directly: ${err.message}`);
+                    log.info("Trying to remove via elevated command...");
+                    runOrElevate(`rmdir /s /q "${localShareSolana}"`, `Remove folder ${localShareSolana}`);
+                }
+            } else {
+                log.warn(`Could not find Solana at ${localShareSolana}. It might be already removed.`);
+            }
+        }
+    }
+
+    // 3. Uninstall Rust
+    const rustInstalled = shell.which('rustc');
+    if (rustInstalled) {
+        const removeRust = await askQuestion("\n🦀 Remove Rust? (y/N): ");
+        if (removeRust.toLowerCase() === 'y') {
+            log.info("Running rustup self uninstall...");
+            runOrElevate('rustup self uninstall -y', 'Uninstall Rust');
+        }
+    }
+
+    // 4. WALLET REMOVAL (DANGER)
+    const walletPath = path.join(os.homedir(), '.config', 'solana', 'id.json');
+    if (fs.existsSync(walletPath)) {
+        log.error("\n⚠️  DANGER ZONE ⚠️");
+        log.warn(`Found a Solana wallet at: ${walletPath}`);
+        log.warn("If you delete this without a backup, your funds will be LOST FOREVER.");
+
+        const removeWallet = await askQuestion("💥 Do you REALLY want to delete this wallet? (type 'DELETE' to confirm): ");
+        if (removeWallet === 'DELETE') {
+            try {
+                fs.unlinkSync(walletPath);
+                log.success("Wallet deleted.");
+
+                // Clean up parent config dir if empty
+                const configDir = path.dirname(walletPath);
+                try {
+                    if (fs.readdirSync(configDir).length === 0) {
+                        fs.rmSync(configDir, { recursive: true, force: true });
+                    }
+                } catch (e) { }
+            } catch (err) {
+                log.error(`Failed to delete wallet: ${err.message}`);
+            }
+        } else {
+            log.info("Skipping wallet deletion.");
+        }
+    }
+
+    log.header("\n✅ Cleanup complete.");
+    log.info("To remove the 'uso' tool itself, run:");
+    log.info("   npm uninstall -g uso");
+};
+
+module.exports = { uninstall };

package/src/commands/verify.js

@@ -0,0 +1,195 @@
+const shell = require('shelljs');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const readline = require('readline');
+const { log, spinner } = require('../utils/logger');
+const { ensureWalletInteractive, resolveSolanaKeygen } = require('../utils/wallet');
+const { getCargoBinPath } = require('../utils/paths');
+
+const getSolanaBin = () => {
+    if (shell.which('solana')) return 'solana';
+    if (os.platform() === 'win32') {
+        const defaultPath = path.join(os.homedir(), '.local', 'share', 'solana', 'install', 'active_release', 'bin', 'solana.exe');
+        if (fs.existsSync(defaultPath)) return `"${defaultPath}"`;
+    }
+    return 'solana';
+};
+
+const getAnchorBin = () => {
+    if (shell.which('anchor')) return 'anchor';
+    return 'anchor';
+};
+
+const askBuildConfirmation = async () => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        log.info("");
+        log.info("ℹ️  The next step verifies your toolchain by building a real project.");
+        log.warn("⚠️  NOTE: If this is your first time, it will download ~200MB of platform tools.");
+        log.warn("   This can take 5-10 minutes depending on your internet.");
+
+        rl.question("👉 Do you want to proceed with the full build verification? [Y/n] ", (answer) => {
+            rl.close();
+            const a = answer.toLowerCase();
+            if (a === 'n' || a === 'no') {
+                resolve(false);
+            } else {
+                resolve(true);
+            }
+        });
+    });
+};
+
+const verify = async () => {
+    log.header("🧪 Verifying Solana Setup...");
+
+    const anchorCmd = getAnchorBin();
+
+    // 1. Check/Create Wallet
+    const walletReady = await ensureWalletInteractive();
+
+    if (!walletReady) {
+        log.error("❌ Verification cancelled. A wallet is required to build/test.");
+        return;
+    }
+
+    // Fix PATH for cargo-build-sbf logic (Windows)
+    if (os.platform() === 'win32') {
+        const solanaBase = path.join(os.homedir(), '.local', 'share', 'solana', 'install');
+        const activeRelease = path.join(solanaBase, 'active_release');
+        const activeBin = path.join(activeRelease, 'bin');
+
+        let realBin = activeBin;
+        try {
+            if (fs.existsSync(activeRelease)) {
+                const realRelease = fs.realpathSync(activeRelease);
+                realBin = path.join(realRelease, 'bin');
+            }
+        } catch (e) { }
+
+        const pathsToAdd = [activeBin];
+        if (realBin !== activeBin) pathsToAdd.push(realBin);
+
+        let pathKey = 'PATH';
+        for (const key of Object.keys(process.env)) {
+            if (key.toUpperCase() === 'PATH') {
+                pathKey = key;
+                break;
+            }
+        }
+
+        let currentPath = process.env[pathKey] || '';
+        let modified = false;
+
+        pathsToAdd.forEach(p => {
+            if (fs.existsSync(p) && !currentPath.includes(p)) {
+                currentPath = `${p};${currentPath}`;
+                modified = true;
+            }
+        });
+
+        if (modified) {
+            process.env[pathKey] = currentPath;
+            log.success("✅ Solana bin temporarily added to PATH.");
+        }
+    }
+
+    // 2. Ask for confirmation before building
+    const proceed = await askBuildConfirmation();
+    if (!proceed) {
+        log.info("\n⏭️  Skipping build verification.");
+        log.success("✅ Basic tools are installed.");
+        log.info("👉 You can run 'npx uso doctor' for a quick version check.");
+        return;
+    }
+
+    // 3. Build Project
+    log.info("🔨 Building verification project...");
+
+    const templateDir = path.resolve(__dirname, '../../anchor_project');
+    const tempDir = path.join(os.tmpdir(), 'uso-verification-' + Date.now());
+
+    try {
+        shell.cp('-R', templateDir, tempDir);
+
+        let attempts = 0;
+        const maxAttempts = 3;
+        let success = false;
+        let finalError = "";
+
+        while (attempts < maxAttempts && !success) {
+            attempts++;
+            if (attempts > 1) {
+                log.warn(`⚠️  Retrying build (Attempt ${attempts}/${maxAttempts})...`);
+            }
+
+            const buildResult = shell.exec(`cd "${tempDir}" && ${anchorCmd} build`, {
+                silent: false,
+                env: process.env
+            });
+
+            success = buildResult.code === 0;
+            let stderr = buildResult.stderr + buildResult.stdout;
+
+            if (!success) {
+                finalError = stderr;
+
+                if (stderr.includes('TimedOut') || stderr.includes('reqwest::Error') || stderr.includes('Failed to install platform-tools')) {
+                    log.warn(`⚠️  Network timeout detected. Retrying...`);
+                    continue;
+                }
+
+                if (os.platform() === 'win32' && stderr.includes('os error 1314')) {
+                    log.warn("⚠️  Privilege error detected (os error 1314).");
+                    log.info("ℹ️  First-time Solana build requires Administrator privileges to install tools.");
+                    log.info("🛡️  Retrying with Elevated Permissions (Please accept UAC prompt)...");
+
+                    let absAnchor = anchorCmd;
+                    if (anchorCmd === 'anchor') {
+                        if (shell.which('anchor')) absAnchor = shell.which('anchor').toString();
+                        else absAnchor = path.join(getCargoBinPath(), 'anchor.exe');
+                    }
+
+                    const psCommand = `cd '${tempDir}'; & '${absAnchor}' build; if ($LASTEXITCODE -ne 0) { Read-Host 'Build Failed. Press Enter to exit...' }`;
+                    const elevateCmd = `powershell -Command "Start-Process powershell -ArgumentList \\"-NoExit\\", \\"-Command\\", \\"${psCommand.replace(/"/g, '\\`"')}\\" -Verb RunAs -Wait"`;
+
+                    shell.exec(elevateCmd);
+
+                    const idlPath = path.join(tempDir, 'target', 'idl', 'uso_verifier.json');
+                    if (fs.existsSync(idlPath)) {
+                        success = true;
+                        log.success("✅ Elevated build passed.");
+                    } else {
+                        log.error("❌ Elevated build failed or was cancelled.");
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+        }
+
+        if (success) {
+            log.success("✅ Verification Successful!");
+            log.success("🎉 Your Solana environment is fully operational.");
+            log.info("    - Rust is working");
+            log.info("    - Solana CLI is working");
+            log.info("    - Anchor is working");
+            log.info("    - Wallet is configured");
+        } else {
+            log.error("❌ Verification Failed.");
+        }
+
+    } catch (err) {
+        log.error("❌ Verification Error: " + err.message);
+    } finally {
+        shell.rm('-rf', tempDir);
+    }
+};
+
+module.exports = { verify };

package/src/commands/workflow.js

@@ -0,0 +1,38 @@
+const shell = require('shelljs');
+const { log, spinner } = require('../utils/logger');
+
+const runProxyCommand = async (command, args = []) => {
+    // Check if anchor is available
+    if (!shell.which('anchor')) {
+        log.error("❌ Anchor is not found in PATH.");
+        log.warn("👉 Run 'uso init' (or 'uso install') to set up your environment.");
+        return;
+    }
+
+    const fullCommand = `anchor ${command} ${args.join(' ')}`;
+    log.header(`🚀 Running: ${fullCommand}`);
+
+    const execution = shell.exec(fullCommand);
+
+    if (execution.code === 0) {
+        log.success(`✅ '${command}' completed successfully.`);
+    } else {
+        log.error(`❌ '${command}' failed.`);
+        // We don't exit process here strictly, but let the user know
+    }
+};
+
+const build = () => runProxyCommand('build');
+const test = () => runProxyCommand('test');
+const deploy = () => runProxyCommand('deploy');
+const clean = () => runProxyCommand('clean');
+
+// Generic run command for other anchor commands? 
+// For now, explicit functions are safer for help generation.
+
+module.exports = {
+    build,
+    test,
+    deploy,
+    clean
+};

package/src/platforms/linux.js

@@ -0,0 +1,36 @@
+const shell = require('shelljs');
+const { log } = require('../utils/logger');
+
+const installLinux = async (shouldInstallRust, shouldInstallSolana) => {
+    log.header("🐧 Linux detected.");
+
+    // 1. Install dependencies (Quick check, or just run update? 'update' is harmless mostly)
+    // We can assume if Rust/Solana are missing, deps might be too. 
+    // If both are present, we might skip this? For safety, we only run if installing something.
+    if (shouldInstallRust || shouldInstallSolana) {
+        log.info("🐧 Checking Linux dependencies (libudev, pkg-config)...");
+        shell.exec('sudo apt-get update && sudo apt-get install -y libudev-dev pkg-config build-essential');
+    }
+
+    // 2. Install Rust
+    if (shouldInstallRust) {
+        log.info("🦀 Installing Rust...");
+        shell.exec('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y');
+        log.success("✅ Rust installed.");
+    } else {
+        log.info("🦀 Rust is already installed. Skipping.");
+    }
+
+    // 3. Install Solana CLI
+    if (shouldInstallSolana) {
+        log.info("☀️ Installing Solana CLI...");
+        shell.exec('sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"');
+        log.success("✅ Solana CLI installed.");
+    } else {
+        log.info("☀️ Solana CLI is already installed. Skipping.");
+    }
+
+    return true;
+};
+
+module.exports = { installLinux };

package/src/platforms/macos.js

@@ -0,0 +1,30 @@
+const shell = require('shelljs');
+const { log } = require('../utils/logger');
+
+const installMacOS = async (shouldInstallRust, shouldInstallSolana) => {
+    log.header("🍎 macOS detected.");
+
+    // 1. Install Rust
+    if (shouldInstallRust) {
+        log.info("🦀 Installing Rust...");
+        const rustInstall = shell.exec('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y');
+        if (rustInstall.code !== 0) return false;
+        log.success("✅ Rust installed.");
+    } else {
+        log.info("🦀 Rust is already installed. Skipping.");
+    }
+
+    // 2. Install Solana CLI
+    if (shouldInstallSolana) {
+        log.info("☀️ Installing Solana CLI...");
+        const solanaInstall = shell.exec('sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"');
+        if (solanaInstall.code !== 0) return false;
+        log.success("✅ Solana CLI installed.");
+    } else {
+        log.info("☀️ Solana CLI is already installed. Skipping.");
+    }
+
+    return true;
+};
+
+module.exports = { installMacOS };

package/src/platforms/windows.js

@@ -0,0 +1,102 @@
+const shell = require('shelljs');
+const { log, spinner } = require('../utils/logger');
+const fs = require('fs');
+const path = require('path');
+
+const installWindows = async (shouldInstallRust, shouldInstallSolana) => {
+    log.header("🪟 Windows detected.");
+
+    // 1. Check for C++ Build Tools
+    if (shouldInstallRust) {
+        const hasCl = shell.which('cl');
+        if (!hasCl) {
+            log.warn("⚠️  Visual Studio C++ Build Tools (cl.exe) not found!");
+            log.warn("👉 Please install them from: https://visualstudio.microsoft.com/visual-cpp-build-tools/");
+            log.warn("   Make sure to select 'Desktop development with C++' workload before installing Rust.");
+        }
+    }
+
+    // 2. Install Rust
+    if (shouldInstallRust) {
+        log.info("🦀 Installing Rust (rustup-init.exe)...");
+        shell.exec('powershell -Command "Invoke-WebRequest -Uri https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-msvc/rustup-init.exe -OutFile rustup-init.exe"');
+
+        const rustInstall = shell.exec('powershell -Command "./rustup-init.exe -y"');
+
+        if (rustInstall.code !== 0) {
+            log.warn("⚠️  Rust installer finished with a non-zero code. It might have succeeded if you saw 'Rust is installed now'.");
+        } else {
+            log.success("✅ Rust installed.");
+        }
+
+        if (fs.existsSync('rustup-init.exe')) {
+            shell.rm('rustup-init.exe');
+        }
+    } else {
+        log.info("🦀 Rust is already installed. Skipping.");
+    }
+
+    // 3. Install Solana CLI (Agave)
+    if (shouldInstallSolana) {
+        log.info("☀️ Installing Solana CLI (Agave)...");
+        log.info("   Downloading solana-install-init.exe...");
+
+        const downloadCmd = 'powershell -Command "Invoke-WebRequest -Uri https://release.anza.xyz/stable/solana-install-init-x86_64-pc-windows-msvc.exe -OutFile solana-install.exe"';
+        const dlResult = shell.exec(downloadCmd);
+
+        if (dlResult.code !== 0) {
+            log.error("❌ Failed to download Solana installer.");
+            return false;
+        }
+
+        // Try regular install first
+        log.info("   Running Solana Installer...");
+        const installResult = shell.exec('solana-install.exe stable');
+
+        // Check for Symlink Error (1314) for potential auto-elevation
+        if (installResult.code !== 0) {
+            const output = installResult.stderr + installResult.stdout;
+            if (output.includes("os error 1314")) {
+                log.warn("⚠️  Permission denied (Symlink creation failed).");
+                log.info("🛡️  Triggering Run as Administrator (UAC)...");
+                log.info("👉 Please click 'Yes' in the popup window to allow the installer.");
+
+                const absPath = path.resolve('solana-install.exe');
+                // Use Start-Process with -Verb RunAs to trigger elevation
+                // -Wait ensures we actually wait for it to finish
+                const elevateCmd = `powershell -Command "Start-Process -FilePath '${absPath}' -ArgumentList 'stable' -Verb RunAs -Wait"`;
+
+                const elevatedRun = shell.exec(elevateCmd);
+
+                if (elevatedRun.code === 0) {
+                    // We can't easily capture stdout from the spawned high-privilege window, 
+                    // so we assume success if the process exited cleanly and verify existence.
+                    // A basic verification: check if we can run solana
+                    log.success("✅ Solana Installer finished (Elevated).");
+                } else {
+                    log.error("❌ Elevated installation failed or was cancelled.");
+                    return false;
+                }
+            } else {
+                log.error("❌ Solana CLI installation failed.");
+                // Don't return false hard here as we might want to continue, but usually this is fatal
+            }
+        } else {
+            log.success("✅ Solana CLI installed.");
+        }
+
+        if (fs.existsSync('solana-install.exe')) {
+            shell.rm('solana-install.exe');
+        }
+    } else {
+        log.info("☀️ Solana CLI is already installed. Skipping.");
+    }
+
+    if (shouldInstallRust || shouldInstallSolana) {
+        log.warn("⚠️  NOTE: You may need to restart your terminal for PATH changes to take effect.");
+    }
+
+    return true;
+};
+
+module.exports = { installWindows };

package/src/utils/logger.js

@@ -0,0 +1,15 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+const log = {
+    info: (msg) => console.log(chalk.blue(msg)),
+    success: (msg) => console.log(chalk.green(msg)),
+    warn: (msg) => console.log(chalk.yellow(msg)),
+    error: (msg) => console.log(chalk.red(msg)),
+    header: (msg) => console.log(chalk.bold.cyan(msg)),
+    subHeader: (msg) => console.log(chalk.cyan(msg)),
+};
+
+const spinner = (text) => ora(text);
+
+module.exports = { log, spinner };

package/src/utils/paths.js

@@ -0,0 +1,22 @@
+const shell = require('shelljs');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const getCargoBinPath = () => {
+    return path.join(os.homedir(), '.cargo', 'bin');
+};
+
+const addToPathWindows = (newPath) => {
+    // This is tricky from Node. We can try to use setx but it's permanent and impactful.
+    // For now, we will just warn the user to restart their terminal which usually picks up standard install paths.
+    // Rustup and Solana installers usually handle the permanent PATH update in Registry.
+    // We just need to make sure the CURRENT session knows about it if possible, but that's hard in a child process.
+    // Best advice: Restart Terminal.
+    return;
+};
+
+module.exports = {
+    getCargoBinPath,
+    addToPathWindows
+};

package/src/utils/wallet.js

@@ -0,0 +1,86 @@
+const os = require('os');
+const shell = require('shelljs');
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+const { log } = require('./logger');
+
+const resolveSolanaKeygen = () => {
+    // 1. Try PATH first
+    if (shell.which('solana-keygen')) return 'solana-keygen';
+
+    // 2. Try default Windows path
+    if (os.platform() === 'win32') {
+        const home = os.homedir();
+        const defaultPath = path.join(home, '.local', 'share', 'solana', 'install', 'active_release', 'bin', 'solana-keygen.exe');
+        if (fs.existsSync(defaultPath)) return `"${defaultPath}"`;
+    }
+
+    // Fallback
+    return 'solana-keygen';
+};
+
+/**
+ * Checks for wallet and prompts user to create one if missing.
+ * Returns true if wallet exists (or was created), false if user declined.
+ */
+const ensureWalletInteractive = async () => {
+    const walletDir = path.join(os.homedir(), '.config', 'solana');
+    const walletPath = path.join(walletDir, 'id.json');
+
+    if (fs.existsSync(walletPath)) {
+        log.info("🔑 Wallet found.");
+        return true;
+    }
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        log.info("");
+        log.warn("⚠️  No Solana wallet found.");
+        rl.question("👉 Do you want to generate a new Solana wallet? [y/N] ", (answer) => {
+            rl.close();
+            if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                log.info("🔑 Generating wallet...");
+                if (!fs.existsSync(walletDir)) fs.mkdirSync(walletDir, { recursive: true });
+
+                const keygenCmd = resolveSolanaKeygen();
+
+                // Use spawnSync to allow interactive input (passphrase)
+                const { spawnSync } = require('child_process');
+
+                // We need to strip quotes for spawn
+                let cmd = keygenCmd;
+                if (cmd.startsWith('"') && cmd.endsWith('"')) cmd = cmd.slice(1, -1);
+
+                try {
+                    // We use 'new' command which might prompt for passphrase
+                    spawnSync(cmd, ['new', '--outfile', walletPath], { stdio: 'inherit', shell: true });
+
+                    if (fs.existsSync(walletPath)) {
+                        log.success("✅ Wallet generated.");
+                        resolve(true);
+                    } else {
+                        // User might have cancelled via Ctrl+C in the subprocess
+                        log.warn("❌ Creation cancelled or failed.");
+                        resolve(false);
+                    }
+                } catch (e) {
+                    log.error("❌ Failed to generate wallet: " + e.message);
+                    resolve(false);
+                }
+            } else {
+                log.info("   Skipping wallet generation.");
+                resolve(false);
+            }
+        });
+    });
+};
+
+module.exports = {
+    resolveSolanaKeygen,
+    ensureWalletInteractive
+};