`d6e61b4`

Full CLI implementation with 6 commands, YAML/TOML config, integration tests, benchmarks, metrics collection, and comprehensive docs

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 8 months ago

SHA: d6e61b40bc453f8dd68350050024276ce6af56a5
Parents: 97d9f10
Tree: 3b9f8cb

17 changed files

Status	File	+
A	`CHANGELOG.md`	47
M	`Cargo.toml`	12
M	`README.md`	397
A	`benches/cli_benchmarks.rs`	196
A	`src/client.rs`	211
A	`src/commands/download.rs`	116
A	`src/commands/init.rs`	163
A	`src/commands/join.rs`	57
A	`src/commands/list.rs`	148
A	`src/commands/mod.rs`	21
A	`src/commands/status.rs`	156
A	`src/commands/upload.rs`	102
A	`src/config.rs`	142
A	`src/lib.rs`	8
A	`src/main.rs`	76
A	`src/metrics.rs`	301
A	`tests/integration_tests.rs`	234

CHANGELOG.mdadded

 +# Changelog
++
 +All notable changes to this project will be documented in this file.
++
 +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
++
 +## [Unreleased]
++
 +### Added
 +- Initial ZephyrFS CLI implementation
 +- Complete command set: init, join, upload, download, list, status
 +- YAML/TOML configuration support
 +- Interactive and non-interactive modes
 +- Progress bars for file operations
 +- Comprehensive metrics collection
 +- Performance benchmarking framework
 +- Integration test suite
 +- Detailed documentation and examples
++
 +### Features
 +- **Node Management**: Initialize and configure ZephyrFS nodes
 +- **Network Operations**: Join P2P networks with bootstrap peers
 +- **File Operations**: Upload/download with verification and progress tracking
 +- **Monitoring**: Real-time status monitoring with detailed metrics
 +- **Configuration**: Flexible YAML/TOML configuration system
 +- **Testing**: Comprehensive test suite with benchmarks
 +- **Documentation**: Complete user guide with examples
++
 +### Technical Details
 +- Built with Rust using Tokio async runtime
 +- HTTP client for coordinator API communication
 +- Progress tracking with indicatif
 +- Interactive CLI with dialoguer
 +- Configuration management with serde
 +- Metrics collection and analysis
 +- Criterion-based performance benchmarking
++
 +## [0.1.0] - 2024-09-12
++
 +### Added
 +- Initial release
 +- Basic CLI structure with clap
 +- Command framework implementation
 +- Configuration system foundation
 +- Client abstraction for node communication
 +- Test infrastructure setup

Cargo.tomlmodified

  serde = { version = "1.0", features = ["derive"] }
  serde_json = "1.0"
  serde_yaml = "0.9"
 +toml = "0.8"
  # Configuration
  config = "0.14"
  # Utilities
  humansize = "2.1"
  chrono = { version = "0.4", features = ["serde"] }
 +async-trait = "0.1"
 +lazy_static = "1.4"
++
 +[dev-dependencies]
 +tempfile = "3.8"
 +tokio-test = "0.4"
 +criterion = { version = "0.5", features = ["html_reports"] }
  [[bin]]
  name = "zephyrfs"
  path = "src/main.rs"
 +[[bench]]
 +name = "cli_benchmarks"
 +harness = false
++
  [profile.release]
  codegen-units = 1
  lto = true

README.mdmodified

 +# ZephyrFS CLI
++
 +Command-line interface for ZephyrFS distributed P2P storage network.
++
 +## Features
++
 +- =� **Easy Setup**: Initialize and configure nodes with interactive prompts
 +- = **Network Management**: Join and manage P2P network connections
 +- =� **File Operations**: Upload, download, and list files across the network
 +- =� **Monitoring**: Built-in metrics and status monitoring
 +- � **Performance**: Benchmarking and performance analysis tools
 +- =' **Configuration**: YAML/TOML configuration file support
++
 +## Installation
++
 +### From Source
++
 +```bash
 +git clone https://github.com/ZephyrFS/zephyrfs-cli.git
 +cd zephyrfs-cli
 +cargo build --release
 +```
++
 +The compiled binary will be available at `target/release/zephyrfs`.
++
 +### Using Cargo
++
 +```bash
 +cargo install zephyrfs-cli
 +```
++
 +## Quick Start
++
 +### 1. Initialize a Node
++
 +```bash
 +# Interactive setup
 +zephyrfs init
++
 +# Non-interactive with options
 +zephyrfs init --name my-node --port 8080 --storage 50
 +```
++
 +### 2. Join a Network
++
 +```bash
 +zephyrfs join 192.168.1.100:8081
 +```
++
 +### 3. Upload Files
++
 +```bash
 +zephyrfs upload /path/to/file.txt
 +zephyrfs upload large-file.zip --verify
 +```
++
 +### 4. List Files
++
 +```bash
 +zephyrfs list
 +zephyrfs list --long --sort size
 +```
++
 +### 5. Download Files
++
 +```bash
 +zephyrfs download a1b2c3d4e5f6... --output downloaded-file.txt
 +```
++
 +### 6. Check Status
++
 +```bash
 +zephyrfs status
 +zephyrfs status --detailed --watch 5
 +```
++
 +## Commands
++
 +### `init` - Initialize Node
++
 +Initialize a new ZephyrFS node with configuration.
++
 +```bash
 +zephyrfs init [OPTIONS]
++
 +Options:
 +  -n, --name <NAME>        Node name (optional)
 +  -d, --data-dir <DIR>     Data directory path
 +  -p, --port <PORT>        Listen port for the node
 +  -s, --storage <GB>       Maximum storage allocation in GB
 +      --no-interactive     Skip interactive configuration
 +```
++
 +### `join` - Join Network
++
 +Connect to an existing ZephyrFS network.
++
 +```bash
 +zephyrfs join <BOOTSTRAP_PEER> [OPTIONS]
++
 +Arguments:
 +  <BOOTSTRAP_PEER>    Bootstrap peer address (host:port)
++
 +Options:
 +  -t, --timeout <SECS>    Timeout in seconds [default: 30]
 +      --skip-test         Skip connectivity test
 +```
++
 +### `upload` - Upload Files
++
 +Upload files to the distributed network.
++
 +```bash
 +zephyrfs upload <FILE> [OPTIONS]
++
 +Arguments:
 +  <FILE>    File path to upload
++
 +Options:
 +  -n, --name <NAME>      Custom file name
 +      --progress         Show progress bar [default: true]
 +      --verify           Verify upload after completion
 +```
++
 +### `download` - Download Files
++
 +Download files from the network by hash.
++
 +```bash
 +zephyrfs download <FILE_HASH> [OPTIONS]
++
 +Arguments:
 +  <FILE_HASH>    File hash to download
++
 +Options:
 +  -o, --output <PATH>    Output file path
 +      --force            Overwrite existing file
 +      --progress         Show progress bar [default: true]
 +      --verify           Verify download integrity [default: true]
 +```
++
 +### `list` - List Files
++
 +List files available in the network.
++
 +```bash
 +zephyrfs list [OPTIONS]
++
 +Options:
 +  -l, --long                Show detailed information
 +  -s, --sort <COLUMN>       Sort by column (name, size, date, chunks) [default: name]
 +  -r, --reverse             Reverse sort order
 +  -f, --filter <PATTERN>    Filter by name pattern
 +      --format <FORMAT>     Output format (table, json, csv) [default: table]
 +```
++
 +### `status` - Node Status
++
 +Show node status and network information.
++
 +```bash
 +zephyrfs status [OPTIONS]
++
 +Options:
 +  -d, --detailed           Show detailed status information
 +      --format <FORMAT>    Output format (table, json) [default: table]
 +  -r, --watch <SECS>       Refresh interval in seconds (0 for single check) [default: 0]
 +```
++
 +## Configuration
++
 +ZephyrFS CLI uses a configuration file to store node settings. The default location is:
 +- Linux/macOS: `~/.config/zephyrfs/config.yaml`
 +- Windows: `%APPDATA%\\zephyrfs\\config.yaml`
++
 +### Configuration File Format
++
 +```yaml
 +node:
 +  id: null
 +  name: "my-zephyr-node"
 +  data_dir: "~/.zephyrfs"
 +  listen_port: 8080
++
 +network:
 +  bootstrap_peers:
 +    - "127.0.0.1:8081"
 +    - "127.0.0.1:8082"
 +  max_connections: 50
 +  connection_timeout: 30
++
 +storage:
 +  max_storage_gb: 10
 +  chunk_size_mb: 1
 +  replication_factor: 3
++
 +coordinator:
 +  endpoint: "http://127.0.0.1:9000"
 +  timeout: 30
 +  retry_attempts: 3
 +```
++
 +### TOML Configuration
++
 +You can also use TOML format by saving as `config.toml`:
++
 +```toml
 +[node]
 +name = "my-zephyr-node"
 +data_dir = "~/.zephyrfs"
 +listen_port = 8080
++
 +[network]
 +bootstrap_peers = ["127.0.0.1:8081", "127.0.0.1:8082"]
 +max_connections = 50
 +connection_timeout = 30
++
 +[storage]
 +max_storage_gb = 10
 +chunk_size_mb = 1
 +replication_factor = 3
++
 +[coordinator]
 +endpoint = "http://127.0.0.1:9000"
 +timeout = 30
 +retry_attempts = 3
 +```
++
 +## Examples
++
 +### Basic File Operations
