World Engine Tool Launcher (we) - Download and run WE tools

README.md

World Engine Tool Launcher (we)

A simple tool to download, cache, and run World Engine tools from GitHub releases.

Quick Install

macOS / Linux

curl -fsSL https://gist.githubusercontent.com/__GIST_USER__/__GIST_ID__/raw/we.sh | bash

Then run any tool:

we gui_test
we client --help
we asset_cooker --input ./assets

Windows (PowerShell)

irm https://gist.githubusercontent.com/__GIST_USER__/__GIST_ID__/raw/we.ps1 | iex

Then run any tool:

we gui_test
we client --help
we asset_cooker --input .\assets

Available Tools

Tool	Description
gpu_info	Display GPU information (Vulkan-capable GPUs)
gui_test	GUI testing and benchmarking application
pkg_viewer	Interactive 3D viewer for asset packages
client	World Engine game client
asset_cooker	Asset processing and packaging tool

Commands

we <app> [args...]     # Run app (auto-updates if new version available)
we update <app>        # Force update an app
we list                # List available apps
we installed           # Show installed apps with versions
we clean               # Clean download cache
we help                # Show help

Configuration

Environment Variable	Description	Default
WE_HOME	Installation directory	~/.world-engine (Unix) or %LOCALAPPDATA%\WorldEngine (Windows)
WE_CONFIG	Build configuration	release

Using Debug Builds

# Unix
WE_CONFIG=debug we gui_test

# Windows (PowerShell)
$env:WE_CONFIG="debug"; we gui_test

How It Works

1. First run: Installs the we script to ~/.world-engine/bin/
2. Running an app:
   • Checks GitHub for latest release
   • Downloads only if there's a new version
   • Caches downloads locally
   • Extracts and runs the app
3. Subsequent runs: Uses cached version unless newer release available

File Locations

macOS / Linux

~/.world-engine/
├── bin/we           # The launcher script
├── apps/            # Installed applications
│   └── gui_test/
│       ├── version.txt
│       └── gui_test.app/  (macOS)
│       └── gui_test       (Linux)
└── cache/           # Downloaded archives

Windows

%LOCALAPPDATA%\WorldEngine\
├── bin\
│   ├── we.ps1       # PowerShell script
│   └── we.cmd       # CMD wrapper
├── apps\            # Installed applications
│   └── gui_test\
│       ├── version.txt
│       └── gui_test.exe
└── cache\           # Downloaded archives

Adding to PATH

macOS / Linux (bash/zsh)

echo 'export PATH="$HOME/.world-engine/bin:$PATH"' >> ~/.bashrc  # or ~/.zshrc
source ~/.bashrc

Windows (PowerShell)

[Environment]::SetEnvironmentVariable('PATH', $env:PATH + ';' + "$env:LOCALAPPDATA\WorldEngine\bin", 'User')
# Restart terminal

Troubleshooting

macOS: "App is damaged" or Gatekeeper warning

The we script automatically removes quarantine attributes. If you still see warnings:

xattr -cr ~/.world-engine/apps/

Windows: SmartScreen warning

The executables are signed with an EV certificate, so SmartScreen should not block them. If it does, click "More info" → "Run anyway".

Windows Defender performance

For better performance, add an exclusion:

Add-MpPreference -ExclusionPath "$env:LOCALAPPDATA\WorldEngine"

Can't check for updates

Make sure you have internet access. The tool will use cached versions if it can't reach GitHub.

Internal Use Only

This tool is for internal World Engine team use. The GitHub PAT embedded in the scripts has read-only access to releases.

we.ps1

# World Engine Tool Launcher (we)
# Downloads, caches, and runs World Engine tools from GitHub releases
#
# Usage:
#   we <app> [args...]     Run app (auto-updates if new version available)
#   we update <app>        Force update an app
#   we list                List available apps
#   we clean               Clean download cache
#   we help                Show this help
#
# One-liner install:
#   irm https://gist.githubusercontent.com/USER/GIST_ID/raw/we.ps1 | iex
#   we gui_test
#

# ============================================================================
# Configuration
# ============================================================================
$script:REPO = "GoNeuralAI/world-engine"
# Fine-grained PAT with contents:read permission only
$script:PAT = "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"
$script:WE_HOME = if ($env:WE_HOME) { $env:WE_HOME } else { "$env:LOCALAPPDATA\WorldEngine" }
$script:CONFIG = if ($env:WE_CONFIG) { $env:WE_CONFIG } else { "release" }
$script:AVAILABLE_APPS = @("gpu_info", "gui_test", "pkg_viewer", "client", "asset_cooker")

