@xaidenlabs/uso 1.1.80 → 1.1.82

package/README.md

@@ -10,6 +10,7 @@ USO is a zero-friction CLI toolchain that installs, manages, and runs your entir
 
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [AI Agent (New)](#ai-agent-new)
 - [Stealth WSL Mode (Windows)](#stealth-wsl-mode-windows)
 - [Full Environment Setup](#full-environment-setup)
 - [Granular Installation](#granular-installation)
@@ -66,6 +67,48 @@ uso dev
 
 ---
 
+## AI Agent (New)
+
+USO isn't just a command runner — it's an **Autonomous AI Agent** that can write code, build programs, debug errors, and deploy. Powered by ReAct (Reason + Act) architecture, the agent thinks step-by-step and uses tools to accomplish your goals.
+
+### 1. Configure an LLM Provider
+
+The agent needs an LLM to think. It supports four providers out of the box:
+
+```bash
+# Option A: Local & Free (Ollama)
+# Install from ollama.com, then run:
+ollama pull llama3.1:8b
+
+# Option B: GitHub Models (Free with GitHub Account)
+uso agent-config --github-token <your-github-pat>
+
+# Option C: Gemini
+uso agent-config --gemini-key <your-api-key>
+
+# Option D: OpenAI
+uso agent-config --openai-key <your-api-key>
+```
+
+### 2. Give it a Goal
+
+Just tell the agent what you want to do. It will check your environment, plan a strategy, execute the commands, and automatically self-heal if any step fails.
+
+```bash
+# General environment fixing
+uso agent "Check my Solana development environment and fix any missing tools"
+
+# Build and test cycle
+uso agent "Build my program and run the tests. If tests fail, fix the errors."
+
+# Deployment
+uso agent "Deploy my staking program to devnet and airdrop SOL if I don't have enough."
+```
+
+The agent runs a continuous FSM loop (`plan` → `execute` → `validate` → `heal`), streaming its thoughts and actions directly to your terminal.
+
+---
+
 ## Stealth WSL Mode (Windows Only)
 
 **The recommended mode for Windows developers.** Stealth Mode deploys a hidden WSL2 Linux environment (the "Uso Engine") that runs all your tooling inside Linux while you stay in PowerShell.
@@ -397,6 +440,8 @@ npm uninstall -g @xaidenlabs/uso
 | `uso init rust` | `uso install rust` | Install Rust only |
 | `uso init solana` | `uso install solana` | Install Solana CLI only |
 | `uso init anchor` | `uso install anchor` | Install Anchor Framework only |
+| `uso agent <goal>` | — | Run the Autonomous AI Agent |
+| `uso agent-config` | — | Configure Agent LLM providers |
 | `uso doctor` | — | Diagnose environment |
 | `uso verify` | — | End-to-end verification build |
 | `uso create <name>` | — | Scaffold a new Anchor project |

package/bin/index.js

@@ -6,6 +6,7 @@ const { verify } = require('../src/commands/verify');
 const { create } = require('../src/commands/create');
 const { build, test, deploy, clean, unblock, airdrop, address, balance, validator, dev } = require('../src/commands/workflow');
 const { uninstall } = require('../src/commands/uninstall');
+const { agent, agentConfig } = require('../src/commands/agent');
 
 program
     .name('uso')
@@ -16,12 +17,14 @@ program
     .command('init [component]')
     .alias('install')
     .description('Install Rust, Solana CLI, Anchor Framework, or specific component (rust, solana, anchor)')
+    .option('-g, --global', 'Compatibility flag (ignored). uso manages toolchain components, not npm packages')
     .option('--wsl', 'Install in Stealth WSL Mode (Windows Only)')
     .action(init);
 
 program
     .command('setup [component]')
     .description('Alias for init (Install components)')
+    .option('-g, --global', 'Compatibility flag (ignored). uso manages toolchain components, not npm packages')
     .option('--wsl', 'Install in Stealth WSL Mode (Windows Only)')
     .action(init);
 
@@ -99,4 +102,21 @@ program
     .description('Uninstall uso components (rust, solana, anchor) or all')
     .action(uninstall);
 
+program
+    .command('agent [goal...]')
+    .description('Start the AI Agent to accomplish a goal autonomously')
+    .option('--model <model>', 'LLM model to use (e.g., llama3.1:8b, gemini-2.0-flash, openai/gpt-4o)')
+    .option('--provider <provider>', 'Force a specific LLM provider (ollama, gemini, openai, github)')
+    .option('--max-loops <n>', 'Maximum reasoning iterations', '3')
+    .option('--verbose', 'Show full reasoning traces')
+    .action(agent);
+
+program
+    .command('agent-config')
+    .description('Configure API keys and preferences for the AI Agent')
+    .option('--gemini-key <key>', 'Set Gemini API key')
+    .option('--openai-key <key>', 'Set OpenAI API key')
+    .option('--github-token <token>', 'Set GitHub Models PAT token')
+    .action(agentConfig);
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xaidenlabs/uso",
-  "version": "1.1.80",
+  "version": "1.1.82",
   "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/agent.js

@@ -0,0 +1,295 @@
+const os = require("os");
+const path = require("path");
+const chalk = require("chalk");
+const { log, spinner } = require("../utils/logger");
+
+/**
+ * `uso agent "<goal>"` — Run the AI Agent to accomplish a goal.
+ *
+ * This command handler:
+ *   1. Loads agent config from ~/.uso-agent.json
+ *   2. Resolves an LLM provider (Ollama → GitHub → Gemini → OpenAI)
+ *   3. Runs the ReAct FSM loop
+ *   4. Streams reasoning + actions to the terminal with styled output
+ */
+const agent = async (goalParts, options) => {
+  // Commander passes args differently depending on definition
+  const goalArray = Array.isArray(goalParts) ? goalParts : [goalParts];
+  const goal = goalArray.filter(Boolean).join(" ").trim();
+
+  if (!goal) {
+    log.error("❌ No goal provided.");
+    log.info('Usage: uso agent "Deploy my staking program to devnet"');
+    log.info('       uso agent "Check my environment and fix any issues"');
+    log.info('       uso agent "Build and test my program"');
+    return;
+  }
+
+  // Dynamic import of uso-core (ESM from CJS)
+  let UsoAgent, loadAgentConfig;
+  try {
+    const core = require("../../packages/uso-core/dist/cjs/index.js");
+    UsoAgent = core.UsoAgent;
+    loadAgentConfig = core.loadAgentConfig;
+  } catch (err) {
+    log.error("❌ uso-core agent module not found.");
+    log.warn(
+      "Run 'cd packages/uso-core && npm run build' to compile the agent.",
+    );
+    log.warn(`Detail: ${err.message}`);
+    return;
+  }
+
+  const config = loadAgentConfig();
+
+  // Override config from CLI flags
+  if (options.model) {
+    // Try to infer provider from model name
+    if (options.model.includes("/")) {
+      // GitHub Models format: "openai/gpt-4o-mini"
+      config.github = { ...config.github, model: options.model };
+    } else if (options.model.startsWith("gemini")) {
+      config.gemini = { ...config.gemini, model: options.model };
+    } else if (
+      options.model.startsWith("gpt") ||
+      options.model.startsWith("o1") ||
+      options.model.startsWith("o3")
+    ) {
+      config.openai = { ...config.openai, model: options.model };
+    } else {
+      config.ollama = { ...config.ollama, model: options.model };
+    }
+  }
+
+  const maxLoops = parseInt(options.maxLoops || "3", 10);
+
+  // ─── Banner ────────────────────────────────────────────────
+  console.log();
+  console.log(
+    chalk.bold.cyan("  ┌─────────────────────────────────────────┐"),
+  );
+  console.log(
+    chalk.bold.cyan("  │") +
+      chalk.bold.white("         USO Agent v1.0              ") +
+      chalk.bold.cyan("│"),
+  );
+  console.log(
+    chalk.bold.cyan("  │") +
+      chalk.dim("   Autonomous Solana DevOps Engine    ") +
+      chalk.bold.cyan("│"),
+  );
+  console.log(
+    chalk.bold.cyan("  └─────────────────────────────────────────┘"),
+  );
+  console.log();
+  console.log(chalk.dim("  Goal: ") + chalk.white.bold(goal));
+  console.log(chalk.dim("  Max iterations: ") + chalk.yellow(maxLoops));
+  console.log();
+
+  // ─── FSM Callbacks (render to terminal) ────────────────────
+  const callbacks = {
+    onPhaseChange: (phase, state) => {
+      const phases = {
+        planning: "🧠 Planning",
+        executing: "⚡ Executing",
+        validating: "✅ Validating",
+        healing: "🔧 Self-Healing",
+      };
+      if (phases[phase]) {
+        console.log(chalk.dim(`  ── ${phases[phase]} ──`));
+      }
+    },
+
+    onThought: (thought, state) => {
+      console.log(chalk.blue("  💭 ") + chalk.italic(thought));
+    },
+
+    onToolCall: (toolName, params, state) => {
+      const paramStr = Object.keys(params).length > 0
+        ? chalk.dim(` ${JSON.stringify(params).slice(0, 80)}`)
+        : "";
+      console.log(chalk.yellow("  🔧 ") + chalk.bold(toolName) + paramStr);
+    },
+
+    onObservation: (observation, success, state) => {
+      const lines = observation.split("\n").slice(0, 10);
+      const color = success ? chalk.green : chalk.red;
+      const icon = success ? "  ✅ " : "  ❌ ";
+
+      for (const line of lines) {
+        if (line.trim()) {
+          console.log(color(icon + line.trim().slice(0, 120)));
+        }
+      }
+      if (observation.split("\n").length > 10) {
+        console.log(chalk.dim("     ... (output truncated)"));
+      }
+    },
+
+    onIteration: (iteration, maxIterations, state) => {
+      console.log(
+        chalk.dim(`\n  ─── Iteration ${iteration}/${maxIterations} ───`),
+      );
+    },
+
+    onComplete: (summary, state) => {
+      console.log();
+      console.log(chalk.green.bold("  ✅ GOAL ACCOMPLISHED"));
+      console.log(chalk.green("  " + summary));
+      console.log();
+    },
+
+    onFailed: (reason, state) => {
+      console.log();
+      console.log(chalk.red.bold("  ❌ GOAL FAILED"));
+      console.log(chalk.red("  " + reason));
+      console.log();
+    },
+  };
+
+  // ─── Run Agent ─────────────────────────────────────────────
+  const spin = spinner("Resolving LLM provider...").start();
+
+  try {
+    const usoAgent = new UsoAgent(config);
+
+    // Resolve LLM first to show which provider is being used
+    const llmDiag = await usoAgent.diagnoseLlm();
+    const available = llmDiag.filter((d) => d.available);
+
+    if (available.length === 0) {
+      spin.fail("No LLM provider available.");
+      console.log();
+      log.error("The USO Agent needs at least one LLM to reason.");
+      console.log();
+      log.info("Options (pick any):");
+      log.info("  1. Install Ollama (free, local): https://ollama.com");
+      log.info("     Then run: ollama pull llama3.1:8b");
+      log.info(
+        "  2. uso agent-config --github-token <your-github-pat>",
+      );
+      log.info(
+        "  3. uso agent-config --gemini-key <your-api-key>",
+      );
+      log.info(
+        "  4. uso agent-config --openai-key <your-api-key>",
+      );
+      return;
+    }
+
+    spin.succeed(
+      `LLM: ${chalk.bold(available[0].name)} ${chalk.dim(`(${available.length} provider${available.length > 1 ? "s" : ""} available)`)}`,
+    );
+
+    // Run the agent
+    const result = await usoAgent.run({
+      goal,
+      provider: options.provider,
+      maxIterations: maxLoops,
+      verbose: !!options.verbose,
+      callbacks,
+    });
+
+    // ─── Summary ───────────────────────────────────────────
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    console.log(
+      chalk.dim("  Provider: ") + chalk.white(result.llmProvider),
+    );
+    console.log(
+      chalk.dim("  Iterations: ") +
+        chalk.white(`${result.totalIterations}/${maxLoops}`),
+    );
+    console.log(
+      chalk.dim("  Duration: ") +
+        chalk.white(`${(result.durationMs / 1000).toFixed(1)}s`),
+    );
+    console.log(
+      chalk.dim("  Status: ") +
+        (result.success
+          ? chalk.green.bold("SUCCESS")
+          : chalk.red.bold("FAILED")),
+    );
+    console.log();
+
+    process.exitCode = result.success ? 0 : 1;
+  } catch (err) {
+    spin.fail("Agent failed to start.");
+    log.error(`Error: ${err.message}`);
+    process.exitCode = 1;
+  }
+};
+
+/**
+ * `uso agent-config` — Configure API keys and preferences.
+ */
+const agentConfig = async (options) => {
+  let setApiKey, loadAgentConfig, saveAgentConfig;
+  try {
+    const core = require("../../packages/uso-core/dist/cjs/index.js");
+    setApiKey = core.setApiKey;
+    loadAgentConfig = core.loadAgentConfig;
+    saveAgentConfig = core.saveAgentConfig;
+  } catch (err) {
+    log.error("❌ uso-core agent module not found.");
+    log.warn("Run 'cd packages/uso-core && npm run build' to compile.");
+    return;
+  }
+
+  // Set API keys from flags
+  if (options.geminiKey) {
+    setApiKey("gemini", options.geminiKey);
+    log.success("✅ Gemini API key saved.");
+  }
+  if (options.openaiKey) {
+    setApiKey("openai", options.openaiKey);
+    log.success("✅ OpenAI API key saved.");
+  }
+  if (options.githubToken) {
+    setApiKey("github", options.githubToken);
+    log.success("✅ GitHub Models token saved.");
+  }
+
+  // Show current config
+  if (!options.geminiKey && !options.openaiKey && !options.githubToken) {
+    const config = loadAgentConfig();
+    console.log();
+    console.log(chalk.bold("USO Agent Configuration"));
+    console.log(chalk.dim("Config file: ~/.uso-agent.json"));
+    console.log();
+    console.log(chalk.bold("LLM Providers:"));
+    console.log(
+      `  Ollama:    model=${chalk.cyan(config.ollama?.model || "llama3.1:8b")} url=${chalk.dim(config.ollama?.baseUrl || "http://localhost:11434")}`,
+    );
+    console.log(
+      `  GitHub:    model=${chalk.cyan(config.github?.model || "openai/gpt-4o-mini")} token=${config.github?.token ? chalk.green("SET") : chalk.red("NOT SET")}`,
+    );
+    console.log(
+      `  Gemini:    model=${chalk.cyan(config.gemini?.model || "gemini-2.0-flash")} key=${config.gemini?.apiKey ? chalk.green("SET") : chalk.red("NOT SET")}`,
+    );
+    console.log(
+      `  OpenAI:    model=${chalk.cyan(config.openai?.model || "gpt-4o-mini")} key=${config.openai?.apiKey ? chalk.green("SET") : chalk.red("NOT SET")}`,
+    );
+    console.log();
+    console.log(chalk.bold("Agent Settings:"));
+    console.log(
+      `  Max iterations: ${chalk.cyan(config.agent?.maxIterations || 3)}`,
+    );
+    console.log(
+      `  Confirm destructive: ${chalk.cyan(config.agent?.confirmDestructive ?? true)}`,
+    );
+    console.log();
+    console.log(chalk.dim("Set API keys:"));
+    console.log(
+      chalk.dim("  uso agent-config --gemini-key <key>"),
+    );
+    console.log(
+      chalk.dim("  uso agent-config --openai-key <key>"),
+    );
+    console.log(
+      chalk.dim("  uso agent-config --github-token <token>"),
+    );
+    console.log();
+  }
+};
+
+module.exports = { agent, agentConfig };

package/src/commands/init.js

@@ -15,6 +15,22 @@ const { installWsl, installWslFeature } = require("../platforms/wsl");
 const init = async (component, options) => {
   const platform = os.platform();
 
+  if (options?.global) {
+    log.warn(
+      "⚠️  '-g/--global' is an npm flag and is ignored by 'uso install'.",
+    );
+  }
+
+  if (
+    typeof component === "string" &&
+    (component.startsWith("@") || component.includes("/"))
+  ) {
+    log.error(`❌ '${component}' is not a valid uso component.`);
+    log.info("👉 Use one of: rust, solana, anchor");
+    log.info("👉 To install this CLI globally, run: npm install -g @xaidenlabs/uso");
+    return;
+  }
+
   // --- On Windows, ALWAYS use the WSL path ---
   if (platform === "win32") {
     const hasWslBinary = !!shell.which("wsl");

package/src/commands/uninstall.js

@@ -45,6 +45,64 @@ const commandExists = (command, stealth) => {
 const wslPathExists = (wslPath, stealth) => {
   const result = runInStealth(`[ -e "${wslPath}" ]`, stealth, true);
   return result.code === 0;
+<<<<<<< HEAD
+};
+
+const getInstalledAvmVersions = (stealth) => {
+  const listResult = stealth.enabled
+    ? runInStealth("avm list", stealth, true)
+    : shell.exec("avm list", { silent: true });
+
+  if (listResult.code !== 0) return [];
+
+  const versions = [];
+  for (const rawLine of listResult.stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    // avm list output can contain markers like "* 0.30.1" or "0.30.1 (current)"
+    const match = line.match(/(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/);
+    if (match) versions.push(match[1]);
+  }
+
+  return [...new Set(versions)];
+};
+
+const isCargoPackageInstalled = (packageName, stealth) => {
+  const checkCmd = `cargo install --list | grep -q '^${packageName} v'`;
+  const result = stealth.enabled
+    ? runInStealth(checkCmd, stealth, true)
+    : shell.exec(checkCmd, { silent: true });
+  return result.code === 0;
+};
+
+const uninstallAnchorComponents = (stealth) => {
+  if (commandExists("avm", stealth)) {
+    const versions = getInstalledAvmVersions(stealth);
+    if (versions.length > 0) {
+      for (const version of versions) {
+        runOrElevate(`avm uninstall ${version}`, `Uninstall Anchor (AVM ${version})`, stealth);
+      }
+    } else {
+      log.info("No AVM-managed Anchor versions found to remove.");
+    }
+  }
+
+  if (isCargoPackageInstalled("anchor-cli", stealth)) {
+    runOrElevate(
+      "cargo uninstall anchor-cli",
+      "Uninstall anchor-cli",
+      stealth,
+    );
+  }
+
+  if (isCargoPackageInstalled("avm", stealth)) {
+    runOrElevate("cargo uninstall avm", "Uninstall avm", stealth);
+  }
+
+  log.success("Anchor removal steps completed.");
+=======
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
 };
 
 /**
@@ -136,6 +194,9 @@ const uninstall = async (component) => {
       const anchorInstalled = commandExists("anchor", stealth);
       if (anchorInstalled) {
         log.info("Removing Anchor...");
+<<<<<<< HEAD
+        uninstallAnchorComponents(stealth);
+=======
         // Try avm uninstall first if available
         if (commandExists("avm", stealth)) {
           runOrElevate(
@@ -151,6 +212,7 @@ const uninstall = async (component) => {
         );
         runOrElevate("cargo uninstall avm", "Uninstall avm", stealth);
         log.success("Anchor removal steps completed.");
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
       } else {
         log.success("✅ Anchor is not installed.");
       }
@@ -253,6 +315,9 @@ const uninstall = async (component) => {
     );
     if (removeAnchor.toLowerCase() === "y") {
       log.info("Removing Anchor...");
+<<<<<<< HEAD
+      uninstallAnchorComponents(stealth);
+=======
       // Try avm uninstall first if available
       if (commandExists("avm", stealth)) {
         runOrElevate("avm uninstall latest", "Uninstall Anchor (AVM)", stealth);
@@ -264,6 +329,7 @@ const uninstall = async (component) => {
       );
       runOrElevate("cargo uninstall avm", "Uninstall avm", stealth);
       log.success("Anchor removal steps completed.");
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
     }
   }
 
@@ -331,6 +397,7 @@ const uninstall = async (component) => {
     }
   }
 
+<<<<<<< HEAD
   // 3.5 Remove WSL Distro (if stealth mode is active)
   if (stealth.enabled && os.platform() === "win32") {
     const removeWslDistro = await askQuestion(
@@ -360,6 +427,8 @@ const uninstall = async (component) => {
     }
   }
 
+=======
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
   // 4. WALLET REMOVAL (DANGER)
   const walletPath = path.join(os.homedir(), ".config", "solana", "id.json");
   const wslWalletPath = "$HOME/.config/solana/id.json";

package/src/platforms/wsl.js

@@ -6,6 +6,7 @@ const fs = require("fs");
 const os = require("os");
 const { spawnSync } = require("child_process");
 const chalk = require("chalk");
+<<<<<<< HEAD
 const WSL_DISTRO = "Ubuntu";
 
 const progressHelpers = `
@@ -40,6 +41,8 @@ run_with_progress() {
   return "$status"
 }
 `.replace(/\r\n/g, "\n");
+=======
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
 
 /**
  * Installs the WSL Windows Feature via an elevated PowerShell UAC prompt.
@@ -105,9 +108,13 @@ const installWsl = async () => {
   // 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.
+<<<<<<< HEAD
   const checkDistro = shell.exec(`wsl -d ${WSL_DISTRO} -e true`, {
     silent: true,
   });
+=======
+  const checkDistro = shell.exec("wsl -d Ubuntu -e true", { silent: true });
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
 
   // If exit code is 0, it's installed and working.
   if (checkDistro.code !== 0) {
@@ -125,10 +132,14 @@ const installWsl = async () => {
     };
 
     // Attempt 1: Standard Install
+<<<<<<< HEAD
     let success = tryInstall(
       ["--install", "-d", WSL_DISTRO],
       "Standard Install",
     );
+=======
+    let success = tryInstall(["--install", "-d", "Ubuntu"], "Standard Install");
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
 
     // Attempt 2: Update WSL Kernel (Fixes network/protocol issues)
     if (!success) {
@@ -137,7 +148,11 @@ const installWsl = async () => {
       );
       spawnSync("wsl", ["--update"], { stdio: "inherit", shell: false });
       success = tryInstall(
+<<<<<<< HEAD
         ["--install", "-d", WSL_DISTRO],
+=======
+        ["--install", "-d", "Ubuntu"],
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
         "Install after Update",
       );
     }
@@ -146,7 +161,11 @@ const installWsl = async () => {
     if (!success) {
       log.warn("⚠️  Still failing. Trying --web-download (Bypasses Store)...");
       success = tryInstall(
+<<<<<<< HEAD
         ["--install", "-d", WSL_DISTRO, "--web-download"],
+=======
+        ["--install", "-d", "Ubuntu", "--web-download"],
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
         "Web Download Install",
       );
     }
@@ -159,13 +178,18 @@ const installWsl = async () => {
         "\n👉 ACTION REQUIRED: Run this command manually in PowerShell as Administrator:",
       );
       console.log(
+<<<<<<< HEAD
         chalk.bold.yellow(`    wsl --install -d ${WSL_DISTRO} --web-download`),
+=======
+        chalk.bold.yellow("    wsl --install -d Ubuntu --web-download"),
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
       );
       log.warn(
         "\nOnce that completes successfully, run 'uso setup --wsl' again.",
       );
       return false;
     }
+<<<<<<< HEAD
 
     const verifyInstall = shell.exec(`wsl -d ${WSL_DISTRO} -e true`, {
       silent: true,
@@ -191,6 +215,19 @@ const installWsl = async () => {
   // 3. Configure Internal Environment (Rust + Solana + Anchor)
   // We create a shell script and run it inside WSL.
 
+=======
+    log.success("✅ Uso Engine configured.");
+  } else {
+    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.
+
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
   log.info("⚙️  Initializing Uso Engine environment...");
 
   // --- PHASE 1: System Dependencies (as root, no sudo needed) ---
@@ -215,7 +252,11 @@ fi
 
   const spin1 = spinner("Phase 1/2: Installing system dependencies...").start();
   const rootRes = shell.exec(
+<<<<<<< HEAD
     `wsl -d ${WSL_DISTRO} -u root -e bash "${wslRootScriptPath}"`,
+=======
+    `wsl -d Ubuntu -u root -e bash "${wslRootScriptPath}"`,
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
   );
   fs.unlinkSync(rootScriptPath);
 
@@ -415,9 +456,13 @@ fi
   const spin2 = spinner(
     "Phase 2/2: Installing Rust, Solana, Anchor (this takes a while)...",
   ).start();
+<<<<<<< HEAD
   const userRes = shell.exec(
     `wsl -d ${WSL_DISTRO} -e bash "${wslUserScriptPath}"`,
   );
+=======
+  const userRes = shell.exec(`wsl -d Ubuntu -e bash "${wslUserScriptPath}"`);
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
   fs.unlinkSync(userScriptPath);
 
   if (userRes.code === 0) {
@@ -429,7 +474,11 @@ fi
 
   // Always set stealth mode config — even partial setup enables routing
   const configPath = path.join(os.homedir(), ".uso-config.json");
+<<<<<<< HEAD
   const config = { mode: "wsl", distro: WSL_DISTRO };
+=======
+  const config = { mode: "wsl", distro: "Ubuntu" };
+>>>>>>> d47ca156cb2a252419c54c520c7fcd0f0c18c525
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 
   log.success("✅ Stealth Mode Enabled. 'uso' commands will now run via WSL.");