claude-yolo-extended 1.8.0

package/README.md

@@ -0,0 +1,178 @@
+# Claude YOLO Extended
+
+A wrapper for the Claude CLI that can run in YOLO mode (bypassing all safety checks) OR Safe mode (standard Claude CLI behavior).
+
+⚠️ **SECURITY WARNING**: YOLO mode bypasses important safety checks! This completely bypasses the "human in the loop" checks, this could delete your data, leak your secrets and even brick your computer. Use at your own risk.
+
+## Features
+
+- **Cross-Platform**: Works on Windows, Ubuntu, and other Unix-like systems
+- **Dual Mode Support**: Switch between YOLO and SAFE modes
+- **Mode Persistence**: Your mode choice is saved between sessions
+- **Auto-start**: Claude starts automatically after mode switch
+- **Root User Support**: YOLO mode works even as root user
+- **Visual Mode Indicators**: Clear `[YOLO]` or `[SAFE]` prefixes
+- **Auto-update**: Automatically checks for and installs updates to the Claude package
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/jslitzkerttcu/claude-yolo-extended.git
+cd claude-yolo-extended
+
+# Install dependencies
+npm install
+
+# Link globally to use the command anywhere
+npm link
+```
+
+The first time you run `claude-yolo-extended`, you will be presented with a consent prompt explaining the security implications. You must explicitly agree to continue.
+
+<img width="750" alt="image" src="https://github.com/user-attachments/assets/f8e07cf0-6c43-4663-b9e2-f61b1afb4e99" />
+
+Your consent choice is remembered for future runs.
+
+## New Safe Mode Feature 🛡️
+
+### Using command-line flags
+
+```bash
+# Run in SAFE mode (normal Claude CLI behavior)
+claude-yolo-extended --safe
+claude-yolo-extended --no-yolo
+
+# Run in YOLO mode (default)
+claude-yolo-extended
+```
+
+### Using mode commands
+
+```bash
+# Switch to YOLO mode
+claude-yolo-extended mode yolo
+
+# Switch to SAFE mode
+claude-yolo-extended mode safe
+
+# Check current mode
+claude-yolo-extended mode
+```
+
+### Using the cl wrapper script (Recommended!)
+
+For even easier mode management, use the included `cl` wrapper script (works on both Windows and Unix systems):
+
+```bash
+# After npm link, the cl wrapper is available globally
+# Or copy manually to your PATH
+cp node_modules/claude-yolo-extended/bin/cl /usr/local/bin/cl
+chmod +x /usr/local/bin/cl
+
+# Now you can use:
+cl /YON      # Switch to YOLO mode AND start Claude
+cl /YOFF     # Switch to SAFE mode AND start Claude
+cl /STATUS   # Show current mode (without starting Claude)
+cl /HELP     # Show help
+
+# Run Claude in current mode
+cl "write a hello world function"
+
+# Switch mode and run with command
+cl /YON "create a web server"
+```
+
+Mode preference is saved in `~/.claude_yolo_state` and persists between sessions.
+
+## Visual Mode Indicators
+
+The tool now shows clear visual indicators of which mode you're in:
+
+- **YOLO Mode**: `[YOLO]` prefix in yellow 🔥
+- **SAFE Mode**: `[SAFE]` prefix in cyan 🛡️
+
+## Root User Support
+
+Unlike the standard Claude CLI, this fork allows YOLO mode to run even as root user:
+
+- Standard Claude CLI blocks `--dangerously-skip-permissions` when running as root
+- This fork bypasses that check in YOLO mode
+- You'll see a warning when running as root, but it will work
+- SAFE mode respects all original Claude CLI security features
+
+## Usage
+
+```bash
+claude-yolo-extended [options]
+```
+
+All arguments and options are passed directly to the Claude CLI.
+
+This wrapper in YOLO mode:
+1. Checks for and automatically installs updates to the Claude package
+2. Displays "🔥 YOLO MODE ACTIVATED 🔥" warning in yellow text
+3. Creates a modified copy of the Claude CLI code to bypass permission checks
+   - Replaces all `getIsDocker()` calls with `true`
+   - Replaces all `hasInternetAccess()` calls with `false`
+   - Bypasses root user checks (process.getuid() === 0)
+   - Adds colorful YOLO-themed loading messages
+4. Leaves the original Claude CLI file untouched (won't affect your normal `claude` command)
+5. Adds the `--dangerously-skip-permissions` flag to command line arguments
+6. Imports the modified copy of the CLI
+
+In SAFE mode, it simply runs the original Claude CLI without modifications.
+
+
+## How It Works
+
+- **YOLO Mode**: Creates a modified copy of the Claude CLI that bypasses permission checks
+- **SAFE Mode**: Runs the original Claude CLI without modifications
+- **Non-destructive**: Your regular `claude` command remains untouched
+- **Debug mode**: Set `DEBUG=1` to see detailed logs
+
+## Why?
+
+Sometimes you just want to YOLO and skip those pesky permission checks. But sometimes you want the safety checks back! This tool gives you the best of both worlds.
+
+## Debugging
+
+If you encounter any issues, you can run with debug output:
+
+```bash
+DEBUG=1 claude-yolo-extended
+```
+
+This will show additional information about:
+- Claude package update checks
+- Current and latest available versions
+- When updates are being installed
+- Modifications being made to the CLI file
+- Root bypass operations
+
+## Auto-Update Feature
+
+Claude YOLO automatically checks for updates to the Claude package each time it runs:
+
+1. When you run `claude-yolo-extended`, it checks for the latest version of `@anthropic-ai/claude-code` on npm
+2. If your installed version is outdated, it will:
+   - Update your package.json with the latest version
+   - Run npm install to get the newest version
+   - Notify you that an update was applied
+3. This ensures you're always using the latest Claude CLI features
+
+## Important Security Disclaimer
+
+This is an unofficial tool and not supported by Anthropic. Use at your own risk.
+
+**SECURITY WARNING**:
+- YOLO mode bypasses safety mechanisms intentionally built into the Claude CLI
+- The `--dangerously-skip-permissions` flag was designed for use in container environments
+- This fork additionally bypasses root user restrictions in YOLO mode
+- By using this tool in YOLO mode, you acknowledge that:
+  - Important safety checks are being bypassed
+  - Claude may access files it normally would not have permission to access
+  - Running as root with bypassed permissions is extremely dangerous
+  - You accept full responsibility for any security implications
+  
+Anthropic designed these safety checks for good reason. Only use YOLO mode if you fully understand and accept these risks. Use SAFE mode when you want the standard Claude CLI protections.

package/bin/cl

@@ -0,0 +1,117 @@
+#!/bin/bash
+
+# Claude YOLO/SAFE Mode Wrapper Script
+# Usage: cl /YON | /YOFF | /STATUS | /HELP | [claude commands]
+
+# Barvy pro výstup
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+RESET='\033[0m'
+BOLD='\033[1m'
+
+# Soubor pro uložení stavu
+STATE_FILE="$HOME/.claude_yolo_state"
+
+# Funkce pro čtení aktuálního režimu
+get_mode() {
+    if [ -f "$STATE_FILE" ]; then
+        cat "$STATE_FILE"
+    else
+        echo "SAFE"  # Výchozí je bezpečný režim
+    fi
+}
+
+# Funkce pro nastavení režimu
+set_mode() {
+    echo "$1" > "$STATE_FILE"
+}
+
+# Zpracování argumentů
+case "$1" in
+    /YON)
+        echo -e "${YELLOW}${BOLD}🔥 ACTIVATING YOLO MODE 🔥${RESET}"
+        echo -e "${RED}⚠️  WARNING: All safety checks will be DISABLED!${RESET}"
+        echo -e "${RED}⚠️  Claude can access ANY file without asking!${RESET}"
+        set_mode "YOLO"
+        echo -e "${YELLOW}✓ YOLO mode is now ON${RESET}"
+        ;;
+        
+    /YOFF)
+        echo -e "${CYAN}${BOLD}🛡️  ACTIVATING SAFE MODE 🛡️${RESET}"
+        echo -e "${GREEN}✓ Safety checks will be enabled${RESET}"
+        echo -e "${GREEN}✓ Claude will ask for permissions${RESET}"
+        set_mode "SAFE"
+        echo -e "${CYAN}✓ YOLO mode is now OFF (Safe mode ON)${RESET}"
+        ;;
+        
+    /STATUS)
+        MODE=$(get_mode)
+        echo -e "${BOLD}Claude CLI Status:${RESET}"
+        echo -e "━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        if [ "$MODE" = "YOLO" ]; then
+            echo -e "Mode: ${YELLOW}${BOLD}YOLO${RESET} 🔥"
+            echo -e "Safety: ${RED}DISABLED${RESET}"
+            echo -e "Permissions: ${RED}BYPASSED${RESET}"
+        else
+            echo -e "Mode: ${CYAN}${BOLD}SAFE${RESET} 🛡️"
+            echo -e "Safety: ${GREEN}ENABLED${RESET}"
+            echo -e "Permissions: ${GREEN}REQUIRED${RESET}"
+        fi
+        echo -e "━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        ;;
+        
+    /HELP|/H|/?)
+        echo -e "${BOLD}Claude CLI Wrapper - Help${RESET}"
+        echo -e "━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo -e "${CYAN}cl /YON${RESET}     - Enable YOLO mode (bypass safety)"
+        echo -e "${CYAN}cl /YOFF${RESET}    - Disable YOLO mode (safe mode)"
+        echo -e "${CYAN}cl /STATUS${RESET}  - Show current mode"
+        echo -e "${CYAN}cl /HELP${RESET}    - Show this help"
+        echo -e "${CYAN}cl [args]${RESET}   - Run claude with current mode"
+        echo -e "━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        echo -e ""
+        echo -e "${BOLD}Examples:${RESET}"
+        echo -e "  cl /YON                    # Enable YOLO mode"
+        echo -e "  cl /YOFF                   # Enable SAFE mode"
+        echo -e "  cl \"write a function\"      # Run Claude in current mode"
+        echo -e ""
+        echo -e "${BOLD}Mode Persistence:${RESET}"
+        echo -e "Your mode choice is saved in ~/.claude_yolo_state"
+        echo -e "and persists between terminal sessions."
+        ;;
+        
+    *)
+        # Spustit Claude v aktuálním režimu
+        MODE=$(get_mode)
+        
+        # Zobrazit režim před spuštěním
+        if [ "$MODE" = "YOLO" ]; then
+            echo -e "${YELLOW}[YOLO]${RESET} Running Claude in YOLO mode..."
+            # Check if claude-yolo-extended is installed
+            if command -v claude-yolo-extended &> /dev/null; then
+                claude-yolo-extended "$@"
+            else
+                echo -e "${RED}Error: claude-yolo-extended is not installed${RESET}"
+                echo -e "Install it with: ${CYAN}npm install -g claude-yolo-extended${RESET}"
+                exit 1
+            fi
+        else
+            echo -e "${CYAN}[SAFE]${RESET} Running Claude in SAFE mode..."
+            # Check if claude is installed
+            if command -v claude &> /dev/null; then
+                claude "$@"
+            else
+                # If regular claude is not installed, use claude-yolo-extended with --safe flag
+                if command -v claude-yolo-extended &> /dev/null; then
+                    claude-yolo-extended --safe "$@"
+                else
+                    echo -e "${RED}Error: Neither claude nor claude-yolo-extended is installed${RESET}"
+                    echo -e "Install claude-yolo-extended with: ${CYAN}npm install -g claude-yolo-extended${RESET}"
+                    exit 1
+                fi
+            fi
+        fi
+        ;;
+esac

package/bin/cl.ps1

@@ -0,0 +1,36 @@
+# Claude YOLO/SAFE Mode Wrapper Script
+# Usage: cl.ps1 /YON | /YOFF | /STATUS | /HELP | [claude commands]
+
+param(
+    [Parameter(Position=0)]
+    [string]$Command,
+    [Parameter(Position=1)]
+    [string]$Argument
+)
+
+# Colors for output
+$RED = "`e[31m"
+$YELLOW = "`e[33m"
+$CYAN = "`e[36m"
+$GREEN = "`e[32m"
+$RESET = "`e[0m"
+
+function Write-Colored($Text, $Color) {
+    Write-Host "$Color$Text$RESET"
+}
+
+# Check if Node.js is installed
+if (-not (Get-Command node -ErrorAction SilentlyContinue)) {
+    Write-Colored "Error: Node.js is not installed. Please install Node.js first." $RED
+    exit 1
+}
+
+# Check if the main script exists
+$scriptPath = Join-Path $PSScriptRoot "claude-yolo.js"
+if (-not (Test-Path $scriptPath)) {
+    Write-Colored "Error: Main script not found. Please reinstall the package." $RED
+    exit 1
+}
+
+# Run the main script with arguments
+& node $scriptPath $Command $Argument

package/bin/claude-yolo.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+
+
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import os from 'os';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import readline from 'readline';
+
+// ANSI color codes
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+
+// Path to persistent state file
+const stateFile = path.join(os.homedir(), '.claude_yolo_state');
+
+// Function to get current mode from state file
+function getMode() {
+  try {
+    return fs.readFileSync(stateFile, 'utf8').trim();
+  } catch {
+    return 'YOLO'; // Default mode
+  }
+}
+
+// Function to set mode in state file
+function setMode(mode) {
+  fs.writeFileSync(stateFile, mode);
+}
+
+// Debug logging function that only logs if DEBUG env var is set
+const debug = (message) => {
+  if (process.env.DEBUG) {
+    console.log(message);
+  }
+};
+
+// Function to ask for user consent
+function askForConsent() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log(`\n${BOLD}${YELLOW}🔥 CLAUDE-YOLO-EXTENDED CONSENT REQUIRED 🔥${RESET}\n`);
+    console.log(`${CYAN}----------------------------------------${RESET}`);
+    console.log(`${BOLD}What is claude-yolo-extended?${RESET}`);
+    console.log(`This package creates a wrapper around the official Claude CLI tool that:`);
+    console.log(`  1. ${RED}BYPASSES safety checks${RESET} by automatically adding the --dangerously-skip-permissions flag`);
+    console.log(`  2. Automatically updates to the latest Claude CLI version`);
+    console.log(`  3. Adds colorful YOLO-themed loading messages`);
+    console.log(`  4. ${GREEN}NOW SUPPORTS SAFE MODE${RESET} with --safe flag\n`);
+
+    console.log(`${BOLD}${RED}⚠️ IMPORTANT SECURITY WARNING ⚠️${RESET}`);
+    console.log(`The ${BOLD}--dangerously-skip-permissions${RESET} flag was designed for use in containers`);
+    console.log(`and bypasses important safety checks. This includes ignoring file access`);
+    console.log(`permissions that protect your system and privacy.\n`);
+
+    console.log(`${BOLD}By using claude-yolo-extended in YOLO mode:${RESET}`);
+    console.log(`  • You acknowledge these safety checks are being bypassed`);
+    console.log(`  • You understand this may allow Claude CLI to access sensitive files`);
+    console.log(`  • You accept full responsibility for any security implications\n`);
+
+    console.log(`${CYAN}----------------------------------------${RESET}\n`);
+
+    rl.question(`${YELLOW}Do you consent to using claude-yolo-extended with these modifications? (yes/no): ${RESET}`, (answer) => {
+      rl.close();
+      const lowerAnswer = answer.toLowerCase().trim();
+      if (lowerAnswer === 'yes' || lowerAnswer === 'y') {
+        console.log(`\n${YELLOW}🔥 YOLO MODE APPROVED 🔥${RESET}`);
+        resolve(true);
+      } else {
+        console.log(`\n${CYAN}Aborted. YOLO mode not activated.${RESET}`);
+        console.log(`If you want the official Claude CLI with normal safety features, run:`);
+        console.log(`claude`);
+        resolve(false);
+      }
+    });
+  });
+}
+
+// Get the directory of the current module
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Find node_modules directory by walking up from current file
+let nodeModulesDir = path.resolve(__dirname, '..');
+while (!fs.existsSync(path.join(nodeModulesDir, 'node_modules')) && nodeModulesDir !== '/') {
+  nodeModulesDir = path.resolve(nodeModulesDir, '..');
+}
+
+// Path to check package info
+const packageJsonPath = path.join(nodeModulesDir, 'package.json');
+
+// Check for updates to Claude package
+async function checkForUpdates() {
+  try {
+    debug("Checking for Claude package updates...");
+    
+    // Get the latest version available on npm
+    const latestVersionCmd = "npm view @anthropic-ai/claude-code version";
+    const latestVersion = execSync(latestVersionCmd).toString().trim();
+    debug(`Latest Claude version on npm: ${latestVersion}`);
+    
+    // Get our current installed version
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = packageJson.dependencies || {};
+    const currentVersion = dependencies['@anthropic-ai/claude-code'];
+    
+    debug(`Claude version from package.json: ${currentVersion}`);
+    
+    // Get the global Claude version if available
+    let globalVersion;
+    if (globalClaudeDir) {
+      try {
+        const globalPackageJsonPath = path.join(globalClaudeDir, 'package.json');
+        if (fs.existsSync(globalPackageJsonPath)) {
+          const globalPackageJson = JSON.parse(fs.readFileSync(globalPackageJsonPath, 'utf8'));
+          globalVersion = globalPackageJson.version;
+          debug(`Global Claude version: ${globalVersion}`);
+          
+          // If global version is latest, inform user
+          if (globalVersion === latestVersion) {
+            debug(`Global Claude installation is already the latest version`);
+          } else if (globalVersion && latestVersion) {
+            debug(`Global Claude installation (${globalVersion}) differs from latest (${latestVersion})`);
+          }
+        }
+      } catch (err) {
+        debug(`Error getting global Claude version: ${err.message}`);
+      }
+    }
+    
+    // If using a specific version (not "latest"), and it's out of date, update
+    if (currentVersion !== "latest" && currentVersion !== latestVersion) {
+      console.log(`Updating Claude package from ${currentVersion || 'unknown'} to ${latestVersion}...`);
+      
+      // Update package.json
+      packageJson.dependencies['@anthropic-ai/claude-code'] = latestVersion;
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      
+      // Run npm install
+      console.log("Running npm install to update dependencies...");
+      execSync("npm install", { stdio: 'inherit', cwd: nodeModulesDir });
+      console.log("Update complete!");
+    } else if (currentVersion === "latest") {
+      // If using "latest", just make sure we have the latest version installed
+      debug("Using 'latest' tag in package.json, running npm install to ensure we have the newest version");
+      execSync("npm install", { stdio: 'inherit', cwd: nodeModulesDir });
+    }
+  } catch (error) {
+    console.error("Error checking for updates:", error.message);
+    debug(error.stack);
+  }
+}
+
+// Try to find global installation of Claude CLI first
+let globalClaudeDir;
+try {
+  const globalNodeModules = execSync('npm -g root').toString().trim();
+  debug(`Global node_modules: ${globalNodeModules}`);
+  const potentialGlobalDir = path.join(globalNodeModules, '@anthropic-ai', 'claude-code');
+  
+  if (fs.existsSync(potentialGlobalDir)) {
+    globalClaudeDir = potentialGlobalDir;
+    debug(`Found global Claude installation at: ${globalClaudeDir}`);
+  }
+} catch (error) {
+  debug(`Error finding global Claude installation: ${error.message}`);
+}
+
+// Path to the local Claude CLI installation
+const localClaudeDir = path.join(nodeModulesDir, 'node_modules', '@anthropic-ai', 'claude-code');
+
+// Prioritize global installation, fall back to local
+const claudeDir = globalClaudeDir || localClaudeDir;
+debug(`Using Claude installation from: ${claudeDir}`);
+debug(`Using ${claudeDir === globalClaudeDir ? 'GLOBAL' : 'LOCAL'} Claude installation`);
+
+// Check for both .js and .mjs versions of the CLI
+let mjs = path.join(claudeDir, 'cli.mjs');
+let js = path.join(claudeDir, 'cli.js');
+let originalCliPath;
+let yoloCliPath;
+
+if (fs.existsSync(js)) {
+  originalCliPath = js;
+  yoloCliPath = path.join(claudeDir, 'cli-yolo.js');
+  debug(`Found Claude CLI at ${originalCliPath} (js version)`);
+} else if (fs.existsSync(mjs)) {
+  originalCliPath = mjs;
+  yoloCliPath = path.join(claudeDir, 'cli-yolo.mjs');
+  debug(`Found Claude CLI at ${originalCliPath} (mjs version)`);
+} else {
+  console.error(`Error: Claude CLI not found in ${claudeDir}. Make sure @anthropic-ai/claude-code is installed.`);
+  process.exit(1);
+}
+const consentFlagPath = path.join(claudeDir, '.claude-yolo-extended-consent');
+
+// Main function to run the application
+async function run() {
+  // Handle mode commands first
+  const args = process.argv.slice(2);
+  if (args[0] === 'mode') {
+    if (args[1] === 'yolo') {
+      console.log(`${YELLOW}🔥 Switching to YOLO mode...${RESET}`);
+      console.log(`${RED}⚠️  WARNING: All safety checks will be DISABLED!${RESET}`);
+      setMode('YOLO');
+      console.log(`${YELLOW}✓ YOLO mode activated${RESET}`);
+      return;
+    } else if (args[1] === 'safe') {
+      console.log(`${CYAN}🛡️  Switching to SAFE mode...${RESET}`);
+      console.log(`${GREEN}✓ Safety checks will be enabled${RESET}`);
+      setMode('SAFE');
+      console.log(`${CYAN}✓ SAFE mode activated${RESET}`);
+      return;
+    } else {
+      const currentMode = getMode();
+      console.log(`Current mode: ${currentMode === 'YOLO' ? YELLOW : CYAN}${currentMode}${RESET}`);
+      return;
+    }
+  }
+
+  // Check for --safe or --no-yolo flags
+  const safeMode = process.argv.includes('--safe') || 
+                   process.argv.includes('--no-yolo') ||
+                   getMode() === 'SAFE';
+  
+  if (safeMode) {
+    // Remove our flags before passing to original CLI
+    process.argv = process.argv.filter(arg => 
+      arg !== '--safe' && arg !== '--no-yolo'
+    );
+    
+    console.log(`${CYAN}[SAFE] Running Claude in SAFE mode${RESET}`);
+    
+    // Update if needed
+    await checkForUpdates();
+    
+    // Ensure original CLI exists
+    if (!fs.existsSync(originalCliPath)) {
+      console.error(`Error: ${originalCliPath} not found. Make sure @anthropic-ai/claude-code is installed.`);
+      process.exit(1);
+    }
+    
+    // Run original CLI without modifications
+    const cliUrl = pathToFileURL(originalCliPath).href;
+    await import(cliUrl);
+    return; // Exit early
+  }
+
+  // YOLO MODE continues below
+  console.log(`${YELLOW}[YOLO] Running Claude in YOLO mode${RESET}`);
+  
+  // Temporarily fake non-root for YOLO mode
+  if (process.getuid && process.getuid() === 0) {
+    console.log(`${YELLOW}⚠️  Running as root - applying YOLO bypass...${RESET}`);
+    // Store original getuid
+    const originalGetuid = process.getuid;
+    // Override getuid to return non-root
+    process.getuid = () => 1000; // Fake regular user ID
+    // Restore after a delay to allow CLI to start
+    setTimeout(() => {
+      process.getuid = originalGetuid;
+    }, 100);
+  }
+  
+  // Check and update Claude package first
+  await checkForUpdates();
+
+  if (!fs.existsSync(originalCliPath)) {
+    console.error(`Error: ${originalCliPath} not found. Make sure @anthropic-ai/claude-code is installed.`);
+    process.exit(1);
+  }
+
+  // Check if consent is needed
+  const consentNeeded = !fs.existsSync(yoloCliPath) || !fs.existsSync(consentFlagPath);
+  
+  // If consent is needed and not already given, ask for it
+  if (consentNeeded) {
+    const consent = await askForConsent();
+    if (!consent) {
+      // User didn't consent, exit
+      process.exit(1);
+    }
+    
+    // Create a flag file to remember that consent was given
+    try {
+      fs.writeFileSync(consentFlagPath, 'consent-given');
+      debug("Created consent flag file");
+    } catch (err) {
+      debug(`Error creating consent flag file: ${err.message}`);
+      // Continue anyway
+    }
+  }
+
+  // Read the original CLI file content
+  let cliContent = fs.readFileSync(originalCliPath, 'utf8');
+
+  if (claudeDir === localClaudeDir) {
+    cliContent = cliContent.replace(/"punycode"/g, '"punycode/"');
+    debug('Replaced all instances of "punycode" with "punycode/"');
+  }
+
+  // Replace getIsDocker() calls with true
+  cliContent = cliContent.replace(/[a-zA-Z0-9_]*\.getIsDocker\(\)/g, 'true');
+  debug("Replaced all instances of *.getIsDocker() with true");
+
+  // Replace hasInternetAccess() calls with false
+  cliContent = cliContent.replace(/[a-zA-Z0-9_]*\.hasInternetAccess\(\)/g, 'false');
+  debug("Replaced all instances of *.hasInternetAccess() with false");
+
+  // Replace root check patterns
+  // Pattern 1: process.getuid() === 0
+  cliContent = cliContent.replace(/process\.getuid\(\)\s*===\s*0/g, 'false');
+  debug("Replaced process.getuid() === 0 checks with false");
+
+  // Pattern 2: process.getuid?.() === 0
+  cliContent = cliContent.replace(/process\.getuid\?\.\(\)\s*===\s*0/g, 'false');
+  debug("Replaced process.getuid?.() === 0 checks with false");
+
+  // Pattern 3: getuid() === 0 (with any variable)
+  cliContent = cliContent.replace(/(\w+)\.getuid\(\)\s*===\s*0/g, 'false');
+  debug("Replaced all getuid() === 0 checks with false");
+
+  // Pattern 4: Replace any EUID checks
+  cliContent = cliContent.replace(/process\.geteuid\(\)\s*===\s*0/g, 'false');
+  cliContent = cliContent.replace(/process\.geteuid\?\.\(\)\s*===\s*0/g, 'false');
+  debug("Replaced geteuid() checks with false");
+
+  // Add warning message
+  console.log(`${YELLOW}🔥 YOLO MODE ACTIVATED 🔥${RESET}`);
+
+  // Replace the loading messages array with YOLO versions
+  const originalArray = '["Accomplishing","Actioning","Actualizing","Baking","Brewing","Calculating","Cerebrating","Churning","Clauding","Coalescing","Cogitating","Computing","Conjuring","Considering","Cooking","Crafting","Creating","Crunching","Deliberating","Determining","Doing","Effecting","Finagling","Forging","Forming","Generating","Hatching","Herding","Honking","Hustling","Ideating","Inferring","Manifesting","Marinating","Moseying","Mulling","Mustering","Musing","Noodling","Percolating","Pondering","Processing","Puttering","Reticulating","Ruminating","Schlepping","Shucking","Simmering","Smooshing","Spinning","Stewing","Synthesizing","Thinking","Transmuting","Vibing","Working"]';
+  const yoloSuffixes = [
+    ` ${RED}(safety's off, hold on tight)${RESET}`,
+    ` ${YELLOW}(all gas, no brakes, lfg)${RESET}`,
+    ` ${BOLD}\x1b[35m(yolo mode engaged)${RESET}`,
+    ` ${CYAN}(dangerous mode! I guess you can just do things)${RESET}`
+  ];
+
+  // Function to add a random YOLO suffix to each word in the array
+  const addYoloSuffixes = (arrayStr) => {
+    try {
+      const array = JSON.parse(arrayStr);
+      const yoloArray = array.map(word => {
+        const randomSuffix = yoloSuffixes[Math.floor(Math.random() * yoloSuffixes.length)];
+        return word + randomSuffix;
+      });
+      return JSON.stringify(yoloArray);
+    } catch (e) {
+      debug(`Error modifying loading messages array: ${e.message}`);
+      return arrayStr;
+    }
+  };
+
+  cliContent = cliContent.replace(originalArray, addYoloSuffixes(originalArray));
+  debug("Replaced loading messages with YOLO versions");
+
+  // Write the modified content to a new file, leaving the original untouched
+  fs.writeFileSync(yoloCliPath, cliContent);
+  debug(`Created modified CLI at ${yoloCliPath}`);
+  debug("Modifications complete. The --dangerously-skip-permissions flag should now work everywhere.");
+
+  // Add the --dangerously-skip-permissions flag to the command line arguments
+  // This will ensure it's passed to the CLI even if the user didn't specify it
+  process.argv.splice(2, 0, '--dangerously-skip-permissions');
+  debug("Added --dangerously-skip-permissions flag to command line arguments");
+
+  // Now import the modified CLI
+  const yoloCliUrl = pathToFileURL(yoloCliPath).href;
+  await import(yoloCliUrl);
+}
+
+// Run the main function
+run().catch(err => {
+  console.error("Error:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "claude-yolo-extended",
+  "version": "1.8.0",
+  "description": "Claude CLI wrapper with YOLO mode (bypass safety) and SAFE mode support, auto-updates, and colorful loading messages",
+  "bin": {
+    "claude-yolo-extended": "bin/claude-yolo.js",
+    "cl": "bin/cl"
+  },
+  "dependencies": {
+    "punycode": "latest",
+    "@anthropic-ai/claude-code": "1.0.53"
+  },
+  "type": "module",
+  "scripts": {
+    "postinstall": "node -e \"require('fs').chmodSync('./bin/cl', 0o755);\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jslitzkerttcu/claude-yolo.git"
+  },
+  "keywords": [
+    "claude",
+    "cli",
+    "anthropic",
+    "wrapper",
+    "yolo",
+    "safe-mode",
+    "permissions"
+  ],
+  "author": "jslitzkerttcu",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jslitzkerttcu/claude-yolo/issues"
+  },
+  "homepage": "https://github.com/jslitzkerttcu/claude-yolo#readme",
+  "engines": {
+    "node": ">=14.16"
+  },
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ]
+}