# ============================================================================
# Helper Functions
# ============================================================================
function Write-Log {
    param([string]$Message)
    Write-Host "[we] $Message" -ForegroundColor Cyan
}

function Write-Err {
    param([string]$Message)
    Write-Host "[we] ERROR: $Message" -ForegroundColor Red
    exit 1
}

function Ensure-Dirs {
    $dirs = @(
        "$script:WE_HOME\apps",
        "$script:WE_HOME\cache",
        "$script:WE_HOME\bin"
    )
    foreach ($dir in $dirs) {
        if (-not (Test-Path $dir)) {
            New-Item -ItemType Directory -Path $dir -Force | Out-Null
        }
    }
}

function Get-ReleaseInfo {
    param([string]$App)

    $headers = @{
        "Authorization" = "token $script:PAT"
        "Accept" = "application/vnd.github.v3+json"
    }

    try {
        $response = Invoke-RestMethod -Uri "https://api.github.com/repos/$script:REPO/releases/tags/$App" `
            -Headers $headers -ErrorAction Stop
        return $response
    }
    catch {
        return $null
    }
}

function Get-VersionFromRelease {
    param($ReleaseInfo)

    if ($ReleaseInfo -and $ReleaseInfo.name) {
        # Extract version from "app_name (version)"
        if ($ReleaseInfo.name -match '\(([^)]+)\)') {
            return $matches[1]
        }
    }
    return $null
}

function Find-Asset {
    param($ReleaseInfo, [string]$Pattern)

    foreach ($asset in $ReleaseInfo.assets) {
        if ($asset.name -like "*$Pattern*") {
            return @{
                Id = $asset.id
                Name = $asset.name
            }
        }
    }
    return $null
}

function Download-Asset {
    param([int]$AssetId, [string]$OutputPath)

    $headers = @{
        "Authorization" = "token $script:PAT"
        "Accept" = "application/octet-stream"
    }

    Write-Log "Downloading..."

    # Use WebClient for download progress
    $webClient = New-Object System.Net.WebClient
    $webClient.Headers.Add("Authorization", "token $script:PAT")
    $webClient.Headers.Add("Accept", "application/octet-stream")

    # GitHub API redirects, so we need to follow
    $uri = "https://api.github.com/repos/$script:REPO/releases/assets/$AssetId"

    try {
        # Get redirect URL
        $request = [System.Net.HttpWebRequest]::Create($uri)
        $request.Headers.Add("Authorization", "token $script:PAT")
        $request.Accept = "application/octet-stream"
        $request.AllowAutoRedirect = $false
        $response = $request.GetResponse()
        $redirectUrl = $response.GetResponseHeader("Location")
        $response.Close()

        if ($redirectUrl) {
            # Download from redirect URL
            Invoke-WebRequest -Uri $redirectUrl -OutFile $OutputPath -UseBasicParsing
        }
        else {
            Write-Err "Failed to get download URL"
        }
    }
    catch {
        Write-Err "Download failed: $_"
    }
}

function Install-App {
    param([string]$App, [string]$Archive)

    $appDir = "$script:WE_HOME\apps\$App"

    # Clean previous installation
    if (Test-Path $appDir) {
        Remove-Item -Recurse -Force $appDir
    }
    New-Item -ItemType Directory -Path $appDir -Force | Out-Null

    Write-Log "Extracting..."
    Expand-Archive -Path $Archive -DestinationPath $appDir -Force

    # Handle Windows Defender
    try {
        $exclusionPath = $script:WE_HOME
        $existingExclusions = Get-MpPreference -ErrorAction SilentlyContinue | Select-Object -ExpandProperty ExclusionPath

        if ($existingExclusions -notcontains $exclusionPath) {
            Write-Log "Note: You may want to add Windows Defender exclusion for better performance:"
            Write-Log "  Add-MpPreference -ExclusionPath '$exclusionPath'"
        }
    }
    catch {
        # Windows Defender cmdlets not available, skip
    }
}

function Get-BinaryPath {
    param([string]$App)
    return "$script:WE_HOME\apps\$App\$App.exe"
}

# ============================================================================
# Commands
# ============================================================================
function Show-Help {
    @"
World Engine Tool Launcher (we)

Usage:
  we <app> [args...]     Run app (auto-updates if new version available)
  we update <app>        Force update an app
  we list                List available apps
  we clean               Clean download cache
  we installed           List installed apps with versions
  we help                Show this help

Available apps:
  gpu_info      - GPU information tool
  gui_test      - GUI testing application
  pkg_viewer    - Package viewer
  client        - Game engine client
  asset_cooker  - Asset processing tool

Environment variables:
  WE_HOME       Installation directory (default: %LOCALAPPDATA%\WorldEngine)
  WE_CONFIG     Build config: release or debug (default: release)

Examples:
  we gui_test                    # Run gui_test
  we gui_test --help             # Pass args to gui_test
  `$env:WE_CONFIG="debug"; we client  # Run debug build
  we update gui_test             # Force update
"@
}

function Show-List {
    Write-Host "Available apps:"
    foreach ($app in $script:AVAILABLE_APPS) {
        Write-Host "  $app"
    }
}

function Show-Installed {
    Write-Host "Installed apps:"
    foreach ($app in $script:AVAILABLE_APPS) {
        $versionFile = "$script:WE_HOME\apps\$app\version.txt"
        if (Test-Path $versionFile) {
            $version = Get-Content $versionFile -Raw
            Write-Host "  $app ($($version.Trim()))"
        }
    }
}

function Invoke-Clean {
    Write-Log "Cleaning cache..."
    $cachePath = "$script:WE_HOME\cache"
    if (Test-Path $cachePath) {
        Remove-Item -Recurse -Force $cachePath
    }
    Write-Log "Cache cleaned"
}

function Invoke-Update {
    param([string]$App)

    if (-not $App) {
        Write-Err "Usage: we update <app>"
    }

    # Remove version file to force update
    $versionFile = "$script:WE_HOME\apps\$App\version.txt"
    if (Test-Path $versionFile) {
        Remove-Item $versionFile
    }

    Invoke-Run -App $App
}

function Invoke-Run {
    param(
        [string]$App,
        [string[]]$AppArgs = @()
    )

    if (-not $App) {
        Show-Help
        return
    }

    # Validate app name
    if ($App -notin $script:AVAILABLE_APPS) {
        Write-Err "Unknown app: $App. Run 'we list' to see available apps."
    }

    Ensure-Dirs

    $versionFile = "$script:WE_HOME\apps\$App\version.txt"
    $localVersion = ""
    if (Test-Path $versionFile) {
        $localVersion = (Get-Content $versionFile -Raw).Trim()
    }

    # Get latest release info
    Write-Log "Checking for updates..."
    $releaseInfo = Get-ReleaseInfo -App $App

    if (-not $releaseInfo) {
        if ($localVersion) {
            Write-Log "Could not check for updates, using cached version"
        }
        else {
            Write-Err "Release not found for $App. The release may not exist yet."
        }
    }
    else {
        $latestVersion = Get-VersionFromRelease -ReleaseInfo $releaseInfo

        if ($localVersion -ne $latestVersion) {
            Write-Log "Updating $App: $localVersion -> $latestVersion"

            # Find matching asset
            $assetPattern = "$App-windows-$script:CONFIG-"
            $asset = Find-Asset -ReleaseInfo $releaseInfo -Pattern $assetPattern

            if (-not $asset) {
                Write-Err "No matching asset found for pattern: $assetPattern"
            }

            # Download
            $cacheFile = "$script:WE_HOME\cache\$($asset.Name)"
            New-Item -ItemType Directory -Path "$script:WE_HOME\cache" -Force | Out-Null
            Download-Asset -AssetId $asset.Id -OutputPath $cacheFile

            # Install
            Install-App -App $App -Archive $cacheFile

            # Save version
            $latestVersion | Out-File -FilePath $versionFile -NoNewline
            Write-Log "$App updated to $latestVersion"
        }
        else {
            Write-Log "$App is up to date ($localVersion)"
        }
    }

    # Run the app
    $binary = Get-BinaryPath -App $App

    if (-not (Test-Path $binary)) {
        Write-Err "Binary not found: $binary"
    }

    & $binary @AppArgs
}

function Invoke-Bootstrap {
    Ensure-Dirs

    $weScript = "$script:WE_HOME\bin\we.ps1"
    $weCmd = "$script:WE_HOME\bin\we.cmd"

    Write-Log "Installing 'we' command..."

    # Download this script
    $gistUrl = "https://gist.githubusercontent.com/__GIST_USER__/__GIST_ID__/raw/we.ps1"
    try {
        Invoke-WebRequest -Uri $gistUrl -OutFile $weScript -UseBasicParsing
    }
    catch {
        # If gist URL fails, copy from current invocation if possible
        $scriptContent = $MyInvocation.MyCommand.ScriptBlock.ToString()
        if ($scriptContent) {
            $scriptContent | Out-File -FilePath $weScript -Encoding UTF8
        }
    }

    # Create .cmd wrapper
    @"
@echo off
powershell -ExecutionPolicy Bypass -File "%~dp0we.ps1" %*
"@ | Out-File -FilePath $weCmd -Encoding ASCII

    Write-Log "Installed to: $weScript"

    # Check if already in PATH
    $binPath = "$script:WE_HOME\bin"
    $currentPath = [Environment]::GetEnvironmentVariable("PATH", "User")

    if ($currentPath -notlike "*$binPath*") {
        Write-Log ""
        Write-Log "Add to PATH by running (requires new terminal):"
        Write-Log "  `$env:PATH += `";$binPath`""
        Write-Log "  [Environment]::SetEnvironmentVariable('PATH', `$env:PATH + ';$binPath', 'User')"
        Write-Log ""
        Write-Log "Or run directly: $weCmd <app>"
    }
    else {
        Write-Log "'we' command is ready to use"
    }
}

