更新 .gitignore 文件以排除测试脚本；修改 README.md 中的安装链接和命令行选项描述；在 main.rs 中添加对目标 URL 的规范化支持，并增强参数的灵活性；新增 CONTRIBUTING.md 文件以指导贡献流程。

Author: jamiesun

.gitignore

@@ -14,3 +14,7 @@ Cargo.lock
 # OS
 .DS_Store
 Thumbs.db
+
+# Test scripts
+test_target_formats.sh
+manual_test.sh

CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# Contributing to apxy
+
+Thank you for your interest in contributing to apxy! 🎉
+
+## Development Setup
+
+### Prerequisites
+
+- Rust 1.70 or later
+- cargo
+
+### Clone and Build
+
+```bash
+git clone https://github.com/talkincode/apxy
+cd apxy
+cargo build
+```
+
+### Run Tests
+
+```bash
+cargo test
+cargo clippy
+cargo fmt --check
+```
+
+## Making Changes
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Make your changes
+4. Run tests: `cargo test`
+5. Format code: `cargo fmt`
+6. Check lints: `cargo clippy`
+7. Commit: `git commit -am 'Add some feature'`
+8. Push: `git push origin feature/my-feature`
+9. Create a Pull Request
+
+## Code Style
+
+- Follow standard Rust formatting (use `cargo fmt`)
+- Keep functions small and focused
+- Add comments for complex logic
+- Update documentation for API changes
+
+## Pull Request Process
+
+1. Update README.md if needed
+2. Update version in Cargo.toml following semver
+3. Ensure CI passes
+4. Request review
+
+## Report Bugs
+
+Open an issue with:
+
+- OS and architecture
+- apxy version
+- Steps to reproduce
+- Expected vs actual behavior
+
+## Feature Requests
+
+Open an issue describing:
+
+- The problem you're trying to solve
+- Your proposed solution
+- Any alternatives considered
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.

README.md

@@ -22,22 +22,22 @@ cargo install apxy
 
 ```bash
 # Linux/macOS ARM64
-curl -L https://github.com/YOUR_USERNAME/apxy/releases/latest/download/apxy-aarch64-unknown-linux-musl -o apxy
+curl -L https://github.com/talkincode/apxy/releases/latest/download/apxy-aarch64-unknown-linux-musl -o apxy
 chmod +x apxy
 sudo mv apxy /usr/local/bin/
 
 # Linux AMD64
-curl -L https://github.com/YOUR_USERNAME/apxy/releases/latest/download/apxy-x86_64-unknown-linux-musl -o apxy
+curl -L https://github.com/talkincode/apxy/releases/latest/download/apxy-x86_64-unknown-linux-musl -o apxy
 chmod +x apxy
 sudo mv apxy /usr/local/bin/
 
 # macOS ARM64
-curl -L https://github.com/YOUR_USERNAME/apxy/releases/latest/download/apxy-aarch64-apple-darwin -o apxy
+curl -L https://github.com/talkincode/apxy/releases/latest/download/apxy-aarch64-apple-darwin -o apxy
 chmod +x apxy
 sudo mv apxy /usr/local/bin/
 
 # macOS AMD64
-curl -L https://github.com/YOUR_USERNAME/apxy/releases/latest/download/apxy-x86_64-apple-darwin -o apxy
+curl -L https://github.com/talkincode/apxy/releases/latest/download/apxy-x86_64-apple-darwin -o apxy
 chmod +x apxy
 sudo mv apxy /usr/local/bin/
 ```
@@ -47,10 +47,20 @@ sudo mv apxy /usr/local/bin/
 ### Basic Proxy (No Authentication)
 
 ```bash
+# Full URL format
 apxy --target http://localhost:3000
+
+# Shorthand: just port number
+apxy --target 3000
+
+# Shorthand: with colon
+apxy --target :3000
+
+# Shorthand: localhost with port
+apxy --target localhost:3000
 ```
 
-This will start a proxy on port 8080 that forwards all requests to `http://localhost:3000`.
+All the above commands will proxy to `http://localhost:3000`. This will start a proxy on port 8080 that forwards all requests.
 
 ### With Authentication
 
@@ -89,15 +99,26 @@ apxy \
 
 ## Command Line Options
 
-```
+```text
 Options:
   -p, --port <PORT>              Port to listen on [default: 8080]
-  -t, --target <TARGET>          Target URL to proxy to
+  -t, --target <TARGET>          Target URL to proxy to (supports shorthand: port, :port, localhost:port, or full URL)
   -a, --auth-token <AUTH_TOKEN>  Authentication token
   -h, --help                     Print help
   -V, --version                  Print version
 ```
 
+### Target Format Examples
+
+The `--target` parameter supports various formats for convenience:
+
+- **Port only**: `3000` → `http://localhost:3000`
+- **With colon**: `:3000` → `http://localhost:3000`
+- **Host:port**: `localhost:3000` → `http://localhost:3000`
+- **Full URL**: `http://localhost:3000` → `http://localhost:3000`
+- **Remote**: `example.com:8080` → `http://example.com:8080`
+- **HTTPS**: `https://api.example.com` → `https://api.example.com`
+
 ## Use Cases
 
 - Add authentication layer to existing services