package/postinstall.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import readline from 'readline';
+
+// ANSI color codes
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+
+// Create readline interface for user input
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+console.log(`\n${BOLD}${YELLOW}🔥 CLAUDE-YOLO INSTALLATION CONSENT REQUIRED 🔥${RESET}\n`);
+console.log(`${CYAN}----------------------------------------${RESET}`);
+console.log(`${BOLD}What is claude-yolo?${RESET}`);
+console.log(`This package creates a wrapper around the official Claude CLI tool that:`);
+console.log(`  1. ${RED}BYPASSES safety checks${RESET} by automatically adding the --dangerously-skip-permissions flag`);
+console.log(`  2. Automatically updates to the latest Claude CLI version`);
+console.log(`  3. Adds colorful YOLO-themed loading messages\n`);
+
+console.log(`${BOLD}${RED}⚠️ IMPORTANT SECURITY WARNING ⚠️${RESET}`);
+console.log(`The ${BOLD}--dangerously-skip-permissions${RESET} flag was designed for use in containers`);
+console.log(`and bypasses important safety checks. This includes ignoring file access`);
+console.log(`permissions that protect your system and privacy.\n`);
+
+console.log(`${BOLD}By using claude-yolo:${RESET}`);
+console.log(`  • You acknowledge these safety checks are being bypassed`);
+console.log(`  • You understand this may allow Claude CLI to access sensitive files`);
+console.log(`  • You accept full responsibility for any security implications\n`);
+
+console.log(`${CYAN}----------------------------------------${RESET}\n`);
+
+// Ask for explicit consent
+rl.question(`${YELLOW}Do you consent to installing claude-yolo with these modifications? (yes/no): ${RESET}`, (answer) => {
+  const lowerAnswer = answer.toLowerCase().trim();
+  
+  if (lowerAnswer === 'yes' || lowerAnswer === 'y') {
+    console.log(`\n${YELLOW}🔥 YOLO MODE INSTALLATION APPROVED 🔥${RESET}`);
+    console.log(`Installation will continue. Use 'claude-yolo' instead of 'claude' to run in YOLO mode.`);
+    process.exit(0); // Success exit code
+  } else {
+    console.log(`\n${CYAN}Installation cancelled by user.${RESET}`);
+    console.log(`If you want the official Claude CLI with normal safety features, run:`);
+    console.log(`npm install -g @anthropic-ai/claude-code`);
+    process.exit(1); // Error exit code to abort installation
+  }
+});