Proxy Environment Variable Support by Runtime/Language

# proxychains4
sudo apt install proxychains4        # Ubuntu/Debian
brew install proxychains-ng          # macOS
sudo dnf install proxychains-ng      # Fedora

# tsocks
sudo apt install tsocks              # Ubuntu/Debian
brew install tsocks                  # macOS

# torify/torsocks
sudo apt install tor torsocks        # Ubuntu/Debian
brew install tor torsocks            # macOS

# gost
go install github.com/ginuerzh/gost/cmd/gost@latest

# v2ray
bash <(curl -L https://raw.githubusercontent.com/v2fly/fhs-install-v2ray/master/install-release.sh)

# brook
go install github.com/txthinking/brook/cmd/brook@latest

# Configure
sudo nano /etc/proxychains4.conf
# Add: socks5 127.0.0.1 1080

# Use
proxychains4 curl http://httpbin.org/ip
proxychains4 bun test.js
proxychains4 go run main.go

# Configure
sudo nano /etc/tsocks.conf
# Add: server = 127.0.0.1, server_port = 1080

# Use
tsocks curl http://httpbin.org/ip
tsocks node script.js

# SOCKS5 proxy
gost -L :8080 -F socks5://127.0.0.1:1080

# HTTP proxy  
gost -L :8080 -F http://proxy:8080

# Chain proxies
gost -L :8080 -F socks5://proxy1:1080 -F http://proxy2:8080

export HTTP_PROXY=http://proxy:8080
export SOCKS_PROXY=socks5://127.0.0.1:1080
with-proxy curl http://httpbin.org/ip
with-proxy bun script.js

// Option 1: global-agent (affects ALL modules)
const globalAgent = require('global-agent');
globalAgent.bootstrap();
process.env.GLOBAL_AGENT_HTTP_PROXY = 'http://proxy:8080';
process.env.GLOBAL_AGENT_HTTPS_PROXY = 'socks5://proxy:1080';

// Now ALL HTTP requests go through proxy automatically
const axios = require('axios');
const response = await axios.get('http://httpbin.org/ip'); // Uses proxy

// Option 2: proxy-agent (auto-detects proxy type)
const { ProxyAgent } = require('proxy-agent');
const agent = new ProxyAgent('socks5://proxy:1080');
const response = await fetch('http://httpbin.org/ip', { agent });

// Option 3: Create universal proxy wrapper
class UniversalProxy {
    constructor() {
        this.agents = new Map();
    }
    
    getAgent(url) {
        const proxyUrl = process.env.ALL_PROXY || process.env.HTTP_PROXY;
        if (!proxyUrl) return undefined;
        
        if (!this.agents.has(proxyUrl)) {
            if (proxyUrl.startsWith('socks')) {
                this.agents.set(proxyUrl, new (require('socks-proxy-agent').SocksProxyAgent)(proxyUrl));
            } else {
                this.agents.set(proxyUrl, new (require('https-proxy-agent').HttpsProxyAgent)(proxyUrl));
            }
        }
        return this.agents.get(proxyUrl);
    }
    
    async fetch(url, options = {}) {
        options.agent = this.getAgent(url);
        return fetch(url, options);
    }
}

// Option 1: Use built-in environment variable support
client := &http.Client{
    Transport: &http.Transport{
        Proxy: http.ProxyFromEnvironment, // Supports HTTP_PROXY, HTTPS_PROXY, ALL_PROXY
    },
}

// Option 2: Manual SOCKS5 setup
import "golang.org/x/net/proxy"
dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:1080", nil, proxy.Direct)
transport := &http.Transport{
    DialContext: dialer.DialContext,
}
client := &http.Client{Transport: transport}

// Option 3: Universal proxy function
func CreateProxyClient() *http.Client {
    proxyURL := os.Getenv("ALL_PROXY")
    if proxyURL == "" {
        proxyURL = os.Getenv("HTTP_PROXY")
    }
    
    if proxyURL != "" {
        if strings.HasPrefix(proxyURL, "socks5://") {
            // SOCKS5 proxy
            dialer, _ := proxy.SOCKS5("tcp", strings.TrimPrefix(proxyURL, "socks5://"), nil, proxy.Direct)
            return &http.Client{
                Transport: &http.Transport{DialContext: dialer.DialContext},
            }
        } else {
            // HTTP proxy
            return &http.Client{
                Transport: &http.Transport{Proxy: http.ProxyURL(mustParseURL(proxyURL))},
            }
        }
    }
    return &http.Client{}
}

// Option 1: Environment variable support (built-in)
let client = reqwest::Client::builder()
    .proxy(reqwest::Proxy::all(std::env::var("ALL_PROXY")?)?)
    .build()?;

// Option 2: Manual SOCKS5 configuration
use tokio_socks::tcp::Socks5Stream;
let proxy_stream = Socks5Stream::connect("127.0.0.1:1080", "httpbin.org:80").await?;

// Option 3: Universal proxy client
use std::env;
use reqwest::{Client, Proxy};

fn create_proxy_client() -> Result<Client, Box<dyn std::error::Error>> {
    let mut builder = Client::builder();
    
    if let Ok(proxy_url) = env::var("ALL_PROXY") {
        builder = builder.proxy(Proxy::all(&proxy_url)?);
    } else if let Ok(http_proxy) = env::var("HTTP_PROXY") {
        builder = builder.proxy(Proxy::http(&http_proxy)?);
    }
    
    Ok(builder.build()?)
}

(* SOCKS5 client implementation *)
module ProxyClient = struct
    type proxy_config = 
        | HTTP of Uri.t
        | SOCKS5 of string * int * (string * string) option
        | Direct
    
    let get_proxy_from_env () =
        match Sys.getenv_opt "ALL_PROXY" with
        | Some url when String.prefix ~pre:"socks5://" url -> 
            (* Parse SOCKS5 URL *)
            SOCKS5 ("127.0.0.1", 1080, None)
        | Some url -> HTTP (Uri.of_string url)
        | None -> 
            match Sys.getenv_opt "HTTP_PROXY" with
            | Some url -> HTTP (Uri.of_string url)
            | None -> Direct
    
    let make_request ~proxy_config ~uri =
        match proxy_config with
        | Direct -> Cohttp_lwt_unix.Client.get uri
        | HTTP proxy_uri -> 
            let resolver = Resolver.create ~proxy:proxy_uri () in
            Cohttp_lwt_unix.Client.get ~resolver uri
        | SOCKS5 (host, port, auth) ->
            (* Use lwt-socks or similar *)
            Socks_client.connect ~proxy:(`TCP (`IP (Ipaddr.of_string host), port)) 
                               ~target:(`Domain (Uri.host_with_default uri, 80)) ()
end