++
 +```bash
 +# Initialize node with 100GB storage
 +zephyrfs init --storage 100 --name production-node
++
 +# Join production network
 +zephyrfs join prod.zephyrfs.net:8081
++
 +# Upload important files
 +zephyrfs upload documents.tar.gz --verify
 +zephyrfs upload photos/ --name family-photos
++
 +# List all files with details
 +zephyrfs list --long --sort date --reverse
++
 +# Download specific file
 +zephyrfs download abc123... --output restored-documents.tar.gz
 +```
++
 +### Monitoring and Maintenance
++
 +```bash
 +# Watch node status in real-time
 +zephyrfs status --detailed --watch 10
++
 +# Export metrics for analysis
 +zephyrfs status --format json > node-metrics.json
++
 +# Check network connectivity
 +zephyrfs join test.zephyrfs.net:8081 --skip-test false
 +```
++
 +### Batch Operations
++
 +```bash
 +# Upload multiple files
 +for file in /data/*.backup; do
 +    zephyrfs upload "$file" --verify
 +done
++
 +# List files in CSV format for processing
 +zephyrfs list --format csv > file-inventory.csv
 +```
++
 +## Performance
++
 +### Benchmarking
++
 +Run performance benchmarks:
++
 +```bash
 +cargo bench
 +```
++
 +This will generate HTML reports in `target/criterion/` with detailed performance analysis.
++
 +### Metrics
++
 +The CLI automatically collects performance metrics including:
 +- Command execution times
 +- Network request latencies
 +- File transfer speeds
 +- Memory and CPU usage
 +- Cache hit rates
++
 +View current metrics:
 +```bash
 +zephyrfs status --detailed --format json
 +```
++
 +## Testing
++
 +### Unit Tests
++
 +```bash
 +cargo test
 +```
++
 +### Integration Tests
++
 +```bash
 +cargo test --test integration_tests
 +```
++
 +Note: Some integration tests require running ZephyrFS nodes and are marked with `#[ignore]`. To run them:
++
 +```bash
 +cargo test --test integration_tests -- --ignored
 +```
++
 +## Troubleshooting
++
 +### Common Issues
++
 +**Connection Refused**
 +```
 +Error: Failed to connect to node
 +```
 +- Ensure the ZephyrFS node is running
 +- Check the listen port in configuration
 +- Verify firewall settings
++
 +**File Not Found**
 +```
 +Error: File not found: abc123...
 +```
 +- File may have been removed from the network
 +- Check file hash is correct
 +- Try listing files to see what's available
++
 +**Configuration Error**
 +```
 +Error: Failed to parse YAML config
 +```
 +- Validate YAML/TOML syntax
 +- Check file permissions
 +- Use `--config` flag to specify custom location
++
 +### Debug Mode
++
 +Enable verbose logging:
++
 +```bash
 +zephyrfs --verbose <command>
 +```
++
 +### Log Files
++
 +Check logs in the data directory:
 +- `~/.zephyrfs/logs/zephyrfs-cli.log`
++
 +## Development
++
 +### Building from Source
++
 +```bash
 +git clone https://github.com/ZephyrFS/zephyrfs-cli.git
 +cd zephyrfs-cli
 +cargo build
 +```
++
 +### Running Tests
++
 +```bash
 +cargo test --all-features
 +```
++
 +### Contributing
++
 +1. Fork the repository
 +2. Create a feature branch
 +3. Make your changes
 +4. Add tests
 +5. Run tests and benchmarks
 +6. Submit a pull request
++
 +## License
++
 +This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
++
 +## Related Projects