# ============================================================================
# Main
# ============================================================================
function Main {
    param([string[]]$Arguments)

    # If being piped (no args, not interactive), bootstrap
    if ($Arguments.Count -eq 0) {
        # Check if running interactively
        $isInteractive = [Environment]::UserInteractive -and -not $Host.Name.Contains("ISE")
        if (-not $isInteractive -or $MyInvocation.InvocationName -eq "&") {
            Invoke-Bootstrap
            return
        }
        Show-Help
        return
    }

    $command = $Arguments[0]
    $remaining = if ($Arguments.Count -gt 1) { $Arguments[1..($Arguments.Count-1)] } else { @() }

    switch ($command) {
        { $_ -in @("help", "--help", "-h", "/?") } {
            Show-Help
        }
        "list" {
            Show-List
        }
        "installed" {
            Show-Installed
        }
        "clean" {
            Invoke-Clean
        }
        "update" {
            if ($remaining.Count -gt 0) {
                Invoke-Update -App $remaining[0]
            }
            else {
                Write-Err "Usage: we update <app>"
            }
        }
        { $_ -in @("bootstrap", "install") } {
            Invoke-Bootstrap
        }
        default {
            Invoke-Run -App $command -AppArgs $remaining
        }
    }
}

# Handle invocation
if ($MyInvocation.InvocationName -ne ".") {
    Main -Arguments $args
}