@@ -108,7 +129,7 @@ Options:
 ## Building from Source
 
 ```bash
-git clone https://github.com/YOUR_USERNAME/apxy
+git clone https://github.com/talkincode/apxy
 cd apxy
 cargo build --release
 ```

src/main.rs

@@ -8,20 +8,28 @@ use hyper_util::rt::TokioIo;
 use std::net::SocketAddr;
 use tokio::net::TcpListener;
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, Clone)]
 #[command(author, version, about, long_about = None)]
 struct Args {
     /// Port to listen on
     #[arg(short, long, default_value = "8080")]
     port: u16,
 
-    /// Target URL to proxy to
+    /// Target URL to proxy to (supports shorthand: port, :port, localhost:port, or full URL)
     #[arg(short, long)]
     target: String,
 
-    /// Authentication token (can be passed via URL param 'token' or header 'X-Auth-Token')
+    /// Authentication token (can be passed via URL param or header)
     #[arg(short, long)]
     auth_token: Option<String>,
+
+    /// URL parameter name for authentication token
+    #[arg(long, default_value = "token")]
+    auth_param: String,
+
+    /// Header name for authentication token
+    #[arg(long, default_value = "X-Auth-Token")]
+    auth_header: String,
 }
 
 type BoxBody = http_body_util::combinators::BoxBody<Bytes, hyper::Error>;
@@ -32,10 +40,40 @@ fn full<T: Into<Bytes>>(chunk: T) -> BoxBody {
         .boxed()
 }
 
+/// Normalize target URL from various shorthand formats
+fn normalize_target(target: &str) -> String {
+    let target = target.trim();
+    
+    // If it already starts with http:// or https://, return as is
+    if target.starts_with("http://") || target.starts_with("https://") {
+        return target.to_string();
+    }
+    
+    // If it's just a port number (e.g., "3000")
+    if target.parse::<u16>().is_ok() {
+        return format!("http://localhost:{}", target);
+    }
+    
+    // If it starts with : (e.g., ":3000")
+    if target.starts_with(':') {
+        return format!("http://localhost{}", target);
+    }
+    
+    // If it's localhost:port or 127.0.0.1:port format (no protocol)
+    if !target.contains("://") {
+        return format!("http://{}", target);
+    }
+    
+    // Default: assume it's meant to be http
+    format!("http://{}", target)
+}
+
 async fn handle_request(
     req: Request<Incoming>,
     target: String,
     auth_token: Option<String>,
+    auth_param: String,
+    auth_header: String,
 ) -> Result<Response<BoxBody>, hyper::Error> {
     // Check authentication if token is set
     if let Some(expected_token) = &auth_token {
@@ -45,7 +83,7 @@ async fn handle_request(
         if let Some(query) = req.uri().query() {
             for pair in query.split('&') {
                 if let Some((key, value)) = pair.split_once('=') {
-                    if key == "token" && value == expected_token {
+                    if key == auth_param && value == expected_token {
                         authenticated = true;
                         break;
                     }
@@ -55,7 +93,7 @@ async fn handle_request(
 
         // Check header
         if !authenticated {
-            if let Some(header_token) = req.headers().get("x-auth-token") {
+            if let Some(header_token) = req.headers().get(auth_header.to_lowercase().as_str()) {
                 if header_token.to_str().unwrap_or("") == expected_token {
                     authenticated = true;
                 }
@@ -122,23 +160,30 @@ async fn handle_request(
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = Args::parse();
+    
+    // Normalize target URL to support shorthand formats
+    let target = normalize_target(&args.target);
 
     let addr: SocketAddr = ([0, 0, 0, 0], args.port).into();
     let listener = TcpListener::bind(addr).await?;
 
     println!("🚀 apxy listening on http://{}", addr);
-    println!("📡 Proxying to: {}", args.target);
+    println!("📡 Proxying to: {}", target);
     if args.auth_token.is_some() {
         println!("🔒 Authentication: enabled");
+        println!("   URL param: {}", args.auth_param);
+        println!("   Header: {}", args.auth_header);
     } else {
         println!("⚠️  Authentication: disabled");
     }
 
     loop {
         let (stream, _) = listener.accept().await?;
         let io = TokioIo::new(stream);
-        let target = args.target.clone();
+        let target = target.clone();
         let auth_token = args.auth_token.clone();
+        let auth_param = args.auth_param.clone();
+        let auth_header = args.auth_header.clone();
 
         tokio::spawn(async move {
             if let Err(err) = http1::Builder::new()
@@ -147,7 +192,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     service_fn(move |req| {
                         let target = target.clone();
                         let auth_token = auth_token.clone();
-                        handle_request(req, target, auth_token)
+                        let auth_param = auth_param.clone();
+                        let auth_header = auth_header.clone();
+                        handle_request(req, target, auth_token, auth_param, auth_header)
                     }),
                 )
                 .await