++
 +- [zephyrfs-node](https://github.com/ZephyrFS/zephyrfs-node) - Core P2P storage node
 +- [zephyrfs-coordinator](https://github.com/ZephyrFS/zephyrfs-coordinator) - Network coordination service
 +- [zephyrfs-proto](https://github.com/ZephyrFS/zephyrfs-proto) - Protocol definitions
 +- [zephyrfs-deploy](https://github.com/ZephyrFS/zephyrfs-deploy) - Deployment configurations

benches/cli_benchmarks.rsadded

 +use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId, Throughput};
 +use std::time::Duration;
 +use tempfile::TempDir;
 +use tokio::runtime::Runtime;
 +use zephyrfs_cli::{Config, ZephyrClient};
++
 +fn config_benchmarks(c: &mut Criterion) {
 +    let rt = Runtime::new().unwrap();
++
 +    c.bench_function("config_default_creation", |b| {
 +        b.iter(|| Config::default())
 +    });
++
 +    let temp_dir = tempfile::tempdir().unwrap();
 +    let config = Config::default();
 +    let config_path = temp_dir.path().join("bench_config.yaml");
++
 +    // Benchmark config save
 +    c.bench_function("config_save_yaml", |b| {
 +        b.iter(|| {
 +            config.save(Some(black_box(config_path.to_str().unwrap()))).unwrap();
 +        })
 +    });
++
 +    // Ensure config file exists for load benchmark
 +    config.save(Some(config_path.to_str().unwrap())).unwrap();
++
 +    // Benchmark config load
 +    c.bench_function("config_load_yaml", |b| {
 +        b.iter(|| {
 +            Config::load(Some(black_box(config_path.to_str().unwrap()))).unwrap();
 +        })
 +    });
 +}
++
 +fn file_operation_benchmarks(c: &mut Criterion) {
 +    let rt = Runtime::new().unwrap();
 +    let temp_dir = tempfile::tempdir().unwrap();
++
 +    // Test different file sizes
 +    let sizes = vec![1024, 10_240, 102_400, 1_048_576]; // 1KB, 10KB, 100KB, 1MB
++
 +    for size in sizes {
 +        let data = vec![0u8; size];
 +        let file_path = temp_dir.path().join(format!("test_{}.bin", size));
++
 +        c.bench_with_input(
 +            BenchmarkId::new("file_write", size),
 +            &(file_path.clone(), data.clone()),
 +            |b, (path, data)| {
 +                b.to_async(&rt).iter(|| async {
 +                    tokio::fs::write(black_box(path), black_box(data)).await.unwrap();
 +                });
 +            }
 +        );
++
 +        // Create file for read benchmark
 +        rt.block_on(tokio::fs::write(&file_path, &data)).unwrap();
++
 +        c.bench_with_input(
 +            BenchmarkId::new("file_read", size),
 +            &file_path,
 +            |b, path| {
 +                b.to_async(&rt).iter(|| async {
 +                    tokio::fs::read(black_box(path)).await.unwrap();
 +                });
 +            }
 +        );
 +    }
 +}
++
 +fn throughput_benchmarks(c: &mut Criterion) {
 +    let mut group = c.benchmark_group("throughput");
++
 +    // Config serialization throughput
 +    let config = Config::default();
++
 +    group.bench_function("yaml_serialization", |b| {
 +        b.iter(|| {
 +            serde_yaml::to_string(black_box(&config)).unwrap();
 +        })
 +    });
++
 +    group.bench_function("json_serialization", |b| {
 +        b.iter(|| {
 +            serde_json::to_string(black_box(&config)).unwrap();
 +        })
 +    });
++
 +    group.bench_function("toml_serialization", |b| {
 +        b.iter(|| {
 +            toml::to_string(black_box(&config)).unwrap();
 +        })
 +    });
++
 +    // Deserialization benchmarks
 +    let yaml_data = serde_yaml::to_string(&config).unwrap();
 +    let json_data = serde_json::to_string(&config).unwrap();
 +    let toml_data = toml::to_string(&config).unwrap();
++
 +    group.bench_function("yaml_deserialization", |b| {
 +        b.iter(|| {
 +            serde_yaml::from_str::<Config>(black_box(&yaml_data)).unwrap();
 +        })
 +    });
++
 +    group.bench_function("json_deserialization", |b| {
 +        b.iter(|| {
 +            serde_json::from_str::<Config>(black_box(&json_data)).unwrap();
 +        })
 +    });
++
 +    group.bench_function("toml_deserialization", |b| {
 +        b.iter(|| {
 +            toml::from_str::<Config>(black_box(&toml_data)).unwrap();
 +        })
 +    });
++
 +    group.finish();
 +}
++
 +fn client_benchmarks(c: &mut Criterion) {
 +    let config = Config::default();
++
 +    c.bench_function("client_creation", |b| {
 +        b.iter(|| {
 +            ZephyrClient::new(black_box(&config));
 +        })
 +    });
 +}
++
 +fn memory_benchmarks(c: &mut Criterion) {
 +    let mut group = c.benchmark_group("memory");
 +    group.measurement_time(Duration::from_secs(10));
++
 +    // Benchmark memory usage for different operations
 +    group.bench_function("config_clones", |b| {
 +        let config = Config::default();
 +        b.iter(|| {
 +            let _clones: Vec<Config> = (0..1000).map(|_| config.clone()).collect();
 +        })
 +    });
++
 +    group.bench_function("large_file_simulation", |b| {
 +        b.iter(|| {
 +            // Simulate processing a large file in chunks
 +            let chunk_size = 1024 * 1024; // 1MB chunks
 +            let num_chunks = 100;
++
 +            for _ in 0..num_chunks {
 +                let _chunk = vec![0u8; chunk_size];
 +                black_box(_chunk);
 +            }
 +        })
 +    });
++
 +    group.finish();
 +}
++
 +fn hash_benchmarks(c: &mut Criterion) {
 +    let mut group = c.benchmark_group("hashing");
++
 +    let data_sizes = vec![1024, 10_240, 102_400, 1_048_576]; // 1KB to 1MB
++
 +    for size in data_sizes {
 +        let data = vec![0u8; size];
++
 +        group.throughput(Throughput::Bytes(size as u64));
++
 +        group.bench_with_input(
 +            BenchmarkId::new("sha256", size),
 +            &data,
 +            |b, data| {
 +                use sha2::{Sha256, Digest};
 +                b.iter(|| {
 +                    let mut hasher = Sha256::new();
 +                    hasher.update(black_box(data));
 +                    hasher.finalize();
 +                })
 +            }
 +        );
 +    }
++
 +    group.finish();
 +}
++
 +criterion_group!(
 +    benches,
 +    config_benchmarks,
 +    file_operation_benchmarks,
 +    throughput_benchmarks,
 +    client_benchmarks,
 +    memory_benchmarks,
 +    hash_benchmarks
 +);
 +criterion_main!(benches);

src/client.rsadded

 +use anyhow::{Context, Result};
 +use reqwest::Client;
 +use serde::{Deserialize, Serialize};
 +use std::path::Path;
 +use std::time::Duration;
 +use tokio::fs;
++
 +use crate::config::Config;
++
 +#[derive(Debug, Clone)]
 +pub struct ZephyrClient {
 +    client: Client,
 +    coordinator_url: String,
 +    node_url: String,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct NodeInfo {
 +    pub id: String,
 +    pub name: String,
 +    pub status: String,
 +    pub peers_connected: usize,
 +    pub storage_used_gb: f64,
 +    pub storage_available_gb: f64,
 +    pub uptime_seconds: u64,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct FileInfo {
 +    pub name: String,
 +    pub size: u64,
 +    pub hash: String,
 +    pub uploaded_at: chrono::DateTime<chrono::Utc>,
 +    pub chunks: usize,
 +    pub replicas: usize,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct UploadRequest {
 +    pub file_path: String,
 +    pub file_name: String,
 +    pub file_size: u64,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct UploadResponse {
 +    pub success: bool,
 +    pub file_hash: String,
 +    pub chunks_uploaded: usize,
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct DownloadRequest {
 +    pub file_hash: String,
 +    pub output_path: String,
 +}
++
 +impl ZephyrClient {
 +    pub fn new(config: &Config) -> Self {
 +        let client = Client::builder()
 +            .timeout(Duration::from_secs(config.coordinator.timeout))
 +            .build()
 +            .expect("Failed to create HTTP client");
++
 +        Self {
 +            client,
 +            coordinator_url: config.coordinator.endpoint.clone(),
 +            node_url: format!("http://127.0.0.1:{}", config.node.listen_port),
 +        }
 +    }
++
 +    pub async fn get_node_status(&self) -> Result<NodeInfo> {
 +        let response = self
 +            .client
 +            .get(&format!("{}/api/status", self.node_url))
 +            .send()
 +            .await
 +            .context("Failed to connect to node")?;
++
 +        if !response.status().is_success() {
 +            anyhow::bail!("Node returned error: {}", response.status());
 +        }
++
 +        let node_info: NodeInfo = response
 +            .json()
 +            .await
 +            .context("Failed to parse node status response")?;
++
 +        Ok(node_info)
 +    }
++
 +    pub async fn list_files(&self) -> Result<Vec<FileInfo>> {
 +        let response = self
 +            .client
 +            .get(&format!("{}/api/files", self.node_url))
 +            .send()
 +            .await
 +            .context("Failed to connect to node")?;
++
 +        if !response.status().is_success() {
 +            anyhow::bail!("Node returned error: {}", response.status());
 +        }
++
 +        let files: Vec<FileInfo> = response
 +            .json()
 +            .await
 +            .context("Failed to parse files list response")?;
++
 +        Ok(files)
 +    }
++
 +    pub async fn upload_file(&self, file_path: &Path) -> Result<UploadResponse> {
 +        let metadata = fs::metadata(file_path).await
 +            .with_context(|| format!("Failed to read file metadata: {:?}", file_path))?;
++
 +        let file_name = file_path
 +            .file_name()
 +            .and_then(|n| n.to_str())
 +            .context("Invalid file name")?;
++
 +        let request = UploadRequest {
 +            file_path: file_path.to_string_lossy().to_string(),
 +            file_name: file_name.to_string(),
 +            file_size: metadata.len(),
 +        };
++
 +        // Read file content
 +        let file_content = fs::read(file_path).await
 +            .with_context(|| format!("Failed to read file: {:?}", file_path))?;
++
 +        let response = self
 +            .client
 +            .post(&format!("{}/api/upload", self.node_url))
 +            .json(&request)
 +            .body(file_content)
 +            .send()
 +            .await
 +            .context("Failed to upload file to node")?;
++
 +        if !response.status().is_success() {
 +            anyhow::bail!("Upload failed: {}", response.status());
 +        }
++
 +        let upload_response: UploadResponse = response
 +            .json()
 +            .await
 +            .context("Failed to parse upload response")?;
++
 +        Ok(upload_response)
 +    }
++
 +    pub async fn download_file(&self, file_hash: &str, output_path: &Path) -> Result<()> {
 +        let request = DownloadRequest {
 +            file_hash: file_hash.to_string(),
 +            output_path: output_path.to_string_lossy().to_string(),
 +        };
++
 +        let response = self
 +            .client
 +            .post(&format!("{}/api/download", self.node_url))
 +            .json(&request)
 +            .send()
 +            .await
 +            .context("Failed to download file from node")?;
++
 +        if !response.status().is_success() {
 +            anyhow::bail!("Download failed: {}", response.status());
 +        }
++
 +        let file_content = response
 +            .bytes()
 +            .await
 +            .context("Failed to read download response")?;
++
 +        fs::write(output_path, file_content).await
 +            .with_context(|| format!("Failed to write file: {:?}", output_path))?;
++
 +        Ok(())
 +    }
++
 +    pub async fn join_network(&self, bootstrap_peer: &str) -> Result<()> {
 +        let response = self
 +            .client
 +            .post(&format!("{}/api/network/join", self.node_url))
 +            .json(&serde_json::json!({ "bootstrap_peer": bootstrap_peer }))
 +            .send()
 +            .await
 +            .context("Failed to join network")?;
++
 +        if !response.status().is_success() {
 +            anyhow::bail!("Failed to join network: {}", response.status());
 +        }
++
 +        Ok(())
 +    }
++
 +    pub async fn initialize_node(&self) -> Result<()> {
 +        let response = self
 +            .client
 +            .post(&format!("{}/api/node/init", self.node_url))
 +            .send()
 +            .await
 +            .context("Failed to initialize node")?;
++
 +        if !response.status().is_success() {
 +            anyhow::bail!("Failed to initialize node: {}", response.status());
 +        }
++
 +        Ok(())
 +    }
 +}

src/commands/download.rsadded

 +use clap::Args;
 +use anyhow::{Context, Result};
 +use indicatif::{ProgressBar, ProgressStyle};
 +use std::path::PathBuf;
 +use tracing::info;
 +use humansize::{format_size, BINARY};
++
 +use crate::config::Config;
 +use crate::client::ZephyrClient;
 +use super::Command;
++
 +#[derive(Debug, Args)]
 +pub struct DownloadCommand {
 +    /// File hash to download
 +    file_hash: String,
++
 +    /// Output file path (defaults to original filename)
 +    #[arg(short, long)]
 +    output: Option<PathBuf>,
++
 +    /// Overwrite existing file
 +    #[arg(long)]
 +    force: bool,
++
 +    /// Show progress bar
 +    #[arg(long, default_value = "true")]
 +    progress: bool,
++
 +    /// Verify download integrity
 +    #[arg(long, default_value = "true")]
 +    verify: bool,
 +}
++
 +#[async_trait::async_trait]
 +impl Command for DownloadCommand {
 +    async fn execute(&self, config: &Config) -> Result<()> {
 +        info!("Downloading file: {}", self.file_hash);
++
 +        let client = ZephyrClient::new(config);
++
 +        // Get file info first
 +        let files = client.list_files().await
 +            .context("Failed to list files")?;
++
 +        let file_info = files.iter()
 +            .find(|f| f.hash == self.file_hash)
 +            .with_context(|| format!("File not found: {}", self.file_hash))?;
++
 +        // Determine output path
 +        let output_path = match &self.output {
 +            Some(path) => path.clone(),
 +            None => PathBuf::from(&file_info.name),
 +        };
++
 +        // Check if file exists and handle overwrite
 +        if output_path.exists() && !self.force {
 +            anyhow::bail!(
 +                "Output file already exists: {:?}. Use --force to overwrite.",
 +                output_path
 +            );
 +        }
++
 +        println!("Downloading: {}", file_info.name);
 +        println!("  Hash: {}", file_info.hash);
 +        println!("  Size: {}", format_size(file_info.size, BINARY));
 +        println!("  Chunks: {}", file_info.chunks);
 +        println!("  Output: {:?}", output_path);
++
 +        // Create progress bar
 +        let progress = if self.progress {
 +            let pb = ProgressBar::new(file_info.size);
 +            pb.set_style(
 +                ProgressStyle::default_bar()
 +                    .template("[{elapsed_precise}] {bar:40.cyan/blue} {percent}% {bytes}/{total_bytes} ETA: {eta}")
 +                    .unwrap()
 +                    .progress_chars("##-")
 +            );
 +            Some(pb)
 +        } else {
 +            None
 +        };
++
 +        // Download the file
 +        client.download_file(&self.file_hash, &output_path).await
 +            .context("Failed to download file")?;
++
 +        if let Some(pb) = progress {
 +            pb.finish_with_message("Download complete");
 +        }
++
 +        // Verify download if requested
 +        if self.verify {
 +            println!("Verifying download integrity...");
++
 +            let downloaded_metadata = tokio::fs::metadata(&output_path).await
 +                .context("Failed to read downloaded file metadata")?;
++
 +            if downloaded_metadata.len() != file_info.size {
 +                anyhow::bail!(
 +                    "File size mismatch: expected {}, got {}",
 +                    file_info.size,
 +                    downloaded_metadata.len()
 +                );
 +            }
++
 +            // TODO: Verify file hash
 +            println!("✓ Download verified successfully");
 +        }
++
 +        println!("✓ File downloaded successfully!");
 +        println!("  Location: {:?}", output_path);
 +        println!("  Size: {}", format_size(file_info.size, BINARY));
++
 +        Ok(())
 +    }
 +}

src/commands/init.rsadded

 +use clap::Args;
 +use anyhow::{Context, Result};
 +use dialoguer::{theme::ColorfulTheme, Input, Confirm};
 +use std::path::PathBuf;
 +use tracing::{info, warn};
++
 +use crate::config::Config;
 +use crate::client::ZephyrClient;
 +use super::Command;
++
 +#[derive(Debug, Args)]
 +pub struct InitCommand {
 +    /// Node name (optional)
 +    #[arg(short, long)]
 +    name: Option<String>,
++
 +    /// Data directory path
 +    #[arg(short, long)]
 +    data_dir: Option<PathBuf>,
++
 +    /// Listen port for the node
 +    #[arg(short, long)]
 +    port: Option<u16>,
++
 +    /// Maximum storage allocation in GB
 +    #[arg(short, long)]
 +    storage: Option<u64>,
++
 +    /// Skip interactive configuration
 +    #[arg(long)]
 +    no_interactive: bool,
 +}
++
 +#[async_trait::async_trait]
 +impl Command for InitCommand {
 +    async fn execute(&self, config: &Config) -> Result<()> {
 +        info!("Initializing ZephyrFS node...");
++
 +        let mut node_config = config.clone();
++
 +        // Interactive configuration if not skipped
 +        if !self.no_interactive {
 +            self.interactive_config(&mut node_config)?;
 +        } else {
 +            self.apply_args(&mut node_config)?;
 +        }
++
 +        // Ensure data directory exists
 +        node_config.ensure_data_dir()
 +            .context("Failed to create data directory")?;
++
 +        // Save configuration
 +        node_config.save(None)
 +            .context("Failed to save configuration")?;
++
 +        // Initialize the node
 +        let client = ZephyrClient::new(&node_config);
 +        client.initialize_node().await
 +            .context("Failed to initialize node")?;
++
 +        println!("✓ ZephyrFS node initialized successfully!");
 +        println!("  Node ID: {}", node_config.node.id.unwrap_or_else(|| "auto-generated".to_string()));
 +        println!("  Data directory: {:?}", node_config.node.data_dir);
 +        println!("  Listen port: {}", node_config.node.listen_port);
 +        println!("  Max storage: {} GB", node_config.storage.max_storage_gb);
++
 +        println!("\nNext steps:");
 +        println!("  1. Start the node: zephyrfs status");
 +        println!("  2. Join a network: zephyrfs join <bootstrap-peer>");
++
 +        Ok(())
 +    }
 +}
++
 +impl InitCommand {
 +    fn interactive_config(&self, config: &mut Config) -> Result<()> {
 +        let theme = ColorfulTheme::default();
++
 +        // Node name
 +        if let Some(name) = &self.name {
 +            config.node.name = Some(name.clone());
 +        } else {
 +            let name: String = Input::with_theme(&theme)
 +                .with_prompt("Node name (optional)")
 +                .default(config.node.name.clone().unwrap_or_else(|| "zephyr-node".to_string()))
 +                .allow_empty(true)
 +                .interact_text()?;
++
 +            config.node.name = if name.is_empty() { None } else { Some(name) };
 +        }
++
 +        // Data directory
 +        if let Some(data_dir) = &self.data_dir {
 +            config.node.data_dir = data_dir.clone();
 +        } else {
 +            let data_dir_str = Input::with_theme(&theme)
 +                .with_prompt("Data directory")
 +                .default(config.node.data_dir.to_string_lossy().to_string())
 +                .interact_text()?;
++
 +            config.node.data_dir = PathBuf::from(data_dir_str);
 +        }
++
 +        // Listen port
 +        if let Some(port) = self.port {
 +            config.node.listen_port = port;
 +        } else {
 +            config.node.listen_port = Input::with_theme(&theme)
 +                .with_prompt("Listen port")
 +                .default(config.node.listen_port)
 +                .interact()?;
 +        }
++
 +        // Storage allocation
 +        if let Some(storage) = self.storage {
 +            config.storage.max_storage_gb = storage;
 +        } else {
 +            config.storage.max_storage_gb = Input::with_theme(&theme)
 +                .with_prompt("Maximum storage allocation (GB)")
 +                .default(config.storage.max_storage_gb)
 +                .interact()?;
 +        }
++
 +        // Confirm settings
 +        println!("\nConfiguration summary:");
 +        println!("  Name: {}", config.node.name.as_deref().unwrap_or("auto-generated"));
 +        println!("  Data directory: {:?}", config.node.data_dir);
 +        println!("  Listen port: {}", config.node.listen_port);
 +        println!("  Max storage: {} GB", config.storage.max_storage_gb);
++
 +        let confirm = Confirm::with_theme(&theme)
 +            .with_prompt("Proceed with initialization?")
 +            .default(true)
 +            .interact()?;
++
 +        if !confirm {
 +            warn!("Initialization cancelled by user");
 +            std::process::exit(0);
 +        }
++
 +        Ok(())
 +    }
++
 +    fn apply_args(&self, config: &mut Config) -> Result<()> {
 +        if let Some(name) = &self.name {
 +            config.node.name = Some(name.clone());
 +        }
++
 +        if let Some(data_dir) = &self.data_dir {
 +            config.node.data_dir = data_dir.clone();
 +        }
++
 +        if let Some(port) = self.port {
 +            config.node.listen_port = port;
 +        }
++
 +        if let Some(storage) = self.storage {
 +            config.storage.max_storage_gb = storage;
 +        }
++
 +        Ok(())
 +    }
 +}

src/commands/join.rsadded

 +use clap::Args;
 +use anyhow::{Context, Result};
 +use tracing::info;
++
 +use crate::config::Config;
 +use crate::client::ZephyrClient;
 +use super::Command;
++
 +#[derive(Debug, Args)]
 +pub struct JoinCommand {
 +    /// Bootstrap peer address (host:port)
 +    bootstrap_peer: String,
++
 +    /// Timeout in seconds
 +    #[arg(short, long, default_value = "30")]
 +    timeout: u64,
++
 +    /// Skip connectivity test
 +    #[arg(long)]
 +    skip_test: bool,
 +}
++
 +#[async_trait::async_trait]
 +impl Command for JoinCommand {
 +    async fn execute(&self, config: &Config) -> Result<()> {
 +        info!("Joining ZephyrFS network via bootstrap peer: {}", self.bootstrap_peer);
++
 +        let client = ZephyrClient::new(config);
++
 +        // Test connectivity to bootstrap peer if not skipped
 +        if !self.skip_test {
 +            println!("Testing connectivity to bootstrap peer...");
 +            // TODO: Implement ping/connectivity test
 +        }
++
 +        // Join the network
 +        println!("Joining network...");
 +        client.join_network(&self.bootstrap_peer).await
 +            .context("Failed to join network")?;
++
 +        // Verify connection
 +        println!("Verifying connection...");
 +        let node_info = client.get_node_status().await
 +            .context("Failed to get node status after joining")?;
++
 +        println!("✓ Successfully joined ZephyrFS network!");
 +        println!("  Bootstrap peer: {}", self.bootstrap_peer);
 +        println!("  Connected peers: {}", node_info.peers_connected);
 +        println!("  Node status: {}", node_info.status);
++
 +        if node_info.peers_connected == 0 {
 +            println!("\n⚠  Warning: No peers connected yet. This might be expected for a new network.");
 +        }
++
 +        Ok(())
 +    }
 +}

src/commands/list.rsadded

 +use clap::Args;
 +use anyhow::{Context, Result};
 +use chrono::{DateTime, Local};
 +use humansize::{format_size, BINARY};
 +use tracing::info;
++
 +use crate::config::Config;
 +use crate::client::ZephyrClient;
 +use super::Command;
++
 +#[derive(Debug, Args)]
 +pub struct ListCommand {
 +    /// Show detailed information
 +    #[arg(short, long)]
 +    long: bool,
++
 +    /// Sort by column (name, size, date, chunks)
 +    #[arg(short, long, default_value = "name")]
 +    sort: String,
++
 +    /// Reverse sort order
 +    #[arg(short, long)]
 +    reverse: bool,
++
 +    /// Filter by name pattern
 +    #[arg(short, long)]
 +    filter: Option<String>,
++
 +    /// Output format (table, json, csv)
 +    #[arg(long, default_value = "table")]
 +    format: String,
 +}
++
 +#[async_trait::async_trait]
 +impl Command for ListCommand {
 +    async fn execute(&self, config: &Config) -> Result<()> {
 +        info!("Listing files in ZephyrFS network");
++
 +        let client = ZephyrClient::new(config);
 +        let mut files = client.list_files().await
 +            .context("Failed to list files")?;
++
 +        // Apply filter if specified
 +        if let Some(filter) = &self.filter {
 +            files.retain(|f| f.name.contains(filter));
 +        }
++
 +        // Sort files
 +        match self.sort.as_str() {
 +            "name" => files.sort_by(|a, b| a.name.cmp(&b.name)),
 +            "size" => files.sort_by(|a, b| a.size.cmp(&b.size)),
 +            "date" => files.sort_by(|a, b| a.uploaded_at.cmp(&b.uploaded_at)),
 +            "chunks" => files.sort_by(|a, b| a.chunks.cmp(&b.chunks)),
 +            _ => anyhow::bail!("Invalid sort column: {}. Valid options: name, size, date, chunks", self.sort),
 +        }
++
 +        if self.reverse {
 +            files.reverse();
 +        }
++
 +        if files.is_empty() {
 +            println!("No files found in the network.");
 +            return Ok(());
 +        }
++
 +        match self.format.as_str() {
 +            "table" => self.print_table(&files),
 +            "json" => self.print_json(&files)?,
 +            "csv" => self.print_csv(&files),
 +            _ => anyhow::bail!("Invalid format: {}. Valid options: table, json, csv", self.format),
 +        }
++
 +        println!("\nTotal files: {}", files.len());
 +        let total_size: u64 = files.iter().map(|f| f.size).sum();
 +        println!("Total size: {}", format_size(total_size, BINARY));
++
 +        Ok(())
 +    }
 +}
++
 +impl ListCommand {
 +    fn print_table(&self, files: &[crate::client::FileInfo]) {
 +        if self.long {
 +            // Detailed view
 +            println!("{:<12} {:>10} {:>8} {:>8} {:<20} {}",
 +                     "HASH", "SIZE", "CHUNKS", "REPLICAS", "UPLOADED", "NAME");
 +            println!("{}", "-".repeat(80));
++
 +            for file in files {
 +                let local_time: DateTime<Local> = file.uploaded_at.into();
 +                let hash_short = if file.hash.len() > 12 {
 +                    &file.hash[..12]
 +                } else {
 +                    &file.hash
 +                };
++
 +                println!("{:<12} {:>10} {:>8} {:>8} {:<20} {}",
 +                         hash_short,
 +                         format_size(file.size, BINARY),
 +                         file.chunks,
 +                         file.replicas,
 +                         local_time.format("%Y-%m-%d %H:%M"),
 +                         file.name);
 +            }
 +        } else {
 +            // Simple view
 +            println!("{:<40} {:>10} {}", "NAME", "SIZE", "HASH");
 +            println!("{}", "-".repeat(60));
++
 +            for file in files {
 +                let hash_short = if file.hash.len() > 8 {
 +                    &file.hash[..8]
 +                } else {
 +                    &file.hash
 +                };
++
 +                println!("{:<40} {:>10} {}",
 +                         if file.name.len() > 40 {
 +                             format!("{}...", &file.name[..37])
 +                         } else {
 +                             file.name.clone()
 +                         },
 +                         format_size(file.size, BINARY),
 +                         hash_short);
 +            }
 +        }
 +    }
++
 +    fn print_json(&self, files: &[crate::client::FileInfo]) -> Result<()> {
 +        let json = serde_json::to_string_pretty(files)
 +            .context("Failed to serialize files to JSON")?;
 +        println!("{}", json);
 +        Ok(())
 +    }
++
 +    fn print_csv(&self, files: &[crate::client::FileInfo]) {
 +        println!("name,size,hash,chunks,replicas,uploaded_at");
 +        for file in files {
 +            println!("{},{},{},{},{},{}",
 +                     file.name,
 +                     file.size,
 +                     file.hash,
 +                     file.chunks,
 +                     file.replicas,
 +                     file.uploaded_at.to_rfc3339());
 +        }
 +    }
 +}

src/commands/mod.rsadded

 +mod init;
 +mod join;
 +mod upload;
 +mod download;
 +mod list;
 +mod status;
++
 +pub use init::InitCommand;
 +pub use join::JoinCommand;
 +pub use upload::UploadCommand;
 +pub use download::DownloadCommand;
 +pub use list::ListCommand;
 +pub use status::StatusCommand;
++
 +use anyhow::Result;
 +use crate::config::Config;
++
 +#[async_trait::async_trait]
 +pub trait Command {
 +    async fn execute(&self, config: &Config) -> Result<()>;
 +}

src/commands/status.rsadded

 +use clap::Args;
 +use anyhow::{Context, Result};
 +use humansize::{format_size, BINARY};
 +use std::time::Duration;
 +use tracing::info;
++
 +use crate::config::Config;
 +use crate::client::ZephyrClient;
 +use super::Command;
++
 +#[derive(Debug, Args)]
 +pub struct StatusCommand {
 +    /// Show detailed status information
 +    #[arg(short, long)]
 +    detailed: bool,
++
 +    /// Output format (table, json)
 +    #[arg(long, default_value = "table")]
 +    format: String,
++
 +    /// Refresh interval in seconds (0 for single check)
 +    #[arg(short, long, default_value = "0")]
 +    watch: u64,
 +}
++
 +#[async_trait::async_trait]
 +impl Command for StatusCommand {
 +    async fn execute(&self, config: &Config) -> Result<()> {
 +        info!("Getting ZephyrFS node status");
++
 +        if self.watch > 0 {
 +            self.watch_status(config).await
 +        } else {
 +            self.show_status(config).await
 +        }
 +    }
 +}
++
 +impl StatusCommand {
 +    async fn show_status(&self, config: &Config) -> Result<()> {
 +        let client = ZephyrClient::new(config);
++
 +        // Get node status
 +        let node_info = client.get_node_status().await
 +            .context("Failed to get node status. Is the node running?")?;
++
 +        match self.format.as_str() {
 +            "table" => self.print_table_status(&node_info, config),
 +            "json" => self.print_json_status(&node_info)?,
 +            _ => anyhow::bail!("Invalid format: {}. Valid options: table, json", self.format),
 +        }
++
 +        Ok(())
 +    }
++
 +    async fn watch_status(&self, config: &Config) -> Result<()> {
 +        println!("Watching node status (refresh every {} seconds)...", self.watch);
 +        println!("Press Ctrl+C to stop\n");
++
 +        loop {
 +            // Clear screen
 +            print!("\x1B[2J\x1B[1;1H");
++
 +            match self.show_status(config).await {
 +                Ok(()) => {},
 +                Err(e) => println!("Error getting status: {}", e),
 +            }
++
 +            tokio::time::sleep(Duration::from_secs(self.watch)).await;
 +        }
 +    }
++
 +    fn print_table_status(&self, node_info: &crate::client::NodeInfo, config: &Config) {
 +        println!("ZephyrFS Node Status");
 +        println!("{}", "=".repeat(50));
 +        println!();
++
 +        // Basic info
 +        println!("Node Information:");
 +        println!("  ID: {}", node_info.id);
 +        println!("  Name: {}", node_info.name);
 +        println!("  Status: {}", self.format_status(&node_info.status));
 +        println!();
++
 +        // Network info
 +        println!("Network:");
 +        println!("  Connected peers: {}", node_info.peers_connected);
 +        println!("  Listen port: {}", config.node.listen_port);
 +        println!("  Coordinator: {}", config.coordinator.endpoint);
 +        println!();
++
 +        // Storage info
 +        let used_gb = node_info.storage_used_gb;
 +        let available_gb = node_info.storage_available_gb;
 +        let total_gb = used_gb + available_gb;
 +        let usage_percent = if total_gb > 0.0 { (used_gb / total_gb) * 100.0 } else { 0.0 };
++
 +        println!("Storage:");
 +        println!("  Used: {} ({:.1}%)", format_size((used_gb * 1e9) as u64, BINARY), usage_percent);
 +        println!("  Available: {}", format_size((available_gb * 1e9) as u64, BINARY));
 +        println!("  Total allocated: {}", format_size((total_gb * 1e9) as u64, BINARY));
 +        println!("  Max allocation: {} GB", config.storage.max_storage_gb);
 +        println!();
++
 +        // Runtime info
 +        let uptime = Duration::from_secs(node_info.uptime_seconds);
 +        println!("Runtime:");
 +        println!("  Uptime: {}", self.format_duration(uptime));
 +        println!("  Data directory: {:?}", config.node.data_dir);
++
 +        if self.detailed {
 +            println!();
 +            println!("Configuration:");
 +            println!("  Chunk size: {} MB", config.storage.chunk_size_mb);
 +            println!("  Replication factor: {}", config.storage.replication_factor);
 +            println!("  Max connections: {}", config.network.max_connections);
 +            println!("  Connection timeout: {}s", config.network.connection_timeout);
 +        }
 +    }
++
 +    fn print_json_status(&self, node_info: &crate::client::NodeInfo) -> Result<()> {
 +        let json = serde_json::to_string_pretty(node_info)
 +            .context("Failed to serialize node info to JSON")?;
 +        println!("{}", json);
 +        Ok(())
 +    }
++
 +    fn format_status(&self, status: &str) -> String {
 +        match status.to_lowercase().as_str() {
 +            "running" => "🟢 Running".to_string(),
 +            "starting" => "🟡 Starting".to_string(),
 +            "stopping" => "🟡 Stopping".to_string(),
 +            "stopped" => "🔴 Stopped".to_string(),
 +            "error" => "❌ Error".to_string(),
 +            _ => format!("❓ {}", status),
 +        }
 +    }
++
 +    fn format_duration(&self, duration: Duration) -> String {
 +        let secs = duration.as_secs();
++
 +        if secs < 60 {
 +            format!("{}s", secs)
 +        } else if secs < 3600 {
 +            format!("{}m {}s", secs / 60, secs % 60)
 +        } else if secs < 86400 {
 +            let hours = secs / 3600;
 +            let mins = (secs % 3600) / 60;
 +            format!("{}h {}m", hours, mins)
 +        } else {
 +            let days = secs / 86400;
 +            let hours = (secs % 86400) / 3600;
 +            format!("{}d {}h", days, hours)
 +        }
 +    }
 +}

src/commands/upload.rsadded

 +use clap::Args;
 +use anyhow::{Context, Result};
 +use indicatif::{ProgressBar, ProgressStyle};
 +use std::path::PathBuf;
 +use tracing::info;
 +use humansize::{format_size, BINARY};
++
 +use crate::config::Config;
 +use crate::client::ZephyrClient;
 +use super::Command;
++
 +#[derive(Debug, Args)]
 +pub struct UploadCommand {
 +    /// File path to upload
 +    file: PathBuf,
++
 +    /// Custom file name (defaults to original filename)
 +    #[arg(short, long)]
 +    name: Option<String>,
++
 +    /// Show progress bar
 +    #[arg(long, default_value = "true")]
 +    progress: bool,
++
 +    /// Verify upload after completion
 +    #[arg(long)]
 +    verify: bool,
 +}
++
 +#[async_trait::async_trait]
 +impl Command for UploadCommand {
 +    async fn execute(&self, config: &Config) -> Result<()> {
 +        info!("Uploading file: {:?}", self.file);
++
 +        // Validate file exists and is readable
 +        if !self.file.exists() {
 +            anyhow::bail!("File does not exist: {:?}", self.file);
 +        }
++
 +        if !self.file.is_file() {
 +            anyhow::bail!("Path is not a file: {:?}", self.file);
 +        }
++
 +        let metadata = tokio::fs::metadata(&self.file).await
 +            .with_context(|| format!("Failed to read file metadata: {:?}", self.file))?;
++
 +        let file_size = metadata.len();
 +        let display_name = self.name.as_deref()
 +            .or_else(|| self.file.file_name().and_then(|n| n.to_str()))
 +            .unwrap_or("unknown");
++
 +        println!("Uploading: {}", display_name);
 +        println!("  Size: {}", format_size(file_size, BINARY));
 +        println!("  Path: {:?}", self.file);
++
 +        // Create progress bar
 +        let progress = if self.progress {
 +            let pb = ProgressBar::new(file_size);
 +            pb.set_style(
 +                ProgressStyle::default_bar()
 +                    .template("[{elapsed_precise}] {bar:40.cyan/blue} {percent}% {bytes}/{total_bytes} ETA: {eta}")
 +                    .unwrap()
 +                    .progress_chars("##-")
 +            );
 +            Some(pb)
 +        } else {
 +            None
 +        };
++
 +        let client = ZephyrClient::new(config);
++
 +        // Upload the file
 +        let upload_result = client.upload_file(&self.file).await
 +            .context("Failed to upload file")?;
++
 +        if let Some(pb) = progress {
 +            pb.finish_with_message("Upload complete");
 +        }
++
 +        println!("✓ File uploaded successfully!");
 +        println!("  File hash: {}", upload_result.file_hash);
 +        println!("  Chunks: {}", upload_result.chunks_uploaded);
++
 +        // Verify upload if requested
 +        if self.verify {
 +            println!("\nVerifying upload...");
 +            let files = client.list_files().await
 +                .context("Failed to list files for verification")?;
++
 +            if files.iter().any(|f| f.hash == upload_result.file_hash) {
 +                println!("✓ Upload verified successfully");
 +            } else {
 +                println!("⚠  Warning: Could not verify upload in file list");
 +            }
 +        }
++
 +        println!("\nTo download this file later, use:");
 +        println!("  zephyrfs download {}", upload_result.file_hash);
++
 +        Ok(())
 +    }
 +}

src/config.rsadded

 +use anyhow::{Context, Result};
 +use serde::{Deserialize, Serialize};
 +use std::path::PathBuf;
 +use std::fs;
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Config {
 +    pub node: NodeConfig,
 +    pub network: NetworkConfig,
 +    pub storage: StorageConfig,
 +    pub coordinator: CoordinatorConfig,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NodeConfig {
 +    pub id: Option<String>,
 +    pub name: Option<String>,
 +    pub data_dir: PathBuf,
 +    pub listen_port: u16,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NetworkConfig {
 +    pub bootstrap_peers: Vec<String>,
 +    pub max_connections: usize,
 +    pub connection_timeout: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct StorageConfig {
 +    pub max_storage_gb: u64,
 +    pub chunk_size_mb: u32,
 +    pub replication_factor: u32,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct CoordinatorConfig {
 +    pub endpoint: String,
 +    pub timeout: u64,
 +    pub retry_attempts: u32,
 +}
++
 +impl Default for Config {
 +    fn default() -> Self {
 +        Self {
 +            node: NodeConfig {
 +                id: None,
 +                name: None,
 +                data_dir: dirs::home_dir()
 +                    .unwrap_or_else(|| PathBuf::from("."))
 +                    .join(".zephyrfs"),
 +                listen_port: 8080,
 +            },
 +            network: NetworkConfig {
 +                bootstrap_peers: vec![
 +                    "127.0.0.1:8081".to_string(),
 +                    "127.0.0.1:8082".to_string(),
 +                ],
 +                max_connections: 50,
 +                connection_timeout: 30,
 +            },
 +            storage: StorageConfig {
 +                max_storage_gb: 10,
 +                chunk_size_mb: 1,
 +                replication_factor: 3,
 +            },
 +            coordinator: CoordinatorConfig {
 +                endpoint: "http://127.0.0.1:9000".to_string(),
 +                timeout: 30,
 +                retry_attempts: 3,
 +            },
 +        }
 +    }
 +}
++
 +impl Config {
 +    pub fn load(config_path: Option<&str>) -> Result<Self> {
 +        let path = match config_path {
 +            Some(p) => PathBuf::from(p),
 +            None => Self::default_config_path()?,
 +        };
++
 +        if !path.exists() {
 +            tracing::info!("Config file not found, using defaults: {:?}", path);
 +            return Ok(Self::default());
 +        }
++
 +        let content = fs::read_to_string(&path)
 +            .with_context(|| format!("Failed to read config file: {:?}", path))?;
++
 +        let config: Config = if path.extension().and_then(|s| s.to_str()) == Some("toml") {
 +            toml::from_str(&content)
 +                .with_context(|| format!("Failed to parse TOML config: {:?}", path))?
 +        } else {
 +            serde_yaml::from_str(&content)
 +                .with_context(|| format!("Failed to parse YAML config: {:?}", path))?
 +        };
++
 +        tracing::info!("Loaded config from: {:?}", path);
 +        Ok(config)
 +    }
++
 +    pub fn save(&self, config_path: Option<&str>) -> Result<()> {
 +        let path = match config_path {
 +            Some(p) => PathBuf::from(p),
 +            None => Self::default_config_path()?,
 +        };
++
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent)
 +                .with_context(|| format!("Failed to create config directory: {:?}", parent))?;
 +        }
++
 +        let content = if path.extension().and_then(|s| s.to_str()) == Some("toml") {
 +            toml::to_string_pretty(self)
 +                .context("Failed to serialize config to TOML")?
 +        } else {
 +            serde_yaml::to_string(self)
 +                .context("Failed to serialize config to YAML")?
 +        };
++
 +        fs::write(&path, content)
 +            .with_context(|| format!("Failed to write config file: {:?}", path))?;
++
 +        tracing::info!("Saved config to: {:?}", path);
 +        Ok(())
 +    }
++
 +    fn default_config_path() -> Result<PathBuf> {
 +        let config_dir = dirs::config_dir()
 +            .or_else(|| dirs::home_dir().map(|h| h.join(".config")))
 +            .context("Could not determine config directory")?;
++
 +        Ok(config_dir.join("zephyrfs").join("config.yaml"))
 +    }
++
 +    pub fn ensure_data_dir(&self) -> Result<()> {
 +        fs::create_dir_all(&self.node.data_dir)
 +            .with_context(|| format!("Failed to create data directory: {:?}", self.node.data_dir))?;
 +        Ok(())
 +    }
 +}

src/lib.rsadded

 +pub mod commands;
 +pub mod config;
 +pub mod client;
 +pub mod metrics;
++
 +pub use config::Config;
 +pub use client::ZephyrClient;
 +pub use metrics::{MetricsCollector, METRICS};

src/main.rsadded

 +use clap::{Parser, Subcommand};
 +use anyhow::Result;
 +use tracing::{info, Level};
 +use tracing_subscriber::FmtSubscriber;
++
 +mod commands;
 +mod config;
 +mod client;
++
 +use commands::{InitCommand, JoinCommand, UploadCommand, DownloadCommand, ListCommand, StatusCommand, Command};
++
 +#[derive(Parser)]
 +#[command(name = "zephyrfs")]
 +#[command(about = "A distributed P2P storage system")]
 +#[command(version)]
 +struct Cli {
 +    #[command(subcommand)]
 +    command: Commands,
++
 +    #[arg(short, long, global = true)]
 +    verbose: bool,
++
 +    #[arg(short, long, global = true)]
 +    config: Option<String>,
 +}
++
 +#[derive(Subcommand)]
 +enum Commands {
 +    /// Initialize a new ZephyrFS node
 +    Init(InitCommand),
++
 +    /// Join an existing ZephyrFS network
 +    Join(JoinCommand),
++
 +    /// Upload a file to the network
 +    Upload(UploadCommand),
++
 +    /// Download a file from the network
 +    Download(DownloadCommand),
++
 +    /// List files in the network
 +    #[command(alias = "ls")]
 +    List(ListCommand),
++
 +    /// Show node status and network information
 +    Status(StatusCommand),
 +}
++
 +#[tokio::main]
 +async fn main() -> Result<()> {
 +    let cli = Cli::parse();
++
 +    // Initialize logging
 +    let level = if cli.verbose { Level::DEBUG } else { Level::INFO };
 +    let subscriber = FmtSubscriber::builder()
 +        .with_max_level(level)
 +        .finish();
 +    tracing::subscriber::set_global_default(subscriber)
 +        .expect("setting default subscriber failed");
++
 +    info!("Starting ZephyrFS CLI");
++
 +    // Load configuration
 +    let config_path = cli.config.as_deref();
 +    let config = config::Config::load(config_path)?;
++
 +    // Execute command
 +    match cli.command {
 +        Commands::Init(cmd) => cmd.execute(&config).await,
 +        Commands::Join(cmd) => cmd.execute(&config).await,
 +        Commands::Upload(cmd) => cmd.execute(&config).await,
 +        Commands::Download(cmd) => cmd.execute(&config).await,
 +        Commands::List(cmd) => cmd.execute(&config).await,
 +        Commands::Status(cmd) => cmd.execute(&config).await,
 +    }
 +}

src/metrics.rsadded

 +use serde::{Deserialize, Serialize};
 +use std::collections::HashMap;
 +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 +use tokio::sync::RwLock;
 +use std::sync::Arc;
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Metrics {
 +    pub commands: CommandMetrics,
 +    pub network: NetworkMetrics,
 +    pub storage: StorageMetrics,
 +    pub performance: PerformanceMetrics,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct CommandMetrics {
 +    pub total_commands: u64,
 +    pub commands_by_type: HashMap<String, u64>,
 +    pub command_durations: HashMap<String, Vec<f64>>, // in milliseconds
 +    pub failed_commands: u64,
 +    pub last_command_time: Option<u64>, // unix timestamp
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct NetworkMetrics {
 +    pub total_requests: u64,
 +    pub failed_requests: u64,
 +    pub average_response_time: f64, // milliseconds
 +    pub timeouts: u64,
 +    pub bytes_uploaded: u64,
 +    pub bytes_downloaded: u64,
 +    pub peer_connections: u32,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct StorageMetrics {
 +    pub files_uploaded: u64,
 +    pub files_downloaded: u64,
 +    pub total_bytes_processed: u64,
 +    pub cache_hits: u64,
 +    pub cache_misses: u64,
 +    pub disk_operations: u64,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct PerformanceMetrics {
 +    pub memory_usage_mb: f64,
 +    pub cpu_usage_percent: f64,
 +    pub startup_time_ms: f64,
 +    pub gc_collections: u32,
 +    pub peak_memory_mb: f64,
 +}
++
 +#[derive(Debug)]
 +pub struct MetricsCollector {
 +    metrics: Arc<RwLock<Metrics>>,
 +    start_time: Instant,
 +}
++
 +impl Default for Metrics {
 +    fn default() -> Self {
 +        Self {
 +            commands: CommandMetrics {
 +                total_commands: 0,
 +                commands_by_type: HashMap::new(),
 +                command_durations: HashMap::new(),
 +                failed_commands: 0,
 +                last_command_time: None,
 +            },
 +            network: NetworkMetrics {
 +                total_requests: 0,
 +                failed_requests: 0,
 +                average_response_time: 0.0,
 +                timeouts: 0,
 +                bytes_uploaded: 0,
 +                bytes_downloaded: 0,
 +                peer_connections: 0,
 +            },
 +            storage: StorageMetrics {
 +                files_uploaded: 0,
 +                files_downloaded: 0,
 +                total_bytes_processed: 0,
 +                cache_hits: 0,
 +                cache_misses: 0,
 +                disk_operations: 0,
 +            },
 +            performance: PerformanceMetrics {
 +                memory_usage_mb: 0.0,
 +                cpu_usage_percent: 0.0,
 +                startup_time_ms: 0.0,
 +                gc_collections: 0,
 +                peak_memory_mb: 0.0,
 +            },
 +        }
 +    }
 +}
++
 +impl MetricsCollector {
 +    pub fn new() -> Self {
 +        Self {
 +            metrics: Arc::new(RwLock::new(Metrics::default())),
 +            start_time: Instant::now(),
 +        }
 +    }
++
 +    pub async fn record_command_start(&self, command: &str) -> CommandTimer {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.commands.total_commands += 1;
 +        *metrics.commands.commands_by_type.entry(command.to_string()).or_insert(0) += 1;
 +        metrics.commands.last_command_time = Some(
 +            SystemTime::now()
 +                .duration_since(UNIX_EPOCH)
 +                .unwrap_or_default()
 +                .as_secs()
 +        );
++
 +        CommandTimer {
 +            command: command.to_string(),
 +            start_time: Instant::now(),
 +            collector: self.metrics.clone(),
 +        }
 +    }
++
 +    pub async fn record_network_request(&self, duration: Duration, success: bool, bytes_transferred: u64, upload: bool) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.network.total_requests += 1;
++
 +        if !success {
 +            metrics.network.failed_requests += 1;
 +        }
++
 +        // Update average response time (simple moving average)
 +        let duration_ms = duration.as_secs_f64() * 1000.0;
 +        let total_requests = metrics.network.total_requests as f64;
 +        metrics.network.average_response_time =
 +            (metrics.network.average_response_time * (total_requests - 1.0) + duration_ms) / total_requests;
++
 +        if upload {
 +            metrics.network.bytes_uploaded += bytes_transferred;
 +        } else {
 +            metrics.network.bytes_downloaded += bytes_transferred;
 +        }
 +    }
++
 +    pub async fn record_timeout(&self) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.network.timeouts += 1;
 +        metrics.network.failed_requests += 1;
 +    }
++
 +    pub async fn record_file_upload(&self, file_size: u64) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.storage.files_uploaded += 1;
 +        metrics.storage.total_bytes_processed += file_size;
 +        metrics.storage.disk_operations += 1;
 +    }
++
 +    pub async fn record_file_download(&self, file_size: u64) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.storage.files_downloaded += 1;
 +        metrics.storage.total_bytes_processed += file_size;
 +        metrics.storage.disk_operations += 1;
 +    }
++
 +    pub async fn record_cache_hit(&self) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.storage.cache_hits += 1;
 +    }
++
 +    pub async fn record_cache_miss(&self) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.storage.cache_misses += 1;
 +    }
++
 +    pub async fn update_peer_count(&self, peer_count: u32) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.network.peer_connections = peer_count;
 +    }
++
 +    pub async fn record_memory_usage(&self, memory_mb: f64) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.performance.memory_usage_mb = memory_mb;
 +        if memory_mb > metrics.performance.peak_memory_mb {
 +            metrics.performance.peak_memory_mb = memory_mb;
 +        }
 +    }
++
 +    pub async fn record_cpu_usage(&self, cpu_percent: f64) {
 +        let mut metrics = self.metrics.write().await;
 +        metrics.performance.cpu_usage_percent = cpu_percent;
 +    }
++
 +    pub async fn get_metrics(&self) -> Metrics {
 +        let metrics = self.metrics.read().await;
 +        let mut result = metrics.clone();
 +        result.performance.startup_time_ms = self.start_time.elapsed().as_secs_f64() * 1000.0;
 +        result
 +    }
++
 +    pub async fn get_summary(&self) -> MetricsSummary {
 +        let metrics = self.get_metrics().await;
++
 +        MetricsSummary {
 +            uptime_seconds: self.start_time.elapsed().as_secs(),
 +            total_commands: metrics.commands.total_commands,
 +            success_rate: if metrics.commands.total_commands > 0 {
 +                ((metrics.commands.total_commands - metrics.commands.failed_commands) as f64
 +                 / metrics.commands.total_commands as f64) * 100.0
 +            } else { 0.0 },
 +            network_success_rate: if metrics.network.total_requests > 0 {
 +                ((metrics.network.total_requests - metrics.network.failed_requests) as f64
 +                 / metrics.network.total_requests as f64) * 100.0
 +            } else { 0.0 },
 +            average_response_time_ms: metrics.network.average_response_time,
 +            total_bytes_transferred: metrics.network.bytes_uploaded + metrics.network.bytes_downloaded,
 +            files_processed: metrics.storage.files_uploaded + metrics.storage.files_downloaded,
 +            cache_hit_rate: if metrics.storage.cache_hits + metrics.storage.cache_misses > 0 {
 +                (metrics.storage.cache_hits as f64 /
 +                 (metrics.storage.cache_hits + metrics.storage.cache_misses) as f64) * 100.0
 +            } else { 0.0 },
 +            memory_usage_mb: metrics.performance.memory_usage_mb,
 +            peak_memory_mb: metrics.performance.peak_memory_mb,
 +        }
 +    }
++
 +    pub async fn export_metrics(&self) -> Result<String, serde_json::Error> {
 +        let metrics = self.get_metrics().await;
 +        serde_json::to_string_pretty(&metrics)
 +    }
++
 +    pub async fn reset_metrics(&self) {
 +        let mut metrics = self.metrics.write().await;
 +        *metrics = Metrics::default();
 +    }
 +}
++
 +#[derive(Debug)]
 +pub struct CommandTimer {
 +    command: String,
 +    start_time: Instant,
 +    collector: Arc<RwLock<Metrics>>,
 +}
++
 +impl Drop for CommandTimer {
 +    fn drop(&mut self) {
 +        let duration = self.start_time.elapsed();
 +        let duration_ms = duration.as_secs_f64() * 1000.0;
++
 +        // Use a blocking task to update metrics since we're in Drop
 +        tokio::task::block_in_place(|| {
 +            tokio::runtime::Handle::current().block_on(async {
 +                let mut metrics = self.collector.write().await;
 +                metrics.commands.command_durations
 +                    .entry(self.command.clone())
 +                    .or_insert_with(Vec::new)
 +                    .push(duration_ms);
 +            });
 +        });
 +    }
 +}
++
 +#[derive(Debug, Serialize, Deserialize)]
 +pub struct MetricsSummary {
 +    pub uptime_seconds: u64,
 +    pub total_commands: u64,
 +    pub success_rate: f64,
 +    pub network_success_rate: f64,
 +    pub average_response_time_ms: f64,
 +    pub total_bytes_transferred: u64,
 +    pub files_processed: u64,
 +    pub cache_hit_rate: f64,
 +    pub memory_usage_mb: f64,
 +    pub peak_memory_mb: f64,
 +}
++
 +// Global metrics collector instance
 +lazy_static::lazy_static! {
 +    pub static ref METRICS: MetricsCollector = MetricsCollector::new();
 +}
++
 +// Convenience macros for metrics collection
 +#[macro_export]
 +macro_rules! time_command {
 +    ($command:expr) => {
 +        crate::metrics::METRICS.record_command_start($command).await
 +    };
 +}
++
 +#[macro_export]
 +macro_rules! record_network_success {
 +    ($duration:expr, $bytes:expr, $upload:expr) => {
 +        crate::metrics::METRICS.record_network_request($duration, true, $bytes, $upload).await
 +    };
 +}
++
 +#[macro_export]
 +macro_rules! record_network_failure {
 +    ($duration:expr, $bytes:expr, $upload:expr) => {
 +        crate::metrics::METRICS.record_network_request($duration, false, $bytes, $upload).await
 +    };
 +}

tests/integration_tests.rsadded

 +use anyhow::Result;
 +use std::path::PathBuf;
 +use std::time::Duration;
 +use tempfile::TempDir;
 +use tokio::fs;
 +use zephyrfs_cli::{Config, ZephyrClient};
++
 +struct TestEnvironment {
 +    temp_dir: TempDir,
 +    config: Config,
 +}
++
 +impl TestEnvironment {
 +    fn new() -> Result<Self> {
 +        let temp_dir = tempfile::tempdir()?;
 +        let mut config = Config::default();
 +        config.node.data_dir = temp_dir.path().join("data");
 +        config.node.listen_port = 0; // Let OS choose port for tests
++
 +        Ok(Self { temp_dir, config })
 +    }
++
 +    async fn create_test_file(&self, name: &str, content: &[u8]) -> Result<PathBuf> {
 +        let file_path = self.temp_dir.path().join(name);
 +        fs::write(&file_path, content).await?;
 +        Ok(file_path)
 +    }
 +}
++
 +#[tokio::test]
 +async fn test_config_load_default() -> Result<()> {
 +    let config = Config::load(None)?;
 +    assert!(!config.node.data_dir.as_os_str().is_empty());
 +    assert!(config.node.listen_port > 0);
 +    assert!(!config.coordinator.endpoint.is_empty());
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_config_save_load_yaml() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let config_path = env.temp_dir.path().join("test_config.yaml");
++
 +    // Save config
 +    env.config.save(Some(config_path.to_str().unwrap()))?;
++
 +    // Load config
 +    let loaded_config = Config::load(Some(config_path.to_str().unwrap()))?;
++
 +    assert_eq!(env.config.node.listen_port, loaded_config.node.listen_port);
 +    assert_eq!(env.config.storage.max_storage_gb, loaded_config.storage.max_storage_gb);
 +    assert_eq!(env.config.coordinator.endpoint, loaded_config.coordinator.endpoint);
++
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_config_save_load_toml() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let config_path = env.temp_dir.path().join("test_config.toml");
++
 +    // Save config
 +    env.config.save(Some(config_path.to_str().unwrap()))?;
++
 +    // Load config
 +    let loaded_config = Config::load(Some(config_path.to_str().unwrap()))?;
++
 +    assert_eq!(env.config.node.listen_port, loaded_config.node.listen_port);
 +    assert_eq!(env.config.storage.max_storage_gb, loaded_config.storage.max_storage_gb);
++
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_config_ensure_data_dir() -> Result<()> {
 +    let env = TestEnvironment::new()?;
++
 +    // Data dir shouldn't exist yet
 +    assert!(!env.config.node.data_dir.exists());
++
 +    // Ensure data dir
 +    env.config.ensure_data_dir()?;
++
 +    // Data dir should exist now
 +    assert!(env.config.node.data_dir.exists());
 +    assert!(env.config.node.data_dir.is_dir());
++
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_client_creation() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let _client = ZephyrClient::new(&env.config);
 +    Ok(())
 +}
++
 +// Mock server tests would go here if we had a test server
 +// For now, these test the client creation and basic config handling
++
 +#[tokio::test]
 +async fn test_file_operations_offline() -> Result<()> {
 +    let env = TestEnvironment::new()?;
++
 +    // Create a test file
 +    let test_content = b"Hello, ZephyrFS!";
 +    let test_file = env.create_test_file("test.txt", test_content).await?;
++
 +    // Verify file was created correctly
 +    let read_content = fs::read(&test_file).await?;
 +    assert_eq!(read_content, test_content);
++
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_large_file_handling() -> Result<()> {
 +    let env = TestEnvironment::new()?;
++
 +    // Create a 10MB test file
 +    let test_content = vec![0u8; 10 * 1024 * 1024];
 +    let test_file = env.create_test_file("large.bin", &test_content).await?;
++
 +    // Verify file size
 +    let metadata = fs::metadata(&test_file).await?;
 +    assert_eq!(metadata.len(), test_content.len() as u64);
++
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_invalid_config_handling() -> Result<()> {
 +    let temp_dir = tempfile::tempdir()?;
 +    let invalid_config_path = temp_dir.path().join("invalid.yaml");
++
 +    // Write invalid YAML
 +    fs::write(&invalid_config_path, "invalid: yaml: content: [").await?;
++
 +    // Should return error
 +    let result = Config::load(Some(invalid_config_path.to_str().unwrap()));
 +    assert!(result.is_err());
++
 +    Ok(())
 +}
++
 +#[tokio::test]
 +async fn test_nonexistent_config_uses_defaults() -> Result<()> {
 +    let temp_dir = tempfile::tempdir()?;
 +    let nonexistent_path = temp_dir.path().join("nonexistent.yaml");
++
 +    // Should return default config
 +    let config = Config::load(Some(nonexistent_path.to_str().unwrap()))?;
 +    let default_config = Config::default();
++
 +    assert_eq!(config.node.listen_port, default_config.node.listen_port);
 +    assert_eq!(config.storage.max_storage_gb, default_config.storage.max_storage_gb);
++
 +    Ok(())
 +}
++
 +// Performance tests
 +#[tokio::test]
 +async fn test_config_load_performance() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let config_path = env.temp_dir.path().join("perf_test.yaml");
 +    env.config.save(Some(config_path.to_str().unwrap()))?;
++
 +    let start = std::time::Instant::now();
 +    for _ in 0..100 {
 +        let _config = Config::load(Some(config_path.to_str().unwrap()))?;
 +    }
 +    let duration = start.elapsed();
++
 +    // Should load 100 configs in under 1 second
 +    assert!(duration < Duration::from_secs(1));
++
 +    Ok(())
 +}
++
 +// Network simulation tests (would require mock server)
 +// These are placeholders for future implementation
++
 +#[ignore] // Requires running node
 +#[tokio::test]
 +async fn test_node_status_integration() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let client = ZephyrClient::new(&env.config);
++
 +    // This would test against a running node
 +    let _status = client.get_node_status().await?;
++
 +    Ok(())
 +}
++
 +#[ignore] // Requires running node and network
 +#[tokio::test]
 +async fn test_file_upload_download_integration() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let client = ZephyrClient::new(&env.config);
++
 +    // Create test file
 +    let test_content = b"Integration test content";
 +    let test_file = env.create_test_file("integration_test.txt", test_content).await?;
++
 +    // Upload file
 +    let upload_result = client.upload_file(&test_file).await?;
 +    assert!(!upload_result.file_hash.is_empty());
++
 +    // Download file
 +    let download_path = env.temp_dir.path().join("downloaded.txt");
 +    client.download_file(&upload_result.file_hash, &download_path).await?;
++
 +    // Verify content
 +    let downloaded_content = fs::read(&download_path).await?;
 +    assert_eq!(downloaded_content, test_content);
++
 +    Ok(())
 +}
++
 +#[ignore] // Requires multiple running nodes
 +#[tokio::test]
 +async fn test_network_join_integration() -> Result<()> {
 +    let env = TestEnvironment::new()?;
 +    let client = ZephyrClient::new(&env.config);
++
 +    // Join network
 +    client.join_network("127.0.0.1:8081").await?;
++
 +    // Verify connection
 +    let status = client.get_node_status().await?;
 +    assert!(status.peers_connected > 0);
++
 +    Ok(())
 +}