we.sh

#!/bin/bash
# World Engine Tool Launcher (we)
# Downloads, caches, and runs World Engine tools from GitHub releases
#
# Usage:
#   we <app> [args...]     Run app (auto-updates if new version available)
#   we update <app>        Force update an app
#   we list                List available apps
#   we clean               Clean download cache
#   we help                Show this help
#
# One-liner install:
#   curl -fsSL https://gist.githubusercontent.com/USER/GIST_ID/raw/we.sh | bash
#   we gui_test
#
set -e

# ============================================================================
# Configuration
# ============================================================================
REPO="GoNeuralAI/world-engine"
# Fine-grained PAT with contents:read permission only
PAT="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"
WE_HOME="${WE_HOME:-$HOME/.world-engine}"
CONFIG="${WE_CONFIG:-release}"  # Can be overridden: WE_CONFIG=debug we gui_test
AVAILABLE_APPS="gpu_info gui_test pkg_viewer client asset_cooker"

# ============================================================================
# Detect Platform
# ============================================================================
detect_platform() {
    local os
    os=$(uname -s | tr '[:upper:]' '[:lower:]')
    case "$os" in
        darwin) echo "macos" ;;
        linux)  echo "linux" ;;
        *)      echo "Unsupported OS: $os" >&2; exit 1 ;;
    esac
}

PLATFORM=$(detect_platform)

# ============================================================================
# Helper Functions
# ============================================================================
log() {
    echo "[we] $*" >&2
}

error() {
    echo "[we] ERROR: $*" >&2
    exit 1
}

ensure_dirs() {
    mkdir -p "$WE_HOME/apps" "$WE_HOME/cache" "$WE_HOME/bin"
}

# Get release info from GitHub API
get_release_info() {
    local app="$1"
    curl -sfL -H "Authorization: token $PAT" \
        -H "Accept: application/vnd.github.v3+json" \
        "https://api.github.com/repos/$REPO/releases/tags/$app" 2>/dev/null
}

# Extract version from release name: "app_name (version)" -> "version"
extract_version() {
    local release_info="$1"
    echo "$release_info" | grep -o '"name":[[:space:]]*"[^"]*"' | head -1 | sed 's/.*(\([^)]*\)).*/\1/'
}

# Find asset ID and name matching pattern
find_asset() {
    local release_info="$1"
    local pattern="$2"

    # Use jq if available, otherwise fall back to grep/sed
    if command -v jq &>/dev/null; then
        echo "$release_info" | jq -r --arg p "$pattern" \
            '.assets[] | select(.name | contains($p)) | "\(.id) \(.name)"' | head -1
    else
        # Fallback: extract asset info using grep/sed
        local assets
        assets=$(echo "$release_info" | tr ',' '\n' | grep -A5 '"name":.*'"$pattern")
        local id name
        id=$(echo "$assets" | grep -o '"id":[[:space:]]*[0-9]*' | head -1 | grep -o '[0-9]*')
        name=$(echo "$assets" | grep -o '"name":[[:space:]]*"[^"]*'"$pattern"'[^"]*"' | head -1 | sed 's/"name":[[:space:]]*"//;s/"//')
        echo "$id $name"
    fi
}

# Download asset from GitHub
download_asset() {
    local asset_id="$1"
    local output="$2"

    log "Downloading..."
    curl -#fL -H "Authorization: token $PAT" \
        -H "Accept: application/octet-stream" \
        "https://api.github.com/repos/$REPO/releases/assets/$asset_id" \
        -o "$output"
}

# Extract and install app
install_app() {
    local app="$1"
    local archive="$2"
    local app_dir="$WE_HOME/apps/$app"

    # Clean previous installation
    rm -rf "$app_dir"
    mkdir -p "$app_dir"

    if [[ "$PLATFORM" == "macos" ]]; then
        # macOS: Mount DMG, copy .app bundle
        log "Mounting DMG..."
        local mount_output mount_point

        mount_output=$(hdiutil attach "$archive" -nobrowse -readonly 2>&1)
        mount_point=$(echo "$mount_output" | grep -o '/Volumes/[^[:space:]]*' | tail -1)

        if [[ -z "$mount_point" ]]; then
            error "Failed to mount DMG: $mount_output"
        fi

        log "Copying application..."
        cp -R "$mount_point"/*.app "$app_dir/" 2>/dev/null || true

        hdiutil detach "$mount_point" -quiet 2>/dev/null || true

        # Remove quarantine attribute
        log "Removing quarantine attributes..."
        xattr -cr "$app_dir" 2>/dev/null || true
    else
        # Linux: Extract ZIP
        log "Extracting..."
        unzip -qo "$archive" -d "$app_dir"
        chmod +x "$app_dir/$app" 2>/dev/null || true
        # Also make any .so files accessible
        chmod +x "$app_dir"/*.so 2>/dev/null || true
    fi
}

# Get binary path for an app
get_binary_path() {
    local app="$1"
    local app_dir="$WE_HOME/apps/$app"

    if [[ "$PLATFORM" == "macos" ]]; then
        echo "$app_dir/$app.app/Contents/MacOS/$app"
    else
        echo "$app_dir/$app"
    fi
}

# ============================================================================
# Commands
# ============================================================================
cmd_help() {
    cat <<'EOF'
World Engine Tool Launcher (we)

Usage:
  we <app> [args...]     Run app (auto-updates if new version available)
  we update <app>        Force update an app
  we list                List available apps
  we clean               Clean download cache
  we installed           List installed apps with versions
  we help                Show this help

Available apps:
  gpu_info      - GPU information tool
  gui_test      - GUI testing application
  pkg_viewer    - Package viewer
  client        - Game engine client
  asset_cooker  - Asset processing tool

Environment variables:
  WE_HOME       Installation directory (default: ~/.world-engine)
  WE_CONFIG     Build config: release or debug (default: release)

Examples:
  we gui_test                    # Run gui_test
  we gui_test --help             # Pass args to gui_test
  WE_CONFIG=debug we client      # Run debug build
  we update gui_test             # Force update
EOF
}

cmd_list() {
    echo "Available apps:"
    for app in $AVAILABLE_APPS; do
        echo "  $app"
    done
}

cmd_installed() {
    echo "Installed apps:"
    for app in $AVAILABLE_APPS; do
        local version_file="$WE_HOME/apps/$app/version.txt"
        if [[ -f "$version_file" ]]; then
            local version
            version=$(cat "$version_file")
            echo "  $app ($version)"
        fi
    done
}

cmd_clean() {
    log "Cleaning cache..."
    rm -rf "$WE_HOME/cache"
    log "Cache cleaned"
}

cmd_update() {
    local app="$1"
    if [[ -z "$app" ]]; then
        error "Usage: we update <app>"
    fi

    # Remove version file to force update
    rm -f "$WE_HOME/apps/$app/version.txt"
    cmd_run "$app"
}

cmd_run() {
    local app="$1"
    shift || true

    if [[ -z "$app" ]]; then
        cmd_help
        exit 1
    fi

    # Validate app name
    if ! echo "$AVAILABLE_APPS" | grep -qw "$app"; then
        error "Unknown app: $app. Run 'we list' to see available apps."
    fi

    ensure_dirs

    local version_file="$WE_HOME/apps/$app/version.txt"
    local local_version=""
    [[ -f "$version_file" ]] && local_version=$(cat "$version_file")

    # Get latest release info
    log "Checking for updates..."
    local release_info
    release_info=$(get_release_info "$app")

    if [[ -z "$release_info" ]] || echo "$release_info" | grep -q '"message":.*"Not Found"'; then
        if [[ -n "$local_version" ]]; then
            log "Could not check for updates, using cached version"
        else
            error "Release not found for $app. The release may not exist yet."
        fi
    else
        local latest_version
        latest_version=$(extract_version "$release_info")

        if [[ "$local_version" != "$latest_version" ]]; then
            log "Updating $app: $local_version -> $latest_version"

            # Find matching asset
            local asset_pattern="$app-$PLATFORM-$CONFIG-"
            local asset_info
            asset_info=$(find_asset "$release_info" "$asset_pattern")

            if [[ -z "$asset_info" ]]; then
                error "No matching asset found for pattern: $asset_pattern"
            fi

            local asset_id asset_name
            asset_id=$(echo "$asset_info" | awk '{print $1}')
            asset_name=$(echo "$asset_info" | awk '{print $2}')

            if [[ -z "$asset_id" ]] || [[ -z "$asset_name" ]]; then
                error "Failed to parse asset info"
            fi

            # Download
            local cache_file="$WE_HOME/cache/$asset_name"
            download_asset "$asset_id" "$cache_file"

            # Install
            install_app "$app" "$cache_file"

            # Save version
            echo "$latest_version" > "$version_file"
            log "$app updated to $latest_version"
        else
            log "$app is up to date ($local_version)"
        fi
    fi

    # Run the app
    local binary
    binary=$(get_binary_path "$app")

    if [[ ! -x "$binary" ]]; then
        error "Binary not found or not executable: $binary"
    fi

    exec "$binary" "$@"
}

# ============================================================================
# Bootstrap: Install 'we' command
# ============================================================================
cmd_bootstrap() {
    ensure_dirs

    local we_script="$WE_HOME/bin/we"

    # Download latest version of this script
    log "Installing 'we' command..."

    # Copy this script to the bin directory
    if [[ -n "${BASH_SOURCE[0]}" ]] && [[ -f "${BASH_SOURCE[0]}" ]]; then
        cp "${BASH_SOURCE[0]}" "$we_script"
    else
        # Being piped, download from gist
        curl -sfL "https://gist.githubusercontent.com/__GIST_USER__/__GIST_ID__/raw/we.sh" -o "$we_script"
    fi

    chmod +x "$we_script"

    log "Installed to: $we_script"

    # Check if already in PATH
    if command -v we &>/dev/null; then
        log "'we' command is ready to use"
    else
        log ""
        log "Add to PATH by running:"
        log "  echo 'export PATH=\"\$HOME/.world-engine/bin:\$PATH\"' >> ~/.${SHELL##*/}rc"
        log "  source ~/.${SHELL##*/}rc"
        log ""
        log "Or run directly: $we_script <app>"
    fi
}

# ============================================================================
# Main
# ============================================================================
main() {
    # If no args and script is being piped, bootstrap
    if [[ $# -eq 0 ]]; then
        if [[ ! -t 0 ]]; then
            cmd_bootstrap
            exit 0
        fi
        cmd_help
        exit 0
    fi

    case "$1" in
        help|--help|-h)
            cmd_help
            ;;
        list)
            cmd_list
            ;;
        installed)
            cmd_installed
            ;;
        clean)
            cmd_clean
            ;;
        update)
            shift
            cmd_update "$@"
            ;;
        bootstrap|install)
            cmd_bootstrap
            ;;
        *)
            cmd_run "$@"
            ;;
    esac
}

main "$@"